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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __esm = (fn2, res) => function __init() {
  return fn2 && (res = (0, fn2[__getOwnPropNames(fn2)[0]])(fn2 = 0)), res;
};
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all2) => {
  for (var name in all2)
    __defProp(target, name, { get: all2[name], 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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
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);

// import_meta_url.js
var import_meta_url;
var init_import_meta_url = __esm({
  "import_meta_url.js"() {
    import_meta_url = require("url").pathToFileURL(__filename);
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/core/symbols.js
var require_symbols = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/core/symbols.js"(exports2, module3) {
    init_import_meta_url();
    module3.exports = {
      kClose: Symbol("close"),
      kDestroy: Symbol("destroy"),
      kDispatch: Symbol("dispatch"),
      kUrl: Symbol("url"),
      kWriting: Symbol("writing"),
      kResuming: Symbol("resuming"),
      kQueue: Symbol("queue"),
      kConnect: Symbol("connect"),
      kConnecting: Symbol("connecting"),
      kHeadersList: Symbol("headers list"),
      kKeepAliveDefaultTimeout: Symbol("default keep alive timeout"),
      kKeepAliveMaxTimeout: Symbol("max keep alive timeout"),
      kKeepAliveTimeoutThreshold: Symbol("keep alive timeout threshold"),
      kKeepAliveTimeoutValue: Symbol("keep alive timeout"),
      kKeepAlive: Symbol("keep alive"),
      kHeadersTimeout: Symbol("headers timeout"),
      kBodyTimeout: Symbol("body timeout"),
      kServerName: Symbol("server name"),
      kLocalAddress: Symbol("local address"),
      kHost: Symbol("host"),
      kNoRef: Symbol("no ref"),
      kBodyUsed: Symbol("used"),
      kRunning: Symbol("running"),
      kBlocking: Symbol("blocking"),
      kPending: Symbol("pending"),
      kSize: Symbol("size"),
      kBusy: Symbol("busy"),
      kQueued: Symbol("queued"),
      kFree: Symbol("free"),
      kConnected: Symbol("connected"),
      kClosed: Symbol("closed"),
      kNeedDrain: Symbol("need drain"),
      kReset: Symbol("reset"),
      kDestroyed: Symbol.for("nodejs.stream.destroyed"),
      kMaxHeadersSize: Symbol("max headers size"),
      kRunningIdx: Symbol("running index"),
      kPendingIdx: Symbol("pending index"),
      kError: Symbol("error"),
      kClients: Symbol("clients"),
      kClient: Symbol("client"),
      kParser: Symbol("parser"),
      kOnDestroyed: Symbol("destroy callbacks"),
      kPipelining: Symbol("pipelining"),
      kSocket: Symbol("socket"),
      kHostHeader: Symbol("host header"),
      kConnector: Symbol("connector"),
      kStrictContentLength: Symbol("strict content length"),
      kMaxRedirections: Symbol("maxRedirections"),
      kMaxRequests: Symbol("maxRequestsPerClient"),
      kProxy: Symbol("proxy agent options"),
      kCounter: Symbol("socket request counter"),
      kInterceptors: Symbol("dispatch interceptors"),
      kMaxResponseSize: Symbol("max response size"),
      kHTTP2Session: Symbol("http2Session"),
      kHTTP2SessionState: Symbol("http2Session state"),
      kHTTP2BuildRequest: Symbol("http2 build request"),
      kHTTP1BuildRequest: Symbol("http1 build request"),
      kHTTP2CopyHeaders: Symbol("http2 copy headers"),
      kHTTPConnVersion: Symbol("http connection version"),
      kRetryHandlerDefaultRetry: Symbol("retry agent default retry"),
      kConstruct: Symbol("constructable")
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/core/errors.js
var require_errors = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/core/errors.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var UndiciError = class extends Error {
      constructor(message) {
        super(message);
        this.name = "UndiciError";
        this.code = "UND_ERR";
      }
    };
    __name(UndiciError, "UndiciError");
    var ConnectTimeoutError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, ConnectTimeoutError);
        this.name = "ConnectTimeoutError";
        this.message = message || "Connect Timeout Error";
        this.code = "UND_ERR_CONNECT_TIMEOUT";
      }
    };
    __name(ConnectTimeoutError, "ConnectTimeoutError");
    var HeadersTimeoutError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, HeadersTimeoutError);
        this.name = "HeadersTimeoutError";
        this.message = message || "Headers Timeout Error";
        this.code = "UND_ERR_HEADERS_TIMEOUT";
      }
    };
    __name(HeadersTimeoutError, "HeadersTimeoutError");
    var HeadersOverflowError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, HeadersOverflowError);
        this.name = "HeadersOverflowError";
        this.message = message || "Headers Overflow Error";
        this.code = "UND_ERR_HEADERS_OVERFLOW";
      }
    };
    __name(HeadersOverflowError, "HeadersOverflowError");
    var BodyTimeoutError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, BodyTimeoutError);
        this.name = "BodyTimeoutError";
        this.message = message || "Body Timeout Error";
        this.code = "UND_ERR_BODY_TIMEOUT";
      }
    };
    __name(BodyTimeoutError, "BodyTimeoutError");
    var ResponseStatusCodeError = class extends UndiciError {
      constructor(message, statusCode, headers, body) {
        super(message);
        Error.captureStackTrace(this, ResponseStatusCodeError);
        this.name = "ResponseStatusCodeError";
        this.message = message || "Response Status Code Error";
        this.code = "UND_ERR_RESPONSE_STATUS_CODE";
        this.body = body;
        this.status = statusCode;
        this.statusCode = statusCode;
        this.headers = headers;
      }
    };
    __name(ResponseStatusCodeError, "ResponseStatusCodeError");
    var InvalidArgumentError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, InvalidArgumentError);
        this.name = "InvalidArgumentError";
        this.message = message || "Invalid Argument Error";
        this.code = "UND_ERR_INVALID_ARG";
      }
    };
    __name(InvalidArgumentError, "InvalidArgumentError");
    var InvalidReturnValueError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, InvalidReturnValueError);
        this.name = "InvalidReturnValueError";
        this.message = message || "Invalid Return Value Error";
        this.code = "UND_ERR_INVALID_RETURN_VALUE";
      }
    };
    __name(InvalidReturnValueError, "InvalidReturnValueError");
    var RequestAbortedError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, RequestAbortedError);
        this.name = "AbortError";
        this.message = message || "Request aborted";
        this.code = "UND_ERR_ABORTED";
      }
    };
    __name(RequestAbortedError, "RequestAbortedError");
    var InformationalError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, InformationalError);
        this.name = "InformationalError";
        this.message = message || "Request information";
        this.code = "UND_ERR_INFO";
      }
    };
    __name(InformationalError, "InformationalError");
    var RequestContentLengthMismatchError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, RequestContentLengthMismatchError);
        this.name = "RequestContentLengthMismatchError";
        this.message = message || "Request body length does not match content-length header";
        this.code = "UND_ERR_REQ_CONTENT_LENGTH_MISMATCH";
      }
    };
    __name(RequestContentLengthMismatchError, "RequestContentLengthMismatchError");
    var ResponseContentLengthMismatchError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, ResponseContentLengthMismatchError);
        this.name = "ResponseContentLengthMismatchError";
        this.message = message || "Response body length does not match content-length header";
        this.code = "UND_ERR_RES_CONTENT_LENGTH_MISMATCH";
      }
    };
    __name(ResponseContentLengthMismatchError, "ResponseContentLengthMismatchError");
    var ClientDestroyedError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, ClientDestroyedError);
        this.name = "ClientDestroyedError";
        this.message = message || "The client is destroyed";
        this.code = "UND_ERR_DESTROYED";
      }
    };
    __name(ClientDestroyedError, "ClientDestroyedError");
    var ClientClosedError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, ClientClosedError);
        this.name = "ClientClosedError";
        this.message = message || "The client is closed";
        this.code = "UND_ERR_CLOSED";
      }
    };
    __name(ClientClosedError, "ClientClosedError");
    var SocketError = class extends UndiciError {
      constructor(message, socket) {
        super(message);
        Error.captureStackTrace(this, SocketError);
        this.name = "SocketError";
        this.message = message || "Socket error";
        this.code = "UND_ERR_SOCKET";
        this.socket = socket;
      }
    };
    __name(SocketError, "SocketError");
    var NotSupportedError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, NotSupportedError);
        this.name = "NotSupportedError";
        this.message = message || "Not supported error";
        this.code = "UND_ERR_NOT_SUPPORTED";
      }
    };
    __name(NotSupportedError, "NotSupportedError");
    var BalancedPoolMissingUpstreamError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, NotSupportedError);
        this.name = "MissingUpstreamError";
        this.message = message || "No upstream has been added to the BalancedPool";
        this.code = "UND_ERR_BPL_MISSING_UPSTREAM";
      }
    };
    __name(BalancedPoolMissingUpstreamError, "BalancedPoolMissingUpstreamError");
    var HTTPParserError = class extends Error {
      constructor(message, code, data) {
        super(message);
        Error.captureStackTrace(this, HTTPParserError);
        this.name = "HTTPParserError";
        this.code = code ? `HPE_${code}` : void 0;
        this.data = data ? data.toString() : void 0;
      }
    };
    __name(HTTPParserError, "HTTPParserError");
    var ResponseExceededMaxSizeError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, ResponseExceededMaxSizeError);
        this.name = "ResponseExceededMaxSizeError";
        this.message = message || "Response content exceeded max size";
        this.code = "UND_ERR_RES_EXCEEDED_MAX_SIZE";
      }
    };
    __name(ResponseExceededMaxSizeError, "ResponseExceededMaxSizeError");
    var RequestRetryError = class extends UndiciError {
      constructor(message, code, { headers, data }) {
        super(message);
        Error.captureStackTrace(this, RequestRetryError);
        this.name = "RequestRetryError";
        this.message = message || "Request retry error";
        this.code = "UND_ERR_REQ_RETRY";
        this.statusCode = code;
        this.data = data;
        this.headers = headers;
      }
    };
    __name(RequestRetryError, "RequestRetryError");
    module3.exports = {
      HTTPParserError,
      UndiciError,
      HeadersTimeoutError,
      HeadersOverflowError,
      BodyTimeoutError,
      RequestContentLengthMismatchError,
      ConnectTimeoutError,
      ResponseStatusCodeError,
      InvalidArgumentError,
      InvalidReturnValueError,
      RequestAbortedError,
      ClientDestroyedError,
      ClientClosedError,
      InformationalError,
      SocketError,
      NotSupportedError,
      ResponseContentLengthMismatchError,
      BalancedPoolMissingUpstreamError,
      ResponseExceededMaxSizeError,
      RequestRetryError
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/core/util.js
var require_util = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/core/util.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var assert27 = require("assert");
    var { kDestroyed, kBodyUsed } = require_symbols();
    var { IncomingMessage } = require("http");
    var stream2 = require("stream");
    var net3 = require("net");
    var { InvalidArgumentError } = require_errors();
    var { Blob: Blob6 } = require("buffer");
    var nodeUtil = require("util");
    var { stringify } = require("querystring");
    var [nodeMajor, nodeMinor] = process.versions.node.split(".").map((v2) => Number(v2));
    function nop() {
    }
    __name(nop, "nop");
    function isStream2(obj) {
      return obj && typeof obj === "object" && typeof obj.pipe === "function" && typeof obj.on === "function";
    }
    __name(isStream2, "isStream");
    function isBlobLike(object) {
      return Blob6 && object instanceof Blob6 || object && typeof object === "object" && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && /^(Blob|File)$/.test(object[Symbol.toStringTag]);
    }
    __name(isBlobLike, "isBlobLike");
    function buildURL(url4, queryParams) {
      if (url4.includes("?") || url4.includes("#")) {
        throw new Error('Query params cannot be passed when url already contains "?" or "#".');
      }
      const stringified = stringify(queryParams);
      if (stringified) {
        url4 += "?" + stringified;
      }
      return url4;
    }
    __name(buildURL, "buildURL");
    function parseURL(url4) {
      if (typeof url4 === "string") {
        url4 = new URL(url4);
        if (!/^https?:/.test(url4.origin || url4.protocol)) {
          throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
        }
        return url4;
      }
      if (!url4 || typeof url4 !== "object") {
        throw new InvalidArgumentError("Invalid URL: The URL argument must be a non-null object.");
      }
      if (!/^https?:/.test(url4.origin || url4.protocol)) {
        throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
      }
      if (!(url4 instanceof URL)) {
        if (url4.port != null && url4.port !== "" && !Number.isFinite(parseInt(url4.port))) {
          throw new InvalidArgumentError("Invalid URL: port must be a valid integer or a string representation of an integer.");
        }
        if (url4.path != null && typeof url4.path !== "string") {
          throw new InvalidArgumentError("Invalid URL path: the path must be a string or null/undefined.");
        }
        if (url4.pathname != null && typeof url4.pathname !== "string") {
          throw new InvalidArgumentError("Invalid URL pathname: the pathname must be a string or null/undefined.");
        }
        if (url4.hostname != null && typeof url4.hostname !== "string") {
          throw new InvalidArgumentError("Invalid URL hostname: the hostname must be a string or null/undefined.");
        }
        if (url4.origin != null && typeof url4.origin !== "string") {
          throw new InvalidArgumentError("Invalid URL origin: the origin must be a string or null/undefined.");
        }
        const port2 = url4.port != null ? url4.port : url4.protocol === "https:" ? 443 : 80;
        let origin = url4.origin != null ? url4.origin : `${url4.protocol}//${url4.hostname}:${port2}`;
        let path67 = url4.path != null ? url4.path : `${url4.pathname || ""}${url4.search || ""}`;
        if (origin.endsWith("/")) {
          origin = origin.substring(0, origin.length - 1);
        }
        if (path67 && !path67.startsWith("/")) {
          path67 = `/${path67}`;
        }
        url4 = new URL(origin + path67);
      }
      return url4;
    }
    __name(parseURL, "parseURL");
    function parseOrigin(url4) {
      url4 = parseURL(url4);
      if (url4.pathname !== "/" || url4.search || url4.hash) {
        throw new InvalidArgumentError("invalid url");
      }
      return url4;
    }
    __name(parseOrigin, "parseOrigin");
    function getHostname(host) {
      if (host[0] === "[") {
        const idx2 = host.indexOf("]");
        assert27(idx2 !== -1);
        return host.substring(1, idx2);
      }
      const idx = host.indexOf(":");
      if (idx === -1)
        return host;
      return host.substring(0, idx);
    }
    __name(getHostname, "getHostname");
    function getServerName(host) {
      if (!host) {
        return null;
      }
      assert27.strictEqual(typeof host, "string");
      const servername = getHostname(host);
      if (net3.isIP(servername)) {
        return "";
      }
      return servername;
    }
    __name(getServerName, "getServerName");
    function deepClone(obj) {
      return JSON.parse(JSON.stringify(obj));
    }
    __name(deepClone, "deepClone");
    function isAsyncIterable(obj) {
      return !!(obj != null && typeof obj[Symbol.asyncIterator] === "function");
    }
    __name(isAsyncIterable, "isAsyncIterable");
    function isIterable(obj) {
      return !!(obj != null && (typeof obj[Symbol.iterator] === "function" || typeof obj[Symbol.asyncIterator] === "function"));
    }
    __name(isIterable, "isIterable");
    function bodyLength(body) {
      if (body == null) {
        return 0;
      } else if (isStream2(body)) {
        const state = body._readableState;
        return state && state.objectMode === false && state.ended === true && Number.isFinite(state.length) ? state.length : null;
      } else if (isBlobLike(body)) {
        return body.size != null ? body.size : null;
      } else if (isBuffer(body)) {
        return body.byteLength;
      }
      return null;
    }
    __name(bodyLength, "bodyLength");
    function isDestroyed(stream3) {
      return !stream3 || !!(stream3.destroyed || stream3[kDestroyed]);
    }
    __name(isDestroyed, "isDestroyed");
    function isReadableAborted(stream3) {
      const state = stream3 && stream3._readableState;
      return isDestroyed(stream3) && state && !state.endEmitted;
    }
    __name(isReadableAborted, "isReadableAborted");
    function destroy(stream3, err) {
      if (stream3 == null || !isStream2(stream3) || isDestroyed(stream3)) {
        return;
      }
      if (typeof stream3.destroy === "function") {
        if (Object.getPrototypeOf(stream3).constructor === IncomingMessage) {
          stream3.socket = null;
        }
        stream3.destroy(err);
      } else if (err) {
        process.nextTick((stream4, err2) => {
          stream4.emit("error", err2);
        }, stream3, err);
      }
      if (stream3.destroyed !== true) {
        stream3[kDestroyed] = true;
      }
    }
    __name(destroy, "destroy");
    var KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/;
    function parseKeepAliveTimeout(val) {
      const m2 = val.toString().match(KEEPALIVE_TIMEOUT_EXPR);
      return m2 ? parseInt(m2[1], 10) * 1e3 : null;
    }
    __name(parseKeepAliveTimeout, "parseKeepAliveTimeout");
    function parseHeaders2(headers, obj = {}) {
      if (!Array.isArray(headers))
        return headers;
      for (let i = 0; i < headers.length; i += 2) {
        const key = headers[i].toString().toLowerCase();
        let val = obj[key];
        if (!val) {
          if (Array.isArray(headers[i + 1])) {
            obj[key] = headers[i + 1].map((x2) => x2.toString("utf8"));
          } else {
            obj[key] = headers[i + 1].toString("utf8");
          }
        } else {
          if (!Array.isArray(val)) {
            val = [val];
            obj[key] = val;
          }
          val.push(headers[i + 1].toString("utf8"));
        }
      }
      if ("content-length" in obj && "content-disposition" in obj) {
        obj["content-disposition"] = Buffer.from(obj["content-disposition"]).toString("latin1");
      }
      return obj;
    }
    __name(parseHeaders2, "parseHeaders");
    function parseRawHeaders(headers) {
      const ret = [];
      let hasContentLength = false;
      let contentDispositionIdx = -1;
      for (let n2 = 0; n2 < headers.length; n2 += 2) {
        const key = headers[n2 + 0].toString();
        const val = headers[n2 + 1].toString("utf8");
        if (key.length === 14 && (key === "content-length" || key.toLowerCase() === "content-length")) {
          ret.push(key, val);
          hasContentLength = true;
        } else if (key.length === 19 && (key === "content-disposition" || key.toLowerCase() === "content-disposition")) {
          contentDispositionIdx = ret.push(key, val) - 1;
        } else {
          ret.push(key, val);
        }
      }
      if (hasContentLength && contentDispositionIdx !== -1) {
        ret[contentDispositionIdx] = Buffer.from(ret[contentDispositionIdx]).toString("latin1");
      }
      return ret;
    }
    __name(parseRawHeaders, "parseRawHeaders");
    function isBuffer(buffer) {
      return buffer instanceof Uint8Array || Buffer.isBuffer(buffer);
    }
    __name(isBuffer, "isBuffer");
    function validateHandler(handler30, method, upgrade) {
      if (!handler30 || typeof handler30 !== "object") {
        throw new InvalidArgumentError("handler must be an object");
      }
      if (typeof handler30.onConnect !== "function") {
        throw new InvalidArgumentError("invalid onConnect method");
      }
      if (typeof handler30.onError !== "function") {
        throw new InvalidArgumentError("invalid onError method");
      }
      if (typeof handler30.onBodySent !== "function" && handler30.onBodySent !== void 0) {
        throw new InvalidArgumentError("invalid onBodySent method");
      }
      if (upgrade || method === "CONNECT") {
        if (typeof handler30.onUpgrade !== "function") {
          throw new InvalidArgumentError("invalid onUpgrade method");
        }
      } else {
        if (typeof handler30.onHeaders !== "function") {
          throw new InvalidArgumentError("invalid onHeaders method");
        }
        if (typeof handler30.onData !== "function") {
          throw new InvalidArgumentError("invalid onData method");
        }
        if (typeof handler30.onComplete !== "function") {
          throw new InvalidArgumentError("invalid onComplete method");
        }
      }
    }
    __name(validateHandler, "validateHandler");
    function isDisturbed(body) {
      return !!(body && (stream2.isDisturbed ? stream2.isDisturbed(body) || body[kBodyUsed] : body[kBodyUsed] || body.readableDidRead || body._readableState && body._readableState.dataEmitted || isReadableAborted(body)));
    }
    __name(isDisturbed, "isDisturbed");
    function isErrored(body) {
      return !!(body && (stream2.isErrored ? stream2.isErrored(body) : /state: 'errored'/.test(
        nodeUtil.inspect(body)
      )));
    }
    __name(isErrored, "isErrored");
    function isReadable(body) {
      return !!(body && (stream2.isReadable ? stream2.isReadable(body) : /state: 'readable'/.test(
        nodeUtil.inspect(body)
      )));
    }
    __name(isReadable, "isReadable");
    function getSocketInfo(socket) {
      return {
        localAddress: socket.localAddress,
        localPort: socket.localPort,
        remoteAddress: socket.remoteAddress,
        remotePort: socket.remotePort,
        remoteFamily: socket.remoteFamily,
        timeout: socket.timeout,
        bytesWritten: socket.bytesWritten,
        bytesRead: socket.bytesRead
      };
    }
    __name(getSocketInfo, "getSocketInfo");
    async function* convertIterableToBuffer(iterable) {
      for await (const chunk of iterable) {
        yield Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
      }
    }
    __name(convertIterableToBuffer, "convertIterableToBuffer");
    var ReadableStream2;
    function ReadableStreamFrom(iterable) {
      if (!ReadableStream2) {
        ReadableStream2 = require("stream/web").ReadableStream;
      }
      if (ReadableStream2.from) {
        return ReadableStream2.from(convertIterableToBuffer(iterable));
      }
      let iterator;
      return new ReadableStream2(
        {
          async start() {
            iterator = iterable[Symbol.asyncIterator]();
          },
          async pull(controller) {
            const { done, value } = await iterator.next();
            if (done) {
              queueMicrotask(() => {
                controller.close();
              });
            } else {
              const buf = Buffer.isBuffer(value) ? value : Buffer.from(value);
              controller.enqueue(new Uint8Array(buf));
            }
            return controller.desiredSize > 0;
          },
          async cancel(reason) {
            await iterator.return();
          }
        },
        0
      );
    }
    __name(ReadableStreamFrom, "ReadableStreamFrom");
    function isFormDataLike(object) {
      return object && typeof object === "object" && typeof object.append === "function" && typeof object.delete === "function" && typeof object.get === "function" && typeof object.getAll === "function" && typeof object.has === "function" && typeof object.set === "function" && object[Symbol.toStringTag] === "FormData";
    }
    __name(isFormDataLike, "isFormDataLike");
    function throwIfAborted(signal) {
      if (!signal) {
        return;
      }
      if (typeof signal.throwIfAborted === "function") {
        signal.throwIfAborted();
      } else {
        if (signal.aborted) {
          const err = new Error("The operation was aborted");
          err.name = "AbortError";
          throw err;
        }
      }
    }
    __name(throwIfAborted, "throwIfAborted");
    function addAbortListener(signal, listener) {
      if ("addEventListener" in signal) {
        signal.addEventListener("abort", listener, { once: true });
        return () => signal.removeEventListener("abort", listener);
      }
      signal.addListener("abort", listener);
      return () => signal.removeListener("abort", listener);
    }
    __name(addAbortListener, "addAbortListener");
    var hasToWellFormed = !!String.prototype.toWellFormed;
    function toUSVString(val) {
      if (hasToWellFormed) {
        return `${val}`.toWellFormed();
      } else if (nodeUtil.toUSVString) {
        return nodeUtil.toUSVString(val);
      }
      return `${val}`;
    }
    __name(toUSVString, "toUSVString");
    function parseRangeHeader(range) {
      if (range == null || range === "")
        return { start: 0, end: null, size: null };
      const m2 = range ? range.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null;
      return m2 ? {
        start: parseInt(m2[1]),
        end: m2[2] ? parseInt(m2[2]) : null,
        size: m2[3] ? parseInt(m2[3]) : null
      } : null;
    }
    __name(parseRangeHeader, "parseRangeHeader");
    var kEnumerableProperty = /* @__PURE__ */ Object.create(null);
    kEnumerableProperty.enumerable = true;
    module3.exports = {
      kEnumerableProperty,
      nop,
      isDisturbed,
      isErrored,
      isReadable,
      toUSVString,
      isReadableAborted,
      isBlobLike,
      parseOrigin,
      parseURL,
      getServerName,
      isStream: isStream2,
      isIterable,
      isAsyncIterable,
      isDestroyed,
      parseRawHeaders,
      parseHeaders: parseHeaders2,
      parseKeepAliveTimeout,
      destroy,
      bodyLength,
      deepClone,
      ReadableStreamFrom,
      isBuffer,
      validateHandler,
      getSocketInfo,
      isFormDataLike,
      buildURL,
      throwIfAborted,
      addAbortListener,
      parseRangeHeader,
      nodeMajor,
      nodeMinor,
      nodeHasAutoSelectFamily: nodeMajor > 18 || nodeMajor === 18 && nodeMinor >= 13,
      safeHTTPMethods: ["GET", "HEAD", "OPTIONS", "TRACE"]
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/timers.js
var require_timers = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/timers.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var fastNow = Date.now();
    var fastNowTimeout;
    var fastTimers = [];
    function onTimeout() {
      fastNow = Date.now();
      let len = fastTimers.length;
      let idx = 0;
      while (idx < len) {
        const timer = fastTimers[idx];
        if (timer.state === 0) {
          timer.state = fastNow + timer.delay;
        } else if (timer.state > 0 && fastNow >= timer.state) {
          timer.state = -1;
          timer.callback(timer.opaque);
        }
        if (timer.state === -1) {
          timer.state = -2;
          if (idx !== len - 1) {
            fastTimers[idx] = fastTimers.pop();
          } else {
            fastTimers.pop();
          }
          len -= 1;
        } else {
          idx += 1;
        }
      }
      if (fastTimers.length > 0) {
        refreshTimeout();
      }
    }
    __name(onTimeout, "onTimeout");
    function refreshTimeout() {
      if (fastNowTimeout && fastNowTimeout.refresh) {
        fastNowTimeout.refresh();
      } else {
        clearTimeout(fastNowTimeout);
        fastNowTimeout = setTimeout(onTimeout, 1e3);
        if (fastNowTimeout.unref) {
          fastNowTimeout.unref();
        }
      }
    }
    __name(refreshTimeout, "refreshTimeout");
    var Timeout = class {
      constructor(callback, delay, opaque) {
        this.callback = callback;
        this.delay = delay;
        this.opaque = opaque;
        this.state = -2;
        this.refresh();
      }
      refresh() {
        if (this.state === -2) {
          fastTimers.push(this);
          if (!fastNowTimeout || fastTimers.length === 1) {
            refreshTimeout();
          }
        }
        this.state = 0;
      }
      clear() {
        this.state = -1;
      }
    };
    __name(Timeout, "Timeout");
    module3.exports = {
      setTimeout(callback, delay, opaque) {
        return delay < 1e3 ? setTimeout(callback, delay, opaque) : new Timeout(callback, delay, opaque);
      },
      clearTimeout(timeout) {
        if (timeout instanceof Timeout) {
          timeout.clear();
        } else {
          clearTimeout(timeout);
        }
      }
    };
  }
});

// ../../node_modules/.pnpm/@fastify+busboy@2.1.0/node_modules/@fastify/busboy/deps/streamsearch/sbmh.js
var require_sbmh = __commonJS({
  "../../node_modules/.pnpm/@fastify+busboy@2.1.0/node_modules/@fastify/busboy/deps/streamsearch/sbmh.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var EventEmitter7 = require("node:events").EventEmitter;
    var inherits = require("node:util").inherits;
    function SBMH(needle) {
      if (typeof needle === "string") {
        needle = Buffer.from(needle);
      }
      if (!Buffer.isBuffer(needle)) {
        throw new TypeError("The needle has to be a String or a Buffer.");
      }
      const needleLength = needle.length;
      if (needleLength === 0) {
        throw new Error("The needle cannot be an empty String/Buffer.");
      }
      if (needleLength > 256) {
        throw new Error("The needle cannot have a length bigger than 256.");
      }
      this.maxMatches = Infinity;
      this.matches = 0;
      this._occ = new Array(256).fill(needleLength);
      this._lookbehind_size = 0;
      this._needle = needle;
      this._bufpos = 0;
      this._lookbehind = Buffer.alloc(needleLength);
      for (var i = 0; i < needleLength - 1; ++i) {
        this._occ[needle[i]] = needleLength - 1 - i;
      }
    }
    __name(SBMH, "SBMH");
    inherits(SBMH, EventEmitter7);
    SBMH.prototype.reset = function() {
      this._lookbehind_size = 0;
      this.matches = 0;
      this._bufpos = 0;
    };
    SBMH.prototype.push = function(chunk, pos) {
      if (!Buffer.isBuffer(chunk)) {
        chunk = Buffer.from(chunk, "binary");
      }
      const chlen = chunk.length;
      this._bufpos = pos || 0;
      let r3;
      while (r3 !== chlen && this.matches < this.maxMatches) {
        r3 = this._sbmh_feed(chunk);
      }
      return r3;
    };
    SBMH.prototype._sbmh_feed = function(data) {
      const len = data.length;
      const needle = this._needle;
      const needleLength = needle.length;
      const lastNeedleChar = needle[needleLength - 1];
      let pos = -this._lookbehind_size;
      let ch;
      if (pos < 0) {
        while (pos < 0 && pos <= len - needleLength) {
          ch = this._sbmh_lookup_char(data, pos + needleLength - 1);
          if (ch === lastNeedleChar && this._sbmh_memcmp(data, pos, needleLength - 1)) {
            this._lookbehind_size = 0;
            ++this.matches;
            this.emit("info", true);
            return this._bufpos = pos + needleLength;
          }
          pos += this._occ[ch];
        }
        if (pos < 0) {
          while (pos < 0 && !this._sbmh_memcmp(data, pos, len - pos)) {
            ++pos;
          }
        }
        if (pos >= 0) {
          this.emit("info", false, this._lookbehind, 0, this._lookbehind_size);
          this._lookbehind_size = 0;
        } else {
          const bytesToCutOff = this._lookbehind_size + pos;
          if (bytesToCutOff > 0) {
            this.emit("info", false, this._lookbehind, 0, bytesToCutOff);
          }
          this._lookbehind.copy(
            this._lookbehind,
            0,
            bytesToCutOff,
            this._lookbehind_size - bytesToCutOff
          );
          this._lookbehind_size -= bytesToCutOff;
          data.copy(this._lookbehind, this._lookbehind_size);
          this._lookbehind_size += len;
          this._bufpos = len;
          return len;
        }
      }
      pos += (pos >= 0) * this._bufpos;
      if (data.indexOf(needle, pos) !== -1) {
        pos = data.indexOf(needle, pos);
        ++this.matches;
        if (pos > 0) {
          this.emit("info", true, data, this._bufpos, pos);
        } else {
          this.emit("info", true);
        }
        return this._bufpos = pos + needleLength;
      } else {
        pos = len - needleLength;
      }
      while (pos < len && (data[pos] !== needle[0] || Buffer.compare(
        data.subarray(pos, pos + len - pos),
        needle.subarray(0, len - pos)
      ) !== 0)) {
        ++pos;
      }
      if (pos < len) {
        data.copy(this._lookbehind, 0, pos, pos + (len - pos));
        this._lookbehind_size = len - pos;
      }
      if (pos > 0) {
        this.emit("info", false, data, this._bufpos, pos < len ? pos : len);
      }
      this._bufpos = len;
      return len;
    };
    SBMH.prototype._sbmh_lookup_char = function(data, pos) {
      return pos < 0 ? this._lookbehind[this._lookbehind_size + pos] : data[pos];
    };
    SBMH.prototype._sbmh_memcmp = function(data, pos, len) {
      for (var i = 0; i < len; ++i) {
        if (this._sbmh_lookup_char(data, pos + i) !== this._needle[i]) {
          return false;
        }
      }
      return true;
    };
    module3.exports = SBMH;
  }
});

// ../../node_modules/.pnpm/@fastify+busboy@2.1.0/node_modules/@fastify/busboy/deps/dicer/lib/PartStream.js
var require_PartStream = __commonJS({
  "../../node_modules/.pnpm/@fastify+busboy@2.1.0/node_modules/@fastify/busboy/deps/dicer/lib/PartStream.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var inherits = require("node:util").inherits;
    var ReadableStream2 = require("node:stream").Readable;
    function PartStream(opts) {
      ReadableStream2.call(this, opts);
    }
    __name(PartStream, "PartStream");
    inherits(PartStream, ReadableStream2);
    PartStream.prototype._read = function(n2) {
    };
    module3.exports = PartStream;
  }
});

// ../../node_modules/.pnpm/@fastify+busboy@2.1.0/node_modules/@fastify/busboy/lib/utils/getLimit.js
var require_getLimit = __commonJS({
  "../../node_modules/.pnpm/@fastify+busboy@2.1.0/node_modules/@fastify/busboy/lib/utils/getLimit.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function getLimit(limits, name, defaultLimit) {
      if (!limits || limits[name] === void 0 || limits[name] === null) {
        return defaultLimit;
      }
      if (typeof limits[name] !== "number" || isNaN(limits[name])) {
        throw new TypeError("Limit " + name + " is not a valid number");
      }
      return limits[name];
    }, "getLimit");
  }
});

// ../../node_modules/.pnpm/@fastify+busboy@2.1.0/node_modules/@fastify/busboy/deps/dicer/lib/HeaderParser.js
var require_HeaderParser = __commonJS({
  "../../node_modules/.pnpm/@fastify+busboy@2.1.0/node_modules/@fastify/busboy/deps/dicer/lib/HeaderParser.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var EventEmitter7 = require("node:events").EventEmitter;
    var inherits = require("node:util").inherits;
    var getLimit = require_getLimit();
    var StreamSearch = require_sbmh();
    var B_DCRLF = Buffer.from("\r\n\r\n");
    var RE_CRLF = /\r\n/g;
    var RE_HDR = /^([^:]+):[ \t]?([\x00-\xFF]+)?$/;
    function HeaderParser(cfg) {
      EventEmitter7.call(this);
      cfg = cfg || {};
      const self2 = this;
      this.nread = 0;
      this.maxed = false;
      this.npairs = 0;
      this.maxHeaderPairs = getLimit(cfg, "maxHeaderPairs", 2e3);
      this.maxHeaderSize = getLimit(cfg, "maxHeaderSize", 80 * 1024);
      this.buffer = "";
      this.header = {};
      this.finished = false;
      this.ss = new StreamSearch(B_DCRLF);
      this.ss.on("info", function(isMatch, data, start, end) {
        if (data && !self2.maxed) {
          if (self2.nread + end - start >= self2.maxHeaderSize) {
            end = self2.maxHeaderSize - self2.nread + start;
            self2.nread = self2.maxHeaderSize;
            self2.maxed = true;
          } else {
            self2.nread += end - start;
          }
          self2.buffer += data.toString("binary", start, end);
        }
        if (isMatch) {
          self2._finish();
        }
      });
    }
    __name(HeaderParser, "HeaderParser");
    inherits(HeaderParser, EventEmitter7);
    HeaderParser.prototype.push = function(data) {
      const r3 = this.ss.push(data);
      if (this.finished) {
        return r3;
      }
    };
    HeaderParser.prototype.reset = function() {
      this.finished = false;
      this.buffer = "";
      this.header = {};
      this.ss.reset();
    };
    HeaderParser.prototype._finish = function() {
      if (this.buffer) {
        this._parseHeader();
      }
      this.ss.matches = this.ss.maxMatches;
      const header = this.header;
      this.header = {};
      this.buffer = "";
      this.finished = true;
      this.nread = this.npairs = 0;
      this.maxed = false;
      this.emit("header", header);
    };
    HeaderParser.prototype._parseHeader = function() {
      if (this.npairs === this.maxHeaderPairs) {
        return;
      }
      const lines = this.buffer.split(RE_CRLF);
      const len = lines.length;
      let m2, h2;
      for (var i = 0; i < len; ++i) {
        if (lines[i].length === 0) {
          continue;
        }
        if (lines[i][0] === "	" || lines[i][0] === " ") {
          if (h2) {
            this.header[h2][this.header[h2].length - 1] += lines[i];
            continue;
          }
        }
        const posColon = lines[i].indexOf(":");
        if (posColon === -1 || posColon === 0) {
          return;
        }
        m2 = RE_HDR.exec(lines[i]);
        h2 = m2[1].toLowerCase();
        this.header[h2] = this.header[h2] || [];
        this.header[h2].push(m2[2] || "");
        if (++this.npairs === this.maxHeaderPairs) {
          break;
        }
      }
    };
    module3.exports = HeaderParser;
  }
});

// ../../node_modules/.pnpm/@fastify+busboy@2.1.0/node_modules/@fastify/busboy/deps/dicer/lib/Dicer.js
var require_Dicer = __commonJS({
  "../../node_modules/.pnpm/@fastify+busboy@2.1.0/node_modules/@fastify/busboy/deps/dicer/lib/Dicer.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var WritableStream = require("node:stream").Writable;
    var inherits = require("node:util").inherits;
    var StreamSearch = require_sbmh();
    var PartStream = require_PartStream();
    var HeaderParser = require_HeaderParser();
    var DASH = 45;
    var B_ONEDASH = Buffer.from("-");
    var B_CRLF = Buffer.from("\r\n");
    var EMPTY_FN = /* @__PURE__ */ __name(function() {
    }, "EMPTY_FN");
    function Dicer(cfg) {
      if (!(this instanceof Dicer)) {
        return new Dicer(cfg);
      }
      WritableStream.call(this, cfg);
      if (!cfg || !cfg.headerFirst && typeof cfg.boundary !== "string") {
        throw new TypeError("Boundary required");
      }
      if (typeof cfg.boundary === "string") {
        this.setBoundary(cfg.boundary);
      } else {
        this._bparser = void 0;
      }
      this._headerFirst = cfg.headerFirst;
      this._dashes = 0;
      this._parts = 0;
      this._finished = false;
      this._realFinish = false;
      this._isPreamble = true;
      this._justMatched = false;
      this._firstWrite = true;
      this._inHeader = true;
      this._part = void 0;
      this._cb = void 0;
      this._ignoreData = false;
      this._partOpts = { highWaterMark: cfg.partHwm };
      this._pause = false;
      const self2 = this;
      this._hparser = new HeaderParser(cfg);
      this._hparser.on("header", function(header) {
        self2._inHeader = false;
        self2._part.emit("header", header);
      });
    }
    __name(Dicer, "Dicer");
    inherits(Dicer, WritableStream);
    Dicer.prototype.emit = function(ev) {
      if (ev === "finish" && !this._realFinish) {
        if (!this._finished) {
          const self2 = this;
          process.nextTick(function() {
            self2.emit("error", new Error("Unexpected end of multipart data"));
            if (self2._part && !self2._ignoreData) {
              const type = self2._isPreamble ? "Preamble" : "Part";
              self2._part.emit("error", new Error(type + " terminated early due to unexpected end of multipart data"));
              self2._part.push(null);
              process.nextTick(function() {
                self2._realFinish = true;
                self2.emit("finish");
                self2._realFinish = false;
              });
              return;
            }
            self2._realFinish = true;
            self2.emit("finish");
            self2._realFinish = false;
          });
        }
      } else {
        WritableStream.prototype.emit.apply(this, arguments);
      }
    };
    Dicer.prototype._write = function(data, encoding, cb) {
      if (!this._hparser && !this._bparser) {
        return cb();
      }
      if (this._headerFirst && this._isPreamble) {
        if (!this._part) {
          this._part = new PartStream(this._partOpts);
          if (this._events.preamble) {
            this.emit("preamble", this._part);
          } else {
            this._ignore();
          }
        }
        const r3 = this._hparser.push(data);
        if (!this._inHeader && r3 !== void 0 && r3 < data.length) {
          data = data.slice(r3);
        } else {
          return cb();
        }
      }
      if (this._firstWrite) {
        this._bparser.push(B_CRLF);
        this._firstWrite = false;
      }
      this._bparser.push(data);
      if (this._pause) {
        this._cb = cb;
      } else {
        cb();
      }
    };
    Dicer.prototype.reset = function() {
      this._part = void 0;
      this._bparser = void 0;
      this._hparser = void 0;
    };
    Dicer.prototype.setBoundary = function(boundary) {
      const self2 = this;
      this._bparser = new StreamSearch("\r\n--" + boundary);
      this._bparser.on("info", function(isMatch, data, start, end) {
        self2._oninfo(isMatch, data, start, end);
      });
    };
    Dicer.prototype._ignore = function() {
      if (this._part && !this._ignoreData) {
        this._ignoreData = true;
        this._part.on("error", EMPTY_FN);
        this._part.resume();
      }
    };
    Dicer.prototype._oninfo = function(isMatch, data, start, end) {
      let buf;
      const self2 = this;
      let i = 0;
      let r3;
      let shouldWriteMore = true;
      if (!this._part && this._justMatched && data) {
        while (this._dashes < 2 && start + i < end) {
          if (data[start + i] === DASH) {
            ++i;
            ++this._dashes;
          } else {
            if (this._dashes) {
              buf = B_ONEDASH;
            }
            this._dashes = 0;
            break;
          }
        }
        if (this._dashes === 2) {
          if (start + i < end && this._events.trailer) {
            this.emit("trailer", data.slice(start + i, end));
          }
          this.reset();
          this._finished = true;
          if (self2._parts === 0) {
            self2._realFinish = true;
            self2.emit("finish");
            self2._realFinish = false;
          }
        }
        if (this._dashes) {
          return;
        }
      }
      if (this._justMatched) {
        this._justMatched = false;
      }
      if (!this._part) {
        this._part = new PartStream(this._partOpts);
        this._part._read = function(n2) {
          self2._unpause();
        };
        if (this._isPreamble && this._events.preamble) {
          this.emit("preamble", this._part);
        } else if (this._isPreamble !== true && this._events.part) {
          this.emit("part", this._part);
        } else {
          this._ignore();
        }
        if (!this._isPreamble) {
          this._inHeader = true;
        }
      }
      if (data && start < end && !this._ignoreData) {
        if (this._isPreamble || !this._inHeader) {
          if (buf) {
            shouldWriteMore = this._part.push(buf);
          }
          shouldWriteMore = this._part.push(data.slice(start, end));
          if (!shouldWriteMore) {
            this._pause = true;
          }
        } else if (!this._isPreamble && this._inHeader) {
          if (buf) {
            this._hparser.push(buf);
          }
          r3 = this._hparser.push(data.slice(start, end));
          if (!this._inHeader && r3 !== void 0 && r3 < end) {
            this._oninfo(false, data, start + r3, end);
          }
        }
      }
      if (isMatch) {
        this._hparser.reset();
        if (this._isPreamble) {
          this._isPreamble = false;
        } else {
          if (start !== end) {
            ++this._parts;
            this._part.on("end", function() {
              if (--self2._parts === 0) {
                if (self2._finished) {
                  self2._realFinish = true;
                  self2.emit("finish");
                  self2._realFinish = false;
                } else {
                  self2._unpause();
                }
              }
            });
          }
        }
        this._part.push(null);
        this._part = void 0;
        this._ignoreData = false;
        this._justMatched = true;
        this._dashes = 0;
      }
    };
    Dicer.prototype._unpause = function() {
      if (!this._pause) {
        return;
      }
      this._pause = false;
      if (this._cb) {
        const cb = this._cb;
        this._cb = void 0;
        cb();
      }
    };
    module3.exports = Dicer;
  }
});

// ../../node_modules/.pnpm/@fastify+busboy@2.1.0/node_modules/@fastify/busboy/lib/utils/decodeText.js
var require_decodeText = __commonJS({
  "../../node_modules/.pnpm/@fastify+busboy@2.1.0/node_modules/@fastify/busboy/lib/utils/decodeText.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var utf8Decoder = new TextDecoder("utf-8");
    var textDecoders = /* @__PURE__ */ new Map([
      ["utf-8", utf8Decoder],
      ["utf8", utf8Decoder]
    ]);
    function getDecoder(charset) {
      let lc;
      while (true) {
        switch (charset) {
          case "utf-8":
          case "utf8":
            return decoders.utf8;
          case "latin1":
          case "ascii":
          case "us-ascii":
          case "iso-8859-1":
          case "iso8859-1":
          case "iso88591":
          case "iso_8859-1":
          case "windows-1252":
          case "iso_8859-1:1987":
          case "cp1252":
          case "x-cp1252":
            return decoders.latin1;
          case "utf16le":
          case "utf-16le":
          case "ucs2":
          case "ucs-2":
            return decoders.utf16le;
          case "base64":
            return decoders.base64;
          default:
            if (lc === void 0) {
              lc = true;
              charset = charset.toLowerCase();
              continue;
            }
            return decoders.other.bind(charset);
        }
      }
    }
    __name(getDecoder, "getDecoder");
    var decoders = {
      utf8: (data, sourceEncoding) => {
        if (data.length === 0) {
          return "";
        }
        if (typeof data === "string") {
          data = Buffer.from(data, sourceEncoding);
        }
        return data.utf8Slice(0, data.length);
      },
      latin1: (data, sourceEncoding) => {
        if (data.length === 0) {
          return "";
        }
        if (typeof data === "string") {
          return data;
        }
        return data.latin1Slice(0, data.length);
      },
      utf16le: (data, sourceEncoding) => {
        if (data.length === 0) {
          return "";
        }
        if (typeof data === "string") {
          data = Buffer.from(data, sourceEncoding);
        }
        return data.ucs2Slice(0, data.length);
      },
      base64: (data, sourceEncoding) => {
        if (data.length === 0) {
          return "";
        }
        if (typeof data === "string") {
          data = Buffer.from(data, sourceEncoding);
        }
        return data.base64Slice(0, data.length);
      },
      other: (data, sourceEncoding) => {
        if (data.length === 0) {
          return "";
        }
        if (typeof data === "string") {
          data = Buffer.from(data, sourceEncoding);
        }
        if (textDecoders.has(exports2.toString())) {
          try {
            return textDecoders.get(exports2).decode(data);
          } catch (e3) {
          }
        }
        return typeof data === "string" ? data : data.toString();
      }
    };
    function decodeText(text, sourceEncoding, destEncoding) {
      if (text) {
        return getDecoder(destEncoding)(text, sourceEncoding);
      }
      return text;
    }
    __name(decodeText, "decodeText");
    module3.exports = decodeText;
  }
});

// ../../node_modules/.pnpm/@fastify+busboy@2.1.0/node_modules/@fastify/busboy/lib/utils/parseParams.js
var require_parseParams = __commonJS({
  "../../node_modules/.pnpm/@fastify+busboy@2.1.0/node_modules/@fastify/busboy/lib/utils/parseParams.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var decodeText = require_decodeText();
    var RE_ENCODED = /%[a-fA-F0-9][a-fA-F0-9]/g;
    var EncodedLookup = {
      "%00": "\0",
      "%01": "
",
      "%02": "",
      "%03": "",
      "%04": "",
      "%05": "",
      "%06": "",
      "%07": "\x07",
      "%08": "\b",
      "%09": "	",
      "%0a": "\n",
      "%0A": "\n",
      "%0b": "\v",
      "%0B": "\v",
      "%0c": "\f",
      "%0C": "\f",
      "%0d": "\r",
      "%0D": "\r",
      "%0e": "",
      "%0E": "",
      "%0f": "",
      "%0F": "",
      "%10": "",
      "%11": "",
      "%12": "",
      "%13": "",
      "%14": "",
      "%15": "",
      "%16": "",
      "%17": "",
      "%18": "",
      "%19": "",
      "%1a": "",
      "%1A": "",
      "%1b": "\x1B",
      "%1B": "\x1B",
      "%1c": "",
      "%1C": "",
      "%1d": "",
      "%1D": "",
      "%1e": "",
      "%1E": "",
      "%1f": "",
      "%1F": "",
      "%20": " ",
      "%21": "!",
      "%22": '"',
      "%23": "#",
      "%24": "$",
      "%25": "%",
      "%26": "&",
      "%27": "'",
      "%28": "(",
      "%29": ")",
      "%2a": "*",
      "%2A": "*",
      "%2b": "+",
      "%2B": "+",
      "%2c": ",",
      "%2C": ",",
      "%2d": "-",
      "%2D": "-",
      "%2e": ".",
      "%2E": ".",
      "%2f": "/",
      "%2F": "/",
      "%30": "0",
      "%31": "1",
      "%32": "2",
      "%33": "3",
      "%34": "4",
      "%35": "5",
      "%36": "6",
      "%37": "7",
      "%38": "8",
      "%39": "9",
      "%3a": ":",
      "%3A": ":",
      "%3b": ";",
      "%3B": ";",
      "%3c": "<",
      "%3C": "<",
      "%3d": "=",
      "%3D": "=",
      "%3e": ">",
      "%3E": ">",
      "%3f": "?",
      "%3F": "?",
      "%40": "@",
      "%41": "A",
      "%42": "B",
      "%43": "C",
      "%44": "D",
      "%45": "E",
      "%46": "F",
      "%47": "G",
      "%48": "H",
      "%49": "I",
      "%4a": "J",
      "%4A": "J",
      "%4b": "K",
      "%4B": "K",
      "%4c": "L",
      "%4C": "L",
      "%4d": "M",
      "%4D": "M",
      "%4e": "N",
      "%4E": "N",
      "%4f": "O",
      "%4F": "O",
      "%50": "P",
      "%51": "Q",
      "%52": "R",
      "%53": "S",
      "%54": "T",
      "%55": "U",
      "%56": "V",
      "%57": "W",
      "%58": "X",
      "%59": "Y",
      "%5a": "Z",
      "%5A": "Z",
      "%5b": "[",
      "%5B": "[",
      "%5c": "\\",
      "%5C": "\\",
      "%5d": "]",
      "%5D": "]",
      "%5e": "^",
      "%5E": "^",
      "%5f": "_",
      "%5F": "_",
      "%60": "`",
      "%61": "a",
      "%62": "b",
      "%63": "c",
      "%64": "d",
      "%65": "e",
      "%66": "f",
      "%67": "g",
      "%68": "h",
      "%69": "i",
      "%6a": "j",
      "%6A": "j",
      "%6b": "k",
      "%6B": "k",
      "%6c": "l",
      "%6C": "l",
      "%6d": "m",
      "%6D": "m",
      "%6e": "n",
      "%6E": "n",
      "%6f": "o",
      "%6F": "o",
      "%70": "p",
      "%71": "q",
      "%72": "r",
      "%73": "s",
      "%74": "t",
      "%75": "u",
      "%76": "v",
      "%77": "w",
      "%78": "x",
      "%79": "y",
      "%7a": "z",
      "%7A": "z",
      "%7b": "{",
      "%7B": "{",
      "%7c": "|",
      "%7C": "|",
      "%7d": "}",
      "%7D": "}",
      "%7e": "~",
      "%7E": "~",
      "%7f": "\x7F",
      "%7F": "\x7F",
      "%80": "\x80",
      "%81": "\x81",
      "%82": "\x82",
      "%83": "\x83",
      "%84": "\x84",
      "%85": "\x85",
      "%86": "\x86",
      "%87": "\x87",
      "%88": "\x88",
      "%89": "\x89",
      "%8a": "\x8A",
      "%8A": "\x8A",
      "%8b": "\x8B",
      "%8B": "\x8B",
      "%8c": "\x8C",
      "%8C": "\x8C",
      "%8d": "\x8D",
      "%8D": "\x8D",
      "%8e": "\x8E",
      "%8E": "\x8E",
      "%8f": "\x8F",
      "%8F": "\x8F",
      "%90": "\x90",
      "%91": "\x91",
      "%92": "\x92",
      "%93": "\x93",
      "%94": "\x94",
      "%95": "\x95",
      "%96": "\x96",
      "%97": "\x97",
      "%98": "\x98",
      "%99": "\x99",
      "%9a": "\x9A",
      "%9A": "\x9A",
      "%9b": "\x9B",
      "%9B": "\x9B",
      "%9c": "\x9C",
      "%9C": "\x9C",
      "%9d": "\x9D",
      "%9D": "\x9D",
      "%9e": "\x9E",
      "%9E": "\x9E",
      "%9f": "\x9F",
      "%9F": "\x9F",
      "%a0": "\xA0",
      "%A0": "\xA0",
      "%a1": "\xA1",
      "%A1": "\xA1",
      "%a2": "\xA2",
      "%A2": "\xA2",
      "%a3": "\xA3",
      "%A3": "\xA3",
      "%a4": "\xA4",
      "%A4": "\xA4",
      "%a5": "\xA5",
      "%A5": "\xA5",
      "%a6": "\xA6",
      "%A6": "\xA6",
      "%a7": "\xA7",
      "%A7": "\xA7",
      "%a8": "\xA8",
      "%A8": "\xA8",
      "%a9": "\xA9",
      "%A9": "\xA9",
      "%aa": "\xAA",
      "%Aa": "\xAA",
      "%aA": "\xAA",
      "%AA": "\xAA",
      "%ab": "\xAB",
      "%Ab": "\xAB",
      "%aB": "\xAB",
      "%AB": "\xAB",
      "%ac": "\xAC",
      "%Ac": "\xAC",
      "%aC": "\xAC",
      "%AC": "\xAC",
      "%ad": "\xAD",
      "%Ad": "\xAD",
      "%aD": "\xAD",
      "%AD": "\xAD",
      "%ae": "\xAE",
      "%Ae": "\xAE",
      "%aE": "\xAE",
      "%AE": "\xAE",
      "%af": "\xAF",
      "%Af": "\xAF",
      "%aF": "\xAF",
      "%AF": "\xAF",
      "%b0": "\xB0",
      "%B0": "\xB0",
      "%b1": "\xB1",
      "%B1": "\xB1",
      "%b2": "\xB2",
      "%B2": "\xB2",
      "%b3": "\xB3",
      "%B3": "\xB3",
      "%b4": "\xB4",
      "%B4": "\xB4",
      "%b5": "\xB5",
      "%B5": "\xB5",
      "%b6": "\xB6",
      "%B6": "\xB6",
      "%b7": "\xB7",
      "%B7": "\xB7",
      "%b8": "\xB8",
      "%B8": "\xB8",
      "%b9": "\xB9",
      "%B9": "\xB9",
      "%ba": "\xBA",
      "%Ba": "\xBA",
      "%bA": "\xBA",
      "%BA": "\xBA",
      "%bb": "\xBB",
      "%Bb": "\xBB",
      "%bB": "\xBB",
      "%BB": "\xBB",
      "%bc": "\xBC",
      "%Bc": "\xBC",
      "%bC": "\xBC",
      "%BC": "\xBC",
      "%bd": "\xBD",
      "%Bd": "\xBD",
      "%bD": "\xBD",
      "%BD": "\xBD",
      "%be": "\xBE",
      "%Be": "\xBE",
      "%bE": "\xBE",
      "%BE": "\xBE",
      "%bf": "\xBF",
      "%Bf": "\xBF",
      "%bF": "\xBF",
      "%BF": "\xBF",
      "%c0": "\xC0",
      "%C0": "\xC0",
      "%c1": "\xC1",
      "%C1": "\xC1",
      "%c2": "\xC2",
      "%C2": "\xC2",
      "%c3": "\xC3",
      "%C3": "\xC3",
      "%c4": "\xC4",
      "%C4": "\xC4",
      "%c5": "\xC5",
      "%C5": "\xC5",
      "%c6": "\xC6",
      "%C6": "\xC6",
      "%c7": "\xC7",
      "%C7": "\xC7",
      "%c8": "\xC8",
      "%C8": "\xC8",
      "%c9": "\xC9",
      "%C9": "\xC9",
      "%ca": "\xCA",
      "%Ca": "\xCA",
      "%cA": "\xCA",
      "%CA": "\xCA",
      "%cb": "\xCB",
      "%Cb": "\xCB",
      "%cB": "\xCB",
      "%CB": "\xCB",
      "%cc": "\xCC",
      "%Cc": "\xCC",
      "%cC": "\xCC",
      "%CC": "\xCC",
      "%cd": "\xCD",
      "%Cd": "\xCD",
      "%cD": "\xCD",
      "%CD": "\xCD",
      "%ce": "\xCE",
      "%Ce": "\xCE",
      "%cE": "\xCE",
      "%CE": "\xCE",
      "%cf": "\xCF",
      "%Cf": "\xCF",
      "%cF": "\xCF",
      "%CF": "\xCF",
      "%d0": "\xD0",
      "%D0": "\xD0",
      "%d1": "\xD1",
      "%D1": "\xD1",
      "%d2": "\xD2",
      "%D2": "\xD2",
      "%d3": "\xD3",
      "%D3": "\xD3",
      "%d4": "\xD4",
      "%D4": "\xD4",
      "%d5": "\xD5",
      "%D5": "\xD5",
      "%d6": "\xD6",
      "%D6": "\xD6",
      "%d7": "\xD7",
      "%D7": "\xD7",
      "%d8": "\xD8",
      "%D8": "\xD8",
      "%d9": "\xD9",
      "%D9": "\xD9",
      "%da": "\xDA",
      "%Da": "\xDA",
      "%dA": "\xDA",
      "%DA": "\xDA",
      "%db": "\xDB",
      "%Db": "\xDB",
      "%dB": "\xDB",
      "%DB": "\xDB",
      "%dc": "\xDC",
      "%Dc": "\xDC",
      "%dC": "\xDC",
      "%DC": "\xDC",
      "%dd": "\xDD",
      "%Dd": "\xDD",
      "%dD": "\xDD",
      "%DD": "\xDD",
      "%de": "\xDE",
      "%De": "\xDE",
      "%dE": "\xDE",
      "%DE": "\xDE",
      "%df": "\xDF",
      "%Df": "\xDF",
      "%dF": "\xDF",
      "%DF": "\xDF",
      "%e0": "\xE0",
      "%E0": "\xE0",
      "%e1": "\xE1",
      "%E1": "\xE1",
      "%e2": "\xE2",
      "%E2": "\xE2",
      "%e3": "\xE3",
      "%E3": "\xE3",
      "%e4": "\xE4",
      "%E4": "\xE4",
      "%e5": "\xE5",
      "%E5": "\xE5",
      "%e6": "\xE6",
      "%E6": "\xE6",
      "%e7": "\xE7",
      "%E7": "\xE7",
      "%e8": "\xE8",
      "%E8": "\xE8",
      "%e9": "\xE9",
      "%E9": "\xE9",
      "%ea": "\xEA",
      "%Ea": "\xEA",
      "%eA": "\xEA",
      "%EA": "\xEA",
      "%eb": "\xEB",
      "%Eb": "\xEB",
      "%eB": "\xEB",
      "%EB": "\xEB",
      "%ec": "\xEC",
      "%Ec": "\xEC",
      "%eC": "\xEC",
      "%EC": "\xEC",
      "%ed": "\xED",
      "%Ed": "\xED",
      "%eD": "\xED",
      "%ED": "\xED",
      "%ee": "\xEE",
      "%Ee": "\xEE",
      "%eE": "\xEE",
      "%EE": "\xEE",
      "%ef": "\xEF",
      "%Ef": "\xEF",
      "%eF": "\xEF",
      "%EF": "\xEF",
      "%f0": "\xF0",
      "%F0": "\xF0",
      "%f1": "\xF1",
      "%F1": "\xF1",
      "%f2": "\xF2",
      "%F2": "\xF2",
      "%f3": "\xF3",
      "%F3": "\xF3",
      "%f4": "\xF4",
      "%F4": "\xF4",
      "%f5": "\xF5",
      "%F5": "\xF5",
      "%f6": "\xF6",
      "%F6": "\xF6",
      "%f7": "\xF7",
      "%F7": "\xF7",
      "%f8": "\xF8",
      "%F8": "\xF8",
      "%f9": "\xF9",
      "%F9": "\xF9",
      "%fa": "\xFA",
      "%Fa": "\xFA",
      "%fA": "\xFA",
      "%FA": "\xFA",
      "%fb": "\xFB",
      "%Fb": "\xFB",
      "%fB": "\xFB",
      "%FB": "\xFB",
      "%fc": "\xFC",
      "%Fc": "\xFC",
      "%fC": "\xFC",
      "%FC": "\xFC",
      "%fd": "\xFD",
      "%Fd": "\xFD",
      "%fD": "\xFD",
      "%FD": "\xFD",
      "%fe": "\xFE",
      "%Fe": "\xFE",
      "%fE": "\xFE",
      "%FE": "\xFE",
      "%ff": "\xFF",
      "%Ff": "\xFF",
      "%fF": "\xFF",
      "%FF": "\xFF"
    };
    function encodedReplacer(match) {
      return EncodedLookup[match];
    }
    __name(encodedReplacer, "encodedReplacer");
    var STATE_KEY = 0;
    var STATE_VALUE = 1;
    var STATE_CHARSET = 2;
    var STATE_LANG = 3;
    function parseParams(str) {
      const res = [];
      let state = STATE_KEY;
      let charset = "";
      let inquote = false;
      let escaping = false;
      let p2 = 0;
      let tmp = "";
      const len = str.length;
      for (var i = 0; i < len; ++i) {
        const char = str[i];
        if (char === "\\" && inquote) {
          if (escaping) {
            escaping = false;
          } else {
            escaping = true;
            continue;
          }
        } else if (char === '"') {
          if (!escaping) {
            if (inquote) {
              inquote = false;
              state = STATE_KEY;
            } else {
              inquote = true;
            }
            continue;
          } else {
            escaping = false;
          }
        } else {
          if (escaping && inquote) {
            tmp += "\\";
          }
          escaping = false;
          if ((state === STATE_CHARSET || state === STATE_LANG) && char === "'") {
            if (state === STATE_CHARSET) {
              state = STATE_LANG;
              charset = tmp.substring(1);
            } else {
              state = STATE_VALUE;
            }
            tmp = "";
            continue;
          } else if (state === STATE_KEY && (char === "*" || char === "=") && res.length) {
            state = char === "*" ? STATE_CHARSET : STATE_VALUE;
            res[p2] = [tmp, void 0];
            tmp = "";
            continue;
          } else if (!inquote && char === ";") {
            state = STATE_KEY;
            if (charset) {
              if (tmp.length) {
                tmp = decodeText(
                  tmp.replace(RE_ENCODED, encodedReplacer),
                  "binary",
                  charset
                );
              }
              charset = "";
            } else if (tmp.length) {
              tmp = decodeText(tmp, "binary", "utf8");
            }
            if (res[p2] === void 0) {
              res[p2] = tmp;
            } else {
              res[p2][1] = tmp;
            }
            tmp = "";
            ++p2;
            continue;
          } else if (!inquote && (char === " " || char === "	")) {
            continue;
          }
        }
        tmp += char;
      }
      if (charset && tmp.length) {
        tmp = decodeText(
          tmp.replace(RE_ENCODED, encodedReplacer),
          "binary",
          charset
        );
      } else if (tmp) {
        tmp = decodeText(tmp, "binary", "utf8");
      }
      if (res[p2] === void 0) {
        if (tmp) {
          res[p2] = tmp;
        }
      } else {
        res[p2][1] = tmp;
      }
      return res;
    }
    __name(parseParams, "parseParams");
    module3.exports = parseParams;
  }
});

// ../../node_modules/.pnpm/@fastify+busboy@2.1.0/node_modules/@fastify/busboy/lib/utils/basename.js
var require_basename = __commonJS({
  "../../node_modules/.pnpm/@fastify+busboy@2.1.0/node_modules/@fastify/busboy/lib/utils/basename.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function basename4(path67) {
      if (typeof path67 !== "string") {
        return "";
      }
      for (var i = path67.length - 1; i >= 0; --i) {
        switch (path67.charCodeAt(i)) {
          case 47:
          case 92:
            path67 = path67.slice(i + 1);
            return path67 === ".." || path67 === "." ? "" : path67;
        }
      }
      return path67 === ".." || path67 === "." ? "" : path67;
    }, "basename");
  }
});

// ../../node_modules/.pnpm/@fastify+busboy@2.1.0/node_modules/@fastify/busboy/lib/types/multipart.js
var require_multipart = __commonJS({
  "../../node_modules/.pnpm/@fastify+busboy@2.1.0/node_modules/@fastify/busboy/lib/types/multipart.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { Readable: Readable2 } = require("node:stream");
    var { inherits } = require("node:util");
    var Dicer = require_Dicer();
    var parseParams = require_parseParams();
    var decodeText = require_decodeText();
    var basename4 = require_basename();
    var getLimit = require_getLimit();
    var RE_BOUNDARY = /^boundary$/i;
    var RE_FIELD = /^form-data$/i;
    var RE_CHARSET = /^charset$/i;
    var RE_FILENAME = /^filename$/i;
    var RE_NAME = /^name$/i;
    Multipart.detect = /^multipart\/form-data/i;
    function Multipart(boy, cfg) {
      let i;
      let len;
      const self2 = this;
      let boundary;
      const limits = cfg.limits;
      const isPartAFile = cfg.isPartAFile || ((fieldName, contentType, fileName) => contentType === "application/octet-stream" || fileName !== void 0);
      const parsedConType = cfg.parsedConType || [];
      const defCharset = cfg.defCharset || "utf8";
      const preservePath = cfg.preservePath;
      const fileOpts = { highWaterMark: cfg.fileHwm };
      for (i = 0, len = parsedConType.length; i < len; ++i) {
        if (Array.isArray(parsedConType[i]) && RE_BOUNDARY.test(parsedConType[i][0])) {
          boundary = parsedConType[i][1];
          break;
        }
      }
      function checkFinished() {
        if (nends === 0 && finished && !boy._done) {
          finished = false;
          self2.end();
        }
      }
      __name(checkFinished, "checkFinished");
      if (typeof boundary !== "string") {
        throw new Error("Multipart: Boundary not found");
      }
      const fieldSizeLimit = getLimit(limits, "fieldSize", 1 * 1024 * 1024);
      const fileSizeLimit = getLimit(limits, "fileSize", Infinity);
      const filesLimit = getLimit(limits, "files", Infinity);
      const fieldsLimit = getLimit(limits, "fields", Infinity);
      const partsLimit = getLimit(limits, "parts", Infinity);
      const headerPairsLimit = getLimit(limits, "headerPairs", 2e3);
      const headerSizeLimit = getLimit(limits, "headerSize", 80 * 1024);
      let nfiles = 0;
      let nfields = 0;
      let nends = 0;
      let curFile;
      let curField;
      let finished = false;
      this._needDrain = false;
      this._pause = false;
      this._cb = void 0;
      this._nparts = 0;
      this._boy = boy;
      const parserCfg = {
        boundary,
        maxHeaderPairs: headerPairsLimit,
        maxHeaderSize: headerSizeLimit,
        partHwm: fileOpts.highWaterMark,
        highWaterMark: cfg.highWaterMark
      };
      this.parser = new Dicer(parserCfg);
      this.parser.on("drain", function() {
        self2._needDrain = false;
        if (self2._cb && !self2._pause) {
          const cb = self2._cb;
          self2._cb = void 0;
          cb();
        }
      }).on("part", /* @__PURE__ */ __name(function onPart(part) {
        if (++self2._nparts > partsLimit) {
          self2.parser.removeListener("part", onPart);
          self2.parser.on("part", skipPart);
          boy.hitPartsLimit = true;
          boy.emit("partsLimit");
          return skipPart(part);
        }
        if (curField) {
          const field = curField;
          field.emit("end");
          field.removeAllListeners("end");
        }
        part.on("header", function(header) {
          let contype;
          let fieldname;
          let parsed;
          let charset;
          let encoding;
          let filename;
          let nsize = 0;
          if (header["content-type"]) {
            parsed = parseParams(header["content-type"][0]);
            if (parsed[0]) {
              contype = parsed[0].toLowerCase();
              for (i = 0, len = parsed.length; i < len; ++i) {
                if (RE_CHARSET.test(parsed[i][0])) {
                  charset = parsed[i][1].toLowerCase();
                  break;
                }
              }
            }
          }
          if (contype === void 0) {
            contype = "text/plain";
          }
          if (charset === void 0) {
            charset = defCharset;
          }
          if (header["content-disposition"]) {
            parsed = parseParams(header["content-disposition"][0]);
            if (!RE_FIELD.test(parsed[0])) {
              return skipPart(part);
            }
            for (i = 0, len = parsed.length; i < len; ++i) {
              if (RE_NAME.test(parsed[i][0])) {
                fieldname = parsed[i][1];
              } else if (RE_FILENAME.test(parsed[i][0])) {
                filename = parsed[i][1];
                if (!preservePath) {
                  filename = basename4(filename);
                }
              }
            }
          } else {
            return skipPart(part);
          }
          if (header["content-transfer-encoding"]) {
            encoding = header["content-transfer-encoding"][0].toLowerCase();
          } else {
            encoding = "7bit";
          }
          let onData, onEnd;
          if (isPartAFile(fieldname, contype, filename)) {
            if (nfiles === filesLimit) {
              if (!boy.hitFilesLimit) {
                boy.hitFilesLimit = true;
                boy.emit("filesLimit");
              }
              return skipPart(part);
            }
            ++nfiles;
            if (!boy._events.file) {
              self2.parser._ignore();
              return;
            }
            ++nends;
            const file = new FileStream(fileOpts);
            curFile = file;
            file.on("end", function() {
              --nends;
              self2._pause = false;
              checkFinished();
              if (self2._cb && !self2._needDrain) {
                const cb = self2._cb;
                self2._cb = void 0;
                cb();
              }
            });
            file._read = function(n2) {
              if (!self2._pause) {
                return;
              }
              self2._pause = false;
              if (self2._cb && !self2._needDrain) {
                const cb = self2._cb;
                self2._cb = void 0;
                cb();
              }
            };
            boy.emit("file", fieldname, file, filename, encoding, contype);
            onData = /* @__PURE__ */ __name(function(data) {
              if ((nsize += data.length) > fileSizeLimit) {
                const extralen = fileSizeLimit - nsize + data.length;
                if (extralen > 0) {
                  file.push(data.slice(0, extralen));
                }
                file.truncated = true;
                file.bytesRead = fileSizeLimit;
                part.removeAllListeners("data");
                file.emit("limit");
                return;
              } else if (!file.push(data)) {
                self2._pause = true;
              }
              file.bytesRead = nsize;
            }, "onData");
            onEnd = /* @__PURE__ */ __name(function() {
              curFile = void 0;
              file.push(null);
            }, "onEnd");
          } else {
            if (nfields === fieldsLimit) {
              if (!boy.hitFieldsLimit) {
                boy.hitFieldsLimit = true;
                boy.emit("fieldsLimit");
              }
              return skipPart(part);
            }
            ++nfields;
            ++nends;
            let buffer = "";
            let truncated = false;
            curField = part;
            onData = /* @__PURE__ */ __name(function(data) {
              if ((nsize += data.length) > fieldSizeLimit) {
                const extralen = fieldSizeLimit - (nsize - data.length);
                buffer += data.toString("binary", 0, extralen);
                truncated = true;
                part.removeAllListeners("data");
              } else {
                buffer += data.toString("binary");
              }
            }, "onData");
            onEnd = /* @__PURE__ */ __name(function() {
              curField = void 0;
              if (buffer.length) {
                buffer = decodeText(buffer, "binary", charset);
              }
              boy.emit("field", fieldname, buffer, false, truncated, encoding, contype);
              --nends;
              checkFinished();
            }, "onEnd");
          }
          part._readableState.sync = false;
          part.on("data", onData);
          part.on("end", onEnd);
        }).on("error", function(err) {
          if (curFile) {
            curFile.emit("error", err);
          }
        });
      }, "onPart")).on("error", function(err) {
        boy.emit("error", err);
      }).on("finish", function() {
        finished = true;
        checkFinished();
      });
    }
    __name(Multipart, "Multipart");
    Multipart.prototype.write = function(chunk, cb) {
      const r3 = this.parser.write(chunk);
      if (r3 && !this._pause) {
        cb();
      } else {
        this._needDrain = !r3;
        this._cb = cb;
      }
    };
    Multipart.prototype.end = function() {
      const self2 = this;
      if (self2.parser.writable) {
        self2.parser.end();
      } else if (!self2._boy._done) {
        process.nextTick(function() {
          self2._boy._done = true;
          self2._boy.emit("finish");
        });
      }
    };
    function skipPart(part) {
      part.resume();
    }
    __name(skipPart, "skipPart");
    function FileStream(opts) {
      Readable2.call(this, opts);
      this.bytesRead = 0;
      this.truncated = false;
    }
    __name(FileStream, "FileStream");
    inherits(FileStream, Readable2);
    FileStream.prototype._read = function(n2) {
    };
    module3.exports = Multipart;
  }
});

// ../../node_modules/.pnpm/@fastify+busboy@2.1.0/node_modules/@fastify/busboy/lib/utils/Decoder.js
var require_Decoder = __commonJS({
  "../../node_modules/.pnpm/@fastify+busboy@2.1.0/node_modules/@fastify/busboy/lib/utils/Decoder.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var RE_PLUS = /\+/g;
    var HEX = [
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0
    ];
    function Decoder() {
      this.buffer = void 0;
    }
    __name(Decoder, "Decoder");
    Decoder.prototype.write = function(str) {
      str = str.replace(RE_PLUS, " ");
      let res = "";
      let i = 0;
      let p2 = 0;
      const len = str.length;
      for (; i < len; ++i) {
        if (this.buffer !== void 0) {
          if (!HEX[str.charCodeAt(i)]) {
            res += "%" + this.buffer;
            this.buffer = void 0;
            --i;
          } else {
            this.buffer += str[i];
            ++p2;
            if (this.buffer.length === 2) {
              res += String.fromCharCode(parseInt(this.buffer, 16));
              this.buffer = void 0;
            }
          }
        } else if (str[i] === "%") {
          if (i > p2) {
            res += str.substring(p2, i);
            p2 = i;
          }
          this.buffer = "";
          ++p2;
        }
      }
      if (p2 < len && this.buffer === void 0) {
        res += str.substring(p2);
      }
      return res;
    };
    Decoder.prototype.reset = function() {
      this.buffer = void 0;
    };
    module3.exports = Decoder;
  }
});

// ../../node_modules/.pnpm/@fastify+busboy@2.1.0/node_modules/@fastify/busboy/lib/types/urlencoded.js
var require_urlencoded = __commonJS({
  "../../node_modules/.pnpm/@fastify+busboy@2.1.0/node_modules/@fastify/busboy/lib/types/urlencoded.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var Decoder = require_Decoder();
    var decodeText = require_decodeText();
    var getLimit = require_getLimit();
    var RE_CHARSET = /^charset$/i;
    UrlEncoded.detect = /^application\/x-www-form-urlencoded/i;
    function UrlEncoded(boy, cfg) {
      const limits = cfg.limits;
      const parsedConType = cfg.parsedConType;
      this.boy = boy;
      this.fieldSizeLimit = getLimit(limits, "fieldSize", 1 * 1024 * 1024);
      this.fieldNameSizeLimit = getLimit(limits, "fieldNameSize", 100);
      this.fieldsLimit = getLimit(limits, "fields", Infinity);
      let charset;
      for (var i = 0, len = parsedConType.length; i < len; ++i) {
        if (Array.isArray(parsedConType[i]) && RE_CHARSET.test(parsedConType[i][0])) {
          charset = parsedConType[i][1].toLowerCase();
          break;
        }
      }
      if (charset === void 0) {
        charset = cfg.defCharset || "utf8";
      }
      this.decoder = new Decoder();
      this.charset = charset;
      this._fields = 0;
      this._state = "key";
      this._checkingBytes = true;
      this._bytesKey = 0;
      this._bytesVal = 0;
      this._key = "";
      this._val = "";
      this._keyTrunc = false;
      this._valTrunc = false;
      this._hitLimit = false;
    }
    __name(UrlEncoded, "UrlEncoded");
    UrlEncoded.prototype.write = function(data, cb) {
      if (this._fields === this.fieldsLimit) {
        if (!this.boy.hitFieldsLimit) {
          this.boy.hitFieldsLimit = true;
          this.boy.emit("fieldsLimit");
        }
        return cb();
      }
      let idxeq;
      let idxamp;
      let i;
      let p2 = 0;
      const len = data.length;
      while (p2 < len) {
        if (this._state === "key") {
          idxeq = idxamp = void 0;
          for (i = p2; i < len; ++i) {
            if (!this._checkingBytes) {
              ++p2;
            }
            if (data[i] === 61) {
              idxeq = i;
              break;
            } else if (data[i] === 38) {
              idxamp = i;
              break;
            }
            if (this._checkingBytes && this._bytesKey === this.fieldNameSizeLimit) {
              this._hitLimit = true;
              break;
            } else if (this._checkingBytes) {
              ++this._bytesKey;
            }
          }
          if (idxeq !== void 0) {
            if (idxeq > p2) {
              this._key += this.decoder.write(data.toString("binary", p2, idxeq));
            }
            this._state = "val";
            this._hitLimit = false;
            this._checkingBytes = true;
            this._val = "";
            this._bytesVal = 0;
            this._valTrunc = false;
            this.decoder.reset();
            p2 = idxeq + 1;
          } else if (idxamp !== void 0) {
            ++this._fields;
            let key;
            const keyTrunc = this._keyTrunc;
            if (idxamp > p2) {
              key = this._key += this.decoder.write(data.toString("binary", p2, idxamp));
            } else {
              key = this._key;
            }
            this._hitLimit = false;
            this._checkingBytes = true;
            this._key = "";
            this._bytesKey = 0;
            this._keyTrunc = false;
            this.decoder.reset();
            if (key.length) {
              this.boy.emit(
                "field",
                decodeText(key, "binary", this.charset),
                "",
                keyTrunc,
                false
              );
            }
            p2 = idxamp + 1;
            if (this._fields === this.fieldsLimit) {
              return cb();
            }
          } else if (this._hitLimit) {
            if (i > p2) {
              this._key += this.decoder.write(data.toString("binary", p2, i));
            }
            p2 = i;
            if ((this._bytesKey = this._key.length) === this.fieldNameSizeLimit) {
              this._checkingBytes = false;
              this._keyTrunc = true;
            }
          } else {
            if (p2 < len) {
              this._key += this.decoder.write(data.toString("binary", p2));
            }
            p2 = len;
          }
        } else {
          idxamp = void 0;
          for (i = p2; i < len; ++i) {
            if (!this._checkingBytes) {
              ++p2;
            }
            if (data[i] === 38) {
              idxamp = i;
              break;
            }
            if (this._checkingBytes && this._bytesVal === this.fieldSizeLimit) {
              this._hitLimit = true;
              break;
            } else if (this._checkingBytes) {
              ++this._bytesVal;
            }
          }
          if (idxamp !== void 0) {
            ++this._fields;
            if (idxamp > p2) {
              this._val += this.decoder.write(data.toString("binary", p2, idxamp));
            }
            this.boy.emit(
              "field",
              decodeText(this._key, "binary", this.charset),
              decodeText(this._val, "binary", this.charset),
              this._keyTrunc,
              this._valTrunc
            );
            this._state = "key";
            this._hitLimit = false;
            this._checkingBytes = true;
            this._key = "";
            this._bytesKey = 0;
            this._keyTrunc = false;
            this.decoder.reset();
            p2 = idxamp + 1;
            if (this._fields === this.fieldsLimit) {
              return cb();
            }
          } else if (this._hitLimit) {
            if (i > p2) {
              this._val += this.decoder.write(data.toString("binary", p2, i));
            }
            p2 = i;
            if (this._val === "" && this.fieldSizeLimit === 0 || (this._bytesVal = this._val.length) === this.fieldSizeLimit) {
              this._checkingBytes = false;
              this._valTrunc = true;
            }
          } else {
            if (p2 < len) {
              this._val += this.decoder.write(data.toString("binary", p2));
            }
            p2 = len;
          }
        }
      }
      cb();
    };
    UrlEncoded.prototype.end = function() {
      if (this.boy._done) {
        return;
      }
      if (this._state === "key" && this._key.length > 0) {
        this.boy.emit(
          "field",
          decodeText(this._key, "binary", this.charset),
          "",
          this._keyTrunc,
          false
        );
      } else if (this._state === "val") {
        this.boy.emit(
          "field",
          decodeText(this._key, "binary", this.charset),
          decodeText(this._val, "binary", this.charset),
          this._keyTrunc,
          this._valTrunc
        );
      }
      this.boy._done = true;
      this.boy.emit("finish");
    };
    module3.exports = UrlEncoded;
  }
});

// ../../node_modules/.pnpm/@fastify+busboy@2.1.0/node_modules/@fastify/busboy/lib/main.js
var require_main = __commonJS({
  "../../node_modules/.pnpm/@fastify+busboy@2.1.0/node_modules/@fastify/busboy/lib/main.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var WritableStream = require("node:stream").Writable;
    var { inherits } = require("node:util");
    var Dicer = require_Dicer();
    var MultipartParser = require_multipart();
    var UrlencodedParser = require_urlencoded();
    var parseParams = require_parseParams();
    function Busboy(opts) {
      if (!(this instanceof Busboy)) {
        return new Busboy(opts);
      }
      if (typeof opts !== "object") {
        throw new TypeError("Busboy expected an options-Object.");
      }
      if (typeof opts.headers !== "object") {
        throw new TypeError("Busboy expected an options-Object with headers-attribute.");
      }
      if (typeof opts.headers["content-type"] !== "string") {
        throw new TypeError("Missing Content-Type-header.");
      }
      const {
        headers,
        ...streamOptions
      } = opts;
      this.opts = {
        autoDestroy: false,
        ...streamOptions
      };
      WritableStream.call(this, this.opts);
      this._done = false;
      this._parser = this.getParserByHeaders(headers);
      this._finished = false;
    }
    __name(Busboy, "Busboy");
    inherits(Busboy, WritableStream);
    Busboy.prototype.emit = function(ev) {
      if (ev === "finish") {
        if (!this._done) {
          this._parser?.end();
          return;
        } else if (this._finished) {
          return;
        }
        this._finished = true;
      }
      WritableStream.prototype.emit.apply(this, arguments);
    };
    Busboy.prototype.getParserByHeaders = function(headers) {
      const parsed = parseParams(headers["content-type"]);
      const cfg = {
        defCharset: this.opts.defCharset,
        fileHwm: this.opts.fileHwm,
        headers,
        highWaterMark: this.opts.highWaterMark,
        isPartAFile: this.opts.isPartAFile,
        limits: this.opts.limits,
        parsedConType: parsed,
        preservePath: this.opts.preservePath
      };
      if (MultipartParser.detect.test(parsed[0])) {
        return new MultipartParser(this, cfg);
      }
      if (UrlencodedParser.detect.test(parsed[0])) {
        return new UrlencodedParser(this, cfg);
      }
      throw new Error("Unsupported Content-Type.");
    };
    Busboy.prototype._write = function(chunk, encoding, cb) {
      this._parser.write(chunk, cb);
    };
    module3.exports = Busboy;
    module3.exports.default = Busboy;
    module3.exports.Busboy = Busboy;
    module3.exports.Dicer = Dicer;
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/constants.js
var require_constants = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/constants.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { MessageChannel: MessageChannel2, receiveMessageOnPort } = require("worker_threads");
    var corsSafeListedMethods = ["GET", "HEAD", "POST"];
    var corsSafeListedMethodsSet = new Set(corsSafeListedMethods);
    var nullBodyStatus = [101, 204, 205, 304];
    var redirectStatus = [301, 302, 303, 307, 308];
    var redirectStatusSet = new Set(redirectStatus);
    var badPorts = [
      "1",
      "7",
      "9",
      "11",
      "13",
      "15",
      "17",
      "19",
      "20",
      "21",
      "22",
      "23",
      "25",
      "37",
      "42",
      "43",
      "53",
      "69",
      "77",
      "79",
      "87",
      "95",
      "101",
      "102",
      "103",
      "104",
      "109",
      "110",
      "111",
      "113",
      "115",
      "117",
      "119",
      "123",
      "135",
      "137",
      "139",
      "143",
      "161",
      "179",
      "389",
      "427",
      "465",
      "512",
      "513",
      "514",
      "515",
      "526",
      "530",
      "531",
      "532",
      "540",
      "548",
      "554",
      "556",
      "563",
      "587",
      "601",
      "636",
      "989",
      "990",
      "993",
      "995",
      "1719",
      "1720",
      "1723",
      "2049",
      "3659",
      "4045",
      "5060",
      "5061",
      "6000",
      "6566",
      "6665",
      "6666",
      "6667",
      "6668",
      "6669",
      "6697",
      "10080"
    ];
    var badPortsSet = new Set(badPorts);
    var referrerPolicy = [
      "",
      "no-referrer",
      "no-referrer-when-downgrade",
      "same-origin",
      "origin",
      "strict-origin",
      "origin-when-cross-origin",
      "strict-origin-when-cross-origin",
      "unsafe-url"
    ];
    var referrerPolicySet = new Set(referrerPolicy);
    var requestRedirect = ["follow", "manual", "error"];
    var safeMethods = ["GET", "HEAD", "OPTIONS", "TRACE"];
    var safeMethodsSet = new Set(safeMethods);
    var requestMode = ["navigate", "same-origin", "no-cors", "cors"];
    var requestCredentials = ["omit", "same-origin", "include"];
    var requestCache = [
      "default",
      "no-store",
      "reload",
      "no-cache",
      "force-cache",
      "only-if-cached"
    ];
    var requestBodyHeader = [
      "content-encoding",
      "content-language",
      "content-location",
      "content-type",
      // See https://github.com/nodejs/undici/issues/2021
      // 'Content-Length' is a forbidden header name, which is typically
      // removed in the Headers implementation. However, undici doesn't
      // filter out headers, so we add it here.
      "content-length"
    ];
    var requestDuplex = [
      "half"
    ];
    var forbiddenMethods = ["CONNECT", "TRACE", "TRACK"];
    var forbiddenMethodsSet = new Set(forbiddenMethods);
    var subresource = [
      "audio",
      "audioworklet",
      "font",
      "image",
      "manifest",
      "paintworklet",
      "script",
      "style",
      "track",
      "video",
      "xslt",
      ""
    ];
    var subresourceSet = new Set(subresource);
    var DOMException2 = globalThis.DOMException ?? (() => {
      try {
        atob("~");
      } catch (err) {
        return Object.getPrototypeOf(err).constructor;
      }
    })();
    var channel;
    var structuredClone = globalThis.structuredClone ?? // https://github.com/nodejs/node/blob/b27ae24dcc4251bad726d9d84baf678d1f707fed/lib/internal/structured_clone.js
    // structuredClone was added in v17.0.0, but fetch supports v16.8
    /* @__PURE__ */ __name(function structuredClone2(value, options29 = void 0) {
      if (arguments.length === 0) {
        throw new TypeError("missing argument");
      }
      if (!channel) {
        channel = new MessageChannel2();
      }
      channel.port1.unref();
      channel.port2.unref();
      channel.port1.postMessage(value, options29?.transfer);
      return receiveMessageOnPort(channel.port2).message;
    }, "structuredClone");
    module3.exports = {
      DOMException: DOMException2,
      structuredClone,
      subresource,
      forbiddenMethods,
      requestBodyHeader,
      referrerPolicy,
      requestRedirect,
      requestMode,
      requestCredentials,
      requestCache,
      redirectStatus,
      corsSafeListedMethods,
      nullBodyStatus,
      safeMethods,
      badPorts,
      requestDuplex,
      subresourceSet,
      badPortsSet,
      redirectStatusSet,
      corsSafeListedMethodsSet,
      safeMethodsSet,
      forbiddenMethodsSet,
      referrerPolicySet
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/global.js
var require_global = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/global.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var globalOrigin = Symbol.for("undici.globalOrigin.1");
    function getGlobalOrigin() {
      return globalThis[globalOrigin];
    }
    __name(getGlobalOrigin, "getGlobalOrigin");
    function setGlobalOrigin(newOrigin) {
      if (newOrigin === void 0) {
        Object.defineProperty(globalThis, globalOrigin, {
          value: void 0,
          writable: true,
          enumerable: false,
          configurable: false
        });
        return;
      }
      const parsedURL = new URL(newOrigin);
      if (parsedURL.protocol !== "http:" && parsedURL.protocol !== "https:") {
        throw new TypeError(`Only http & https urls are allowed, received ${parsedURL.protocol}`);
      }
      Object.defineProperty(globalThis, globalOrigin, {
        value: parsedURL,
        writable: true,
        enumerable: false,
        configurable: false
      });
    }
    __name(setGlobalOrigin, "setGlobalOrigin");
    module3.exports = {
      getGlobalOrigin,
      setGlobalOrigin
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/util.js
var require_util2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/util.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = require_constants();
    var { getGlobalOrigin } = require_global();
    var { performance: performance2 } = require("perf_hooks");
    var { isBlobLike, toUSVString, ReadableStreamFrom } = require_util();
    var assert27 = require("assert");
    var { isUint8Array } = require("util/types");
    var crypto5;
    try {
      crypto5 = require("crypto");
    } catch {
    }
    function responseURL(response) {
      const urlList = response.urlList;
      const length = urlList.length;
      return length === 0 ? null : urlList[length - 1].toString();
    }
    __name(responseURL, "responseURL");
    function responseLocationURL(response, requestFragment) {
      if (!redirectStatusSet.has(response.status)) {
        return null;
      }
      let location = response.headersList.get("location");
      if (location !== null && isValidHeaderValue(location)) {
        location = new URL(location, responseURL(response));
      }
      if (location && !location.hash) {
        location.hash = requestFragment;
      }
      return location;
    }
    __name(responseLocationURL, "responseLocationURL");
    function requestCurrentURL(request3) {
      return request3.urlList[request3.urlList.length - 1];
    }
    __name(requestCurrentURL, "requestCurrentURL");
    function requestBadPort(request3) {
      const url4 = requestCurrentURL(request3);
      if (urlIsHttpHttpsScheme(url4) && badPortsSet.has(url4.port)) {
        return "blocked";
      }
      return "allowed";
    }
    __name(requestBadPort, "requestBadPort");
    function isErrorLike(object) {
      return object instanceof Error || (object?.constructor?.name === "Error" || object?.constructor?.name === "DOMException");
    }
    __name(isErrorLike, "isErrorLike");
    function isValidReasonPhrase(statusText) {
      for (let i = 0; i < statusText.length; ++i) {
        const c2 = statusText.charCodeAt(i);
        if (!(c2 === 9 || // HTAB
        c2 >= 32 && c2 <= 126 || // SP / VCHAR
        c2 >= 128 && c2 <= 255)) {
          return false;
        }
      }
      return true;
    }
    __name(isValidReasonPhrase, "isValidReasonPhrase");
    function isTokenCharCode(c2) {
      switch (c2) {
        case 34:
        case 40:
        case 41:
        case 44:
        case 47:
        case 58:
        case 59:
        case 60:
        case 61:
        case 62:
        case 63:
        case 64:
        case 91:
        case 92:
        case 93:
        case 123:
        case 125:
          return false;
        default:
          return c2 >= 33 && c2 <= 126;
      }
    }
    __name(isTokenCharCode, "isTokenCharCode");
    function isValidHTTPToken(characters) {
      if (characters.length === 0) {
        return false;
      }
      for (let i = 0; i < characters.length; ++i) {
        if (!isTokenCharCode(characters.charCodeAt(i))) {
          return false;
        }
      }
      return true;
    }
    __name(isValidHTTPToken, "isValidHTTPToken");
    function isValidHeaderName(potentialValue) {
      return isValidHTTPToken(potentialValue);
    }
    __name(isValidHeaderName, "isValidHeaderName");
    function isValidHeaderValue(potentialValue) {
      if (potentialValue.startsWith("	") || potentialValue.startsWith(" ") || potentialValue.endsWith("	") || potentialValue.endsWith(" ")) {
        return false;
      }
      if (potentialValue.includes("\0") || potentialValue.includes("\r") || potentialValue.includes("\n")) {
        return false;
      }
      return true;
    }
    __name(isValidHeaderValue, "isValidHeaderValue");
    function setRequestReferrerPolicyOnRedirect(request3, actualResponse) {
      const { headersList } = actualResponse;
      const policyHeader = (headersList.get("referrer-policy") ?? "").split(",");
      let policy = "";
      if (policyHeader.length > 0) {
        for (let i = policyHeader.length; i !== 0; i--) {
          const token = policyHeader[i - 1].trim();
          if (referrerPolicyTokens.has(token)) {
            policy = token;
            break;
          }
        }
      }
      if (policy !== "") {
        request3.referrerPolicy = policy;
      }
    }
    __name(setRequestReferrerPolicyOnRedirect, "setRequestReferrerPolicyOnRedirect");
    function crossOriginResourcePolicyCheck() {
      return "allowed";
    }
    __name(crossOriginResourcePolicyCheck, "crossOriginResourcePolicyCheck");
    function corsCheck() {
      return "success";
    }
    __name(corsCheck, "corsCheck");
    function TAOCheck() {
      return "success";
    }
    __name(TAOCheck, "TAOCheck");
    function appendFetchMetadata(httpRequest) {
      let header = null;
      header = httpRequest.mode;
      httpRequest.headersList.set("sec-fetch-mode", header);
    }
    __name(appendFetchMetadata, "appendFetchMetadata");
    function appendRequestOriginHeader(request3) {
      let serializedOrigin = request3.origin;
      if (request3.responseTainting === "cors" || request3.mode === "websocket") {
        if (serializedOrigin) {
          request3.headersList.append("origin", serializedOrigin);
        }
      } else if (request3.method !== "GET" && request3.method !== "HEAD") {
        switch (request3.referrerPolicy) {
          case "no-referrer":
            serializedOrigin = null;
            break;
          case "no-referrer-when-downgrade":
          case "strict-origin":
          case "strict-origin-when-cross-origin":
            if (request3.origin && urlHasHttpsScheme(request3.origin) && !urlHasHttpsScheme(requestCurrentURL(request3))) {
              serializedOrigin = null;
            }
            break;
          case "same-origin":
            if (!sameOrigin(request3, requestCurrentURL(request3))) {
              serializedOrigin = null;
            }
            break;
          default:
        }
        if (serializedOrigin) {
          request3.headersList.append("origin", serializedOrigin);
        }
      }
    }
    __name(appendRequestOriginHeader, "appendRequestOriginHeader");
    function coarsenedSharedCurrentTime(crossOriginIsolatedCapability) {
      return performance2.now();
    }
    __name(coarsenedSharedCurrentTime, "coarsenedSharedCurrentTime");
    function createOpaqueTimingInfo(timingInfo) {
      return {
        startTime: timingInfo.startTime ?? 0,
        redirectStartTime: 0,
        redirectEndTime: 0,
        postRedirectStartTime: timingInfo.startTime ?? 0,
        finalServiceWorkerStartTime: 0,
        finalNetworkResponseStartTime: 0,
        finalNetworkRequestStartTime: 0,
        endTime: 0,
        encodedBodySize: 0,
        decodedBodySize: 0,
        finalConnectionTimingInfo: null
      };
    }
    __name(createOpaqueTimingInfo, "createOpaqueTimingInfo");
    function makePolicyContainer() {
      return {
        referrerPolicy: "strict-origin-when-cross-origin"
      };
    }
    __name(makePolicyContainer, "makePolicyContainer");
    function clonePolicyContainer(policyContainer) {
      return {
        referrerPolicy: policyContainer.referrerPolicy
      };
    }
    __name(clonePolicyContainer, "clonePolicyContainer");
    function determineRequestsReferrer(request3) {
      const policy = request3.referrerPolicy;
      assert27(policy);
      let referrerSource = null;
      if (request3.referrer === "client") {
        const globalOrigin = getGlobalOrigin();
        if (!globalOrigin || globalOrigin.origin === "null") {
          return "no-referrer";
        }
        referrerSource = new URL(globalOrigin);
      } else if (request3.referrer instanceof URL) {
        referrerSource = request3.referrer;
      }
      let referrerURL = stripURLForReferrer(referrerSource);
      const referrerOrigin = stripURLForReferrer(referrerSource, true);
      if (referrerURL.toString().length > 4096) {
        referrerURL = referrerOrigin;
      }
      const areSameOrigin = sameOrigin(request3, referrerURL);
      const isNonPotentiallyTrustWorthy = isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(request3.url);
      switch (policy) {
        case "origin":
          return referrerOrigin != null ? referrerOrigin : stripURLForReferrer(referrerSource, true);
        case "unsafe-url":
          return referrerURL;
        case "same-origin":
          return areSameOrigin ? referrerOrigin : "no-referrer";
        case "origin-when-cross-origin":
          return areSameOrigin ? referrerURL : referrerOrigin;
        case "strict-origin-when-cross-origin": {
          const currentURL = requestCurrentURL(request3);
          if (sameOrigin(referrerURL, currentURL)) {
            return referrerURL;
          }
          if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) {
            return "no-referrer";
          }
          return referrerOrigin;
        }
        case "strict-origin":
        case "no-referrer-when-downgrade":
        default:
          return isNonPotentiallyTrustWorthy ? "no-referrer" : referrerOrigin;
      }
    }
    __name(determineRequestsReferrer, "determineRequestsReferrer");
    function stripURLForReferrer(url4, originOnly) {
      assert27(url4 instanceof URL);
      if (url4.protocol === "file:" || url4.protocol === "about:" || url4.protocol === "blank:") {
        return "no-referrer";
      }
      url4.username = "";
      url4.password = "";
      url4.hash = "";
      if (originOnly) {
        url4.pathname = "";
        url4.search = "";
      }
      return url4;
    }
    __name(stripURLForReferrer, "stripURLForReferrer");
    function isURLPotentiallyTrustworthy(url4) {
      if (!(url4 instanceof URL)) {
        return false;
      }
      if (url4.href === "about:blank" || url4.href === "about:srcdoc") {
        return true;
      }
      if (url4.protocol === "data:")
        return true;
      if (url4.protocol === "file:")
        return true;
      return isOriginPotentiallyTrustworthy(url4.origin);
      function isOriginPotentiallyTrustworthy(origin) {
        if (origin == null || origin === "null")
          return false;
        const originAsURL = new URL(origin);
        if (originAsURL.protocol === "https:" || originAsURL.protocol === "wss:") {
          return true;
        }
        if (/^127(?:\.[0-9]+){0,2}\.[0-9]+$|^\[(?:0*:)*?:?0*1\]$/.test(originAsURL.hostname) || (originAsURL.hostname === "localhost" || originAsURL.hostname.includes("localhost.")) || originAsURL.hostname.endsWith(".localhost")) {
          return true;
        }
        return false;
      }
      __name(isOriginPotentiallyTrustworthy, "isOriginPotentiallyTrustworthy");
    }
    __name(isURLPotentiallyTrustworthy, "isURLPotentiallyTrustworthy");
    function bytesMatch(bytes, metadataList) {
      if (crypto5 === void 0) {
        return true;
      }
      const parsedMetadata = parseMetadata(metadataList);
      if (parsedMetadata === "no metadata") {
        return true;
      }
      if (parsedMetadata.length === 0) {
        return true;
      }
      const list = parsedMetadata.sort((c2, d2) => d2.algo.localeCompare(c2.algo));
      const strongest = list[0].algo;
      const metadata = list.filter((item) => item.algo === strongest);
      for (const item of metadata) {
        const algorithm = item.algo;
        let expectedValue = item.hash;
        if (expectedValue.endsWith("==")) {
          expectedValue = expectedValue.slice(0, -2);
        }
        let actualValue = crypto5.createHash(algorithm).update(bytes).digest("base64");
        if (actualValue.endsWith("==")) {
          actualValue = actualValue.slice(0, -2);
        }
        if (actualValue === expectedValue) {
          return true;
        }
        let actualBase64URL = crypto5.createHash(algorithm).update(bytes).digest("base64url");
        if (actualBase64URL.endsWith("==")) {
          actualBase64URL = actualBase64URL.slice(0, -2);
        }
        if (actualBase64URL === expectedValue) {
          return true;
        }
      }
      return false;
    }
    __name(bytesMatch, "bytesMatch");
    var parseHashWithOptions = /((?<algo>sha256|sha384|sha512)-(?<hash>[A-z0-9+/]{1}.*={0,2}))( +[\x21-\x7e]?)?/i;
    function parseMetadata(metadata) {
      const result = [];
      let empty2 = true;
      const supportedHashes = crypto5.getHashes();
      for (const token of metadata.split(" ")) {
        empty2 = false;
        const parsedToken = parseHashWithOptions.exec(token);
        if (parsedToken === null || parsedToken.groups === void 0) {
          continue;
        }
        const algorithm = parsedToken.groups.algo;
        if (supportedHashes.includes(algorithm.toLowerCase())) {
          result.push(parsedToken.groups);
        }
      }
      if (empty2 === true) {
        return "no metadata";
      }
      return result;
    }
    __name(parseMetadata, "parseMetadata");
    function tryUpgradeRequestToAPotentiallyTrustworthyURL(request3) {
    }
    __name(tryUpgradeRequestToAPotentiallyTrustworthyURL, "tryUpgradeRequestToAPotentiallyTrustworthyURL");
    function sameOrigin(A2, B2) {
      if (A2.origin === B2.origin && A2.origin === "null") {
        return true;
      }
      if (A2.protocol === B2.protocol && A2.hostname === B2.hostname && A2.port === B2.port) {
        return true;
      }
      return false;
    }
    __name(sameOrigin, "sameOrigin");
    function createDeferredPromise() {
      let res;
      let rej;
      const promise = new Promise((resolve19, reject) => {
        res = resolve19;
        rej = reject;
      });
      return { promise, resolve: res, reject: rej };
    }
    __name(createDeferredPromise, "createDeferredPromise");
    function isAborted(fetchParams) {
      return fetchParams.controller.state === "aborted";
    }
    __name(isAborted, "isAborted");
    function isCancelled(fetchParams) {
      return fetchParams.controller.state === "aborted" || fetchParams.controller.state === "terminated";
    }
    __name(isCancelled, "isCancelled");
    var normalizeMethodRecord = {
      delete: "DELETE",
      DELETE: "DELETE",
      get: "GET",
      GET: "GET",
      head: "HEAD",
      HEAD: "HEAD",
      options: "OPTIONS",
      OPTIONS: "OPTIONS",
      post: "POST",
      POST: "POST",
      put: "PUT",
      PUT: "PUT"
    };
    Object.setPrototypeOf(normalizeMethodRecord, null);
    function normalizeMethod(method) {
      return normalizeMethodRecord[method.toLowerCase()] ?? method;
    }
    __name(normalizeMethod, "normalizeMethod");
    function serializeJavascriptValueToJSONString(value) {
      const result = JSON.stringify(value);
      if (result === void 0) {
        throw new TypeError("Value is not JSON serializable");
      }
      assert27(typeof result === "string");
      return result;
    }
    __name(serializeJavascriptValueToJSONString, "serializeJavascriptValueToJSONString");
    var esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
    function makeIterator(iterator, name, kind) {
      const object = {
        index: 0,
        kind,
        target: iterator
      };
      const i = {
        next() {
          if (Object.getPrototypeOf(this) !== i) {
            throw new TypeError(
              `'next' called on an object that does not implement interface ${name} Iterator.`
            );
          }
          const { index, kind: kind2, target } = object;
          const values = target();
          const len = values.length;
          if (index >= len) {
            return { value: void 0, done: true };
          }
          const pair = values[index];
          object.index = index + 1;
          return iteratorResult(pair, kind2);
        },
        // The class string of an iterator prototype object for a given interface is the
        // result of concatenating the identifier of the interface and the string " Iterator".
        [Symbol.toStringTag]: `${name} Iterator`
      };
      Object.setPrototypeOf(i, esIteratorPrototype);
      return Object.setPrototypeOf({}, i);
    }
    __name(makeIterator, "makeIterator");
    function iteratorResult(pair, kind) {
      let result;
      switch (kind) {
        case "key": {
          result = pair[0];
          break;
        }
        case "value": {
          result = pair[1];
          break;
        }
        case "key+value": {
          result = pair;
          break;
        }
      }
      return { value: result, done: false };
    }
    __name(iteratorResult, "iteratorResult");
    async function fullyReadBody(body, processBody, processBodyError) {
      const successSteps = processBody;
      const errorSteps = processBodyError;
      let reader;
      try {
        reader = body.stream.getReader();
      } catch (e3) {
        errorSteps(e3);
        return;
      }
      try {
        const result = await readAllBytes(reader);
        successSteps(result);
      } catch (e3) {
        errorSteps(e3);
      }
    }
    __name(fullyReadBody, "fullyReadBody");
    var ReadableStream2 = globalThis.ReadableStream;
    function isReadableStreamLike(stream2) {
      if (!ReadableStream2) {
        ReadableStream2 = require("stream/web").ReadableStream;
      }
      return stream2 instanceof ReadableStream2 || stream2[Symbol.toStringTag] === "ReadableStream" && typeof stream2.tee === "function";
    }
    __name(isReadableStreamLike, "isReadableStreamLike");
    var MAXIMUM_ARGUMENT_LENGTH = 65535;
    function isomorphicDecode(input) {
      if (input.length < MAXIMUM_ARGUMENT_LENGTH) {
        return String.fromCharCode(...input);
      }
      return input.reduce((previous, current) => previous + String.fromCharCode(current), "");
    }
    __name(isomorphicDecode, "isomorphicDecode");
    function readableStreamClose(controller) {
      try {
        controller.close();
      } catch (err) {
        if (!err.message.includes("Controller is already closed")) {
          throw err;
        }
      }
    }
    __name(readableStreamClose, "readableStreamClose");
    function isomorphicEncode(input) {
      for (let i = 0; i < input.length; i++) {
        assert27(input.charCodeAt(i) <= 255);
      }
      return input;
    }
    __name(isomorphicEncode, "isomorphicEncode");
    async function readAllBytes(reader) {
      const bytes = [];
      let byteLength = 0;
      while (true) {
        const { done, value: chunk } = await reader.read();
        if (done) {
          return Buffer.concat(bytes, byteLength);
        }
        if (!isUint8Array(chunk)) {
          throw new TypeError("Received non-Uint8Array chunk");
        }
        bytes.push(chunk);
        byteLength += chunk.length;
      }
    }
    __name(readAllBytes, "readAllBytes");
    function urlIsLocal(url4) {
      assert27("protocol" in url4);
      const protocol = url4.protocol;
      return protocol === "about:" || protocol === "blob:" || protocol === "data:";
    }
    __name(urlIsLocal, "urlIsLocal");
    function urlHasHttpsScheme(url4) {
      if (typeof url4 === "string") {
        return url4.startsWith("https:");
      }
      return url4.protocol === "https:";
    }
    __name(urlHasHttpsScheme, "urlHasHttpsScheme");
    function urlIsHttpHttpsScheme(url4) {
      assert27("protocol" in url4);
      const protocol = url4.protocol;
      return protocol === "http:" || protocol === "https:";
    }
    __name(urlIsHttpHttpsScheme, "urlIsHttpHttpsScheme");
    var hasOwn = Object.hasOwn || ((dict, key) => Object.prototype.hasOwnProperty.call(dict, key));
    module3.exports = {
      isAborted,
      isCancelled,
      createDeferredPromise,
      ReadableStreamFrom,
      toUSVString,
      tryUpgradeRequestToAPotentiallyTrustworthyURL,
      coarsenedSharedCurrentTime,
      determineRequestsReferrer,
      makePolicyContainer,
      clonePolicyContainer,
      appendFetchMetadata,
      appendRequestOriginHeader,
      TAOCheck,
      corsCheck,
      crossOriginResourcePolicyCheck,
      createOpaqueTimingInfo,
      setRequestReferrerPolicyOnRedirect,
      isValidHTTPToken,
      requestBadPort,
      requestCurrentURL,
      responseURL,
      responseLocationURL,
      isBlobLike,
      isURLPotentiallyTrustworthy,
      isValidReasonPhrase,
      sameOrigin,
      normalizeMethod,
      serializeJavascriptValueToJSONString,
      makeIterator,
      isValidHeaderName,
      isValidHeaderValue,
      hasOwn,
      isErrorLike,
      fullyReadBody,
      bytesMatch,
      isReadableStreamLike,
      readableStreamClose,
      isomorphicEncode,
      isomorphicDecode,
      urlIsLocal,
      urlHasHttpsScheme,
      urlIsHttpHttpsScheme,
      readAllBytes,
      normalizeMethodRecord
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/symbols.js
var require_symbols2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/symbols.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = {
      kUrl: Symbol("url"),
      kHeaders: Symbol("headers"),
      kSignal: Symbol("signal"),
      kState: Symbol("state"),
      kGuard: Symbol("guard"),
      kRealm: Symbol("realm")
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/webidl.js
var require_webidl = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/webidl.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { types } = require("util");
    var { hasOwn, toUSVString } = require_util2();
    var webidl = {};
    webidl.converters = {};
    webidl.util = {};
    webidl.errors = {};
    webidl.errors.exception = function(message) {
      return new TypeError(`${message.header}: ${message.message}`);
    };
    webidl.errors.conversionFailed = function(context2) {
      const plural2 = context2.types.length === 1 ? "" : " one of";
      const message = `${context2.argument} could not be converted to${plural2}: ${context2.types.join(", ")}.`;
      return webidl.errors.exception({
        header: context2.prefix,
        message
      });
    };
    webidl.errors.invalidArgument = function(context2) {
      return webidl.errors.exception({
        header: context2.prefix,
        message: `"${context2.value}" is an invalid ${context2.type}.`
      });
    };
    webidl.brandCheck = function(V2, I2, opts = void 0) {
      if (opts?.strict !== false && !(V2 instanceof I2)) {
        throw new TypeError("Illegal invocation");
      } else {
        return V2?.[Symbol.toStringTag] === I2.prototype[Symbol.toStringTag];
      }
    };
    webidl.argumentLengthCheck = function({ length }, min, ctx) {
      if (length < min) {
        throw webidl.errors.exception({
          message: `${min} argument${min !== 1 ? "s" : ""} required, but${length ? " only" : ""} ${length} found.`,
          ...ctx
        });
      }
    };
    webidl.illegalConstructor = function() {
      throw webidl.errors.exception({
        header: "TypeError",
        message: "Illegal constructor"
      });
    };
    webidl.util.Type = function(V2) {
      switch (typeof V2) {
        case "undefined":
          return "Undefined";
        case "boolean":
          return "Boolean";
        case "string":
          return "String";
        case "symbol":
          return "Symbol";
        case "number":
          return "Number";
        case "bigint":
          return "BigInt";
        case "function":
        case "object": {
          if (V2 === null) {
            return "Null";
          }
          return "Object";
        }
      }
    };
    webidl.util.ConvertToInt = function(V2, bitLength, signedness, opts = {}) {
      let upperBound;
      let lowerBound2;
      if (bitLength === 64) {
        upperBound = Math.pow(2, 53) - 1;
        if (signedness === "unsigned") {
          lowerBound2 = 0;
        } else {
          lowerBound2 = Math.pow(-2, 53) + 1;
        }
      } else if (signedness === "unsigned") {
        lowerBound2 = 0;
        upperBound = Math.pow(2, bitLength) - 1;
      } else {
        lowerBound2 = Math.pow(-2, bitLength) - 1;
        upperBound = Math.pow(2, bitLength - 1) - 1;
      }
      let x2 = Number(V2);
      if (x2 === 0) {
        x2 = 0;
      }
      if (opts.enforceRange === true) {
        if (Number.isNaN(x2) || x2 === Number.POSITIVE_INFINITY || x2 === Number.NEGATIVE_INFINITY) {
          throw webidl.errors.exception({
            header: "Integer conversion",
            message: `Could not convert ${V2} to an integer.`
          });
        }
        x2 = webidl.util.IntegerPart(x2);
        if (x2 < lowerBound2 || x2 > upperBound) {
          throw webidl.errors.exception({
            header: "Integer conversion",
            message: `Value must be between ${lowerBound2}-${upperBound}, got ${x2}.`
          });
        }
        return x2;
      }
      if (!Number.isNaN(x2) && opts.clamp === true) {
        x2 = Math.min(Math.max(x2, lowerBound2), upperBound);
        if (Math.floor(x2) % 2 === 0) {
          x2 = Math.floor(x2);
        } else {
          x2 = Math.ceil(x2);
        }
        return x2;
      }
      if (Number.isNaN(x2) || x2 === 0 && Object.is(0, x2) || x2 === Number.POSITIVE_INFINITY || x2 === Number.NEGATIVE_INFINITY) {
        return 0;
      }
      x2 = webidl.util.IntegerPart(x2);
      x2 = x2 % Math.pow(2, bitLength);
      if (signedness === "signed" && x2 >= Math.pow(2, bitLength) - 1) {
        return x2 - Math.pow(2, bitLength);
      }
      return x2;
    };
    webidl.util.IntegerPart = function(n2) {
      const r3 = Math.floor(Math.abs(n2));
      if (n2 < 0) {
        return -1 * r3;
      }
      return r3;
    };
    webidl.sequenceConverter = function(converter) {
      return (V2) => {
        if (webidl.util.Type(V2) !== "Object") {
          throw webidl.errors.exception({
            header: "Sequence",
            message: `Value of type ${webidl.util.Type(V2)} is not an Object.`
          });
        }
        const method = V2?.[Symbol.iterator]?.();
        const seq = [];
        if (method === void 0 || typeof method.next !== "function") {
          throw webidl.errors.exception({
            header: "Sequence",
            message: "Object is not an iterator."
          });
        }
        while (true) {
          const { done, value } = method.next();
          if (done) {
            break;
          }
          seq.push(converter(value));
        }
        return seq;
      };
    };
    webidl.recordConverter = function(keyConverter, valueConverter) {
      return (O2) => {
        if (webidl.util.Type(O2) !== "Object") {
          throw webidl.errors.exception({
            header: "Record",
            message: `Value of type ${webidl.util.Type(O2)} is not an Object.`
          });
        }
        const result = {};
        if (!types.isProxy(O2)) {
          const keys2 = Object.keys(O2);
          for (const key of keys2) {
            const typedKey = keyConverter(key);
            const typedValue = valueConverter(O2[key]);
            result[typedKey] = typedValue;
          }
          return result;
        }
        const keys = Reflect.ownKeys(O2);
        for (const key of keys) {
          const desc = Reflect.getOwnPropertyDescriptor(O2, key);
          if (desc?.enumerable) {
            const typedKey = keyConverter(key);
            const typedValue = valueConverter(O2[key]);
            result[typedKey] = typedValue;
          }
        }
        return result;
      };
    };
    webidl.interfaceConverter = function(i) {
      return (V2, opts = {}) => {
        if (opts.strict !== false && !(V2 instanceof i)) {
          throw webidl.errors.exception({
            header: i.name,
            message: `Expected ${V2} to be an instance of ${i.name}.`
          });
        }
        return V2;
      };
    };
    webidl.dictionaryConverter = function(converters) {
      return (dictionary) => {
        const type = webidl.util.Type(dictionary);
        const dict = {};
        if (type === "Null" || type === "Undefined") {
          return dict;
        } else if (type !== "Object") {
          throw webidl.errors.exception({
            header: "Dictionary",
            message: `Expected ${dictionary} to be one of: Null, Undefined, Object.`
          });
        }
        for (const options29 of converters) {
          const { key, defaultValue, required, converter } = options29;
          if (required === true) {
            if (!hasOwn(dictionary, key)) {
              throw webidl.errors.exception({
                header: "Dictionary",
                message: `Missing required key "${key}".`
              });
            }
          }
          let value = dictionary[key];
          const hasDefault = hasOwn(options29, "defaultValue");
          if (hasDefault && value !== null) {
            value = value ?? defaultValue;
          }
          if (required || hasDefault || value !== void 0) {
            value = converter(value);
            if (options29.allowedValues && !options29.allowedValues.includes(value)) {
              throw webidl.errors.exception({
                header: "Dictionary",
                message: `${value} is not an accepted type. Expected one of ${options29.allowedValues.join(", ")}.`
              });
            }
            dict[key] = value;
          }
        }
        return dict;
      };
    };
    webidl.nullableConverter = function(converter) {
      return (V2) => {
        if (V2 === null) {
          return V2;
        }
        return converter(V2);
      };
    };
    webidl.converters.DOMString = function(V2, opts = {}) {
      if (V2 === null && opts.legacyNullToEmptyString) {
        return "";
      }
      if (typeof V2 === "symbol") {
        throw new TypeError("Could not convert argument of type symbol to string.");
      }
      return String(V2);
    };
    webidl.converters.ByteString = function(V2) {
      const x2 = webidl.converters.DOMString(V2);
      for (let index = 0; index < x2.length; index++) {
        if (x2.charCodeAt(index) > 255) {
          throw new TypeError(
            `Cannot convert argument to a ByteString because the character at index ${index} has a value of ${x2.charCodeAt(index)} which is greater than 255.`
          );
        }
      }
      return x2;
    };
    webidl.converters.USVString = toUSVString;
    webidl.converters.boolean = function(V2) {
      const x2 = Boolean(V2);
      return x2;
    };
    webidl.converters.any = function(V2) {
      return V2;
    };
    webidl.converters["long long"] = function(V2) {
      const x2 = webidl.util.ConvertToInt(V2, 64, "signed");
      return x2;
    };
    webidl.converters["unsigned long long"] = function(V2) {
      const x2 = webidl.util.ConvertToInt(V2, 64, "unsigned");
      return x2;
    };
    webidl.converters["unsigned long"] = function(V2) {
      const x2 = webidl.util.ConvertToInt(V2, 32, "unsigned");
      return x2;
    };
    webidl.converters["unsigned short"] = function(V2, opts) {
      const x2 = webidl.util.ConvertToInt(V2, 16, "unsigned", opts);
      return x2;
    };
    webidl.converters.ArrayBuffer = function(V2, opts = {}) {
      if (webidl.util.Type(V2) !== "Object" || !types.isAnyArrayBuffer(V2)) {
        throw webidl.errors.conversionFailed({
          prefix: `${V2}`,
          argument: `${V2}`,
          types: ["ArrayBuffer"]
        });
      }
      if (opts.allowShared === false && types.isSharedArrayBuffer(V2)) {
        throw webidl.errors.exception({
          header: "ArrayBuffer",
          message: "SharedArrayBuffer is not allowed."
        });
      }
      return V2;
    };
    webidl.converters.TypedArray = function(V2, T2, opts = {}) {
      if (webidl.util.Type(V2) !== "Object" || !types.isTypedArray(V2) || V2.constructor.name !== T2.name) {
        throw webidl.errors.conversionFailed({
          prefix: `${T2.name}`,
          argument: `${V2}`,
          types: [T2.name]
        });
      }
      if (opts.allowShared === false && types.isSharedArrayBuffer(V2.buffer)) {
        throw webidl.errors.exception({
          header: "ArrayBuffer",
          message: "SharedArrayBuffer is not allowed."
        });
      }
      return V2;
    };
    webidl.converters.DataView = function(V2, opts = {}) {
      if (webidl.util.Type(V2) !== "Object" || !types.isDataView(V2)) {
        throw webidl.errors.exception({
          header: "DataView",
          message: "Object is not a DataView."
        });
      }
      if (opts.allowShared === false && types.isSharedArrayBuffer(V2.buffer)) {
        throw webidl.errors.exception({
          header: "ArrayBuffer",
          message: "SharedArrayBuffer is not allowed."
        });
      }
      return V2;
    };
    webidl.converters.BufferSource = function(V2, opts = {}) {
      if (types.isAnyArrayBuffer(V2)) {
        return webidl.converters.ArrayBuffer(V2, opts);
      }
      if (types.isTypedArray(V2)) {
        return webidl.converters.TypedArray(V2, V2.constructor);
      }
      if (types.isDataView(V2)) {
        return webidl.converters.DataView(V2, opts);
      }
      throw new TypeError(`Could not convert ${V2} to a BufferSource.`);
    };
    webidl.converters["sequence<ByteString>"] = webidl.sequenceConverter(
      webidl.converters.ByteString
    );
    webidl.converters["sequence<sequence<ByteString>>"] = webidl.sequenceConverter(
      webidl.converters["sequence<ByteString>"]
    );
    webidl.converters["record<ByteString, ByteString>"] = webidl.recordConverter(
      webidl.converters.ByteString,
      webidl.converters.ByteString
    );
    module3.exports = {
      webidl
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/dataURL.js
var require_dataURL = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/dataURL.js"(exports2, module3) {
    init_import_meta_url();
    var assert27 = require("assert");
    var { atob: atob2 } = require("buffer");
    var { isomorphicDecode } = require_util2();
    var encoder = new TextEncoder();
    var HTTP_TOKEN_CODEPOINTS = /^[!#$%&'*+-.^_|~A-Za-z0-9]+$/;
    var HTTP_WHITESPACE_REGEX = /(\u000A|\u000D|\u0009|\u0020)/;
    var HTTP_QUOTED_STRING_TOKENS = /[\u0009|\u0020-\u007E|\u0080-\u00FF]/;
    function dataURLProcessor(dataURL) {
      assert27(dataURL.protocol === "data:");
      let input = URLSerializer(dataURL, true);
      input = input.slice(5);
      const position = { position: 0 };
      let mimeType = collectASequenceOfCodePointsFast(
        ",",
        input,
        position
      );
      const mimeTypeLength = mimeType.length;
      mimeType = removeASCIIWhitespace(mimeType, true, true);
      if (position.position >= input.length) {
        return "failure";
      }
      position.position++;
      const encodedBody = input.slice(mimeTypeLength + 1);
      let body = stringPercentDecode(encodedBody);
      if (/;(\u0020){0,}base64$/i.test(mimeType)) {
        const stringBody = isomorphicDecode(body);
        body = forgivingBase64(stringBody);
        if (body === "failure") {
          return "failure";
        }
        mimeType = mimeType.slice(0, -6);
        mimeType = mimeType.replace(/(\u0020)+$/, "");
        mimeType = mimeType.slice(0, -1);
      }
      if (mimeType.startsWith(";")) {
        mimeType = "text/plain" + mimeType;
      }
      let mimeTypeRecord = parseMIMEType(mimeType);
      if (mimeTypeRecord === "failure") {
        mimeTypeRecord = parseMIMEType("text/plain;charset=US-ASCII");
      }
      return { mimeType: mimeTypeRecord, body };
    }
    __name(dataURLProcessor, "dataURLProcessor");
    function URLSerializer(url4, excludeFragment = false) {
      if (!excludeFragment) {
        return url4.href;
      }
      const href = url4.href;
      const hashLength = url4.hash.length;
      return hashLength === 0 ? href : href.substring(0, href.length - hashLength);
    }
    __name(URLSerializer, "URLSerializer");
    function collectASequenceOfCodePoints(condition, input, position) {
      let result = "";
      while (position.position < input.length && condition(input[position.position])) {
        result += input[position.position];
        position.position++;
      }
      return result;
    }
    __name(collectASequenceOfCodePoints, "collectASequenceOfCodePoints");
    function collectASequenceOfCodePointsFast(char, input, position) {
      const idx = input.indexOf(char, position.position);
      const start = position.position;
      if (idx === -1) {
        position.position = input.length;
        return input.slice(start);
      }
      position.position = idx;
      return input.slice(start, position.position);
    }
    __name(collectASequenceOfCodePointsFast, "collectASequenceOfCodePointsFast");
    function stringPercentDecode(input) {
      const bytes = encoder.encode(input);
      return percentDecode(bytes);
    }
    __name(stringPercentDecode, "stringPercentDecode");
    function percentDecode(input) {
      const output = [];
      for (let i = 0; i < input.length; i++) {
        const byte = input[i];
        if (byte !== 37) {
          output.push(byte);
        } else if (byte === 37 && !/^[0-9A-Fa-f]{2}$/i.test(String.fromCharCode(input[i + 1], input[i + 2]))) {
          output.push(37);
        } else {
          const nextTwoBytes = String.fromCharCode(input[i + 1], input[i + 2]);
          const bytePoint = Number.parseInt(nextTwoBytes, 16);
          output.push(bytePoint);
          i += 2;
        }
      }
      return Uint8Array.from(output);
    }
    __name(percentDecode, "percentDecode");
    function parseMIMEType(input) {
      input = removeHTTPWhitespace(input, true, true);
      const position = { position: 0 };
      const type = collectASequenceOfCodePointsFast(
        "/",
        input,
        position
      );
      if (type.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(type)) {
        return "failure";
      }
      if (position.position > input.length) {
        return "failure";
      }
      position.position++;
      let subtype = collectASequenceOfCodePointsFast(
        ";",
        input,
        position
      );
      subtype = removeHTTPWhitespace(subtype, false, true);
      if (subtype.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(subtype)) {
        return "failure";
      }
      const typeLowercase = type.toLowerCase();
      const subtypeLowercase = subtype.toLowerCase();
      const mimeType = {
        type: typeLowercase,
        subtype: subtypeLowercase,
        /** @type {Map<string, string>} */
        parameters: /* @__PURE__ */ new Map(),
        // https://mimesniff.spec.whatwg.org/#mime-type-essence
        essence: `${typeLowercase}/${subtypeLowercase}`
      };
      while (position.position < input.length) {
        position.position++;
        collectASequenceOfCodePoints(
          // https://fetch.spec.whatwg.org/#http-whitespace
          (char) => HTTP_WHITESPACE_REGEX.test(char),
          input,
          position
        );
        let parameterName = collectASequenceOfCodePoints(
          (char) => char !== ";" && char !== "=",
          input,
          position
        );
        parameterName = parameterName.toLowerCase();
        if (position.position < input.length) {
          if (input[position.position] === ";") {
            continue;
          }
          position.position++;
        }
        if (position.position > input.length) {
          break;
        }
        let parameterValue = null;
        if (input[position.position] === '"') {
          parameterValue = collectAnHTTPQuotedString(input, position, true);
          collectASequenceOfCodePointsFast(
            ";",
            input,
            position
          );
        } else {
          parameterValue = collectASequenceOfCodePointsFast(
            ";",
            input,
            position
          );
          parameterValue = removeHTTPWhitespace(parameterValue, false, true);
          if (parameterValue.length === 0) {
            continue;
          }
        }
        if (parameterName.length !== 0 && HTTP_TOKEN_CODEPOINTS.test(parameterName) && (parameterValue.length === 0 || HTTP_QUOTED_STRING_TOKENS.test(parameterValue)) && !mimeType.parameters.has(parameterName)) {
          mimeType.parameters.set(parameterName, parameterValue);
        }
      }
      return mimeType;
    }
    __name(parseMIMEType, "parseMIMEType");
    function forgivingBase64(data) {
      data = data.replace(/[\u0009\u000A\u000C\u000D\u0020]/g, "");
      if (data.length % 4 === 0) {
        data = data.replace(/=?=$/, "");
      }
      if (data.length % 4 === 1) {
        return "failure";
      }
      if (/[^+/0-9A-Za-z]/.test(data)) {
        return "failure";
      }
      const binary = atob2(data);
      const bytes = new Uint8Array(binary.length);
      for (let byte = 0; byte < binary.length; byte++) {
        bytes[byte] = binary.charCodeAt(byte);
      }
      return bytes;
    }
    __name(forgivingBase64, "forgivingBase64");
    function collectAnHTTPQuotedString(input, position, extractValue) {
      const positionStart = position.position;
      let value = "";
      assert27(input[position.position] === '"');
      position.position++;
      while (true) {
        value += collectASequenceOfCodePoints(
          (char) => char !== '"' && char !== "\\",
          input,
          position
        );
        if (position.position >= input.length) {
          break;
        }
        const quoteOrBackslash = input[position.position];
        position.position++;
        if (quoteOrBackslash === "\\") {
          if (position.position >= input.length) {
            value += "\\";
            break;
          }
          value += input[position.position];
          position.position++;
        } else {
          assert27(quoteOrBackslash === '"');
          break;
        }
      }
      if (extractValue) {
        return value;
      }
      return input.slice(positionStart, position.position);
    }
    __name(collectAnHTTPQuotedString, "collectAnHTTPQuotedString");
    function serializeAMimeType(mimeType) {
      assert27(mimeType !== "failure");
      const { parameters, essence } = mimeType;
      let serialization = essence;
      for (let [name, value] of parameters.entries()) {
        serialization += ";";
        serialization += name;
        serialization += "=";
        if (!HTTP_TOKEN_CODEPOINTS.test(value)) {
          value = value.replace(/(\\|")/g, "\\$1");
          value = '"' + value;
          value += '"';
        }
        serialization += value;
      }
      return serialization;
    }
    __name(serializeAMimeType, "serializeAMimeType");
    function isHTTPWhiteSpace(char) {
      return char === "\r" || char === "\n" || char === "	" || char === " ";
    }
    __name(isHTTPWhiteSpace, "isHTTPWhiteSpace");
    function removeHTTPWhitespace(str, leading = true, trailing = true) {
      let lead = 0;
      let trail = str.length - 1;
      if (leading) {
        for (; lead < str.length && isHTTPWhiteSpace(str[lead]); lead++)
          ;
      }
      if (trailing) {
        for (; trail > 0 && isHTTPWhiteSpace(str[trail]); trail--)
          ;
      }
      return str.slice(lead, trail + 1);
    }
    __name(removeHTTPWhitespace, "removeHTTPWhitespace");
    function isASCIIWhitespace(char) {
      return char === "\r" || char === "\n" || char === "	" || char === "\f" || char === " ";
    }
    __name(isASCIIWhitespace, "isASCIIWhitespace");
    function removeASCIIWhitespace(str, leading = true, trailing = true) {
      let lead = 0;
      let trail = str.length - 1;
      if (leading) {
        for (; lead < str.length && isASCIIWhitespace(str[lead]); lead++)
          ;
      }
      if (trailing) {
        for (; trail > 0 && isASCIIWhitespace(str[trail]); trail--)
          ;
      }
      return str.slice(lead, trail + 1);
    }
    __name(removeASCIIWhitespace, "removeASCIIWhitespace");
    module3.exports = {
      dataURLProcessor,
      URLSerializer,
      collectASequenceOfCodePoints,
      collectASequenceOfCodePointsFast,
      stringPercentDecode,
      parseMIMEType,
      collectAnHTTPQuotedString,
      serializeAMimeType
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/file.js
var require_file = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/file.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { Blob: Blob6, File: NativeFile } = require("buffer");
    var { types } = require("util");
    var { kState } = require_symbols2();
    var { isBlobLike } = require_util2();
    var { webidl } = require_webidl();
    var { parseMIMEType, serializeAMimeType } = require_dataURL();
    var { kEnumerableProperty } = require_util();
    var encoder = new TextEncoder();
    var File6 = class extends Blob6 {
      constructor(fileBits, fileName, options29 = {}) {
        webidl.argumentLengthCheck(arguments, 2, { header: "File constructor" });
        fileBits = webidl.converters["sequence<BlobPart>"](fileBits);
        fileName = webidl.converters.USVString(fileName);
        options29 = webidl.converters.FilePropertyBag(options29);
        const n2 = fileName;
        let t3 = options29.type;
        let d2;
        substep: {
          if (t3) {
            t3 = parseMIMEType(t3);
            if (t3 === "failure") {
              t3 = "";
              break substep;
            }
            t3 = serializeAMimeType(t3).toLowerCase();
          }
          d2 = options29.lastModified;
        }
        super(processBlobParts(fileBits, options29), { type: t3 });
        this[kState] = {
          name: n2,
          lastModified: d2,
          type: t3
        };
      }
      get name() {
        webidl.brandCheck(this, File6);
        return this[kState].name;
      }
      get lastModified() {
        webidl.brandCheck(this, File6);
        return this[kState].lastModified;
      }
      get type() {
        webidl.brandCheck(this, File6);
        return this[kState].type;
      }
    };
    __name(File6, "File");
    var FileLike = class {
      constructor(blobLike, fileName, options29 = {}) {
        const n2 = fileName;
        const t3 = options29.type;
        const d2 = options29.lastModified ?? Date.now();
        this[kState] = {
          blobLike,
          name: n2,
          type: t3,
          lastModified: d2
        };
      }
      stream(...args) {
        webidl.brandCheck(this, FileLike);
        return this[kState].blobLike.stream(...args);
      }
      arrayBuffer(...args) {
        webidl.brandCheck(this, FileLike);
        return this[kState].blobLike.arrayBuffer(...args);
      }
      slice(...args) {
        webidl.brandCheck(this, FileLike);
        return this[kState].blobLike.slice(...args);
      }
      text(...args) {
        webidl.brandCheck(this, FileLike);
        return this[kState].blobLike.text(...args);
      }
      get size() {
        webidl.brandCheck(this, FileLike);
        return this[kState].blobLike.size;
      }
      get type() {
        webidl.brandCheck(this, FileLike);
        return this[kState].blobLike.type;
      }
      get name() {
        webidl.brandCheck(this, FileLike);
        return this[kState].name;
      }
      get lastModified() {
        webidl.brandCheck(this, FileLike);
        return this[kState].lastModified;
      }
      get [Symbol.toStringTag]() {
        return "File";
      }
    };
    __name(FileLike, "FileLike");
    Object.defineProperties(File6.prototype, {
      [Symbol.toStringTag]: {
        value: "File",
        configurable: true
      },
      name: kEnumerableProperty,
      lastModified: kEnumerableProperty
    });
    webidl.converters.Blob = webidl.interfaceConverter(Blob6);
    webidl.converters.BlobPart = function(V2, opts) {
      if (webidl.util.Type(V2) === "Object") {
        if (isBlobLike(V2)) {
          return webidl.converters.Blob(V2, { strict: false });
        }
        if (ArrayBuffer.isView(V2) || types.isAnyArrayBuffer(V2)) {
          return webidl.converters.BufferSource(V2, opts);
        }
      }
      return webidl.converters.USVString(V2, opts);
    };
    webidl.converters["sequence<BlobPart>"] = webidl.sequenceConverter(
      webidl.converters.BlobPart
    );
    webidl.converters.FilePropertyBag = webidl.dictionaryConverter([
      {
        key: "lastModified",
        converter: webidl.converters["long long"],
        get defaultValue() {
          return Date.now();
        }
      },
      {
        key: "type",
        converter: webidl.converters.DOMString,
        defaultValue: ""
      },
      {
        key: "endings",
        converter: (value) => {
          value = webidl.converters.DOMString(value);
          value = value.toLowerCase();
          if (value !== "native") {
            value = "transparent";
          }
          return value;
        },
        defaultValue: "transparent"
      }
    ]);
    function processBlobParts(parts, options29) {
      const bytes = [];
      for (const element of parts) {
        if (typeof element === "string") {
          let s = element;
          if (options29.endings === "native") {
            s = convertLineEndingsNative(s);
          }
          bytes.push(encoder.encode(s));
        } else if (types.isAnyArrayBuffer(element) || types.isTypedArray(element)) {
          if (!element.buffer) {
            bytes.push(new Uint8Array(element));
          } else {
            bytes.push(
              new Uint8Array(element.buffer, element.byteOffset, element.byteLength)
            );
          }
        } else if (isBlobLike(element)) {
          bytes.push(element);
        }
      }
      return bytes;
    }
    __name(processBlobParts, "processBlobParts");
    function convertLineEndingsNative(s) {
      let nativeLineEnding = "\n";
      if (process.platform === "win32") {
        nativeLineEnding = "\r\n";
      }
      return s.replace(/\r?\n/g, nativeLineEnding);
    }
    __name(convertLineEndingsNative, "convertLineEndingsNative");
    function isFileLike(object) {
      return NativeFile && object instanceof NativeFile || object instanceof File6 || object && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && object[Symbol.toStringTag] === "File";
    }
    __name(isFileLike, "isFileLike");
    module3.exports = { File: File6, FileLike, isFileLike };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/formdata.js
var require_formdata = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/formdata.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { isBlobLike, toUSVString, makeIterator } = require_util2();
    var { kState } = require_symbols2();
    var { File: UndiciFile, FileLike, isFileLike } = require_file();
    var { webidl } = require_webidl();
    var { Blob: Blob6, File: NativeFile } = require("buffer");
    var File6 = NativeFile ?? UndiciFile;
    var FormData10 = class {
      constructor(form) {
        if (form !== void 0) {
          throw webidl.errors.conversionFailed({
            prefix: "FormData constructor",
            argument: "Argument 1",
            types: ["undefined"]
          });
        }
        this[kState] = [];
      }
      append(name, value, filename = void 0) {
        webidl.brandCheck(this, FormData10);
        webidl.argumentLengthCheck(arguments, 2, { header: "FormData.append" });
        if (arguments.length === 3 && !isBlobLike(value)) {
          throw new TypeError(
            "Failed to execute 'append' on 'FormData': parameter 2 is not of type 'Blob'"
          );
        }
        name = webidl.converters.USVString(name);
        value = isBlobLike(value) ? webidl.converters.Blob(value, { strict: false }) : webidl.converters.USVString(value);
        filename = arguments.length === 3 ? webidl.converters.USVString(filename) : void 0;
        const entry = makeEntry(name, value, filename);
        this[kState].push(entry);
      }
      delete(name) {
        webidl.brandCheck(this, FormData10);
        webidl.argumentLengthCheck(arguments, 1, { header: "FormData.delete" });
        name = webidl.converters.USVString(name);
        this[kState] = this[kState].filter((entry) => entry.name !== name);
      }
      get(name) {
        webidl.brandCheck(this, FormData10);
        webidl.argumentLengthCheck(arguments, 1, { header: "FormData.get" });
        name = webidl.converters.USVString(name);
        const idx = this[kState].findIndex((entry) => entry.name === name);
        if (idx === -1) {
          return null;
        }
        return this[kState][idx].value;
      }
      getAll(name) {
        webidl.brandCheck(this, FormData10);
        webidl.argumentLengthCheck(arguments, 1, { header: "FormData.getAll" });
        name = webidl.converters.USVString(name);
        return this[kState].filter((entry) => entry.name === name).map((entry) => entry.value);
      }
      has(name) {
        webidl.brandCheck(this, FormData10);
        webidl.argumentLengthCheck(arguments, 1, { header: "FormData.has" });
        name = webidl.converters.USVString(name);
        return this[kState].findIndex((entry) => entry.name === name) !== -1;
      }
      set(name, value, filename = void 0) {
        webidl.brandCheck(this, FormData10);
        webidl.argumentLengthCheck(arguments, 2, { header: "FormData.set" });
        if (arguments.length === 3 && !isBlobLike(value)) {
          throw new TypeError(
            "Failed to execute 'set' on 'FormData': parameter 2 is not of type 'Blob'"
          );
        }
        name = webidl.converters.USVString(name);
        value = isBlobLike(value) ? webidl.converters.Blob(value, { strict: false }) : webidl.converters.USVString(value);
        filename = arguments.length === 3 ? toUSVString(filename) : void 0;
        const entry = makeEntry(name, value, filename);
        const idx = this[kState].findIndex((entry2) => entry2.name === name);
        if (idx !== -1) {
          this[kState] = [
            ...this[kState].slice(0, idx),
            entry,
            ...this[kState].slice(idx + 1).filter((entry2) => entry2.name !== name)
          ];
        } else {
          this[kState].push(entry);
        }
      }
      entries() {
        webidl.brandCheck(this, FormData10);
        return makeIterator(
          () => this[kState].map((pair) => [pair.name, pair.value]),
          "FormData",
          "key+value"
        );
      }
      keys() {
        webidl.brandCheck(this, FormData10);
        return makeIterator(
          () => this[kState].map((pair) => [pair.name, pair.value]),
          "FormData",
          "key"
        );
      }
      values() {
        webidl.brandCheck(this, FormData10);
        return makeIterator(
          () => this[kState].map((pair) => [pair.name, pair.value]),
          "FormData",
          "value"
        );
      }
      /**
       * @param {(value: string, key: string, self: FormData) => void} callbackFn
       * @param {unknown} thisArg
       */
      forEach(callbackFn, thisArg = globalThis) {
        webidl.brandCheck(this, FormData10);
        webidl.argumentLengthCheck(arguments, 1, { header: "FormData.forEach" });
        if (typeof callbackFn !== "function") {
          throw new TypeError(
            "Failed to execute 'forEach' on 'FormData': parameter 1 is not of type 'Function'."
          );
        }
        for (const [key, value] of this) {
          callbackFn.apply(thisArg, [value, key, this]);
        }
      }
    };
    __name(FormData10, "FormData");
    FormData10.prototype[Symbol.iterator] = FormData10.prototype.entries;
    Object.defineProperties(FormData10.prototype, {
      [Symbol.toStringTag]: {
        value: "FormData",
        configurable: true
      }
    });
    function makeEntry(name, value, filename) {
      name = Buffer.from(name).toString("utf8");
      if (typeof value === "string") {
        value = Buffer.from(value).toString("utf8");
      } else {
        if (!isFileLike(value)) {
          value = value instanceof Blob6 ? new File6([value], "blob", { type: value.type }) : new FileLike(value, "blob", { type: value.type });
        }
        if (filename !== void 0) {
          const options29 = {
            type: value.type,
            lastModified: value.lastModified
          };
          value = NativeFile && value instanceof NativeFile || value instanceof UndiciFile ? new File6([value], filename, options29) : new FileLike(value, filename, options29);
        }
      }
      return { name, value };
    }
    __name(makeEntry, "makeEntry");
    module3.exports = { FormData: FormData10 };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/body.js
var require_body = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/body.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var Busboy = require_main();
    var util4 = require_util();
    var {
      ReadableStreamFrom,
      isBlobLike,
      isReadableStreamLike,
      readableStreamClose,
      createDeferredPromise,
      fullyReadBody
    } = require_util2();
    var { FormData: FormData10 } = require_formdata();
    var { kState } = require_symbols2();
    var { webidl } = require_webidl();
    var { DOMException: DOMException2, structuredClone } = require_constants();
    var { Blob: Blob6, File: NativeFile } = require("buffer");
    var { kBodyUsed } = require_symbols();
    var assert27 = require("assert");
    var { isErrored } = require_util();
    var { isUint8Array, isArrayBuffer } = require("util/types");
    var { File: UndiciFile } = require_file();
    var { parseMIMEType, serializeAMimeType } = require_dataURL();
    var ReadableStream2 = globalThis.ReadableStream;
    var File6 = NativeFile ?? UndiciFile;
    var textEncoder = new TextEncoder();
    var textDecoder = new TextDecoder();
    function extractBody(object, keepalive = false) {
      if (!ReadableStream2) {
        ReadableStream2 = require("stream/web").ReadableStream;
      }
      let stream2 = null;
      if (object instanceof ReadableStream2) {
        stream2 = object;
      } else if (isBlobLike(object)) {
        stream2 = object.stream();
      } else {
        stream2 = new ReadableStream2({
          async pull(controller) {
            controller.enqueue(
              typeof source === "string" ? textEncoder.encode(source) : source
            );
            queueMicrotask(() => readableStreamClose(controller));
          },
          start() {
          },
          type: void 0
        });
      }
      assert27(isReadableStreamLike(stream2));
      let action = null;
      let source = null;
      let length = null;
      let type = null;
      if (typeof object === "string") {
        source = object;
        type = "text/plain;charset=UTF-8";
      } else if (object instanceof URLSearchParams) {
        source = object.toString();
        type = "application/x-www-form-urlencoded;charset=UTF-8";
      } else if (isArrayBuffer(object)) {
        source = new Uint8Array(object.slice());
      } else if (ArrayBuffer.isView(object)) {
        source = new Uint8Array(object.buffer.slice(object.byteOffset, object.byteOffset + object.byteLength));
      } else if (util4.isFormDataLike(object)) {
        const boundary = `----formdata-undici-0${`${Math.floor(Math.random() * 1e11)}`.padStart(11, "0")}`;
        const prefix = `--${boundary}\r
Content-Disposition: form-data`;
        const escape2 = /* @__PURE__ */ __name((str) => str.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22"), "escape");
        const normalizeLinefeeds = /* @__PURE__ */ __name((value) => value.replace(/\r?\n|\r/g, "\r\n"), "normalizeLinefeeds");
        const blobParts = [];
        const rn = new Uint8Array([13, 10]);
        length = 0;
        let hasUnknownSizeValue = false;
        for (const [name, value] of object) {
          if (typeof value === "string") {
            const chunk2 = textEncoder.encode(prefix + `; name="${escape2(normalizeLinefeeds(name))}"\r
\r
${normalizeLinefeeds(value)}\r
`);
            blobParts.push(chunk2);
            length += chunk2.byteLength;
          } else {
            const chunk2 = textEncoder.encode(`${prefix}; name="${escape2(normalizeLinefeeds(name))}"` + (value.name ? `; filename="${escape2(value.name)}"` : "") + `\r
Content-Type: ${value.type || "application/octet-stream"}\r
\r
`);
            blobParts.push(chunk2, value, rn);
            if (typeof value.size === "number") {
              length += chunk2.byteLength + value.size + rn.byteLength;
            } else {
              hasUnknownSizeValue = true;
            }
          }
        }
        const chunk = textEncoder.encode(`--${boundary}--`);
        blobParts.push(chunk);
        length += chunk.byteLength;
        if (hasUnknownSizeValue) {
          length = null;
        }
        source = object;
        action = /* @__PURE__ */ __name(async function* () {
          for (const part of blobParts) {
            if (part.stream) {
              yield* part.stream();
            } else {
              yield part;
            }
          }
        }, "action");
        type = "multipart/form-data; boundary=" + boundary;
      } else if (isBlobLike(object)) {
        source = object;
        length = object.size;
        if (object.type) {
          type = object.type;
        }
      } else if (typeof object[Symbol.asyncIterator] === "function") {
        if (keepalive) {
          throw new TypeError("keepalive");
        }
        if (util4.isDisturbed(object) || object.locked) {
          throw new TypeError(
            "Response body object should not be disturbed or locked"
          );
        }
        stream2 = object instanceof ReadableStream2 ? object : ReadableStreamFrom(object);
      }
      if (typeof source === "string" || util4.isBuffer(source)) {
        length = Buffer.byteLength(source);
      }
      if (action != null) {
        let iterator;
        stream2 = new ReadableStream2({
          async start() {
            iterator = action(object)[Symbol.asyncIterator]();
          },
          async pull(controller) {
            const { value, done } = await iterator.next();
            if (done) {
              queueMicrotask(() => {
                controller.close();
              });
            } else {
              if (!isErrored(stream2)) {
                controller.enqueue(new Uint8Array(value));
              }
            }
            return controller.desiredSize > 0;
          },
          async cancel(reason) {
            await iterator.return();
          },
          type: void 0
        });
      }
      const body = { stream: stream2, source, length };
      return [body, type];
    }
    __name(extractBody, "extractBody");
    function safelyExtractBody(object, keepalive = false) {
      if (!ReadableStream2) {
        ReadableStream2 = require("stream/web").ReadableStream;
      }
      if (object instanceof ReadableStream2) {
        assert27(!util4.isDisturbed(object), "The body has already been consumed.");
        assert27(!object.locked, "The stream is locked.");
      }
      return extractBody(object, keepalive);
    }
    __name(safelyExtractBody, "safelyExtractBody");
    function cloneBody(body) {
      const [out1, out2] = body.stream.tee();
      const out2Clone = structuredClone(out2, { transfer: [out2] });
      const [, finalClone] = out2Clone.tee();
      body.stream = out1;
      return {
        stream: finalClone,
        length: body.length,
        source: body.source
      };
    }
    __name(cloneBody, "cloneBody");
    async function* consumeBody(body) {
      if (body) {
        if (isUint8Array(body)) {
          yield body;
        } else {
          const stream2 = body.stream;
          if (util4.isDisturbed(stream2)) {
            throw new TypeError("The body has already been consumed.");
          }
          if (stream2.locked) {
            throw new TypeError("The stream is locked.");
          }
          stream2[kBodyUsed] = true;
          yield* stream2;
        }
      }
    }
    __name(consumeBody, "consumeBody");
    function throwIfAborted(state) {
      if (state.aborted) {
        throw new DOMException2("The operation was aborted.", "AbortError");
      }
    }
    __name(throwIfAborted, "throwIfAborted");
    function bodyMixinMethods(instance) {
      const methods = {
        blob() {
          return specConsumeBody(this, (bytes) => {
            let mimeType = bodyMimeType(this);
            if (mimeType === "failure") {
              mimeType = "";
            } else if (mimeType) {
              mimeType = serializeAMimeType(mimeType);
            }
            return new Blob6([bytes], { type: mimeType });
          }, instance);
        },
        arrayBuffer() {
          return specConsumeBody(this, (bytes) => {
            return new Uint8Array(bytes).buffer;
          }, instance);
        },
        text() {
          return specConsumeBody(this, utf8DecodeBytes, instance);
        },
        json() {
          return specConsumeBody(this, parseJSONFromBytes, instance);
        },
        async formData() {
          webidl.brandCheck(this, instance);
          throwIfAborted(this[kState]);
          const contentType = this.headers.get("Content-Type");
          if (/multipart\/form-data/.test(contentType)) {
            const headers = {};
            for (const [key, value] of this.headers)
              headers[key.toLowerCase()] = value;
            const responseFormData = new FormData10();
            let busboy;
            try {
              busboy = new Busboy({
                headers,
                preservePath: true
              });
            } catch (err) {
              throw new DOMException2(`${err}`, "AbortError");
            }
            busboy.on("field", (name, value) => {
              responseFormData.append(name, value);
            });
            busboy.on("file", (name, value, filename, encoding, mimeType) => {
              const chunks = [];
              if (encoding === "base64" || encoding.toLowerCase() === "base64") {
                let base64chunk = "";
                value.on("data", (chunk) => {
                  base64chunk += chunk.toString().replace(/[\r\n]/gm, "");
                  const end = base64chunk.length - base64chunk.length % 4;
                  chunks.push(Buffer.from(base64chunk.slice(0, end), "base64"));
                  base64chunk = base64chunk.slice(end);
                });
                value.on("end", () => {
                  chunks.push(Buffer.from(base64chunk, "base64"));
                  responseFormData.append(name, new File6(chunks, filename, { type: mimeType }));
                });
              } else {
                value.on("data", (chunk) => {
                  chunks.push(chunk);
                });
                value.on("end", () => {
                  responseFormData.append(name, new File6(chunks, filename, { type: mimeType }));
                });
              }
            });
            const busboyResolve = new Promise((resolve19, reject) => {
              busboy.on("finish", resolve19);
              busboy.on("error", (err) => reject(new TypeError(err)));
            });
            if (this.body !== null)
              for await (const chunk of consumeBody(this[kState].body))
                busboy.write(chunk);
            busboy.end();
            await busboyResolve;
            return responseFormData;
          } else if (/application\/x-www-form-urlencoded/.test(contentType)) {
            let entries;
            try {
              let text = "";
              const streamingDecoder = new TextDecoder("utf-8", { ignoreBOM: true });
              for await (const chunk of consumeBody(this[kState].body)) {
                if (!isUint8Array(chunk)) {
                  throw new TypeError("Expected Uint8Array chunk");
                }
                text += streamingDecoder.decode(chunk, { stream: true });
              }
              text += streamingDecoder.decode();
              entries = new URLSearchParams(text);
            } catch (err) {
              throw Object.assign(new TypeError(), { cause: err });
            }
            const formData = new FormData10();
            for (const [name, value] of entries) {
              formData.append(name, value);
            }
            return formData;
          } else {
            await Promise.resolve();
            throwIfAborted(this[kState]);
            throw webidl.errors.exception({
              header: `${instance.name}.formData`,
              message: "Could not parse content as FormData."
            });
          }
        }
      };
      return methods;
    }
    __name(bodyMixinMethods, "bodyMixinMethods");
    function mixinBody(prototype) {
      Object.assign(prototype.prototype, bodyMixinMethods(prototype));
    }
    __name(mixinBody, "mixinBody");
    async function specConsumeBody(object, convertBytesToJSValue, instance) {
      webidl.brandCheck(object, instance);
      throwIfAborted(object[kState]);
      if (bodyUnusable(object[kState].body)) {
        throw new TypeError("Body is unusable");
      }
      const promise = createDeferredPromise();
      const errorSteps = /* @__PURE__ */ __name((error2) => promise.reject(error2), "errorSteps");
      const successSteps = /* @__PURE__ */ __name((data) => {
        try {
          promise.resolve(convertBytesToJSValue(data));
        } catch (e3) {
          errorSteps(e3);
        }
      }, "successSteps");
      if (object[kState].body == null) {
        successSteps(new Uint8Array());
        return promise.promise;
      }
      await fullyReadBody(object[kState].body, successSteps, errorSteps);
      return promise.promise;
    }
    __name(specConsumeBody, "specConsumeBody");
    function bodyUnusable(body) {
      return body != null && (body.stream.locked || util4.isDisturbed(body.stream));
    }
    __name(bodyUnusable, "bodyUnusable");
    function utf8DecodeBytes(buffer) {
      if (buffer.length === 0) {
        return "";
      }
      if (buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) {
        buffer = buffer.subarray(3);
      }
      const output = textDecoder.decode(buffer);
      return output;
    }
    __name(utf8DecodeBytes, "utf8DecodeBytes");
    function parseJSONFromBytes(bytes) {
      return JSON.parse(utf8DecodeBytes(bytes));
    }
    __name(parseJSONFromBytes, "parseJSONFromBytes");
    function bodyMimeType(object) {
      const { headersList } = object[kState];
      const contentType = headersList.get("content-type");
      if (contentType === null) {
        return "failure";
      }
      return parseMIMEType(contentType);
    }
    __name(bodyMimeType, "bodyMimeType");
    module3.exports = {
      extractBody,
      safelyExtractBody,
      cloneBody,
      mixinBody
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/core/request.js
var require_request = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/core/request.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var {
      InvalidArgumentError,
      NotSupportedError
    } = require_errors();
    var assert27 = require("assert");
    var { kHTTP2BuildRequest, kHTTP2CopyHeaders, kHTTP1BuildRequest } = require_symbols();
    var util4 = require_util();
    var tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/;
    var headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
    var invalidPathRegex = /[^\u0021-\u00ff]/;
    var kHandler = Symbol("handler");
    var channels = {};
    var extractBody;
    try {
      const diagnosticsChannel = require("diagnostics_channel");
      channels.create = diagnosticsChannel.channel("undici:request:create");
      channels.bodySent = diagnosticsChannel.channel("undici:request:bodySent");
      channels.headers = diagnosticsChannel.channel("undici:request:headers");
      channels.trailers = diagnosticsChannel.channel("undici:request:trailers");
      channels.error = diagnosticsChannel.channel("undici:request:error");
    } catch {
      channels.create = { hasSubscribers: false };
      channels.bodySent = { hasSubscribers: false };
      channels.headers = { hasSubscribers: false };
      channels.trailers = { hasSubscribers: false };
      channels.error = { hasSubscribers: false };
    }
    var Request3 = class {
      constructor(origin, {
        path: path67,
        method,
        body,
        headers,
        query,
        idempotent,
        blocking,
        upgrade,
        headersTimeout,
        bodyTimeout,
        reset,
        throwOnError,
        expectContinue
      }, handler30) {
        if (typeof path67 !== "string") {
          throw new InvalidArgumentError("path must be a string");
        } else if (path67[0] !== "/" && !(path67.startsWith("http://") || path67.startsWith("https://")) && method !== "CONNECT") {
          throw new InvalidArgumentError("path must be an absolute URL or start with a slash");
        } else if (invalidPathRegex.exec(path67) !== null) {
          throw new InvalidArgumentError("invalid request path");
        }
        if (typeof method !== "string") {
          throw new InvalidArgumentError("method must be a string");
        } else if (tokenRegExp.exec(method) === null) {
          throw new InvalidArgumentError("invalid request method");
        }
        if (upgrade && typeof upgrade !== "string") {
          throw new InvalidArgumentError("upgrade must be a string");
        }
        if (headersTimeout != null && (!Number.isFinite(headersTimeout) || headersTimeout < 0)) {
          throw new InvalidArgumentError("invalid headersTimeout");
        }
        if (bodyTimeout != null && (!Number.isFinite(bodyTimeout) || bodyTimeout < 0)) {
          throw new InvalidArgumentError("invalid bodyTimeout");
        }
        if (reset != null && typeof reset !== "boolean") {
          throw new InvalidArgumentError("invalid reset");
        }
        if (expectContinue != null && typeof expectContinue !== "boolean") {
          throw new InvalidArgumentError("invalid expectContinue");
        }
        this.headersTimeout = headersTimeout;
        this.bodyTimeout = bodyTimeout;
        this.throwOnError = throwOnError === true;
        this.method = method;
        this.abort = null;
        if (body == null) {
          this.body = null;
        } else if (util4.isStream(body)) {
          this.body = body;
          const rState = this.body._readableState;
          if (!rState || !rState.autoDestroy) {
            this.endHandler = /* @__PURE__ */ __name(function autoDestroy() {
              util4.destroy(this);
            }, "autoDestroy");
            this.body.on("end", this.endHandler);
          }
          this.errorHandler = (err) => {
            if (this.abort) {
              this.abort(err);
            } else {
              this.error = err;
            }
          };
          this.body.on("error", this.errorHandler);
        } else if (util4.isBuffer(body)) {
          this.body = body.byteLength ? body : null;
        } else if (ArrayBuffer.isView(body)) {
          this.body = body.buffer.byteLength ? Buffer.from(body.buffer, body.byteOffset, body.byteLength) : null;
        } else if (body instanceof ArrayBuffer) {
          this.body = body.byteLength ? Buffer.from(body) : null;
        } else if (typeof body === "string") {
          this.body = body.length ? Buffer.from(body) : null;
        } else if (util4.isFormDataLike(body) || util4.isIterable(body) || util4.isBlobLike(body)) {
          this.body = body;
        } else {
          throw new InvalidArgumentError("body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable");
        }
        this.completed = false;
        this.aborted = false;
        this.upgrade = upgrade || null;
        this.path = query ? util4.buildURL(path67, query) : path67;
        this.origin = origin;
        this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent;
        this.blocking = blocking == null ? false : blocking;
        this.reset = reset == null ? null : reset;
        this.host = null;
        this.contentLength = null;
        this.contentType = null;
        this.headers = "";
        this.expectContinue = expectContinue != null ? expectContinue : false;
        if (Array.isArray(headers)) {
          if (headers.length % 2 !== 0) {
            throw new InvalidArgumentError("headers array must be even");
          }
          for (let i = 0; i < headers.length; i += 2) {
            processHeader(this, headers[i], headers[i + 1]);
          }
        } else if (headers && typeof headers === "object") {
          const keys = Object.keys(headers);
          for (let i = 0; i < keys.length; i++) {
            const key = keys[i];
            processHeader(this, key, headers[key]);
          }
        } else if (headers != null) {
          throw new InvalidArgumentError("headers must be an object or an array");
        }
        if (util4.isFormDataLike(this.body)) {
          if (util4.nodeMajor < 16 || util4.nodeMajor === 16 && util4.nodeMinor < 8) {
            throw new InvalidArgumentError("Form-Data bodies are only supported in node v16.8 and newer.");
          }
          if (!extractBody) {
            extractBody = require_body().extractBody;
          }
          const [bodyStream, contentType] = extractBody(body);
          if (this.contentType == null) {
            this.contentType = contentType;
            this.headers += `content-type: ${contentType}\r
`;
          }
          this.body = bodyStream.stream;
          this.contentLength = bodyStream.length;
        } else if (util4.isBlobLike(body) && this.contentType == null && body.type) {
          this.contentType = body.type;
          this.headers += `content-type: ${body.type}\r
`;
        }
        util4.validateHandler(handler30, method, upgrade);
        this.servername = util4.getServerName(this.host);
        this[kHandler] = handler30;
        if (channels.create.hasSubscribers) {
          channels.create.publish({ request: this });
        }
      }
      onBodySent(chunk) {
        if (this[kHandler].onBodySent) {
          try {
            return this[kHandler].onBodySent(chunk);
          } catch (err) {
            this.abort(err);
          }
        }
      }
      onRequestSent() {
        if (channels.bodySent.hasSubscribers) {
          channels.bodySent.publish({ request: this });
        }
        if (this[kHandler].onRequestSent) {
          try {
            return this[kHandler].onRequestSent();
          } catch (err) {
            this.abort(err);
          }
        }
      }
      onConnect(abort) {
        assert27(!this.aborted);
        assert27(!this.completed);
        if (this.error) {
          abort(this.error);
        } else {
          this.abort = abort;
          return this[kHandler].onConnect(abort);
        }
      }
      onHeaders(statusCode, headers, resume, statusText) {
        assert27(!this.aborted);
        assert27(!this.completed);
        if (channels.headers.hasSubscribers) {
          channels.headers.publish({ request: this, response: { statusCode, headers, statusText } });
        }
        try {
          return this[kHandler].onHeaders(statusCode, headers, resume, statusText);
        } catch (err) {
          this.abort(err);
        }
      }
      onData(chunk) {
        assert27(!this.aborted);
        assert27(!this.completed);
        try {
          return this[kHandler].onData(chunk);
        } catch (err) {
          this.abort(err);
          return false;
        }
      }
      onUpgrade(statusCode, headers, socket) {
        assert27(!this.aborted);
        assert27(!this.completed);
        return this[kHandler].onUpgrade(statusCode, headers, socket);
      }
      onComplete(trailers) {
        this.onFinally();
        assert27(!this.aborted);
        this.completed = true;
        if (channels.trailers.hasSubscribers) {
          channels.trailers.publish({ request: this, trailers });
        }
        try {
          return this[kHandler].onComplete(trailers);
        } catch (err) {
          this.onError(err);
        }
      }
      onError(error2) {
        this.onFinally();
        if (channels.error.hasSubscribers) {
          channels.error.publish({ request: this, error: error2 });
        }
        if (this.aborted) {
          return;
        }
        this.aborted = true;
        return this[kHandler].onError(error2);
      }
      onFinally() {
        if (this.errorHandler) {
          this.body.off("error", this.errorHandler);
          this.errorHandler = null;
        }
        if (this.endHandler) {
          this.body.off("end", this.endHandler);
          this.endHandler = null;
        }
      }
      // TODO: adjust to support H2
      addHeader(key, value) {
        processHeader(this, key, value);
        return this;
      }
      static [kHTTP1BuildRequest](origin, opts, handler30) {
        return new Request3(origin, opts, handler30);
      }
      static [kHTTP2BuildRequest](origin, opts, handler30) {
        const headers = opts.headers;
        opts = { ...opts, headers: null };
        const request3 = new Request3(origin, opts, handler30);
        request3.headers = {};
        if (Array.isArray(headers)) {
          if (headers.length % 2 !== 0) {
            throw new InvalidArgumentError("headers array must be even");
          }
          for (let i = 0; i < headers.length; i += 2) {
            processHeader(request3, headers[i], headers[i + 1], true);
          }
        } else if (headers && typeof headers === "object") {
          const keys = Object.keys(headers);
          for (let i = 0; i < keys.length; i++) {
            const key = keys[i];
            processHeader(request3, key, headers[key], true);
          }
        } else if (headers != null) {
          throw new InvalidArgumentError("headers must be an object or an array");
        }
        return request3;
      }
      static [kHTTP2CopyHeaders](raw) {
        const rawHeaders = raw.split("\r\n");
        const headers = {};
        for (const header of rawHeaders) {
          const [key, value] = header.split(": ");
          if (value == null || value.length === 0)
            continue;
          if (headers[key])
            headers[key] += `,${value}`;
          else
            headers[key] = value;
        }
        return headers;
      }
    };
    __name(Request3, "Request");
    function processHeaderValue(key, val, skipAppend) {
      if (val && typeof val === "object") {
        throw new InvalidArgumentError(`invalid ${key} header`);
      }
      val = val != null ? `${val}` : "";
      if (headerCharRegex.exec(val) !== null) {
        throw new InvalidArgumentError(`invalid ${key} header`);
      }
      return skipAppend ? val : `${key}: ${val}\r
`;
    }
    __name(processHeaderValue, "processHeaderValue");
    function processHeader(request3, key, val, skipAppend = false) {
      if (val && (typeof val === "object" && !Array.isArray(val))) {
        throw new InvalidArgumentError(`invalid ${key} header`);
      } else if (val === void 0) {
        return;
      }
      if (request3.host === null && key.length === 4 && key.toLowerCase() === "host") {
        if (headerCharRegex.exec(val) !== null) {
          throw new InvalidArgumentError(`invalid ${key} header`);
        }
        request3.host = val;
      } else if (request3.contentLength === null && key.length === 14 && key.toLowerCase() === "content-length") {
        request3.contentLength = parseInt(val, 10);
        if (!Number.isFinite(request3.contentLength)) {
          throw new InvalidArgumentError("invalid content-length header");
        }
      } else if (request3.contentType === null && key.length === 12 && key.toLowerCase() === "content-type") {
        request3.contentType = val;
        if (skipAppend)
          request3.headers[key] = processHeaderValue(key, val, skipAppend);
        else
          request3.headers += processHeaderValue(key, val);
      } else if (key.length === 17 && key.toLowerCase() === "transfer-encoding") {
        throw new InvalidArgumentError("invalid transfer-encoding header");
      } else if (key.length === 10 && key.toLowerCase() === "connection") {
        const value = typeof val === "string" ? val.toLowerCase() : null;
        if (value !== "close" && value !== "keep-alive") {
          throw new InvalidArgumentError("invalid connection header");
        } else if (value === "close") {
          request3.reset = true;
        }
      } else if (key.length === 10 && key.toLowerCase() === "keep-alive") {
        throw new InvalidArgumentError("invalid keep-alive header");
      } else if (key.length === 7 && key.toLowerCase() === "upgrade") {
        throw new InvalidArgumentError("invalid upgrade header");
      } else if (key.length === 6 && key.toLowerCase() === "expect") {
        throw new NotSupportedError("expect header not supported");
      } else if (tokenRegExp.exec(key) === null) {
        throw new InvalidArgumentError("invalid header key");
      } else {
        if (Array.isArray(val)) {
          for (let i = 0; i < val.length; i++) {
            if (skipAppend) {
              if (request3.headers[key])
                request3.headers[key] += `,${processHeaderValue(key, val[i], skipAppend)}`;
              else
                request3.headers[key] = processHeaderValue(key, val[i], skipAppend);
            } else {
              request3.headers += processHeaderValue(key, val[i]);
            }
          }
        } else {
          if (skipAppend)
            request3.headers[key] = processHeaderValue(key, val, skipAppend);
          else
            request3.headers += processHeaderValue(key, val);
        }
      }
    }
    __name(processHeader, "processHeader");
    module3.exports = Request3;
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/dispatcher.js
var require_dispatcher = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/dispatcher.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var EventEmitter7 = require("events");
    var Dispatcher2 = class extends EventEmitter7 {
      dispatch() {
        throw new Error("not implemented");
      }
      close() {
        throw new Error("not implemented");
      }
      destroy() {
        throw new Error("not implemented");
      }
    };
    __name(Dispatcher2, "Dispatcher");
    module3.exports = Dispatcher2;
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/dispatcher-base.js
var require_dispatcher_base = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/dispatcher-base.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var Dispatcher2 = require_dispatcher();
    var {
      ClientDestroyedError,
      ClientClosedError,
      InvalidArgumentError
    } = require_errors();
    var { kDestroy, kClose, kDispatch, kInterceptors } = require_symbols();
    var kDestroyed = Symbol("destroyed");
    var kClosed = Symbol("closed");
    var kOnDestroyed = Symbol("onDestroyed");
    var kOnClosed = Symbol("onClosed");
    var kInterceptedDispatch = Symbol("Intercepted Dispatch");
    var DispatcherBase = class extends Dispatcher2 {
      constructor() {
        super();
        this[kDestroyed] = false;
        this[kOnDestroyed] = null;
        this[kClosed] = false;
        this[kOnClosed] = [];
      }
      get destroyed() {
        return this[kDestroyed];
      }
      get closed() {
        return this[kClosed];
      }
      get interceptors() {
        return this[kInterceptors];
      }
      set interceptors(newInterceptors) {
        if (newInterceptors) {
          for (let i = newInterceptors.length - 1; i >= 0; i--) {
            const interceptor = this[kInterceptors][i];
            if (typeof interceptor !== "function") {
              throw new InvalidArgumentError("interceptor must be an function");
            }
          }
        }
        this[kInterceptors] = newInterceptors;
      }
      close(callback) {
        if (callback === void 0) {
          return new Promise((resolve19, reject) => {
            this.close((err, data) => {
              return err ? reject(err) : resolve19(data);
            });
          });
        }
        if (typeof callback !== "function") {
          throw new InvalidArgumentError("invalid callback");
        }
        if (this[kDestroyed]) {
          queueMicrotask(() => callback(new ClientDestroyedError(), null));
          return;
        }
        if (this[kClosed]) {
          if (this[kOnClosed]) {
            this[kOnClosed].push(callback);
          } else {
            queueMicrotask(() => callback(null, null));
          }
          return;
        }
        this[kClosed] = true;
        this[kOnClosed].push(callback);
        const onClosed = /* @__PURE__ */ __name(() => {
          const callbacks = this[kOnClosed];
          this[kOnClosed] = null;
          for (let i = 0; i < callbacks.length; i++) {
            callbacks[i](null, null);
          }
        }, "onClosed");
        this[kClose]().then(() => this.destroy()).then(() => {
          queueMicrotask(onClosed);
        });
      }
      destroy(err, callback) {
        if (typeof err === "function") {
          callback = err;
          err = null;
        }
        if (callback === void 0) {
          return new Promise((resolve19, reject) => {
            this.destroy(err, (err2, data) => {
              return err2 ? (
                /* istanbul ignore next: should never error */
                reject(err2)
              ) : resolve19(data);
            });
          });
        }
        if (typeof callback !== "function") {
          throw new InvalidArgumentError("invalid callback");
        }
        if (this[kDestroyed]) {
          if (this[kOnDestroyed]) {
            this[kOnDestroyed].push(callback);
          } else {
            queueMicrotask(() => callback(null, null));
          }
          return;
        }
        if (!err) {
          err = new ClientDestroyedError();
        }
        this[kDestroyed] = true;
        this[kOnDestroyed] = this[kOnDestroyed] || [];
        this[kOnDestroyed].push(callback);
        const onDestroyed = /* @__PURE__ */ __name(() => {
          const callbacks = this[kOnDestroyed];
          this[kOnDestroyed] = null;
          for (let i = 0; i < callbacks.length; i++) {
            callbacks[i](null, null);
          }
        }, "onDestroyed");
        this[kDestroy](err).then(() => {
          queueMicrotask(onDestroyed);
        });
      }
      [kInterceptedDispatch](opts, handler30) {
        if (!this[kInterceptors] || this[kInterceptors].length === 0) {
          this[kInterceptedDispatch] = this[kDispatch];
          return this[kDispatch](opts, handler30);
        }
        let dispatch = this[kDispatch].bind(this);
        for (let i = this[kInterceptors].length - 1; i >= 0; i--) {
          dispatch = this[kInterceptors][i](dispatch);
        }
        this[kInterceptedDispatch] = dispatch;
        return dispatch(opts, handler30);
      }
      dispatch(opts, handler30) {
        if (!handler30 || typeof handler30 !== "object") {
          throw new InvalidArgumentError("handler must be an object");
        }
        try {
          if (!opts || typeof opts !== "object") {
            throw new InvalidArgumentError("opts must be an object.");
          }
          if (this[kDestroyed] || this[kOnDestroyed]) {
            throw new ClientDestroyedError();
          }
          if (this[kClosed]) {
            throw new ClientClosedError();
          }
          return this[kInterceptedDispatch](opts, handler30);
        } catch (err) {
          if (typeof handler30.onError !== "function") {
            throw new InvalidArgumentError("invalid onError method");
          }
          handler30.onError(err);
          return false;
        }
      }
    };
    __name(DispatcherBase, "DispatcherBase");
    module3.exports = DispatcherBase;
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/core/connect.js
var require_connect = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/core/connect.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var net3 = require("net");
    var assert27 = require("assert");
    var util4 = require_util();
    var { InvalidArgumentError, ConnectTimeoutError } = require_errors();
    var tls;
    var SessionCache;
    if (global.FinalizationRegistry && !process.env.NODE_V8_COVERAGE) {
      SessionCache = /* @__PURE__ */ __name(class WeakSessionCache {
        constructor(maxCachedSessions) {
          this._maxCachedSessions = maxCachedSessions;
          this._sessionCache = /* @__PURE__ */ new Map();
          this._sessionRegistry = new global.FinalizationRegistry((key) => {
            if (this._sessionCache.size < this._maxCachedSessions) {
              return;
            }
            const ref = this._sessionCache.get(key);
            if (ref !== void 0 && ref.deref() === void 0) {
              this._sessionCache.delete(key);
            }
          });
        }
        get(sessionKey) {
          const ref = this._sessionCache.get(sessionKey);
          return ref ? ref.deref() : null;
        }
        set(sessionKey, session) {
          if (this._maxCachedSessions === 0) {
            return;
          }
          this._sessionCache.set(sessionKey, new WeakRef(session));
          this._sessionRegistry.register(session, sessionKey);
        }
      }, "WeakSessionCache");
    } else {
      SessionCache = /* @__PURE__ */ __name(class SimpleSessionCache {
        constructor(maxCachedSessions) {
          this._maxCachedSessions = maxCachedSessions;
          this._sessionCache = /* @__PURE__ */ new Map();
        }
        get(sessionKey) {
          return this._sessionCache.get(sessionKey);
        }
        set(sessionKey, session) {
          if (this._maxCachedSessions === 0) {
            return;
          }
          if (this._sessionCache.size >= this._maxCachedSessions) {
            const { value: oldestKey } = this._sessionCache.keys().next();
            this._sessionCache.delete(oldestKey);
          }
          this._sessionCache.set(sessionKey, session);
        }
      }, "SimpleSessionCache");
    }
    function buildConnector({ allowH2, maxCachedSessions, socketPath, timeout, ...opts }) {
      if (maxCachedSessions != null && (!Number.isInteger(maxCachedSessions) || maxCachedSessions < 0)) {
        throw new InvalidArgumentError("maxCachedSessions must be a positive integer or zero");
      }
      const options29 = { path: socketPath, ...opts };
      const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions);
      timeout = timeout == null ? 1e4 : timeout;
      allowH2 = allowH2 != null ? allowH2 : false;
      return /* @__PURE__ */ __name(function connect2({ hostname: hostname2, host, protocol, port: port2, servername, localAddress, httpSocket }, callback) {
        let socket;
        if (protocol === "https:") {
          if (!tls) {
            tls = require("tls");
          }
          servername = servername || options29.servername || util4.getServerName(host) || null;
          const sessionKey = servername || hostname2;
          const session = sessionCache.get(sessionKey) || null;
          assert27(sessionKey);
          socket = tls.connect({
            highWaterMark: 16384,
            // TLS in node can't have bigger HWM anyway...
            ...options29,
            servername,
            session,
            localAddress,
            // TODO(HTTP/2): Add support for h2c
            ALPNProtocols: allowH2 ? ["http/1.1", "h2"] : ["http/1.1"],
            socket: httpSocket,
            // upgrade socket connection
            port: port2 || 443,
            host: hostname2
          });
          socket.on("session", function(session2) {
            sessionCache.set(sessionKey, session2);
          });
        } else {
          assert27(!httpSocket, "httpSocket can only be sent on TLS update");
          socket = net3.connect({
            highWaterMark: 64 * 1024,
            // Same as nodejs fs streams.
            ...options29,
            localAddress,
            port: port2 || 80,
            host: hostname2
          });
        }
        if (options29.keepAlive == null || options29.keepAlive) {
          const keepAliveInitialDelay = options29.keepAliveInitialDelay === void 0 ? 6e4 : options29.keepAliveInitialDelay;
          socket.setKeepAlive(true, keepAliveInitialDelay);
        }
        const cancelTimeout = setupTimeout2(() => onConnectTimeout(socket), timeout);
        socket.setNoDelay(true).once(protocol === "https:" ? "secureConnect" : "connect", function() {
          cancelTimeout();
          if (callback) {
            const cb = callback;
            callback = null;
            cb(null, this);
          }
        }).on("error", function(err) {
          cancelTimeout();
          if (callback) {
            const cb = callback;
            callback = null;
            cb(err);
          }
        });
        return socket;
      }, "connect");
    }
    __name(buildConnector, "buildConnector");
    function setupTimeout2(onConnectTimeout2, timeout) {
      if (!timeout) {
        return () => {
        };
      }
      let s1 = null;
      let s2 = null;
      const timeoutId = setTimeout(() => {
        s1 = setImmediate(() => {
          if (process.platform === "win32") {
            s2 = setImmediate(() => onConnectTimeout2());
          } else {
            onConnectTimeout2();
          }
        });
      }, timeout);
      return () => {
        clearTimeout(timeoutId);
        clearImmediate(s1);
        clearImmediate(s2);
      };
    }
    __name(setupTimeout2, "setupTimeout");
    function onConnectTimeout(socket) {
      util4.destroy(socket, new ConnectTimeoutError());
    }
    __name(onConnectTimeout, "onConnectTimeout");
    module3.exports = buildConnector;
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/llhttp/utils.js
var require_utils = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/llhttp/utils.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.enumToMap = void 0;
    function enumToMap(obj) {
      const res = {};
      Object.keys(obj).forEach((key) => {
        const value = obj[key];
        if (typeof value === "number") {
          res[key] = value;
        }
      });
      return res;
    }
    __name(enumToMap, "enumToMap");
    exports2.enumToMap = enumToMap;
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/llhttp/constants.js
var require_constants2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/llhttp/constants.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.SPECIAL_HEADERS = exports2.HEADER_STATE = exports2.MINOR = exports2.MAJOR = exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS = exports2.TOKEN = exports2.STRICT_TOKEN = exports2.HEX = exports2.URL_CHAR = exports2.STRICT_URL_CHAR = exports2.USERINFO_CHARS = exports2.MARK = exports2.ALPHANUM = exports2.NUM = exports2.HEX_MAP = exports2.NUM_MAP = exports2.ALPHA = exports2.FINISH = exports2.H_METHOD_MAP = exports2.METHOD_MAP = exports2.METHODS_RTSP = exports2.METHODS_ICE = exports2.METHODS_HTTP = exports2.METHODS = exports2.LENIENT_FLAGS = exports2.FLAGS = exports2.TYPE = exports2.ERROR = void 0;
    var utils_1 = require_utils();
    var ERROR;
    (function(ERROR2) {
      ERROR2[ERROR2["OK"] = 0] = "OK";
      ERROR2[ERROR2["INTERNAL"] = 1] = "INTERNAL";
      ERROR2[ERROR2["STRICT"] = 2] = "STRICT";
      ERROR2[ERROR2["LF_EXPECTED"] = 3] = "LF_EXPECTED";
      ERROR2[ERROR2["UNEXPECTED_CONTENT_LENGTH"] = 4] = "UNEXPECTED_CONTENT_LENGTH";
      ERROR2[ERROR2["CLOSED_CONNECTION"] = 5] = "CLOSED_CONNECTION";
      ERROR2[ERROR2["INVALID_METHOD"] = 6] = "INVALID_METHOD";
      ERROR2[ERROR2["INVALID_URL"] = 7] = "INVALID_URL";
      ERROR2[ERROR2["INVALID_CONSTANT"] = 8] = "INVALID_CONSTANT";
      ERROR2[ERROR2["INVALID_VERSION"] = 9] = "INVALID_VERSION";
      ERROR2[ERROR2["INVALID_HEADER_TOKEN"] = 10] = "INVALID_HEADER_TOKEN";
      ERROR2[ERROR2["INVALID_CONTENT_LENGTH"] = 11] = "INVALID_CONTENT_LENGTH";
      ERROR2[ERROR2["INVALID_CHUNK_SIZE"] = 12] = "INVALID_CHUNK_SIZE";
      ERROR2[ERROR2["INVALID_STATUS"] = 13] = "INVALID_STATUS";
      ERROR2[ERROR2["INVALID_EOF_STATE"] = 14] = "INVALID_EOF_STATE";
      ERROR2[ERROR2["INVALID_TRANSFER_ENCODING"] = 15] = "INVALID_TRANSFER_ENCODING";
      ERROR2[ERROR2["CB_MESSAGE_BEGIN"] = 16] = "CB_MESSAGE_BEGIN";
      ERROR2[ERROR2["CB_HEADERS_COMPLETE"] = 17] = "CB_HEADERS_COMPLETE";
      ERROR2[ERROR2["CB_MESSAGE_COMPLETE"] = 18] = "CB_MESSAGE_COMPLETE";
      ERROR2[ERROR2["CB_CHUNK_HEADER"] = 19] = "CB_CHUNK_HEADER";
      ERROR2[ERROR2["CB_CHUNK_COMPLETE"] = 20] = "CB_CHUNK_COMPLETE";
      ERROR2[ERROR2["PAUSED"] = 21] = "PAUSED";
      ERROR2[ERROR2["PAUSED_UPGRADE"] = 22] = "PAUSED_UPGRADE";
      ERROR2[ERROR2["PAUSED_H2_UPGRADE"] = 23] = "PAUSED_H2_UPGRADE";
      ERROR2[ERROR2["USER"] = 24] = "USER";
    })(ERROR = exports2.ERROR || (exports2.ERROR = {}));
    var TYPE;
    (function(TYPE2) {
      TYPE2[TYPE2["BOTH"] = 0] = "BOTH";
      TYPE2[TYPE2["REQUEST"] = 1] = "REQUEST";
      TYPE2[TYPE2["RESPONSE"] = 2] = "RESPONSE";
    })(TYPE = exports2.TYPE || (exports2.TYPE = {}));
    var FLAGS;
    (function(FLAGS2) {
      FLAGS2[FLAGS2["CONNECTION_KEEP_ALIVE"] = 1] = "CONNECTION_KEEP_ALIVE";
      FLAGS2[FLAGS2["CONNECTION_CLOSE"] = 2] = "CONNECTION_CLOSE";
      FLAGS2[FLAGS2["CONNECTION_UPGRADE"] = 4] = "CONNECTION_UPGRADE";
      FLAGS2[FLAGS2["CHUNKED"] = 8] = "CHUNKED";
      FLAGS2[FLAGS2["UPGRADE"] = 16] = "UPGRADE";
      FLAGS2[FLAGS2["CONTENT_LENGTH"] = 32] = "CONTENT_LENGTH";
      FLAGS2[FLAGS2["SKIPBODY"] = 64] = "SKIPBODY";
      FLAGS2[FLAGS2["TRAILING"] = 128] = "TRAILING";
      FLAGS2[FLAGS2["TRANSFER_ENCODING"] = 512] = "TRANSFER_ENCODING";
    })(FLAGS = exports2.FLAGS || (exports2.FLAGS = {}));
    var LENIENT_FLAGS;
    (function(LENIENT_FLAGS2) {
      LENIENT_FLAGS2[LENIENT_FLAGS2["HEADERS"] = 1] = "HEADERS";
      LENIENT_FLAGS2[LENIENT_FLAGS2["CHUNKED_LENGTH"] = 2] = "CHUNKED_LENGTH";
      LENIENT_FLAGS2[LENIENT_FLAGS2["KEEP_ALIVE"] = 4] = "KEEP_ALIVE";
    })(LENIENT_FLAGS = exports2.LENIENT_FLAGS || (exports2.LENIENT_FLAGS = {}));
    var METHODS;
    (function(METHODS2) {
      METHODS2[METHODS2["DELETE"] = 0] = "DELETE";
      METHODS2[METHODS2["GET"] = 1] = "GET";
      METHODS2[METHODS2["HEAD"] = 2] = "HEAD";
      METHODS2[METHODS2["POST"] = 3] = "POST";
      METHODS2[METHODS2["PUT"] = 4] = "PUT";
      METHODS2[METHODS2["CONNECT"] = 5] = "CONNECT";
      METHODS2[METHODS2["OPTIONS"] = 6] = "OPTIONS";
      METHODS2[METHODS2["TRACE"] = 7] = "TRACE";
      METHODS2[METHODS2["COPY"] = 8] = "COPY";
      METHODS2[METHODS2["LOCK"] = 9] = "LOCK";
      METHODS2[METHODS2["MKCOL"] = 10] = "MKCOL";
      METHODS2[METHODS2["MOVE"] = 11] = "MOVE";
      METHODS2[METHODS2["PROPFIND"] = 12] = "PROPFIND";
      METHODS2[METHODS2["PROPPATCH"] = 13] = "PROPPATCH";
      METHODS2[METHODS2["SEARCH"] = 14] = "SEARCH";
      METHODS2[METHODS2["UNLOCK"] = 15] = "UNLOCK";
      METHODS2[METHODS2["BIND"] = 16] = "BIND";
      METHODS2[METHODS2["REBIND"] = 17] = "REBIND";
      METHODS2[METHODS2["UNBIND"] = 18] = "UNBIND";
      METHODS2[METHODS2["ACL"] = 19] = "ACL";
      METHODS2[METHODS2["REPORT"] = 20] = "REPORT";
      METHODS2[METHODS2["MKACTIVITY"] = 21] = "MKACTIVITY";
      METHODS2[METHODS2["CHECKOUT"] = 22] = "CHECKOUT";
      METHODS2[METHODS2["MERGE"] = 23] = "MERGE";
      METHODS2[METHODS2["M-SEARCH"] = 24] = "M-SEARCH";
      METHODS2[METHODS2["NOTIFY"] = 25] = "NOTIFY";
      METHODS2[METHODS2["SUBSCRIBE"] = 26] = "SUBSCRIBE";
      METHODS2[METHODS2["UNSUBSCRIBE"] = 27] = "UNSUBSCRIBE";
      METHODS2[METHODS2["PATCH"] = 28] = "PATCH";
      METHODS2[METHODS2["PURGE"] = 29] = "PURGE";
      METHODS2[METHODS2["MKCALENDAR"] = 30] = "MKCALENDAR";
      METHODS2[METHODS2["LINK"] = 31] = "LINK";
      METHODS2[METHODS2["UNLINK"] = 32] = "UNLINK";
      METHODS2[METHODS2["SOURCE"] = 33] = "SOURCE";
      METHODS2[METHODS2["PRI"] = 34] = "PRI";
      METHODS2[METHODS2["DESCRIBE"] = 35] = "DESCRIBE";
      METHODS2[METHODS2["ANNOUNCE"] = 36] = "ANNOUNCE";
      METHODS2[METHODS2["SETUP"] = 37] = "SETUP";
      METHODS2[METHODS2["PLAY"] = 38] = "PLAY";
      METHODS2[METHODS2["PAUSE"] = 39] = "PAUSE";
      METHODS2[METHODS2["TEARDOWN"] = 40] = "TEARDOWN";
      METHODS2[METHODS2["GET_PARAMETER"] = 41] = "GET_PARAMETER";
      METHODS2[METHODS2["SET_PARAMETER"] = 42] = "SET_PARAMETER";
      METHODS2[METHODS2["REDIRECT"] = 43] = "REDIRECT";
      METHODS2[METHODS2["RECORD"] = 44] = "RECORD";
      METHODS2[METHODS2["FLUSH"] = 45] = "FLUSH";
    })(METHODS = exports2.METHODS || (exports2.METHODS = {}));
    exports2.METHODS_HTTP = [
      METHODS.DELETE,
      METHODS.GET,
      METHODS.HEAD,
      METHODS.POST,
      METHODS.PUT,
      METHODS.CONNECT,
      METHODS.OPTIONS,
      METHODS.TRACE,
      METHODS.COPY,
      METHODS.LOCK,
      METHODS.MKCOL,
      METHODS.MOVE,
      METHODS.PROPFIND,
      METHODS.PROPPATCH,
      METHODS.SEARCH,
      METHODS.UNLOCK,
      METHODS.BIND,
      METHODS.REBIND,
      METHODS.UNBIND,
      METHODS.ACL,
      METHODS.REPORT,
      METHODS.MKACTIVITY,
      METHODS.CHECKOUT,
      METHODS.MERGE,
      METHODS["M-SEARCH"],
      METHODS.NOTIFY,
      METHODS.SUBSCRIBE,
      METHODS.UNSUBSCRIBE,
      METHODS.PATCH,
      METHODS.PURGE,
      METHODS.MKCALENDAR,
      METHODS.LINK,
      METHODS.UNLINK,
      METHODS.PRI,
      // TODO(indutny): should we allow it with HTTP?
      METHODS.SOURCE
    ];
    exports2.METHODS_ICE = [
      METHODS.SOURCE
    ];
    exports2.METHODS_RTSP = [
      METHODS.OPTIONS,
      METHODS.DESCRIBE,
      METHODS.ANNOUNCE,
      METHODS.SETUP,
      METHODS.PLAY,
      METHODS.PAUSE,
      METHODS.TEARDOWN,
      METHODS.GET_PARAMETER,
      METHODS.SET_PARAMETER,
      METHODS.REDIRECT,
      METHODS.RECORD,
      METHODS.FLUSH,
      // For AirPlay
      METHODS.GET,
      METHODS.POST
    ];
    exports2.METHOD_MAP = utils_1.enumToMap(METHODS);
    exports2.H_METHOD_MAP = {};
    Object.keys(exports2.METHOD_MAP).forEach((key) => {
      if (/^H/.test(key)) {
        exports2.H_METHOD_MAP[key] = exports2.METHOD_MAP[key];
      }
    });
    var FINISH;
    (function(FINISH2) {
      FINISH2[FINISH2["SAFE"] = 0] = "SAFE";
      FINISH2[FINISH2["SAFE_WITH_CB"] = 1] = "SAFE_WITH_CB";
      FINISH2[FINISH2["UNSAFE"] = 2] = "UNSAFE";
    })(FINISH = exports2.FINISH || (exports2.FINISH = {}));
    exports2.ALPHA = [];
    for (let i = "A".charCodeAt(0); i <= "Z".charCodeAt(0); i++) {
      exports2.ALPHA.push(String.fromCharCode(i));
      exports2.ALPHA.push(String.fromCharCode(i + 32));
    }
    exports2.NUM_MAP = {
      0: 0,
      1: 1,
      2: 2,
      3: 3,
      4: 4,
      5: 5,
      6: 6,
      7: 7,
      8: 8,
      9: 9
    };
    exports2.HEX_MAP = {
      0: 0,
      1: 1,
      2: 2,
      3: 3,
      4: 4,
      5: 5,
      6: 6,
      7: 7,
      8: 8,
      9: 9,
      A: 10,
      B: 11,
      C: 12,
      D: 13,
      E: 14,
      F: 15,
      a: 10,
      b: 11,
      c: 12,
      d: 13,
      e: 14,
      f: 15
    };
    exports2.NUM = [
      "0",
      "1",
      "2",
      "3",
      "4",
      "5",
      "6",
      "7",
      "8",
      "9"
    ];
    exports2.ALPHANUM = exports2.ALPHA.concat(exports2.NUM);
    exports2.MARK = ["-", "_", ".", "!", "~", "*", "'", "(", ")"];
    exports2.USERINFO_CHARS = exports2.ALPHANUM.concat(exports2.MARK).concat(["%", ";", ":", "&", "=", "+", "$", ","]);
    exports2.STRICT_URL_CHAR = [
      "!",
      '"',
      "$",
      "%",
      "&",
      "'",
      "(",
      ")",
      "*",
      "+",
      ",",
      "-",
      ".",
      "/",
      ":",
      ";",
      "<",
      "=",
      ">",
      "@",
      "[",
      "\\",
      "]",
      "^",
      "_",
      "`",
      "{",
      "|",
      "}",
      "~"
    ].concat(exports2.ALPHANUM);
    exports2.URL_CHAR = exports2.STRICT_URL_CHAR.concat(["	", "\f"]);
    for (let i = 128; i <= 255; i++) {
      exports2.URL_CHAR.push(i);
    }
    exports2.HEX = exports2.NUM.concat(["a", "b", "c", "d", "e", "f", "A", "B", "C", "D", "E", "F"]);
    exports2.STRICT_TOKEN = [
      "!",
      "#",
      "$",
      "%",
      "&",
      "'",
      "*",
      "+",
      "-",
      ".",
      "^",
      "_",
      "`",
      "|",
      "~"
    ].concat(exports2.ALPHANUM);
    exports2.TOKEN = exports2.STRICT_TOKEN.concat([" "]);
    exports2.HEADER_CHARS = ["	"];
    for (let i = 32; i <= 255; i++) {
      if (i !== 127) {
        exports2.HEADER_CHARS.push(i);
      }
    }
    exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS.filter((c2) => c2 !== 44);
    exports2.MAJOR = exports2.NUM_MAP;
    exports2.MINOR = exports2.MAJOR;
    var HEADER_STATE;
    (function(HEADER_STATE2) {
      HEADER_STATE2[HEADER_STATE2["GENERAL"] = 0] = "GENERAL";
      HEADER_STATE2[HEADER_STATE2["CONNECTION"] = 1] = "CONNECTION";
      HEADER_STATE2[HEADER_STATE2["CONTENT_LENGTH"] = 2] = "CONTENT_LENGTH";
      HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING"] = 3] = "TRANSFER_ENCODING";
      HEADER_STATE2[HEADER_STATE2["UPGRADE"] = 4] = "UPGRADE";
      HEADER_STATE2[HEADER_STATE2["CONNECTION_KEEP_ALIVE"] = 5] = "CONNECTION_KEEP_ALIVE";
      HEADER_STATE2[HEADER_STATE2["CONNECTION_CLOSE"] = 6] = "CONNECTION_CLOSE";
      HEADER_STATE2[HEADER_STATE2["CONNECTION_UPGRADE"] = 7] = "CONNECTION_UPGRADE";
      HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING_CHUNKED"] = 8] = "TRANSFER_ENCODING_CHUNKED";
    })(HEADER_STATE = exports2.HEADER_STATE || (exports2.HEADER_STATE = {}));
    exports2.SPECIAL_HEADERS = {
      "connection": HEADER_STATE.CONNECTION,
      "content-length": HEADER_STATE.CONTENT_LENGTH,
      "proxy-connection": HEADER_STATE.CONNECTION,
      "transfer-encoding": HEADER_STATE.TRANSFER_ENCODING,
      "upgrade": HEADER_STATE.UPGRADE
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/handler/RedirectHandler.js
var require_RedirectHandler = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/handler/RedirectHandler.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var util4 = require_util();
    var { kBodyUsed } = require_symbols();
    var assert27 = require("assert");
    var { InvalidArgumentError } = require_errors();
    var EE = require("events");
    var redirectableStatusCodes = [300, 301, 302, 303, 307, 308];
    var kBody = Symbol("body");
    var BodyAsyncIterable = class {
      constructor(body) {
        this[kBody] = body;
        this[kBodyUsed] = false;
      }
      async *[Symbol.asyncIterator]() {
        assert27(!this[kBodyUsed], "disturbed");
        this[kBodyUsed] = true;
        yield* this[kBody];
      }
    };
    __name(BodyAsyncIterable, "BodyAsyncIterable");
    var RedirectHandler = class {
      constructor(dispatch, maxRedirections, opts, handler30) {
        if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
          throw new InvalidArgumentError("maxRedirections must be a positive number");
        }
        util4.validateHandler(handler30, opts.method, opts.upgrade);
        this.dispatch = dispatch;
        this.location = null;
        this.abort = null;
        this.opts = { ...opts, maxRedirections: 0 };
        this.maxRedirections = maxRedirections;
        this.handler = handler30;
        this.history = [];
        if (util4.isStream(this.opts.body)) {
          if (util4.bodyLength(this.opts.body) === 0) {
            this.opts.body.on("data", function() {
              assert27(false);
            });
          }
          if (typeof this.opts.body.readableDidRead !== "boolean") {
            this.opts.body[kBodyUsed] = false;
            EE.prototype.on.call(this.opts.body, "data", function() {
              this[kBodyUsed] = true;
            });
          }
        } else if (this.opts.body && typeof this.opts.body.pipeTo === "function") {
          this.opts.body = new BodyAsyncIterable(this.opts.body);
        } else if (this.opts.body && typeof this.opts.body !== "string" && !ArrayBuffer.isView(this.opts.body) && util4.isIterable(this.opts.body)) {
          this.opts.body = new BodyAsyncIterable(this.opts.body);
        }
      }
      onConnect(abort) {
        this.abort = abort;
        this.handler.onConnect(abort, { history: this.history });
      }
      onUpgrade(statusCode, headers, socket) {
        this.handler.onUpgrade(statusCode, headers, socket);
      }
      onError(error2) {
        this.handler.onError(error2);
      }
      onHeaders(statusCode, headers, resume, statusText) {
        this.location = this.history.length >= this.maxRedirections || util4.isDisturbed(this.opts.body) ? null : parseLocation(statusCode, headers);
        if (this.opts.origin) {
          this.history.push(new URL(this.opts.path, this.opts.origin));
        }
        if (!this.location) {
          return this.handler.onHeaders(statusCode, headers, resume, statusText);
        }
        const { origin, pathname, search } = util4.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)));
        const path67 = search ? `${pathname}${search}` : pathname;
        this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin);
        this.opts.path = path67;
        this.opts.origin = origin;
        this.opts.maxRedirections = 0;
        this.opts.query = null;
        if (statusCode === 303 && this.opts.method !== "HEAD") {
          this.opts.method = "GET";
          this.opts.body = null;
        }
      }
      onData(chunk) {
        if (this.location) {
        } else {
          return this.handler.onData(chunk);
        }
      }
      onComplete(trailers) {
        if (this.location) {
          this.location = null;
          this.abort = null;
          this.dispatch(this.opts, this);
        } else {
          this.handler.onComplete(trailers);
        }
      }
      onBodySent(chunk) {
        if (this.handler.onBodySent) {
          this.handler.onBodySent(chunk);
        }
      }
    };
    __name(RedirectHandler, "RedirectHandler");
    function parseLocation(statusCode, headers) {
      if (redirectableStatusCodes.indexOf(statusCode) === -1) {
        return null;
      }
      for (let i = 0; i < headers.length; i += 2) {
        if (headers[i].toString().toLowerCase() === "location") {
          return headers[i + 1];
        }
      }
    }
    __name(parseLocation, "parseLocation");
    function shouldRemoveHeader(header, removeContent, unknownOrigin) {
      return header.length === 4 && header.toString().toLowerCase() === "host" || removeContent && header.toString().toLowerCase().indexOf("content-") === 0 || unknownOrigin && header.length === 13 && header.toString().toLowerCase() === "authorization" || unknownOrigin && header.length === 6 && header.toString().toLowerCase() === "cookie";
    }
    __name(shouldRemoveHeader, "shouldRemoveHeader");
    function cleanRequestHeaders(headers, removeContent, unknownOrigin) {
      const ret = [];
      if (Array.isArray(headers)) {
        for (let i = 0; i < headers.length; i += 2) {
          if (!shouldRemoveHeader(headers[i], removeContent, unknownOrigin)) {
            ret.push(headers[i], headers[i + 1]);
          }
        }
      } else if (headers && typeof headers === "object") {
        for (const key of Object.keys(headers)) {
          if (!shouldRemoveHeader(key, removeContent, unknownOrigin)) {
            ret.push(key, headers[key]);
          }
        }
      } else {
        assert27(headers == null, "headers must be an object or an array");
      }
      return ret;
    }
    __name(cleanRequestHeaders, "cleanRequestHeaders");
    module3.exports = RedirectHandler;
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/interceptor/redirectInterceptor.js
var require_redirectInterceptor = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/interceptor/redirectInterceptor.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var RedirectHandler = require_RedirectHandler();
    function createRedirectInterceptor({ maxRedirections: defaultMaxRedirections }) {
      return (dispatch) => {
        return /* @__PURE__ */ __name(function Intercept(opts, handler30) {
          const { maxRedirections = defaultMaxRedirections } = opts;
          if (!maxRedirections) {
            return dispatch(opts, handler30);
          }
          const redirectHandler = new RedirectHandler(dispatch, maxRedirections, opts, handler30);
          opts = { ...opts, maxRedirections: 0 };
          return dispatch(opts, redirectHandler);
        }, "Intercept");
      };
    }
    __name(createRedirectInterceptor, "createRedirectInterceptor");
    module3.exports = createRedirectInterceptor;
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/llhttp/llhttp-wasm.js
var require_llhttp_wasm = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/llhttp/llhttp-wasm.js"(exports2, module3) {
    init_import_meta_url();
    module3.exports = "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";
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/llhttp/llhttp_simd-wasm.js
var require_llhttp_simd_wasm = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/llhttp/llhttp_simd-wasm.js"(exports2, module3) {
    init_import_meta_url();
    module3.exports = "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";
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/client.js
var require_client = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/client.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var assert27 = require("assert");
    var net3 = require("net");
    var http4 = require("http");
    var { pipeline } = require("stream");
    var util4 = require_util();
    var timers = require_timers();
    var Request3 = require_request();
    var DispatcherBase = require_dispatcher_base();
    var {
      RequestContentLengthMismatchError,
      ResponseContentLengthMismatchError,
      InvalidArgumentError,
      RequestAbortedError,
      HeadersTimeoutError,
      HeadersOverflowError,
      SocketError,
      InformationalError,
      BodyTimeoutError,
      HTTPParserError,
      ResponseExceededMaxSizeError,
      ClientDestroyedError
    } = require_errors();
    var buildConnector = require_connect();
    var {
      kUrl,
      kReset: kReset2,
      kServerName,
      kClient,
      kBusy,
      kParser,
      kConnect,
      kBlocking,
      kResuming,
      kRunning,
      kPending,
      kSize,
      kWriting,
      kQueue,
      kConnected,
      kConnecting,
      kNeedDrain,
      kNoRef,
      kKeepAliveDefaultTimeout,
      kHostHeader,
      kPendingIdx,
      kRunningIdx,
      kError,
      kPipelining,
      kSocket,
      kKeepAliveTimeoutValue,
      kMaxHeadersSize,
      kKeepAliveMaxTimeout,
      kKeepAliveTimeoutThreshold,
      kHeadersTimeout,
      kBodyTimeout,
      kStrictContentLength,
      kConnector,
      kMaxRedirections,
      kMaxRequests,
      kCounter,
      kClose,
      kDestroy,
      kDispatch,
      kInterceptors,
      kLocalAddress,
      kMaxResponseSize,
      kHTTPConnVersion,
      // HTTP2
      kHost,
      kHTTP2Session,
      kHTTP2SessionState,
      kHTTP2BuildRequest,
      kHTTP2CopyHeaders,
      kHTTP1BuildRequest
    } = require_symbols();
    var http22;
    try {
      http22 = require("http2");
    } catch {
      http22 = { constants: {} };
    }
    var {
      constants: {
        HTTP2_HEADER_AUTHORITY,
        HTTP2_HEADER_METHOD,
        HTTP2_HEADER_PATH,
        HTTP2_HEADER_SCHEME,
        HTTP2_HEADER_CONTENT_LENGTH,
        HTTP2_HEADER_EXPECT,
        HTTP2_HEADER_STATUS
      }
    } = http22;
    var h2ExperimentalWarned = false;
    var FastBuffer = Buffer[Symbol.species];
    var kClosedResolve = Symbol("kClosedResolve");
    var channels = {};
    try {
      const diagnosticsChannel = require("diagnostics_channel");
      channels.sendHeaders = diagnosticsChannel.channel("undici:client:sendHeaders");
      channels.beforeConnect = diagnosticsChannel.channel("undici:client:beforeConnect");
      channels.connectError = diagnosticsChannel.channel("undici:client:connectError");
      channels.connected = diagnosticsChannel.channel("undici:client:connected");
    } catch {
      channels.sendHeaders = { hasSubscribers: false };
      channels.beforeConnect = { hasSubscribers: false };
      channels.connectError = { hasSubscribers: false };
      channels.connected = { hasSubscribers: false };
    }
    var Client = class extends DispatcherBase {
      /**
       *
       * @param {string|URL} url
       * @param {import('../types/client').Client.Options} options
       */
      constructor(url4, {
        interceptors,
        maxHeaderSize,
        headersTimeout,
        socketTimeout,
        requestTimeout,
        connectTimeout,
        bodyTimeout,
        idleTimeout,
        keepAlive,
        keepAliveTimeout,
        maxKeepAliveTimeout,
        keepAliveMaxTimeout,
        keepAliveTimeoutThreshold,
        socketPath,
        pipelining,
        tls,
        strictContentLength,
        maxCachedSessions,
        maxRedirections,
        connect: connect3,
        maxRequestsPerClient,
        localAddress,
        maxResponseSize,
        autoSelectFamily,
        autoSelectFamilyAttemptTimeout,
        // h2
        allowH2,
        maxConcurrentStreams
      } = {}) {
        super();
        if (keepAlive !== void 0) {
          throw new InvalidArgumentError("unsupported keepAlive, use pipelining=0 instead");
        }
        if (socketTimeout !== void 0) {
          throw new InvalidArgumentError("unsupported socketTimeout, use headersTimeout & bodyTimeout instead");
        }
        if (requestTimeout !== void 0) {
          throw new InvalidArgumentError("unsupported requestTimeout, use headersTimeout & bodyTimeout instead");
        }
        if (idleTimeout !== void 0) {
          throw new InvalidArgumentError("unsupported idleTimeout, use keepAliveTimeout instead");
        }
        if (maxKeepAliveTimeout !== void 0) {
          throw new InvalidArgumentError("unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead");
        }
        if (maxHeaderSize != null && !Number.isFinite(maxHeaderSize)) {
          throw new InvalidArgumentError("invalid maxHeaderSize");
        }
        if (socketPath != null && typeof socketPath !== "string") {
          throw new InvalidArgumentError("invalid socketPath");
        }
        if (connectTimeout != null && (!Number.isFinite(connectTimeout) || connectTimeout < 0)) {
          throw new InvalidArgumentError("invalid connectTimeout");
        }
        if (keepAliveTimeout != null && (!Number.isFinite(keepAliveTimeout) || keepAliveTimeout <= 0)) {
          throw new InvalidArgumentError("invalid keepAliveTimeout");
        }
        if (keepAliveMaxTimeout != null && (!Number.isFinite(keepAliveMaxTimeout) || keepAliveMaxTimeout <= 0)) {
          throw new InvalidArgumentError("invalid keepAliveMaxTimeout");
        }
        if (keepAliveTimeoutThreshold != null && !Number.isFinite(keepAliveTimeoutThreshold)) {
          throw new InvalidArgumentError("invalid keepAliveTimeoutThreshold");
        }
        if (headersTimeout != null && (!Number.isInteger(headersTimeout) || headersTimeout < 0)) {
          throw new InvalidArgumentError("headersTimeout must be a positive integer or zero");
        }
        if (bodyTimeout != null && (!Number.isInteger(bodyTimeout) || bodyTimeout < 0)) {
          throw new InvalidArgumentError("bodyTimeout must be a positive integer or zero");
        }
        if (connect3 != null && typeof connect3 !== "function" && typeof connect3 !== "object") {
          throw new InvalidArgumentError("connect must be a function or an object");
        }
        if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
          throw new InvalidArgumentError("maxRedirections must be a positive number");
        }
        if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0)) {
          throw new InvalidArgumentError("maxRequestsPerClient must be a positive number");
        }
        if (localAddress != null && (typeof localAddress !== "string" || net3.isIP(localAddress) === 0)) {
          throw new InvalidArgumentError("localAddress must be valid string IP address");
        }
        if (maxResponseSize != null && (!Number.isInteger(maxResponseSize) || maxResponseSize < -1)) {
          throw new InvalidArgumentError("maxResponseSize must be a positive number");
        }
        if (autoSelectFamilyAttemptTimeout != null && (!Number.isInteger(autoSelectFamilyAttemptTimeout) || autoSelectFamilyAttemptTimeout < -1)) {
          throw new InvalidArgumentError("autoSelectFamilyAttemptTimeout must be a positive number");
        }
        if (allowH2 != null && typeof allowH2 !== "boolean") {
          throw new InvalidArgumentError("allowH2 must be a valid boolean value");
        }
        if (maxConcurrentStreams != null && (typeof maxConcurrentStreams !== "number" || maxConcurrentStreams < 1)) {
          throw new InvalidArgumentError("maxConcurrentStreams must be a possitive integer, greater than 0");
        }
        if (typeof connect3 !== "function") {
          connect3 = buildConnector({
            ...tls,
            maxCachedSessions,
            allowH2,
            socketPath,
            timeout: connectTimeout,
            ...util4.nodeHasAutoSelectFamily && autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
            ...connect3
          });
        }
        this[kInterceptors] = interceptors && interceptors.Client && Array.isArray(interceptors.Client) ? interceptors.Client : [createRedirectInterceptor({ maxRedirections })];
        this[kUrl] = util4.parseOrigin(url4);
        this[kConnector] = connect3;
        this[kSocket] = null;
        this[kPipelining] = pipelining != null ? pipelining : 1;
        this[kMaxHeadersSize] = maxHeaderSize || http4.maxHeaderSize;
        this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4e3 : keepAliveTimeout;
        this[kKeepAliveMaxTimeout] = keepAliveMaxTimeout == null ? 6e5 : keepAliveMaxTimeout;
        this[kKeepAliveTimeoutThreshold] = keepAliveTimeoutThreshold == null ? 1e3 : keepAliveTimeoutThreshold;
        this[kKeepAliveTimeoutValue] = this[kKeepAliveDefaultTimeout];
        this[kServerName] = null;
        this[kLocalAddress] = localAddress != null ? localAddress : null;
        this[kResuming] = 0;
        this[kNeedDrain] = 0;
        this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}\r
`;
        this[kBodyTimeout] = bodyTimeout != null ? bodyTimeout : 3e5;
        this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 3e5;
        this[kStrictContentLength] = strictContentLength == null ? true : strictContentLength;
        this[kMaxRedirections] = maxRedirections;
        this[kMaxRequests] = maxRequestsPerClient;
        this[kClosedResolve] = null;
        this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1;
        this[kHTTPConnVersion] = "h1";
        this[kHTTP2Session] = null;
        this[kHTTP2SessionState] = !allowH2 ? null : {
          // streams: null, // Fixed queue of streams - For future support of `push`
          openStreams: 0,
          // Keep track of them to decide wether or not unref the session
          maxConcurrentStreams: maxConcurrentStreams != null ? maxConcurrentStreams : 100
          // Max peerConcurrentStreams for a Node h2 server
        };
        this[kHost] = `${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}`;
        this[kQueue] = [];
        this[kRunningIdx] = 0;
        this[kPendingIdx] = 0;
      }
      get pipelining() {
        return this[kPipelining];
      }
      set pipelining(value) {
        this[kPipelining] = value;
        resume(this, true);
      }
      get [kPending]() {
        return this[kQueue].length - this[kPendingIdx];
      }
      get [kRunning]() {
        return this[kPendingIdx] - this[kRunningIdx];
      }
      get [kSize]() {
        return this[kQueue].length - this[kRunningIdx];
      }
      get [kConnected]() {
        return !!this[kSocket] && !this[kConnecting] && !this[kSocket].destroyed;
      }
      get [kBusy]() {
        const socket = this[kSocket];
        return socket && (socket[kReset2] || socket[kWriting] || socket[kBlocking]) || this[kSize] >= (this[kPipelining] || 1) || this[kPending] > 0;
      }
      /* istanbul ignore: only used for test */
      [kConnect](cb) {
        connect2(this);
        this.once("connect", cb);
      }
      [kDispatch](opts, handler30) {
        const origin = opts.origin || this[kUrl].origin;
        const request3 = this[kHTTPConnVersion] === "h2" ? Request3[kHTTP2BuildRequest](origin, opts, handler30) : Request3[kHTTP1BuildRequest](origin, opts, handler30);
        this[kQueue].push(request3);
        if (this[kResuming]) {
        } else if (util4.bodyLength(request3.body) == null && util4.isIterable(request3.body)) {
          this[kResuming] = 1;
          process.nextTick(resume, this);
        } else {
          resume(this, true);
        }
        if (this[kResuming] && this[kNeedDrain] !== 2 && this[kBusy]) {
          this[kNeedDrain] = 2;
        }
        return this[kNeedDrain] < 2;
      }
      async [kClose]() {
        return new Promise((resolve19) => {
          if (!this[kSize]) {
            resolve19(null);
          } else {
            this[kClosedResolve] = resolve19;
          }
        });
      }
      async [kDestroy](err) {
        return new Promise((resolve19) => {
          const requests = this[kQueue].splice(this[kPendingIdx]);
          for (let i = 0; i < requests.length; i++) {
            const request3 = requests[i];
            errorRequest(this, request3, err);
          }
          const callback = /* @__PURE__ */ __name(() => {
            if (this[kClosedResolve]) {
              this[kClosedResolve]();
              this[kClosedResolve] = null;
            }
            resolve19();
          }, "callback");
          if (this[kHTTP2Session] != null) {
            util4.destroy(this[kHTTP2Session], err);
            this[kHTTP2Session] = null;
            this[kHTTP2SessionState] = null;
          }
          if (!this[kSocket]) {
            queueMicrotask(callback);
          } else {
            util4.destroy(this[kSocket].on("close", callback), err);
          }
          resume(this);
        });
      }
    };
    __name(Client, "Client");
    function onHttp2SessionError(err) {
      assert27(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
      this[kSocket][kError] = err;
      onError(this[kClient], err);
    }
    __name(onHttp2SessionError, "onHttp2SessionError");
    function onHttp2FrameError(type, code, id) {
      const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`);
      if (id === 0) {
        this[kSocket][kError] = err;
        onError(this[kClient], err);
      }
    }
    __name(onHttp2FrameError, "onHttp2FrameError");
    function onHttp2SessionEnd() {
      util4.destroy(this, new SocketError("other side closed"));
      util4.destroy(this[kSocket], new SocketError("other side closed"));
    }
    __name(onHttp2SessionEnd, "onHttp2SessionEnd");
    function onHTTP2GoAway(code) {
      const client = this[kClient];
      const err = new InformationalError(`HTTP/2: "GOAWAY" frame received with code ${code}`);
      client[kSocket] = null;
      client[kHTTP2Session] = null;
      if (client.destroyed) {
        assert27(this[kPending] === 0);
        const requests = client[kQueue].splice(client[kRunningIdx]);
        for (let i = 0; i < requests.length; i++) {
          const request3 = requests[i];
          errorRequest(this, request3, err);
        }
      } else if (client[kRunning] > 0) {
        const request3 = client[kQueue][client[kRunningIdx]];
        client[kQueue][client[kRunningIdx]++] = null;
        errorRequest(client, request3, err);
      }
      client[kPendingIdx] = client[kRunningIdx];
      assert27(client[kRunning] === 0);
      client.emit(
        "disconnect",
        client[kUrl],
        [client],
        err
      );
      resume(client);
    }
    __name(onHTTP2GoAway, "onHTTP2GoAway");
    var constants3 = require_constants2();
    var createRedirectInterceptor = require_redirectInterceptor();
    var EMPTY_BUF = Buffer.alloc(0);
    async function lazyllhttp() {
      const llhttpWasmData = process.env.JEST_WORKER_ID ? require_llhttp_wasm() : void 0;
      let mod;
      try {
        mod = await WebAssembly.compile(Buffer.from(require_llhttp_simd_wasm(), "base64"));
      } catch (e3) {
        mod = await WebAssembly.compile(Buffer.from(llhttpWasmData || require_llhttp_wasm(), "base64"));
      }
      return await WebAssembly.instantiate(mod, {
        env: {
          /* eslint-disable camelcase */
          wasm_on_url: (p2, at, len) => {
            return 0;
          },
          wasm_on_status: (p2, at, len) => {
            assert27.strictEqual(currentParser.ptr, p2);
            const start = at - currentBufferPtr + currentBufferRef.byteOffset;
            return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
          },
          wasm_on_message_begin: (p2) => {
            assert27.strictEqual(currentParser.ptr, p2);
            return currentParser.onMessageBegin() || 0;
          },
          wasm_on_header_field: (p2, at, len) => {
            assert27.strictEqual(currentParser.ptr, p2);
            const start = at - currentBufferPtr + currentBufferRef.byteOffset;
            return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
          },
          wasm_on_header_value: (p2, at, len) => {
            assert27.strictEqual(currentParser.ptr, p2);
            const start = at - currentBufferPtr + currentBufferRef.byteOffset;
            return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
          },
          wasm_on_headers_complete: (p2, statusCode, upgrade, shouldKeepAlive) => {
            assert27.strictEqual(currentParser.ptr, p2);
            return currentParser.onHeadersComplete(statusCode, Boolean(upgrade), Boolean(shouldKeepAlive)) || 0;
          },
          wasm_on_body: (p2, at, len) => {
            assert27.strictEqual(currentParser.ptr, p2);
            const start = at - currentBufferPtr + currentBufferRef.byteOffset;
            return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
          },
          wasm_on_message_complete: (p2) => {
            assert27.strictEqual(currentParser.ptr, p2);
            return currentParser.onMessageComplete() || 0;
          }
          /* eslint-enable camelcase */
        }
      });
    }
    __name(lazyllhttp, "lazyllhttp");
    var llhttpInstance = null;
    var llhttpPromise = lazyllhttp();
    llhttpPromise.catch();
    var currentParser = null;
    var currentBufferRef = null;
    var currentBufferSize = 0;
    var currentBufferPtr = null;
    var TIMEOUT_HEADERS = 1;
    var TIMEOUT_BODY = 2;
    var TIMEOUT_IDLE = 3;
    var Parser2 = class {
      constructor(client, socket, { exports: exports3 }) {
        assert27(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0);
        this.llhttp = exports3;
        this.ptr = this.llhttp.llhttp_alloc(constants3.TYPE.RESPONSE);
        this.client = client;
        this.socket = socket;
        this.timeout = null;
        this.timeoutValue = null;
        this.timeoutType = null;
        this.statusCode = null;
        this.statusText = "";
        this.upgrade = false;
        this.headers = [];
        this.headersSize = 0;
        this.headersMaxSize = client[kMaxHeadersSize];
        this.shouldKeepAlive = false;
        this.paused = false;
        this.resume = this.resume.bind(this);
        this.bytesRead = 0;
        this.keepAlive = "";
        this.contentLength = "";
        this.connection = "";
        this.maxResponseSize = client[kMaxResponseSize];
      }
      setTimeout(value, type) {
        this.timeoutType = type;
        if (value !== this.timeoutValue) {
          timers.clearTimeout(this.timeout);
          if (value) {
            this.timeout = timers.setTimeout(onParserTimeout, value, this);
            if (this.timeout.unref) {
              this.timeout.unref();
            }
          } else {
            this.timeout = null;
          }
          this.timeoutValue = value;
        } else if (this.timeout) {
          if (this.timeout.refresh) {
            this.timeout.refresh();
          }
        }
      }
      resume() {
        if (this.socket.destroyed || !this.paused) {
          return;
        }
        assert27(this.ptr != null);
        assert27(currentParser == null);
        this.llhttp.llhttp_resume(this.ptr);
        assert27(this.timeoutType === TIMEOUT_BODY);
        if (this.timeout) {
          if (this.timeout.refresh) {
            this.timeout.refresh();
          }
        }
        this.paused = false;
        this.execute(this.socket.read() || EMPTY_BUF);
        this.readMore();
      }
      readMore() {
        while (!this.paused && this.ptr) {
          const chunk = this.socket.read();
          if (chunk === null) {
            break;
          }
          this.execute(chunk);
        }
      }
      execute(data) {
        assert27(this.ptr != null);
        assert27(currentParser == null);
        assert27(!this.paused);
        const { socket, llhttp } = this;
        if (data.length > currentBufferSize) {
          if (currentBufferPtr) {
            llhttp.free(currentBufferPtr);
          }
          currentBufferSize = Math.ceil(data.length / 4096) * 4096;
          currentBufferPtr = llhttp.malloc(currentBufferSize);
        }
        new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize).set(data);
        try {
          let ret;
          try {
            currentBufferRef = data;
            currentParser = this;
            ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, data.length);
          } catch (err) {
            throw err;
          } finally {
            currentParser = null;
            currentBufferRef = null;
          }
          const offset = llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr;
          if (ret === constants3.ERROR.PAUSED_UPGRADE) {
            this.onUpgrade(data.slice(offset));
          } else if (ret === constants3.ERROR.PAUSED) {
            this.paused = true;
            socket.unshift(data.slice(offset));
          } else if (ret !== constants3.ERROR.OK) {
            const ptr = llhttp.llhttp_get_error_reason(this.ptr);
            let message = "";
            if (ptr) {
              const len = new Uint8Array(llhttp.memory.buffer, ptr).indexOf(0);
              message = "Response does not match the HTTP/1.1 protocol (" + Buffer.from(llhttp.memory.buffer, ptr, len).toString() + ")";
            }
            throw new HTTPParserError(message, constants3.ERROR[ret], data.slice(offset));
          }
        } catch (err) {
          util4.destroy(socket, err);
        }
      }
      destroy() {
        assert27(this.ptr != null);
        assert27(currentParser == null);
        this.llhttp.llhttp_free(this.ptr);
        this.ptr = null;
        timers.clearTimeout(this.timeout);
        this.timeout = null;
        this.timeoutValue = null;
        this.timeoutType = null;
        this.paused = false;
      }
      onStatus(buf) {
        this.statusText = buf.toString();
      }
      onMessageBegin() {
        const { socket, client } = this;
        if (socket.destroyed) {
          return -1;
        }
        const request3 = client[kQueue][client[kRunningIdx]];
        if (!request3) {
          return -1;
        }
      }
      onHeaderField(buf) {
        const len = this.headers.length;
        if ((len & 1) === 0) {
          this.headers.push(buf);
        } else {
          this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]);
        }
        this.trackHeader(buf.length);
      }
      onHeaderValue(buf) {
        let len = this.headers.length;
        if ((len & 1) === 1) {
          this.headers.push(buf);
          len += 1;
        } else {
          this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]);
        }
        const key = this.headers[len - 2];
        if (key.length === 10 && key.toString().toLowerCase() === "keep-alive") {
          this.keepAlive += buf.toString();
        } else if (key.length === 10 && key.toString().toLowerCase() === "connection") {
          this.connection += buf.toString();
        } else if (key.length === 14 && key.toString().toLowerCase() === "content-length") {
          this.contentLength += buf.toString();
        }
        this.trackHeader(buf.length);
      }
      trackHeader(len) {
        this.headersSize += len;
        if (this.headersSize >= this.headersMaxSize) {
          util4.destroy(this.socket, new HeadersOverflowError());
        }
      }
      onUpgrade(head) {
        const { upgrade, client, socket, headers, statusCode } = this;
        assert27(upgrade);
        const request3 = client[kQueue][client[kRunningIdx]];
        assert27(request3);
        assert27(!socket.destroyed);
        assert27(socket === client[kSocket]);
        assert27(!this.paused);
        assert27(request3.upgrade || request3.method === "CONNECT");
        this.statusCode = null;
        this.statusText = "";
        this.shouldKeepAlive = null;
        assert27(this.headers.length % 2 === 0);
        this.headers = [];
        this.headersSize = 0;
        socket.unshift(head);
        socket[kParser].destroy();
        socket[kParser] = null;
        socket[kClient] = null;
        socket[kError] = null;
        socket.removeListener("error", onSocketError).removeListener("readable", onSocketReadable).removeListener("end", onSocketEnd).removeListener("close", onSocketClose);
        client[kSocket] = null;
        client[kQueue][client[kRunningIdx]++] = null;
        client.emit("disconnect", client[kUrl], [client], new InformationalError("upgrade"));
        try {
          request3.onUpgrade(statusCode, headers, socket);
        } catch (err) {
          util4.destroy(socket, err);
        }
        resume(client);
      }
      onHeadersComplete(statusCode, upgrade, shouldKeepAlive) {
        const { client, socket, headers, statusText } = this;
        if (socket.destroyed) {
          return -1;
        }
        const request3 = client[kQueue][client[kRunningIdx]];
        if (!request3) {
          return -1;
        }
        assert27(!this.upgrade);
        assert27(this.statusCode < 200);
        if (statusCode === 100) {
          util4.destroy(socket, new SocketError("bad response", util4.getSocketInfo(socket)));
          return -1;
        }
        if (upgrade && !request3.upgrade) {
          util4.destroy(socket, new SocketError("bad upgrade", util4.getSocketInfo(socket)));
          return -1;
        }
        assert27.strictEqual(this.timeoutType, TIMEOUT_HEADERS);
        this.statusCode = statusCode;
        this.shouldKeepAlive = shouldKeepAlive || // Override llhttp value which does not allow keepAlive for HEAD.
        request3.method === "HEAD" && !socket[kReset2] && this.connection.toLowerCase() === "keep-alive";
        if (this.statusCode >= 200) {
          const bodyTimeout = request3.bodyTimeout != null ? request3.bodyTimeout : client[kBodyTimeout];
          this.setTimeout(bodyTimeout, TIMEOUT_BODY);
        } else if (this.timeout) {
          if (this.timeout.refresh) {
            this.timeout.refresh();
          }
        }
        if (request3.method === "CONNECT") {
          assert27(client[kRunning] === 1);
          this.upgrade = true;
          return 2;
        }
        if (upgrade) {
          assert27(client[kRunning] === 1);
          this.upgrade = true;
          return 2;
        }
        assert27(this.headers.length % 2 === 0);
        this.headers = [];
        this.headersSize = 0;
        if (this.shouldKeepAlive && client[kPipelining]) {
          const keepAliveTimeout = this.keepAlive ? util4.parseKeepAliveTimeout(this.keepAlive) : null;
          if (keepAliveTimeout != null) {
            const timeout = Math.min(
              keepAliveTimeout - client[kKeepAliveTimeoutThreshold],
              client[kKeepAliveMaxTimeout]
            );
            if (timeout <= 0) {
              socket[kReset2] = true;
            } else {
              client[kKeepAliveTimeoutValue] = timeout;
            }
          } else {
            client[kKeepAliveTimeoutValue] = client[kKeepAliveDefaultTimeout];
          }
        } else {
          socket[kReset2] = true;
        }
        const pause = request3.onHeaders(statusCode, headers, this.resume, statusText) === false;
        if (request3.aborted) {
          return -1;
        }
        if (request3.method === "HEAD") {
          return 1;
        }
        if (statusCode < 200) {
          return 1;
        }
        if (socket[kBlocking]) {
          socket[kBlocking] = false;
          resume(client);
        }
        return pause ? constants3.ERROR.PAUSED : 0;
      }
      onBody(buf) {
        const { client, socket, statusCode, maxResponseSize } = this;
        if (socket.destroyed) {
          return -1;
        }
        const request3 = client[kQueue][client[kRunningIdx]];
        assert27(request3);
        assert27.strictEqual(this.timeoutType, TIMEOUT_BODY);
        if (this.timeout) {
          if (this.timeout.refresh) {
            this.timeout.refresh();
          }
        }
        assert27(statusCode >= 200);
        if (maxResponseSize > -1 && this.bytesRead + buf.length > maxResponseSize) {
          util4.destroy(socket, new ResponseExceededMaxSizeError());
          return -1;
        }
        this.bytesRead += buf.length;
        if (request3.onData(buf) === false) {
          return constants3.ERROR.PAUSED;
        }
      }
      onMessageComplete() {
        const { client, socket, statusCode, upgrade, headers, contentLength, bytesRead, shouldKeepAlive } = this;
        if (socket.destroyed && (!statusCode || shouldKeepAlive)) {
          return -1;
        }
        if (upgrade) {
          return;
        }
        const request3 = client[kQueue][client[kRunningIdx]];
        assert27(request3);
        assert27(statusCode >= 100);
        this.statusCode = null;
        this.statusText = "";
        this.bytesRead = 0;
        this.contentLength = "";
        this.keepAlive = "";
        this.connection = "";
        assert27(this.headers.length % 2 === 0);
        this.headers = [];
        this.headersSize = 0;
        if (statusCode < 200) {
          return;
        }
        if (request3.method !== "HEAD" && contentLength && bytesRead !== parseInt(contentLength, 10)) {
          util4.destroy(socket, new ResponseContentLengthMismatchError());
          return -1;
        }
        request3.onComplete(headers);
        client[kQueue][client[kRunningIdx]++] = null;
        if (socket[kWriting]) {
          assert27.strictEqual(client[kRunning], 0);
          util4.destroy(socket, new InformationalError("reset"));
          return constants3.ERROR.PAUSED;
        } else if (!shouldKeepAlive) {
          util4.destroy(socket, new InformationalError("reset"));
          return constants3.ERROR.PAUSED;
        } else if (socket[kReset2] && client[kRunning] === 0) {
          util4.destroy(socket, new InformationalError("reset"));
          return constants3.ERROR.PAUSED;
        } else if (client[kPipelining] === 1) {
          setImmediate(resume, client);
        } else {
          resume(client);
        }
      }
    };
    __name(Parser2, "Parser");
    function onParserTimeout(parser2) {
      const { socket, timeoutType, client } = parser2;
      if (timeoutType === TIMEOUT_HEADERS) {
        if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) {
          assert27(!parser2.paused, "cannot be paused while waiting for headers");
          util4.destroy(socket, new HeadersTimeoutError());
        }
      } else if (timeoutType === TIMEOUT_BODY) {
        if (!parser2.paused) {
          util4.destroy(socket, new BodyTimeoutError());
        }
      } else if (timeoutType === TIMEOUT_IDLE) {
        assert27(client[kRunning] === 0 && client[kKeepAliveTimeoutValue]);
        util4.destroy(socket, new InformationalError("socket idle timeout"));
      }
    }
    __name(onParserTimeout, "onParserTimeout");
    function onSocketReadable() {
      const { [kParser]: parser2 } = this;
      if (parser2) {
        parser2.readMore();
      }
    }
    __name(onSocketReadable, "onSocketReadable");
    function onSocketError(err) {
      const { [kClient]: client, [kParser]: parser2 } = this;
      assert27(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
      if (client[kHTTPConnVersion] !== "h2") {
        if (err.code === "ECONNRESET" && parser2.statusCode && !parser2.shouldKeepAlive) {
          parser2.onMessageComplete();
          return;
        }
      }
      this[kError] = err;
      onError(this[kClient], err);
    }
    __name(onSocketError, "onSocketError");
    function onError(client, err) {
      if (client[kRunning] === 0 && err.code !== "UND_ERR_INFO" && err.code !== "UND_ERR_SOCKET") {
        assert27(client[kPendingIdx] === client[kRunningIdx]);
        const requests = client[kQueue].splice(client[kRunningIdx]);
        for (let i = 0; i < requests.length; i++) {
          const request3 = requests[i];
          errorRequest(client, request3, err);
        }
        assert27(client[kSize] === 0);
      }
    }
    __name(onError, "onError");
    function onSocketEnd() {
      const { [kParser]: parser2, [kClient]: client } = this;
      if (client[kHTTPConnVersion] !== "h2") {
        if (parser2.statusCode && !parser2.shouldKeepAlive) {
          parser2.onMessageComplete();
          return;
        }
      }
      util4.destroy(this, new SocketError("other side closed", util4.getSocketInfo(this)));
    }
    __name(onSocketEnd, "onSocketEnd");
    function onSocketClose() {
      const { [kClient]: client, [kParser]: parser2 } = this;
      if (client[kHTTPConnVersion] === "h1" && parser2) {
        if (!this[kError] && parser2.statusCode && !parser2.shouldKeepAlive) {
          parser2.onMessageComplete();
        }
        this[kParser].destroy();
        this[kParser] = null;
      }
      const err = this[kError] || new SocketError("closed", util4.getSocketInfo(this));
      client[kSocket] = null;
      if (client.destroyed) {
        assert27(client[kPending] === 0);
        const requests = client[kQueue].splice(client[kRunningIdx]);
        for (let i = 0; i < requests.length; i++) {
          const request3 = requests[i];
          errorRequest(client, request3, err);
        }
      } else if (client[kRunning] > 0 && err.code !== "UND_ERR_INFO") {
        const request3 = client[kQueue][client[kRunningIdx]];
        client[kQueue][client[kRunningIdx]++] = null;
        errorRequest(client, request3, err);
      }
      client[kPendingIdx] = client[kRunningIdx];
      assert27(client[kRunning] === 0);
      client.emit("disconnect", client[kUrl], [client], err);
      resume(client);
    }
    __name(onSocketClose, "onSocketClose");
    async function connect2(client) {
      assert27(!client[kConnecting]);
      assert27(!client[kSocket]);
      let { host, hostname: hostname2, protocol, port: port2 } = client[kUrl];
      if (hostname2[0] === "[") {
        const idx = hostname2.indexOf("]");
        assert27(idx !== -1);
        const ip2 = hostname2.substring(1, idx);
        assert27(net3.isIP(ip2));
        hostname2 = ip2;
      }
      client[kConnecting] = true;
      if (channels.beforeConnect.hasSubscribers) {
        channels.beforeConnect.publish({
          connectParams: {
            host,
            hostname: hostname2,
            protocol,
            port: port2,
            servername: client[kServerName],
            localAddress: client[kLocalAddress]
          },
          connector: client[kConnector]
        });
      }
      try {
        const socket = await new Promise((resolve19, reject) => {
          client[kConnector]({
            host,
            hostname: hostname2,
            protocol,
            port: port2,
            servername: client[kServerName],
            localAddress: client[kLocalAddress]
          }, (err, socket2) => {
            if (err) {
              reject(err);
            } else {
              resolve19(socket2);
            }
          });
        });
        if (client.destroyed) {
          util4.destroy(socket.on("error", () => {
          }), new ClientDestroyedError());
          return;
        }
        client[kConnecting] = false;
        assert27(socket);
        const isH2 = socket.alpnProtocol === "h2";
        if (isH2) {
          if (!h2ExperimentalWarned) {
            h2ExperimentalWarned = true;
            process.emitWarning("H2 support is experimental, expect them to change at any time.", {
              code: "UNDICI-H2"
            });
          }
          const session = http22.connect(client[kUrl], {
            createConnection: () => socket,
            peerMaxConcurrentStreams: client[kHTTP2SessionState].maxConcurrentStreams
          });
          client[kHTTPConnVersion] = "h2";
          session[kClient] = client;
          session[kSocket] = socket;
          session.on("error", onHttp2SessionError);
          session.on("frameError", onHttp2FrameError);
          session.on("end", onHttp2SessionEnd);
          session.on("goaway", onHTTP2GoAway);
          session.on("close", onSocketClose);
          session.unref();
          client[kHTTP2Session] = session;
          socket[kHTTP2Session] = session;
        } else {
          if (!llhttpInstance) {
            llhttpInstance = await llhttpPromise;
            llhttpPromise = null;
          }
          socket[kNoRef] = false;
          socket[kWriting] = false;
          socket[kReset2] = false;
          socket[kBlocking] = false;
          socket[kParser] = new Parser2(client, socket, llhttpInstance);
        }
        socket[kCounter] = 0;
        socket[kMaxRequests] = client[kMaxRequests];
        socket[kClient] = client;
        socket[kError] = null;
        socket.on("error", onSocketError).on("readable", onSocketReadable).on("end", onSocketEnd).on("close", onSocketClose);
        client[kSocket] = socket;
        if (channels.connected.hasSubscribers) {
          channels.connected.publish({
            connectParams: {
              host,
              hostname: hostname2,
              protocol,
              port: port2,
              servername: client[kServerName],
              localAddress: client[kLocalAddress]
            },
            connector: client[kConnector],
            socket
          });
        }
        client.emit("connect", client[kUrl], [client]);
      } catch (err) {
        if (client.destroyed) {
          return;
        }
        client[kConnecting] = false;
        if (channels.connectError.hasSubscribers) {
          channels.connectError.publish({
            connectParams: {
              host,
              hostname: hostname2,
              protocol,
              port: port2,
              servername: client[kServerName],
              localAddress: client[kLocalAddress]
            },
            connector: client[kConnector],
            error: err
          });
        }
        if (err.code === "ERR_TLS_CERT_ALTNAME_INVALID") {
          assert27(client[kRunning] === 0);
          while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) {
            const request3 = client[kQueue][client[kPendingIdx]++];
            errorRequest(client, request3, err);
          }
        } else {
          onError(client, err);
        }
        client.emit("connectionError", client[kUrl], [client], err);
      }
      resume(client);
    }
    __name(connect2, "connect");
    function emitDrain(client) {
      client[kNeedDrain] = 0;
      client.emit("drain", client[kUrl], [client]);
    }
    __name(emitDrain, "emitDrain");
    function resume(client, sync) {
      if (client[kResuming] === 2) {
        return;
      }
      client[kResuming] = 2;
      _resume(client, sync);
      client[kResuming] = 0;
      if (client[kRunningIdx] > 256) {
        client[kQueue].splice(0, client[kRunningIdx]);
        client[kPendingIdx] -= client[kRunningIdx];
        client[kRunningIdx] = 0;
      }
    }
    __name(resume, "resume");
    function _resume(client, sync) {
      while (true) {
        if (client.destroyed) {
          assert27(client[kPending] === 0);
          return;
        }
        if (client[kClosedResolve] && !client[kSize]) {
          client[kClosedResolve]();
          client[kClosedResolve] = null;
          return;
        }
        const socket = client[kSocket];
        if (socket && !socket.destroyed && socket.alpnProtocol !== "h2") {
          if (client[kSize] === 0) {
            if (!socket[kNoRef] && socket.unref) {
              socket.unref();
              socket[kNoRef] = true;
            }
          } else if (socket[kNoRef] && socket.ref) {
            socket.ref();
            socket[kNoRef] = false;
          }
          if (client[kSize] === 0) {
            if (socket[kParser].timeoutType !== TIMEOUT_IDLE) {
              socket[kParser].setTimeout(client[kKeepAliveTimeoutValue], TIMEOUT_IDLE);
            }
          } else if (client[kRunning] > 0 && socket[kParser].statusCode < 200) {
            if (socket[kParser].timeoutType !== TIMEOUT_HEADERS) {
              const request4 = client[kQueue][client[kRunningIdx]];
              const headersTimeout = request4.headersTimeout != null ? request4.headersTimeout : client[kHeadersTimeout];
              socket[kParser].setTimeout(headersTimeout, TIMEOUT_HEADERS);
            }
          }
        }
        if (client[kBusy]) {
          client[kNeedDrain] = 2;
        } else if (client[kNeedDrain] === 2) {
          if (sync) {
            client[kNeedDrain] = 1;
            process.nextTick(emitDrain, client);
          } else {
            emitDrain(client);
          }
          continue;
        }
        if (client[kPending] === 0) {
          return;
        }
        if (client[kRunning] >= (client[kPipelining] || 1)) {
          return;
        }
        const request3 = client[kQueue][client[kPendingIdx]];
        if (client[kUrl].protocol === "https:" && client[kServerName] !== request3.servername) {
          if (client[kRunning] > 0) {
            return;
          }
          client[kServerName] = request3.servername;
          if (socket && socket.servername !== request3.servername) {
            util4.destroy(socket, new InformationalError("servername changed"));
            return;
          }
        }
        if (client[kConnecting]) {
          return;
        }
        if (!socket && !client[kHTTP2Session]) {
          connect2(client);
          return;
        }
        if (socket.destroyed || socket[kWriting] || socket[kReset2] || socket[kBlocking]) {
          return;
        }
        if (client[kRunning] > 0 && !request3.idempotent) {
          return;
        }
        if (client[kRunning] > 0 && (request3.upgrade || request3.method === "CONNECT")) {
          return;
        }
        if (client[kRunning] > 0 && util4.bodyLength(request3.body) !== 0 && (util4.isStream(request3.body) || util4.isAsyncIterable(request3.body))) {
          return;
        }
        if (!request3.aborted && write(client, request3)) {
          client[kPendingIdx]++;
        } else {
          client[kQueue].splice(client[kPendingIdx], 1);
        }
      }
    }
    __name(_resume, "_resume");
    function shouldSendContentLength(method) {
      return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT";
    }
    __name(shouldSendContentLength, "shouldSendContentLength");
    function write(client, request3) {
      if (client[kHTTPConnVersion] === "h2") {
        writeH2(client, client[kHTTP2Session], request3);
        return;
      }
      const { body, method, path: path67, host, upgrade, headers, blocking, reset } = request3;
      const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
      if (body && typeof body.read === "function") {
        body.read(0);
      }
      const bodyLength = util4.bodyLength(body);
      let contentLength = bodyLength;
      if (contentLength === null) {
        contentLength = request3.contentLength;
      }
      if (contentLength === 0 && !expectsPayload) {
        contentLength = null;
      }
      if (shouldSendContentLength(method) && contentLength > 0 && request3.contentLength !== null && request3.contentLength !== contentLength) {
        if (client[kStrictContentLength]) {
          errorRequest(client, request3, new RequestContentLengthMismatchError());
          return false;
        }
        process.emitWarning(new RequestContentLengthMismatchError());
      }
      const socket = client[kSocket];
      try {
        request3.onConnect((err) => {
          if (request3.aborted || request3.completed) {
            return;
          }
          errorRequest(client, request3, err || new RequestAbortedError());
          util4.destroy(socket, new InformationalError("aborted"));
        });
      } catch (err) {
        errorRequest(client, request3, err);
      }
      if (request3.aborted) {
        return false;
      }
      if (method === "HEAD") {
        socket[kReset2] = true;
      }
      if (upgrade || method === "CONNECT") {
        socket[kReset2] = true;
      }
      if (reset != null) {
        socket[kReset2] = reset;
      }
      if (client[kMaxRequests] && socket[kCounter]++ >= client[kMaxRequests]) {
        socket[kReset2] = true;
      }
      if (blocking) {
        socket[kBlocking] = true;
      }
      let header = `${method} ${path67} HTTP/1.1\r
`;
      if (typeof host === "string") {
        header += `host: ${host}\r
`;
      } else {
        header += client[kHostHeader];
      }
      if (upgrade) {
        header += `connection: upgrade\r
upgrade: ${upgrade}\r
`;
      } else if (client[kPipelining] && !socket[kReset2]) {
        header += "connection: keep-alive\r\n";
      } else {
        header += "connection: close\r\n";
      }
      if (headers) {
        header += headers;
      }
      if (channels.sendHeaders.hasSubscribers) {
        channels.sendHeaders.publish({ request: request3, headers: header, socket });
      }
      if (!body || bodyLength === 0) {
        if (contentLength === 0) {
          socket.write(`${header}content-length: 0\r
\r
`, "latin1");
        } else {
          assert27(contentLength === null, "no body must not have content length");
          socket.write(`${header}\r
`, "latin1");
        }
        request3.onRequestSent();
      } else if (util4.isBuffer(body)) {
        assert27(contentLength === body.byteLength, "buffer body must have content length");
        socket.cork();
        socket.write(`${header}content-length: ${contentLength}\r
\r
`, "latin1");
        socket.write(body);
        socket.uncork();
        request3.onBodySent(body);
        request3.onRequestSent();
        if (!expectsPayload) {
          socket[kReset2] = true;
        }
      } else if (util4.isBlobLike(body)) {
        if (typeof body.stream === "function") {
          writeIterable({ body: body.stream(), client, request: request3, socket, contentLength, header, expectsPayload });
        } else {
          writeBlob({ body, client, request: request3, socket, contentLength, header, expectsPayload });
        }
      } else if (util4.isStream(body)) {
        writeStream({ body, client, request: request3, socket, contentLength, header, expectsPayload });
      } else if (util4.isIterable(body)) {
        writeIterable({ body, client, request: request3, socket, contentLength, header, expectsPayload });
      } else {
        assert27(false);
      }
      return true;
    }
    __name(write, "write");
    function writeH2(client, session, request3) {
      const { body, method, path: path67, host, upgrade, expectContinue, signal, headers: reqHeaders } = request3;
      let headers;
      if (typeof reqHeaders === "string")
        headers = Request3[kHTTP2CopyHeaders](reqHeaders.trim());
      else
        headers = reqHeaders;
      if (upgrade) {
        errorRequest(client, request3, new Error("Upgrade not supported for H2"));
        return false;
      }
      try {
        request3.onConnect((err) => {
          if (request3.aborted || request3.completed) {
            return;
          }
          errorRequest(client, request3, err || new RequestAbortedError());
        });
      } catch (err) {
        errorRequest(client, request3, err);
      }
      if (request3.aborted) {
        return false;
      }
      let stream2;
      const h2State = client[kHTTP2SessionState];
      headers[HTTP2_HEADER_AUTHORITY] = host || client[kHost];
      headers[HTTP2_HEADER_METHOD] = method;
      if (method === "CONNECT") {
        session.ref();
        stream2 = session.request(headers, { endStream: false, signal });
        if (stream2.id && !stream2.pending) {
          request3.onUpgrade(null, null, stream2);
          ++h2State.openStreams;
        } else {
          stream2.once("ready", () => {
            request3.onUpgrade(null, null, stream2);
            ++h2State.openStreams;
          });
        }
        stream2.once("close", () => {
          h2State.openStreams -= 1;
          if (h2State.openStreams === 0)
            session.unref();
        });
        return true;
      }
      headers[HTTP2_HEADER_PATH] = path67;
      headers[HTTP2_HEADER_SCHEME] = "https";
      const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
      if (body && typeof body.read === "function") {
        body.read(0);
      }
      let contentLength = util4.bodyLength(body);
      if (contentLength == null) {
        contentLength = request3.contentLength;
      }
      if (contentLength === 0 || !expectsPayload) {
        contentLength = null;
      }
      if (shouldSendContentLength(method) && contentLength > 0 && request3.contentLength != null && request3.contentLength !== contentLength) {
        if (client[kStrictContentLength]) {
          errorRequest(client, request3, new RequestContentLengthMismatchError());
          return false;
        }
        process.emitWarning(new RequestContentLengthMismatchError());
      }
      if (contentLength != null) {
        assert27(body, "no body must not have content length");
        headers[HTTP2_HEADER_CONTENT_LENGTH] = `${contentLength}`;
      }
      session.ref();
      const shouldEndStream = method === "GET" || method === "HEAD";
      if (expectContinue) {
        headers[HTTP2_HEADER_EXPECT] = "100-continue";
        stream2 = session.request(headers, { endStream: shouldEndStream, signal });
        stream2.once("continue", writeBodyH2);
      } else {
        stream2 = session.request(headers, {
          endStream: shouldEndStream,
          signal
        });
        writeBodyH2();
      }
      ++h2State.openStreams;
      stream2.once("response", (headers2) => {
        const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers2;
        if (request3.onHeaders(Number(statusCode), realHeaders, stream2.resume.bind(stream2), "") === false) {
          stream2.pause();
        }
      });
      stream2.once("end", () => {
        request3.onComplete([]);
      });
      stream2.on("data", (chunk) => {
        if (request3.onData(chunk) === false) {
          stream2.pause();
        }
      });
      stream2.once("close", () => {
        h2State.openStreams -= 1;
        if (h2State.openStreams === 0) {
          session.unref();
        }
      });
      stream2.once("error", function(err) {
        if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) {
          h2State.streams -= 1;
          util4.destroy(stream2, err);
        }
      });
      stream2.once("frameError", (type, code) => {
        const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`);
        errorRequest(client, request3, err);
        if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) {
          h2State.streams -= 1;
          util4.destroy(stream2, err);
        }
      });
      return true;
      function writeBodyH2() {
        if (!body) {
          request3.onRequestSent();
        } else if (util4.isBuffer(body)) {
          assert27(contentLength === body.byteLength, "buffer body must have content length");
          stream2.cork();
          stream2.write(body);
          stream2.uncork();
          stream2.end();
          request3.onBodySent(body);
          request3.onRequestSent();
        } else if (util4.isBlobLike(body)) {
          if (typeof body.stream === "function") {
            writeIterable({
              client,
              request: request3,
              contentLength,
              h2stream: stream2,
              expectsPayload,
              body: body.stream(),
              socket: client[kSocket],
              header: ""
            });
          } else {
            writeBlob({
              body,
              client,
              request: request3,
              contentLength,
              expectsPayload,
              h2stream: stream2,
              header: "",
              socket: client[kSocket]
            });
          }
        } else if (util4.isStream(body)) {
          writeStream({
            body,
            client,
            request: request3,
            contentLength,
            expectsPayload,
            socket: client[kSocket],
            h2stream: stream2,
            header: ""
          });
        } else if (util4.isIterable(body)) {
          writeIterable({
            body,
            client,
            request: request3,
            contentLength,
            expectsPayload,
            header: "",
            h2stream: stream2,
            socket: client[kSocket]
          });
        } else {
          assert27(false);
        }
      }
      __name(writeBodyH2, "writeBodyH2");
    }
    __name(writeH2, "writeH2");
    function writeStream({ h2stream, body, client, request: request3, socket, contentLength, header, expectsPayload }) {
      assert27(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined");
      if (client[kHTTPConnVersion] === "h2") {
        let onPipeData = function(chunk) {
          request3.onBodySent(chunk);
        };
        __name(onPipeData, "onPipeData");
        const pipe = pipeline(
          body,
          h2stream,
          (err) => {
            if (err) {
              util4.destroy(body, err);
              util4.destroy(h2stream, err);
            } else {
              request3.onRequestSent();
            }
          }
        );
        pipe.on("data", onPipeData);
        pipe.once("end", () => {
          pipe.removeListener("data", onPipeData);
          util4.destroy(pipe);
        });
        return;
      }
      let finished = false;
      const writer = new AsyncWriter({ socket, request: request3, contentLength, client, expectsPayload, header });
      const onData = /* @__PURE__ */ __name(function(chunk) {
        if (finished) {
          return;
        }
        try {
          if (!writer.write(chunk) && this.pause) {
            this.pause();
          }
        } catch (err) {
          util4.destroy(this, err);
        }
      }, "onData");
      const onDrain = /* @__PURE__ */ __name(function() {
        if (finished) {
          return;
        }
        if (body.resume) {
          body.resume();
        }
      }, "onDrain");
      const onAbort = /* @__PURE__ */ __name(function() {
        if (finished) {
          return;
        }
        const err = new RequestAbortedError();
        queueMicrotask(() => onFinished(err));
      }, "onAbort");
      const onFinished = /* @__PURE__ */ __name(function(err) {
        if (finished) {
          return;
        }
        finished = true;
        assert27(socket.destroyed || socket[kWriting] && client[kRunning] <= 1);
        socket.off("drain", onDrain).off("error", onFinished);
        body.removeListener("data", onData).removeListener("end", onFinished).removeListener("error", onFinished).removeListener("close", onAbort);
        if (!err) {
          try {
            writer.end();
          } catch (er) {
            err = er;
          }
        }
        writer.destroy(err);
        if (err && (err.code !== "UND_ERR_INFO" || err.message !== "reset")) {
          util4.destroy(body, err);
        } else {
          util4.destroy(body);
        }
      }, "onFinished");
      body.on("data", onData).on("end", onFinished).on("error", onFinished).on("close", onAbort);
      if (body.resume) {
        body.resume();
      }
      socket.on("drain", onDrain).on("error", onFinished);
    }
    __name(writeStream, "writeStream");
    async function writeBlob({ h2stream, body, client, request: request3, socket, contentLength, header, expectsPayload }) {
      assert27(contentLength === body.size, "blob body must have content length");
      const isH2 = client[kHTTPConnVersion] === "h2";
      try {
        if (contentLength != null && contentLength !== body.size) {
          throw new RequestContentLengthMismatchError();
        }
        const buffer = Buffer.from(await body.arrayBuffer());
        if (isH2) {
          h2stream.cork();
          h2stream.write(buffer);
          h2stream.uncork();
        } else {
          socket.cork();
          socket.write(`${header}content-length: ${contentLength}\r
\r
`, "latin1");
          socket.write(buffer);
          socket.uncork();
        }
        request3.onBodySent(buffer);
        request3.onRequestSent();
        if (!expectsPayload) {
          socket[kReset2] = true;
        }
        resume(client);
      } catch (err) {
        util4.destroy(isH2 ? h2stream : socket, err);
      }
    }
    __name(writeBlob, "writeBlob");
    async function writeIterable({ h2stream, body, client, request: request3, socket, contentLength, header, expectsPayload }) {
      assert27(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined");
      let callback = null;
      function onDrain() {
        if (callback) {
          const cb = callback;
          callback = null;
          cb();
        }
      }
      __name(onDrain, "onDrain");
      const waitForDrain = /* @__PURE__ */ __name(() => new Promise((resolve19, reject) => {
        assert27(callback === null);
        if (socket[kError]) {
          reject(socket[kError]);
        } else {
          callback = resolve19;
        }
      }), "waitForDrain");
      if (client[kHTTPConnVersion] === "h2") {
        h2stream.on("close", onDrain).on("drain", onDrain);
        try {
          for await (const chunk of body) {
            if (socket[kError]) {
              throw socket[kError];
            }
            const res = h2stream.write(chunk);
            request3.onBodySent(chunk);
            if (!res) {
              await waitForDrain();
            }
          }
        } catch (err) {
          h2stream.destroy(err);
        } finally {
          request3.onRequestSent();
          h2stream.end();
          h2stream.off("close", onDrain).off("drain", onDrain);
        }
        return;
      }
      socket.on("close", onDrain).on("drain", onDrain);
      const writer = new AsyncWriter({ socket, request: request3, contentLength, client, expectsPayload, header });
      try {
        for await (const chunk of body) {
          if (socket[kError]) {
            throw socket[kError];
          }
          if (!writer.write(chunk)) {
            await waitForDrain();
          }
        }
        writer.end();
      } catch (err) {
        writer.destroy(err);
      } finally {
        socket.off("close", onDrain).off("drain", onDrain);
      }
    }
    __name(writeIterable, "writeIterable");
    var AsyncWriter = class {
      constructor({ socket, request: request3, contentLength, client, expectsPayload, header }) {
        this.socket = socket;
        this.request = request3;
        this.contentLength = contentLength;
        this.client = client;
        this.bytesWritten = 0;
        this.expectsPayload = expectsPayload;
        this.header = header;
        socket[kWriting] = true;
      }
      write(chunk) {
        const { socket, request: request3, contentLength, client, bytesWritten, expectsPayload, header } = this;
        if (socket[kError]) {
          throw socket[kError];
        }
        if (socket.destroyed) {
          return false;
        }
        const len = Buffer.byteLength(chunk);
        if (!len) {
          return true;
        }
        if (contentLength !== null && bytesWritten + len > contentLength) {
          if (client[kStrictContentLength]) {
            throw new RequestContentLengthMismatchError();
          }
          process.emitWarning(new RequestContentLengthMismatchError());
        }
        socket.cork();
        if (bytesWritten === 0) {
          if (!expectsPayload) {
            socket[kReset2] = true;
          }
          if (contentLength === null) {
            socket.write(`${header}transfer-encoding: chunked\r
`, "latin1");
          } else {
            socket.write(`${header}content-length: ${contentLength}\r
\r
`, "latin1");
          }
        }
        if (contentLength === null) {
          socket.write(`\r
${len.toString(16)}\r
`, "latin1");
        }
        this.bytesWritten += len;
        const ret = socket.write(chunk);
        socket.uncork();
        request3.onBodySent(chunk);
        if (!ret) {
          if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
            if (socket[kParser].timeout.refresh) {
              socket[kParser].timeout.refresh();
            }
          }
        }
        return ret;
      }
      end() {
        const { socket, contentLength, client, bytesWritten, expectsPayload, header, request: request3 } = this;
        request3.onRequestSent();
        socket[kWriting] = false;
        if (socket[kError]) {
          throw socket[kError];
        }
        if (socket.destroyed) {
          return;
        }
        if (bytesWritten === 0) {
          if (expectsPayload) {
            socket.write(`${header}content-length: 0\r
\r
`, "latin1");
          } else {
            socket.write(`${header}\r
`, "latin1");
          }
        } else if (contentLength === null) {
          socket.write("\r\n0\r\n\r\n", "latin1");
        }
        if (contentLength !== null && bytesWritten !== contentLength) {
          if (client[kStrictContentLength]) {
            throw new RequestContentLengthMismatchError();
          } else {
            process.emitWarning(new RequestContentLengthMismatchError());
          }
        }
        if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
          if (socket[kParser].timeout.refresh) {
            socket[kParser].timeout.refresh();
          }
        }
        resume(client);
      }
      destroy(err) {
        const { socket, client } = this;
        socket[kWriting] = false;
        if (err) {
          assert27(client[kRunning] <= 1, "pipeline should only contain this request");
          util4.destroy(socket, err);
        }
      }
    };
    __name(AsyncWriter, "AsyncWriter");
    function errorRequest(client, request3, err) {
      try {
        request3.onError(err);
        assert27(request3.aborted);
      } catch (err2) {
        client.emit("error", err2);
      }
    }
    __name(errorRequest, "errorRequest");
    module3.exports = Client;
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/node/fixed-queue.js
var require_fixed_queue = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/node/fixed-queue.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var kSize = 2048;
    var kMask = kSize - 1;
    var FixedCircularBuffer = class {
      constructor() {
        this.bottom = 0;
        this.top = 0;
        this.list = new Array(kSize);
        this.next = null;
      }
      isEmpty() {
        return this.top === this.bottom;
      }
      isFull() {
        return (this.top + 1 & kMask) === this.bottom;
      }
      push(data) {
        this.list[this.top] = data;
        this.top = this.top + 1 & kMask;
      }
      shift() {
        const nextItem = this.list[this.bottom];
        if (nextItem === void 0)
          return null;
        this.list[this.bottom] = void 0;
        this.bottom = this.bottom + 1 & kMask;
        return nextItem;
      }
    };
    __name(FixedCircularBuffer, "FixedCircularBuffer");
    module3.exports = /* @__PURE__ */ __name(class FixedQueue {
      constructor() {
        this.head = this.tail = new FixedCircularBuffer();
      }
      isEmpty() {
        return this.head.isEmpty();
      }
      push(data) {
        if (this.head.isFull()) {
          this.head = this.head.next = new FixedCircularBuffer();
        }
        this.head.push(data);
      }
      shift() {
        const tail = this.tail;
        const next = tail.shift();
        if (tail.isEmpty() && tail.next !== null) {
          this.tail = tail.next;
        }
        return next;
      }
    }, "FixedQueue");
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/pool-stats.js
var require_pool_stats = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/pool-stats.js"(exports2, module3) {
    init_import_meta_url();
    var { kFree, kConnected, kPending, kQueued, kRunning, kSize } = require_symbols();
    var kPool = Symbol("pool");
    var PoolStats = class {
      constructor(pool2) {
        this[kPool] = pool2;
      }
      get connected() {
        return this[kPool][kConnected];
      }
      get free() {
        return this[kPool][kFree];
      }
      get pending() {
        return this[kPool][kPending];
      }
      get queued() {
        return this[kPool][kQueued];
      }
      get running() {
        return this[kPool][kRunning];
      }
      get size() {
        return this[kPool][kSize];
      }
    };
    __name(PoolStats, "PoolStats");
    module3.exports = PoolStats;
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/pool-base.js
var require_pool_base = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/pool-base.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var DispatcherBase = require_dispatcher_base();
    var FixedQueue = require_fixed_queue();
    var { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = require_symbols();
    var PoolStats = require_pool_stats();
    var kClients = Symbol("clients");
    var kNeedDrain = Symbol("needDrain");
    var kQueue = Symbol("queue");
    var kClosedResolve = Symbol("closed resolve");
    var kOnDrain = Symbol("onDrain");
    var kOnConnect = Symbol("onConnect");
    var kOnDisconnect = Symbol("onDisconnect");
    var kOnConnectionError = Symbol("onConnectionError");
    var kGetDispatcher = Symbol("get dispatcher");
    var kAddClient = Symbol("add client");
    var kRemoveClient = Symbol("remove client");
    var kStats = Symbol("stats");
    var PoolBase = class extends DispatcherBase {
      constructor() {
        super();
        this[kQueue] = new FixedQueue();
        this[kClients] = [];
        this[kQueued] = 0;
        const pool2 = this;
        this[kOnDrain] = /* @__PURE__ */ __name(function onDrain(origin, targets) {
          const queue = pool2[kQueue];
          let needDrain = false;
          while (!needDrain) {
            const item = queue.shift();
            if (!item) {
              break;
            }
            pool2[kQueued]--;
            needDrain = !this.dispatch(item.opts, item.handler);
          }
          this[kNeedDrain] = needDrain;
          if (!this[kNeedDrain] && pool2[kNeedDrain]) {
            pool2[kNeedDrain] = false;
            pool2.emit("drain", origin, [pool2, ...targets]);
          }
          if (pool2[kClosedResolve] && queue.isEmpty()) {
            Promise.all(pool2[kClients].map((c2) => c2.close())).then(pool2[kClosedResolve]);
          }
        }, "onDrain");
        this[kOnConnect] = (origin, targets) => {
          pool2.emit("connect", origin, [pool2, ...targets]);
        };
        this[kOnDisconnect] = (origin, targets, err) => {
          pool2.emit("disconnect", origin, [pool2, ...targets], err);
        };
        this[kOnConnectionError] = (origin, targets, err) => {
          pool2.emit("connectionError", origin, [pool2, ...targets], err);
        };
        this[kStats] = new PoolStats(this);
      }
      get [kBusy]() {
        return this[kNeedDrain];
      }
      get [kConnected]() {
        return this[kClients].filter((client) => client[kConnected]).length;
      }
      get [kFree]() {
        return this[kClients].filter((client) => client[kConnected] && !client[kNeedDrain]).length;
      }
      get [kPending]() {
        let ret = this[kQueued];
        for (const { [kPending]: pending } of this[kClients]) {
          ret += pending;
        }
        return ret;
      }
      get [kRunning]() {
        let ret = 0;
        for (const { [kRunning]: running } of this[kClients]) {
          ret += running;
        }
        return ret;
      }
      get [kSize]() {
        let ret = this[kQueued];
        for (const { [kSize]: size } of this[kClients]) {
          ret += size;
        }
        return ret;
      }
      get stats() {
        return this[kStats];
      }
      async [kClose]() {
        if (this[kQueue].isEmpty()) {
          return Promise.all(this[kClients].map((c2) => c2.close()));
        } else {
          return new Promise((resolve19) => {
            this[kClosedResolve] = resolve19;
          });
        }
      }
      async [kDestroy](err) {
        while (true) {
          const item = this[kQueue].shift();
          if (!item) {
            break;
          }
          item.handler.onError(err);
        }
        return Promise.all(this[kClients].map((c2) => c2.destroy(err)));
      }
      [kDispatch](opts, handler30) {
        const dispatcher = this[kGetDispatcher]();
        if (!dispatcher) {
          this[kNeedDrain] = true;
          this[kQueue].push({ opts, handler: handler30 });
          this[kQueued]++;
        } else if (!dispatcher.dispatch(opts, handler30)) {
          dispatcher[kNeedDrain] = true;
          this[kNeedDrain] = !this[kGetDispatcher]();
        }
        return !this[kNeedDrain];
      }
      [kAddClient](client) {
        client.on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]);
        this[kClients].push(client);
        if (this[kNeedDrain]) {
          process.nextTick(() => {
            if (this[kNeedDrain]) {
              this[kOnDrain](client[kUrl], [this, client]);
            }
          });
        }
        return this;
      }
      [kRemoveClient](client) {
        client.close(() => {
          const idx = this[kClients].indexOf(client);
          if (idx !== -1) {
            this[kClients].splice(idx, 1);
          }
        });
        this[kNeedDrain] = this[kClients].some((dispatcher) => !dispatcher[kNeedDrain] && dispatcher.closed !== true && dispatcher.destroyed !== true);
      }
    };
    __name(PoolBase, "PoolBase");
    module3.exports = {
      PoolBase,
      kClients,
      kNeedDrain,
      kAddClient,
      kRemoveClient,
      kGetDispatcher
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/pool.js
var require_pool = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/pool.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var {
      PoolBase,
      kClients,
      kNeedDrain,
      kAddClient,
      kGetDispatcher
    } = require_pool_base();
    var Client = require_client();
    var {
      InvalidArgumentError
    } = require_errors();
    var util4 = require_util();
    var { kUrl, kInterceptors } = require_symbols();
    var buildConnector = require_connect();
    var kOptions = Symbol("options");
    var kConnections = Symbol("connections");
    var kFactory = Symbol("factory");
    function defaultFactory(origin, opts) {
      return new Client(origin, opts);
    }
    __name(defaultFactory, "defaultFactory");
    var Pool = class extends PoolBase {
      constructor(origin, {
        connections,
        factory = defaultFactory,
        connect: connect2,
        connectTimeout,
        tls,
        maxCachedSessions,
        socketPath,
        autoSelectFamily,
        autoSelectFamilyAttemptTimeout,
        allowH2,
        ...options29
      } = {}) {
        super();
        if (connections != null && (!Number.isFinite(connections) || connections < 0)) {
          throw new InvalidArgumentError("invalid connections");
        }
        if (typeof factory !== "function") {
          throw new InvalidArgumentError("factory must be a function.");
        }
        if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") {
          throw new InvalidArgumentError("connect must be a function or an object");
        }
        if (typeof connect2 !== "function") {
          connect2 = buildConnector({
            ...tls,
            maxCachedSessions,
            allowH2,
            socketPath,
            timeout: connectTimeout,
            ...util4.nodeHasAutoSelectFamily && autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
            ...connect2
          });
        }
        this[kInterceptors] = options29.interceptors && options29.interceptors.Pool && Array.isArray(options29.interceptors.Pool) ? options29.interceptors.Pool : [];
        this[kConnections] = connections || null;
        this[kUrl] = util4.parseOrigin(origin);
        this[kOptions] = { ...util4.deepClone(options29), connect: connect2, allowH2 };
        this[kOptions].interceptors = options29.interceptors ? { ...options29.interceptors } : void 0;
        this[kFactory] = factory;
      }
      [kGetDispatcher]() {
        let dispatcher = this[kClients].find((dispatcher2) => !dispatcher2[kNeedDrain]);
        if (dispatcher) {
          return dispatcher;
        }
        if (!this[kConnections] || this[kClients].length < this[kConnections]) {
          dispatcher = this[kFactory](this[kUrl], this[kOptions]);
          this[kAddClient](dispatcher);
        }
        return dispatcher;
      }
    };
    __name(Pool, "Pool");
    module3.exports = Pool;
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/balanced-pool.js
var require_balanced_pool = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/balanced-pool.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var {
      BalancedPoolMissingUpstreamError,
      InvalidArgumentError
    } = require_errors();
    var {
      PoolBase,
      kClients,
      kNeedDrain,
      kAddClient,
      kRemoveClient,
      kGetDispatcher
    } = require_pool_base();
    var Pool = require_pool();
    var { kUrl, kInterceptors } = require_symbols();
    var { parseOrigin } = require_util();
    var kFactory = Symbol("factory");
    var kOptions = Symbol("options");
    var kGreatestCommonDivisor = Symbol("kGreatestCommonDivisor");
    var kCurrentWeight = Symbol("kCurrentWeight");
    var kIndex = Symbol("kIndex");
    var kWeight = Symbol("kWeight");
    var kMaxWeightPerServer = Symbol("kMaxWeightPerServer");
    var kErrorPenalty = Symbol("kErrorPenalty");
    function getGreatestCommonDivisor(a, b2) {
      if (b2 === 0)
        return a;
      return getGreatestCommonDivisor(b2, a % b2);
    }
    __name(getGreatestCommonDivisor, "getGreatestCommonDivisor");
    function defaultFactory(origin, opts) {
      return new Pool(origin, opts);
    }
    __name(defaultFactory, "defaultFactory");
    var BalancedPool = class extends PoolBase {
      constructor(upstreams = [], { factory = defaultFactory, ...opts } = {}) {
        super();
        this[kOptions] = opts;
        this[kIndex] = -1;
        this[kCurrentWeight] = 0;
        this[kMaxWeightPerServer] = this[kOptions].maxWeightPerServer || 100;
        this[kErrorPenalty] = this[kOptions].errorPenalty || 15;
        if (!Array.isArray(upstreams)) {
          upstreams = [upstreams];
        }
        if (typeof factory !== "function") {
          throw new InvalidArgumentError("factory must be a function.");
        }
        this[kInterceptors] = opts.interceptors && opts.interceptors.BalancedPool && Array.isArray(opts.interceptors.BalancedPool) ? opts.interceptors.BalancedPool : [];
        this[kFactory] = factory;
        for (const upstream of upstreams) {
          this.addUpstream(upstream);
        }
        this._updateBalancedPoolStats();
      }
      addUpstream(upstream) {
        const upstreamOrigin = parseOrigin(upstream).origin;
        if (this[kClients].find((pool3) => pool3[kUrl].origin === upstreamOrigin && pool3.closed !== true && pool3.destroyed !== true)) {
          return this;
        }
        const pool2 = this[kFactory](upstreamOrigin, Object.assign({}, this[kOptions]));
        this[kAddClient](pool2);
        pool2.on("connect", () => {
          pool2[kWeight] = Math.min(this[kMaxWeightPerServer], pool2[kWeight] + this[kErrorPenalty]);
        });
        pool2.on("connectionError", () => {
          pool2[kWeight] = Math.max(1, pool2[kWeight] - this[kErrorPenalty]);
          this._updateBalancedPoolStats();
        });
        pool2.on("disconnect", (...args) => {
          const err = args[2];
          if (err && err.code === "UND_ERR_SOCKET") {
            pool2[kWeight] = Math.max(1, pool2[kWeight] - this[kErrorPenalty]);
            this._updateBalancedPoolStats();
          }
        });
        for (const client of this[kClients]) {
          client[kWeight] = this[kMaxWeightPerServer];
        }
        this._updateBalancedPoolStats();
        return this;
      }
      _updateBalancedPoolStats() {
        this[kGreatestCommonDivisor] = this[kClients].map((p2) => p2[kWeight]).reduce(getGreatestCommonDivisor, 0);
      }
      removeUpstream(upstream) {
        const upstreamOrigin = parseOrigin(upstream).origin;
        const pool2 = this[kClients].find((pool3) => pool3[kUrl].origin === upstreamOrigin && pool3.closed !== true && pool3.destroyed !== true);
        if (pool2) {
          this[kRemoveClient](pool2);
        }
        return this;
      }
      get upstreams() {
        return this[kClients].filter((dispatcher) => dispatcher.closed !== true && dispatcher.destroyed !== true).map((p2) => p2[kUrl].origin);
      }
      [kGetDispatcher]() {
        if (this[kClients].length === 0) {
          throw new BalancedPoolMissingUpstreamError();
        }
        const dispatcher = this[kClients].find((dispatcher2) => !dispatcher2[kNeedDrain] && dispatcher2.closed !== true && dispatcher2.destroyed !== true);
        if (!dispatcher) {
          return;
        }
        const allClientsBusy = this[kClients].map((pool2) => pool2[kNeedDrain]).reduce((a, b2) => a && b2, true);
        if (allClientsBusy) {
          return;
        }
        let counter = 0;
        let maxWeightIndex = this[kClients].findIndex((pool2) => !pool2[kNeedDrain]);
        while (counter++ < this[kClients].length) {
          this[kIndex] = (this[kIndex] + 1) % this[kClients].length;
          const pool2 = this[kClients][this[kIndex]];
          if (pool2[kWeight] > this[kClients][maxWeightIndex][kWeight] && !pool2[kNeedDrain]) {
            maxWeightIndex = this[kIndex];
          }
          if (this[kIndex] === 0) {
            this[kCurrentWeight] = this[kCurrentWeight] - this[kGreatestCommonDivisor];
            if (this[kCurrentWeight] <= 0) {
              this[kCurrentWeight] = this[kMaxWeightPerServer];
            }
          }
          if (pool2[kWeight] >= this[kCurrentWeight] && !pool2[kNeedDrain]) {
            return pool2;
          }
        }
        this[kCurrentWeight] = this[kClients][maxWeightIndex][kWeight];
        this[kIndex] = maxWeightIndex;
        return this[kClients][maxWeightIndex];
      }
    };
    __name(BalancedPool, "BalancedPool");
    module3.exports = BalancedPool;
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/compat/dispatcher-weakref.js
var require_dispatcher_weakref = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/compat/dispatcher-weakref.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { kConnected, kSize } = require_symbols();
    var CompatWeakRef = class {
      constructor(value) {
        this.value = value;
      }
      deref() {
        return this.value[kConnected] === 0 && this.value[kSize] === 0 ? void 0 : this.value;
      }
    };
    __name(CompatWeakRef, "CompatWeakRef");
    var CompatFinalizer = class {
      constructor(finalizer) {
        this.finalizer = finalizer;
      }
      register(dispatcher, key) {
        if (dispatcher.on) {
          dispatcher.on("disconnect", () => {
            if (dispatcher[kConnected] === 0 && dispatcher[kSize] === 0) {
              this.finalizer(key);
            }
          });
        }
      }
    };
    __name(CompatFinalizer, "CompatFinalizer");
    module3.exports = function() {
      if (process.env.NODE_V8_COVERAGE) {
        return {
          WeakRef: CompatWeakRef,
          FinalizationRegistry: CompatFinalizer
        };
      }
      return {
        WeakRef: global.WeakRef || CompatWeakRef,
        FinalizationRegistry: global.FinalizationRegistry || CompatFinalizer
      };
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/agent.js
var require_agent = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/agent.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { InvalidArgumentError } = require_errors();
    var { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = require_symbols();
    var DispatcherBase = require_dispatcher_base();
    var Pool = require_pool();
    var Client = require_client();
    var util4 = require_util();
    var createRedirectInterceptor = require_redirectInterceptor();
    var { WeakRef: WeakRef2, FinalizationRegistry: FinalizationRegistry2 } = require_dispatcher_weakref()();
    var kOnConnect = Symbol("onConnect");
    var kOnDisconnect = Symbol("onDisconnect");
    var kOnConnectionError = Symbol("onConnectionError");
    var kMaxRedirections = Symbol("maxRedirections");
    var kOnDrain = Symbol("onDrain");
    var kFactory = Symbol("factory");
    var kFinalizer = Symbol("finalizer");
    var kOptions = Symbol("options");
    function defaultFactory(origin, opts) {
      return opts && opts.connections === 1 ? new Client(origin, opts) : new Pool(origin, opts);
    }
    __name(defaultFactory, "defaultFactory");
    var Agent = class extends DispatcherBase {
      constructor({ factory = defaultFactory, maxRedirections = 0, connect: connect2, ...options29 } = {}) {
        super();
        if (typeof factory !== "function") {
          throw new InvalidArgumentError("factory must be a function.");
        }
        if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") {
          throw new InvalidArgumentError("connect must be a function or an object");
        }
        if (!Number.isInteger(maxRedirections) || maxRedirections < 0) {
          throw new InvalidArgumentError("maxRedirections must be a positive number");
        }
        if (connect2 && typeof connect2 !== "function") {
          connect2 = { ...connect2 };
        }
        this[kInterceptors] = options29.interceptors && options29.interceptors.Agent && Array.isArray(options29.interceptors.Agent) ? options29.interceptors.Agent : [createRedirectInterceptor({ maxRedirections })];
        this[kOptions] = { ...util4.deepClone(options29), connect: connect2 };
        this[kOptions].interceptors = options29.interceptors ? { ...options29.interceptors } : void 0;
        this[kMaxRedirections] = maxRedirections;
        this[kFactory] = factory;
        this[kClients] = /* @__PURE__ */ new Map();
        this[kFinalizer] = new FinalizationRegistry2(
          /* istanbul ignore next: gc is undeterministic */
          (key) => {
            const ref = this[kClients].get(key);
            if (ref !== void 0 && ref.deref() === void 0) {
              this[kClients].delete(key);
            }
          }
        );
        const agent = this;
        this[kOnDrain] = (origin, targets) => {
          agent.emit("drain", origin, [agent, ...targets]);
        };
        this[kOnConnect] = (origin, targets) => {
          agent.emit("connect", origin, [agent, ...targets]);
        };
        this[kOnDisconnect] = (origin, targets, err) => {
          agent.emit("disconnect", origin, [agent, ...targets], err);
        };
        this[kOnConnectionError] = (origin, targets, err) => {
          agent.emit("connectionError", origin, [agent, ...targets], err);
        };
      }
      get [kRunning]() {
        let ret = 0;
        for (const ref of this[kClients].values()) {
          const client = ref.deref();
          if (client) {
            ret += client[kRunning];
          }
        }
        return ret;
      }
      [kDispatch](opts, handler30) {
        let key;
        if (opts.origin && (typeof opts.origin === "string" || opts.origin instanceof URL)) {
          key = String(opts.origin);
        } else {
          throw new InvalidArgumentError("opts.origin must be a non-empty string or URL.");
        }
        const ref = this[kClients].get(key);
        let dispatcher = ref ? ref.deref() : null;
        if (!dispatcher) {
          dispatcher = this[kFactory](opts.origin, this[kOptions]).on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]);
          this[kClients].set(key, new WeakRef2(dispatcher));
          this[kFinalizer].register(dispatcher, key);
        }
        return dispatcher.dispatch(opts, handler30);
      }
      async [kClose]() {
        const closePromises = [];
        for (const ref of this[kClients].values()) {
          const client = ref.deref();
          if (client) {
            closePromises.push(client.close());
          }
        }
        await Promise.all(closePromises);
      }
      async [kDestroy](err) {
        const destroyPromises = [];
        for (const ref of this[kClients].values()) {
          const client = ref.deref();
          if (client) {
            destroyPromises.push(client.destroy(err));
          }
        }
        await Promise.all(destroyPromises);
      }
    };
    __name(Agent, "Agent");
    module3.exports = Agent;
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/api/readable.js
var require_readable = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/api/readable.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var assert27 = require("assert");
    var { Readable: Readable2 } = require("stream");
    var { RequestAbortedError, NotSupportedError, InvalidArgumentError } = require_errors();
    var util4 = require_util();
    var { ReadableStreamFrom, toUSVString } = require_util();
    var Blob6;
    var kConsume = Symbol("kConsume");
    var kReading = Symbol("kReading");
    var kBody = Symbol("kBody");
    var kAbort = Symbol("abort");
    var kContentType = Symbol("kContentType");
    var noop = /* @__PURE__ */ __name(() => {
    }, "noop");
    module3.exports = /* @__PURE__ */ __name(class BodyReadable extends Readable2 {
      constructor({
        resume,
        abort,
        contentType = "",
        highWaterMark = 64 * 1024
        // Same as nodejs fs streams.
      }) {
        super({
          autoDestroy: true,
          read: resume,
          highWaterMark
        });
        this._readableState.dataEmitted = false;
        this[kAbort] = abort;
        this[kConsume] = null;
        this[kBody] = null;
        this[kContentType] = contentType;
        this[kReading] = false;
      }
      destroy(err) {
        if (this.destroyed) {
          return this;
        }
        if (!err && !this._readableState.endEmitted) {
          err = new RequestAbortedError();
        }
        if (err) {
          this[kAbort]();
        }
        return super.destroy(err);
      }
      emit(ev, ...args) {
        if (ev === "data") {
          this._readableState.dataEmitted = true;
        } else if (ev === "error") {
          this._readableState.errorEmitted = true;
        }
        return super.emit(ev, ...args);
      }
      on(ev, ...args) {
        if (ev === "data" || ev === "readable") {
          this[kReading] = true;
        }
        return super.on(ev, ...args);
      }
      addListener(ev, ...args) {
        return this.on(ev, ...args);
      }
      off(ev, ...args) {
        const ret = super.off(ev, ...args);
        if (ev === "data" || ev === "readable") {
          this[kReading] = this.listenerCount("data") > 0 || this.listenerCount("readable") > 0;
        }
        return ret;
      }
      removeListener(ev, ...args) {
        return this.off(ev, ...args);
      }
      push(chunk) {
        if (this[kConsume] && chunk !== null && this.readableLength === 0) {
          consumePush(this[kConsume], chunk);
          return this[kReading] ? super.push(chunk) : true;
        }
        return super.push(chunk);
      }
      // https://fetch.spec.whatwg.org/#dom-body-text
      async text() {
        return consume(this, "text");
      }
      // https://fetch.spec.whatwg.org/#dom-body-json
      async json() {
        return consume(this, "json");
      }
      // https://fetch.spec.whatwg.org/#dom-body-blob
      async blob() {
        return consume(this, "blob");
      }
      // https://fetch.spec.whatwg.org/#dom-body-arraybuffer
      async arrayBuffer() {
        return consume(this, "arrayBuffer");
      }
      // https://fetch.spec.whatwg.org/#dom-body-formdata
      async formData() {
        throw new NotSupportedError();
      }
      // https://fetch.spec.whatwg.org/#dom-body-bodyused
      get bodyUsed() {
        return util4.isDisturbed(this);
      }
      // https://fetch.spec.whatwg.org/#dom-body-body
      get body() {
        if (!this[kBody]) {
          this[kBody] = ReadableStreamFrom(this);
          if (this[kConsume]) {
            this[kBody].getReader();
            assert27(this[kBody].locked);
          }
        }
        return this[kBody];
      }
      dump(opts) {
        let limit = opts && Number.isFinite(opts.limit) ? opts.limit : 262144;
        const signal = opts && opts.signal;
        if (signal) {
          try {
            if (typeof signal !== "object" || !("aborted" in signal)) {
              throw new InvalidArgumentError("signal must be an AbortSignal");
            }
            util4.throwIfAborted(signal);
          } catch (err) {
            return Promise.reject(err);
          }
        }
        if (this.closed) {
          return Promise.resolve(null);
        }
        return new Promise((resolve19, reject) => {
          const signalListenerCleanup = signal ? util4.addAbortListener(signal, () => {
            this.destroy();
          }) : noop;
          this.on("close", function() {
            signalListenerCleanup();
            if (signal && signal.aborted) {
              reject(signal.reason || Object.assign(new Error("The operation was aborted"), { name: "AbortError" }));
            } else {
              resolve19(null);
            }
          }).on("error", noop).on("data", function(chunk) {
            limit -= chunk.length;
            if (limit <= 0) {
              this.destroy();
            }
          }).resume();
        });
      }
    }, "BodyReadable");
    function isLocked(self2) {
      return self2[kBody] && self2[kBody].locked === true || self2[kConsume];
    }
    __name(isLocked, "isLocked");
    function isUnusable(self2) {
      return util4.isDisturbed(self2) || isLocked(self2);
    }
    __name(isUnusable, "isUnusable");
    async function consume(stream2, type) {
      if (isUnusable(stream2)) {
        throw new TypeError("unusable");
      }
      assert27(!stream2[kConsume]);
      return new Promise((resolve19, reject) => {
        stream2[kConsume] = {
          type,
          stream: stream2,
          resolve: resolve19,
          reject,
          length: 0,
          body: []
        };
        stream2.on("error", function(err) {
          consumeFinish(this[kConsume], err);
        }).on("close", function() {
          if (this[kConsume].body !== null) {
            consumeFinish(this[kConsume], new RequestAbortedError());
          }
        });
        process.nextTick(consumeStart, stream2[kConsume]);
      });
    }
    __name(consume, "consume");
    function consumeStart(consume2) {
      if (consume2.body === null) {
        return;
      }
      const { _readableState: state } = consume2.stream;
      for (const chunk of state.buffer) {
        consumePush(consume2, chunk);
      }
      if (state.endEmitted) {
        consumeEnd(this[kConsume]);
      } else {
        consume2.stream.on("end", function() {
          consumeEnd(this[kConsume]);
        });
      }
      consume2.stream.resume();
      while (consume2.stream.read() != null) {
      }
    }
    __name(consumeStart, "consumeStart");
    function consumeEnd(consume2) {
      const { type, body, resolve: resolve19, stream: stream2, length } = consume2;
      try {
        if (type === "text") {
          resolve19(toUSVString(Buffer.concat(body)));
        } else if (type === "json") {
          resolve19(JSON.parse(Buffer.concat(body)));
        } else if (type === "arrayBuffer") {
          const dst = new Uint8Array(length);
          let pos = 0;
          for (const buf of body) {
            dst.set(buf, pos);
            pos += buf.byteLength;
          }
          resolve19(dst.buffer);
        } else if (type === "blob") {
          if (!Blob6) {
            Blob6 = require("buffer").Blob;
          }
          resolve19(new Blob6(body, { type: stream2[kContentType] }));
        }
        consumeFinish(consume2);
      } catch (err) {
        stream2.destroy(err);
      }
    }
    __name(consumeEnd, "consumeEnd");
    function consumePush(consume2, chunk) {
      consume2.length += chunk.length;
      consume2.body.push(chunk);
    }
    __name(consumePush, "consumePush");
    function consumeFinish(consume2, err) {
      if (consume2.body === null) {
        return;
      }
      if (err) {
        consume2.reject(err);
      } else {
        consume2.resolve();
      }
      consume2.type = null;
      consume2.stream = null;
      consume2.resolve = null;
      consume2.reject = null;
      consume2.length = 0;
      consume2.body = null;
    }
    __name(consumeFinish, "consumeFinish");
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/api/util.js
var require_util3 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/api/util.js"(exports2, module3) {
    init_import_meta_url();
    var assert27 = require("assert");
    var {
      ResponseStatusCodeError
    } = require_errors();
    var { toUSVString } = require_util();
    async function getResolveErrorBodyCallback({ callback, body, contentType, statusCode, statusMessage, headers }) {
      assert27(body);
      let chunks = [];
      let limit = 0;
      for await (const chunk of body) {
        chunks.push(chunk);
        limit += chunk.length;
        if (limit > 128 * 1024) {
          chunks = null;
          break;
        }
      }
      if (statusCode === 204 || !contentType || !chunks) {
        process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers));
        return;
      }
      try {
        if (contentType.startsWith("application/json")) {
          const payload = JSON.parse(toUSVString(Buffer.concat(chunks)));
          process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers, payload));
          return;
        }
        if (contentType.startsWith("text/")) {
          const payload = toUSVString(Buffer.concat(chunks));
          process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers, payload));
          return;
        }
      } catch (err) {
      }
      process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers));
    }
    __name(getResolveErrorBodyCallback, "getResolveErrorBodyCallback");
    module3.exports = { getResolveErrorBodyCallback };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/api/abort-signal.js
var require_abort_signal = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/api/abort-signal.js"(exports2, module3) {
    init_import_meta_url();
    var { addAbortListener } = require_util();
    var { RequestAbortedError } = require_errors();
    var kListener = Symbol("kListener");
    var kSignal = Symbol("kSignal");
    function abort(self2) {
      if (self2.abort) {
        self2.abort();
      } else {
        self2.onError(new RequestAbortedError());
      }
    }
    __name(abort, "abort");
    function addSignal(self2, signal) {
      self2[kSignal] = null;
      self2[kListener] = null;
      if (!signal) {
        return;
      }
      if (signal.aborted) {
        abort(self2);
        return;
      }
      self2[kSignal] = signal;
      self2[kListener] = () => {
        abort(self2);
      };
      addAbortListener(self2[kSignal], self2[kListener]);
    }
    __name(addSignal, "addSignal");
    function removeSignal(self2) {
      if (!self2[kSignal]) {
        return;
      }
      if ("removeEventListener" in self2[kSignal]) {
        self2[kSignal].removeEventListener("abort", self2[kListener]);
      } else {
        self2[kSignal].removeListener("abort", self2[kListener]);
      }
      self2[kSignal] = null;
      self2[kListener] = null;
    }
    __name(removeSignal, "removeSignal");
    module3.exports = {
      addSignal,
      removeSignal
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/api/api-request.js
var require_api_request = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/api/api-request.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var Readable2 = require_readable();
    var {
      InvalidArgumentError,
      RequestAbortedError
    } = require_errors();
    var util4 = require_util();
    var { getResolveErrorBodyCallback } = require_util3();
    var { AsyncResource } = require("async_hooks");
    var { addSignal, removeSignal } = require_abort_signal();
    var RequestHandler = class extends AsyncResource {
      constructor(opts, callback) {
        if (!opts || typeof opts !== "object") {
          throw new InvalidArgumentError("invalid opts");
        }
        const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError, highWaterMark } = opts;
        try {
          if (typeof callback !== "function") {
            throw new InvalidArgumentError("invalid callback");
          }
          if (highWaterMark && (typeof highWaterMark !== "number" || highWaterMark < 0)) {
            throw new InvalidArgumentError("invalid highWaterMark");
          }
          if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
            throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
          }
          if (method === "CONNECT") {
            throw new InvalidArgumentError("invalid method");
          }
          if (onInfo && typeof onInfo !== "function") {
            throw new InvalidArgumentError("invalid onInfo callback");
          }
          super("UNDICI_REQUEST");
        } catch (err) {
          if (util4.isStream(body)) {
            util4.destroy(body.on("error", util4.nop), err);
          }
          throw err;
        }
        this.responseHeaders = responseHeaders || null;
        this.opaque = opaque || null;
        this.callback = callback;
        this.res = null;
        this.abort = null;
        this.body = body;
        this.trailers = {};
        this.context = null;
        this.onInfo = onInfo || null;
        this.throwOnError = throwOnError;
        this.highWaterMark = highWaterMark;
        if (util4.isStream(body)) {
          body.on("error", (err) => {
            this.onError(err);
          });
        }
        addSignal(this, signal);
      }
      onConnect(abort, context2) {
        if (!this.callback) {
          throw new RequestAbortedError();
        }
        this.abort = abort;
        this.context = context2;
      }
      onHeaders(statusCode, rawHeaders, resume, statusMessage) {
        const { callback, opaque, abort, context: context2, responseHeaders, highWaterMark } = this;
        const headers = responseHeaders === "raw" ? util4.parseRawHeaders(rawHeaders) : util4.parseHeaders(rawHeaders);
        if (statusCode < 200) {
          if (this.onInfo) {
            this.onInfo({ statusCode, headers });
          }
          return;
        }
        const parsedHeaders = responseHeaders === "raw" ? util4.parseHeaders(rawHeaders) : headers;
        const contentType = parsedHeaders["content-type"];
        const body = new Readable2({ resume, abort, contentType, highWaterMark });
        this.callback = null;
        this.res = body;
        if (callback !== null) {
          if (this.throwOnError && statusCode >= 400) {
            this.runInAsyncScope(
              getResolveErrorBodyCallback,
              null,
              { callback, body, contentType, statusCode, statusMessage, headers }
            );
          } else {
            this.runInAsyncScope(callback, null, null, {
              statusCode,
              headers,
              trailers: this.trailers,
              opaque,
              body,
              context: context2
            });
          }
        }
      }
      onData(chunk) {
        const { res } = this;
        return res.push(chunk);
      }
      onComplete(trailers) {
        const { res } = this;
        removeSignal(this);
        util4.parseHeaders(trailers, this.trailers);
        res.push(null);
      }
      onError(err) {
        const { res, callback, body, opaque } = this;
        removeSignal(this);
        if (callback) {
          this.callback = null;
          queueMicrotask(() => {
            this.runInAsyncScope(callback, null, err, { opaque });
          });
        }
        if (res) {
          this.res = null;
          queueMicrotask(() => {
            util4.destroy(res, err);
          });
        }
        if (body) {
          this.body = null;
          util4.destroy(body, err);
        }
      }
    };
    __name(RequestHandler, "RequestHandler");
    function request3(opts, callback) {
      if (callback === void 0) {
        return new Promise((resolve19, reject) => {
          request3.call(this, opts, (err, data) => {
            return err ? reject(err) : resolve19(data);
          });
        });
      }
      try {
        this.dispatch(opts, new RequestHandler(opts, callback));
      } catch (err) {
        if (typeof callback !== "function") {
          throw err;
        }
        const opaque = opts && opts.opaque;
        queueMicrotask(() => callback(err, { opaque }));
      }
    }
    __name(request3, "request");
    module3.exports = request3;
    module3.exports.RequestHandler = RequestHandler;
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/api/api-stream.js
var require_api_stream = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/api/api-stream.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { finished, PassThrough } = require("stream");
    var {
      InvalidArgumentError,
      InvalidReturnValueError,
      RequestAbortedError
    } = require_errors();
    var util4 = require_util();
    var { getResolveErrorBodyCallback } = require_util3();
    var { AsyncResource } = require("async_hooks");
    var { addSignal, removeSignal } = require_abort_signal();
    var StreamHandler = class extends AsyncResource {
      constructor(opts, factory, callback) {
        if (!opts || typeof opts !== "object") {
          throw new InvalidArgumentError("invalid opts");
        }
        const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError } = opts;
        try {
          if (typeof callback !== "function") {
            throw new InvalidArgumentError("invalid callback");
          }
          if (typeof factory !== "function") {
            throw new InvalidArgumentError("invalid factory");
          }
          if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
            throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
          }
          if (method === "CONNECT") {
            throw new InvalidArgumentError("invalid method");
          }
          if (onInfo && typeof onInfo !== "function") {
            throw new InvalidArgumentError("invalid onInfo callback");
          }
          super("UNDICI_STREAM");
        } catch (err) {
          if (util4.isStream(body)) {
            util4.destroy(body.on("error", util4.nop), err);
          }
          throw err;
        }
        this.responseHeaders = responseHeaders || null;
        this.opaque = opaque || null;
        this.factory = factory;
        this.callback = callback;
        this.res = null;
        this.abort = null;
        this.context = null;
        this.trailers = null;
        this.body = body;
        this.onInfo = onInfo || null;
        this.throwOnError = throwOnError || false;
        if (util4.isStream(body)) {
          body.on("error", (err) => {
            this.onError(err);
          });
        }
        addSignal(this, signal);
      }
      onConnect(abort, context2) {
        if (!this.callback) {
          throw new RequestAbortedError();
        }
        this.abort = abort;
        this.context = context2;
      }
      onHeaders(statusCode, rawHeaders, resume, statusMessage) {
        const { factory, opaque, context: context2, callback, responseHeaders } = this;
        const headers = responseHeaders === "raw" ? util4.parseRawHeaders(rawHeaders) : util4.parseHeaders(rawHeaders);
        if (statusCode < 200) {
          if (this.onInfo) {
            this.onInfo({ statusCode, headers });
          }
          return;
        }
        this.factory = null;
        let res;
        if (this.throwOnError && statusCode >= 400) {
          const parsedHeaders = responseHeaders === "raw" ? util4.parseHeaders(rawHeaders) : headers;
          const contentType = parsedHeaders["content-type"];
          res = new PassThrough();
          this.callback = null;
          this.runInAsyncScope(
            getResolveErrorBodyCallback,
            null,
            { callback, body: res, contentType, statusCode, statusMessage, headers }
          );
        } else {
          if (factory === null) {
            return;
          }
          res = this.runInAsyncScope(factory, null, {
            statusCode,
            headers,
            opaque,
            context: context2
          });
          if (!res || typeof res.write !== "function" || typeof res.end !== "function" || typeof res.on !== "function") {
            throw new InvalidReturnValueError("expected Writable");
          }
          finished(res, { readable: false }, (err) => {
            const { callback: callback2, res: res2, opaque: opaque2, trailers, abort } = this;
            this.res = null;
            if (err || !res2.readable) {
              util4.destroy(res2, err);
            }
            this.callback = null;
            this.runInAsyncScope(callback2, null, err || null, { opaque: opaque2, trailers });
            if (err) {
              abort();
            }
          });
        }
        res.on("drain", resume);
        this.res = res;
        const needDrain = res.writableNeedDrain !== void 0 ? res.writableNeedDrain : res._writableState && res._writableState.needDrain;
        return needDrain !== true;
      }
      onData(chunk) {
        const { res } = this;
        return res ? res.write(chunk) : true;
      }
      onComplete(trailers) {
        const { res } = this;
        removeSignal(this);
        if (!res) {
          return;
        }
        this.trailers = util4.parseHeaders(trailers);
        res.end();
      }
      onError(err) {
        const { res, callback, opaque, body } = this;
        removeSignal(this);
        this.factory = null;
        if (res) {
          this.res = null;
          util4.destroy(res, err);
        } else if (callback) {
          this.callback = null;
          queueMicrotask(() => {
            this.runInAsyncScope(callback, null, err, { opaque });
          });
        }
        if (body) {
          this.body = null;
          util4.destroy(body, err);
        }
      }
    };
    __name(StreamHandler, "StreamHandler");
    function stream2(opts, factory, callback) {
      if (callback === void 0) {
        return new Promise((resolve19, reject) => {
          stream2.call(this, opts, factory, (err, data) => {
            return err ? reject(err) : resolve19(data);
          });
        });
      }
      try {
        this.dispatch(opts, new StreamHandler(opts, factory, callback));
      } catch (err) {
        if (typeof callback !== "function") {
          throw err;
        }
        const opaque = opts && opts.opaque;
        queueMicrotask(() => callback(err, { opaque }));
      }
    }
    __name(stream2, "stream");
    module3.exports = stream2;
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/api/api-pipeline.js
var require_api_pipeline = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/api/api-pipeline.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var {
      Readable: Readable2,
      Duplex,
      PassThrough
    } = require("stream");
    var {
      InvalidArgumentError,
      InvalidReturnValueError,
      RequestAbortedError
    } = require_errors();
    var util4 = require_util();
    var { AsyncResource } = require("async_hooks");
    var { addSignal, removeSignal } = require_abort_signal();
    var assert27 = require("assert");
    var kResume = Symbol("resume");
    var PipelineRequest = class extends Readable2 {
      constructor() {
        super({ autoDestroy: true });
        this[kResume] = null;
      }
      _read() {
        const { [kResume]: resume } = this;
        if (resume) {
          this[kResume] = null;
          resume();
        }
      }
      _destroy(err, callback) {
        this._read();
        callback(err);
      }
    };
    __name(PipelineRequest, "PipelineRequest");
    var PipelineResponse = class extends Readable2 {
      constructor(resume) {
        super({ autoDestroy: true });
        this[kResume] = resume;
      }
      _read() {
        this[kResume]();
      }
      _destroy(err, callback) {
        if (!err && !this._readableState.endEmitted) {
          err = new RequestAbortedError();
        }
        callback(err);
      }
    };
    __name(PipelineResponse, "PipelineResponse");
    var PipelineHandler = class extends AsyncResource {
      constructor(opts, handler30) {
        if (!opts || typeof opts !== "object") {
          throw new InvalidArgumentError("invalid opts");
        }
        if (typeof handler30 !== "function") {
          throw new InvalidArgumentError("invalid handler");
        }
        const { signal, method, opaque, onInfo, responseHeaders } = opts;
        if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
          throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
        }
        if (method === "CONNECT") {
          throw new InvalidArgumentError("invalid method");
        }
        if (onInfo && typeof onInfo !== "function") {
          throw new InvalidArgumentError("invalid onInfo callback");
        }
        super("UNDICI_PIPELINE");
        this.opaque = opaque || null;
        this.responseHeaders = responseHeaders || null;
        this.handler = handler30;
        this.abort = null;
        this.context = null;
        this.onInfo = onInfo || null;
        this.req = new PipelineRequest().on("error", util4.nop);
        this.ret = new Duplex({
          readableObjectMode: opts.objectMode,
          autoDestroy: true,
          read: () => {
            const { body } = this;
            if (body && body.resume) {
              body.resume();
            }
          },
          write: (chunk, encoding, callback) => {
            const { req } = this;
            if (req.push(chunk, encoding) || req._readableState.destroyed) {
              callback();
            } else {
              req[kResume] = callback;
            }
          },
          destroy: (err, callback) => {
            const { body, req, res, ret, abort } = this;
            if (!err && !ret._readableState.endEmitted) {
              err = new RequestAbortedError();
            }
            if (abort && err) {
              abort();
            }
            util4.destroy(body, err);
            util4.destroy(req, err);
            util4.destroy(res, err);
            removeSignal(this);
            callback(err);
          }
        }).on("prefinish", () => {
          const { req } = this;
          req.push(null);
        });
        this.res = null;
        addSignal(this, signal);
      }
      onConnect(abort, context2) {
        const { ret, res } = this;
        assert27(!res, "pipeline cannot be retried");
        if (ret.destroyed) {
          throw new RequestAbortedError();
        }
        this.abort = abort;
        this.context = context2;
      }
      onHeaders(statusCode, rawHeaders, resume) {
        const { opaque, handler: handler30, context: context2 } = this;
        if (statusCode < 200) {
          if (this.onInfo) {
            const headers = this.responseHeaders === "raw" ? util4.parseRawHeaders(rawHeaders) : util4.parseHeaders(rawHeaders);
            this.onInfo({ statusCode, headers });
          }
          return;
        }
        this.res = new PipelineResponse(resume);
        let body;
        try {
          this.handler = null;
          const headers = this.responseHeaders === "raw" ? util4.parseRawHeaders(rawHeaders) : util4.parseHeaders(rawHeaders);
          body = this.runInAsyncScope(handler30, null, {
            statusCode,
            headers,
            opaque,
            body: this.res,
            context: context2
          });
        } catch (err) {
          this.res.on("error", util4.nop);
          throw err;
        }
        if (!body || typeof body.on !== "function") {
          throw new InvalidReturnValueError("expected Readable");
        }
        body.on("data", (chunk) => {
          const { ret, body: body2 } = this;
          if (!ret.push(chunk) && body2.pause) {
            body2.pause();
          }
        }).on("error", (err) => {
          const { ret } = this;
          util4.destroy(ret, err);
        }).on("end", () => {
          const { ret } = this;
          ret.push(null);
        }).on("close", () => {
          const { ret } = this;
          if (!ret._readableState.ended) {
            util4.destroy(ret, new RequestAbortedError());
          }
        });
        this.body = body;
      }
      onData(chunk) {
        const { res } = this;
        return res.push(chunk);
      }
      onComplete(trailers) {
        const { res } = this;
        res.push(null);
      }
      onError(err) {
        const { ret } = this;
        this.handler = null;
        util4.destroy(ret, err);
      }
    };
    __name(PipelineHandler, "PipelineHandler");
    function pipeline(opts, handler30) {
      try {
        const pipelineHandler = new PipelineHandler(opts, handler30);
        this.dispatch({ ...opts, body: pipelineHandler.req }, pipelineHandler);
        return pipelineHandler.ret;
      } catch (err) {
        return new PassThrough().destroy(err);
      }
    }
    __name(pipeline, "pipeline");
    module3.exports = pipeline;
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/api/api-upgrade.js
var require_api_upgrade = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/api/api-upgrade.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { InvalidArgumentError, RequestAbortedError, SocketError } = require_errors();
    var { AsyncResource } = require("async_hooks");
    var util4 = require_util();
    var { addSignal, removeSignal } = require_abort_signal();
    var assert27 = require("assert");
    var UpgradeHandler = class extends AsyncResource {
      constructor(opts, callback) {
        if (!opts || typeof opts !== "object") {
          throw new InvalidArgumentError("invalid opts");
        }
        if (typeof callback !== "function") {
          throw new InvalidArgumentError("invalid callback");
        }
        const { signal, opaque, responseHeaders } = opts;
        if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
          throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
        }
        super("UNDICI_UPGRADE");
        this.responseHeaders = responseHeaders || null;
        this.opaque = opaque || null;
        this.callback = callback;
        this.abort = null;
        this.context = null;
        addSignal(this, signal);
      }
      onConnect(abort, context2) {
        if (!this.callback) {
          throw new RequestAbortedError();
        }
        this.abort = abort;
        this.context = null;
      }
      onHeaders() {
        throw new SocketError("bad upgrade", null);
      }
      onUpgrade(statusCode, rawHeaders, socket) {
        const { callback, opaque, context: context2 } = this;
        assert27.strictEqual(statusCode, 101);
        removeSignal(this);
        this.callback = null;
        const headers = this.responseHeaders === "raw" ? util4.parseRawHeaders(rawHeaders) : util4.parseHeaders(rawHeaders);
        this.runInAsyncScope(callback, null, null, {
          headers,
          socket,
          opaque,
          context: context2
        });
      }
      onError(err) {
        const { callback, opaque } = this;
        removeSignal(this);
        if (callback) {
          this.callback = null;
          queueMicrotask(() => {
            this.runInAsyncScope(callback, null, err, { opaque });
          });
        }
      }
    };
    __name(UpgradeHandler, "UpgradeHandler");
    function upgrade(opts, callback) {
      if (callback === void 0) {
        return new Promise((resolve19, reject) => {
          upgrade.call(this, opts, (err, data) => {
            return err ? reject(err) : resolve19(data);
          });
        });
      }
      try {
        const upgradeHandler = new UpgradeHandler(opts, callback);
        this.dispatch({
          ...opts,
          method: opts.method || "GET",
          upgrade: opts.protocol || "Websocket"
        }, upgradeHandler);
      } catch (err) {
        if (typeof callback !== "function") {
          throw err;
        }
        const opaque = opts && opts.opaque;
        queueMicrotask(() => callback(err, { opaque }));
      }
    }
    __name(upgrade, "upgrade");
    module3.exports = upgrade;
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/api/api-connect.js
var require_api_connect = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/api/api-connect.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { AsyncResource } = require("async_hooks");
    var { InvalidArgumentError, RequestAbortedError, SocketError } = require_errors();
    var util4 = require_util();
    var { addSignal, removeSignal } = require_abort_signal();
    var ConnectHandler = class extends AsyncResource {
      constructor(opts, callback) {
        if (!opts || typeof opts !== "object") {
          throw new InvalidArgumentError("invalid opts");
        }
        if (typeof callback !== "function") {
          throw new InvalidArgumentError("invalid callback");
        }
        const { signal, opaque, responseHeaders } = opts;
        if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
          throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
        }
        super("UNDICI_CONNECT");
        this.opaque = opaque || null;
        this.responseHeaders = responseHeaders || null;
        this.callback = callback;
        this.abort = null;
        addSignal(this, signal);
      }
      onConnect(abort, context2) {
        if (!this.callback) {
          throw new RequestAbortedError();
        }
        this.abort = abort;
        this.context = context2;
      }
      onHeaders() {
        throw new SocketError("bad connect", null);
      }
      onUpgrade(statusCode, rawHeaders, socket) {
        const { callback, opaque, context: context2 } = this;
        removeSignal(this);
        this.callback = null;
        let headers = rawHeaders;
        if (headers != null) {
          headers = this.responseHeaders === "raw" ? util4.parseRawHeaders(rawHeaders) : util4.parseHeaders(rawHeaders);
        }
        this.runInAsyncScope(callback, null, null, {
          statusCode,
          headers,
          socket,
          opaque,
          context: context2
        });
      }
      onError(err) {
        const { callback, opaque } = this;
        removeSignal(this);
        if (callback) {
          this.callback = null;
          queueMicrotask(() => {
            this.runInAsyncScope(callback, null, err, { opaque });
          });
        }
      }
    };
    __name(ConnectHandler, "ConnectHandler");
    function connect2(opts, callback) {
      if (callback === void 0) {
        return new Promise((resolve19, reject) => {
          connect2.call(this, opts, (err, data) => {
            return err ? reject(err) : resolve19(data);
          });
        });
      }
      try {
        const connectHandler = new ConnectHandler(opts, callback);
        this.dispatch({ ...opts, method: "CONNECT" }, connectHandler);
      } catch (err) {
        if (typeof callback !== "function") {
          throw err;
        }
        const opaque = opts && opts.opaque;
        queueMicrotask(() => callback(err, { opaque }));
      }
    }
    __name(connect2, "connect");
    module3.exports = connect2;
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/api/index.js
var require_api = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/api/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports.request = require_api_request();
    module3.exports.stream = require_api_stream();
    module3.exports.pipeline = require_api_pipeline();
    module3.exports.upgrade = require_api_upgrade();
    module3.exports.connect = require_api_connect();
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/mock/mock-errors.js
var require_mock_errors = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/mock/mock-errors.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { UndiciError } = require_errors();
    var MockNotMatchedError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, MockNotMatchedError);
        this.name = "MockNotMatchedError";
        this.message = message || "The request does not match any registered mock dispatches";
        this.code = "UND_MOCK_ERR_MOCK_NOT_MATCHED";
      }
    };
    __name(MockNotMatchedError, "MockNotMatchedError");
    module3.exports = {
      MockNotMatchedError
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/mock/mock-symbols.js
var require_mock_symbols = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/mock/mock-symbols.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = {
      kAgent: Symbol("agent"),
      kOptions: Symbol("options"),
      kFactory: Symbol("factory"),
      kDispatches: Symbol("dispatches"),
      kDispatchKey: Symbol("dispatch key"),
      kDefaultHeaders: Symbol("default headers"),
      kDefaultTrailers: Symbol("default trailers"),
      kContentLength: Symbol("content length"),
      kMockAgent: Symbol("mock agent"),
      kMockAgentSet: Symbol("mock agent set"),
      kMockAgentGet: Symbol("mock agent get"),
      kMockDispatch: Symbol("mock dispatch"),
      kClose: Symbol("close"),
      kOriginalClose: Symbol("original agent close"),
      kOrigin: Symbol("origin"),
      kIsMockActive: Symbol("is mock active"),
      kNetConnect: Symbol("net connect"),
      kGetNetConnect: Symbol("get net connect"),
      kConnected: Symbol("connected")
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/mock/mock-utils.js
var require_mock_utils = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/mock/mock-utils.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { MockNotMatchedError } = require_mock_errors();
    var {
      kDispatches,
      kMockAgent,
      kOriginalDispatch,
      kOrigin,
      kGetNetConnect
    } = require_mock_symbols();
    var { buildURL, nop } = require_util();
    var { STATUS_CODES } = require("http");
    var {
      types: {
        isPromise: isPromise2
      }
    } = require("util");
    function matchValue(match, value) {
      if (typeof match === "string") {
        return match === value;
      }
      if (match instanceof RegExp) {
        return match.test(value);
      }
      if (typeof match === "function") {
        return match(value) === true;
      }
      return false;
    }
    __name(matchValue, "matchValue");
    function lowerCaseEntries(headers) {
      return Object.fromEntries(
        Object.entries(headers).map(([headerName, headerValue]) => {
          return [headerName.toLocaleLowerCase(), headerValue];
        })
      );
    }
    __name(lowerCaseEntries, "lowerCaseEntries");
    function getHeaderByName(headers, key) {
      if (Array.isArray(headers)) {
        for (let i = 0; i < headers.length; i += 2) {
          if (headers[i].toLocaleLowerCase() === key.toLocaleLowerCase()) {
            return headers[i + 1];
          }
        }
        return void 0;
      } else if (typeof headers.get === "function") {
        return headers.get(key);
      } else {
        return lowerCaseEntries(headers)[key.toLocaleLowerCase()];
      }
    }
    __name(getHeaderByName, "getHeaderByName");
    function buildHeadersFromArray(headers) {
      const clone = headers.slice();
      const entries = [];
      for (let index = 0; index < clone.length; index += 2) {
        entries.push([clone[index], clone[index + 1]]);
      }
      return Object.fromEntries(entries);
    }
    __name(buildHeadersFromArray, "buildHeadersFromArray");
    function matchHeaders(mockDispatch2, headers) {
      if (typeof mockDispatch2.headers === "function") {
        if (Array.isArray(headers)) {
          headers = buildHeadersFromArray(headers);
        }
        return mockDispatch2.headers(headers ? lowerCaseEntries(headers) : {});
      }
      if (typeof mockDispatch2.headers === "undefined") {
        return true;
      }
      if (typeof headers !== "object" || typeof mockDispatch2.headers !== "object") {
        return false;
      }
      for (const [matchHeaderName, matchHeaderValue] of Object.entries(mockDispatch2.headers)) {
        const headerValue = getHeaderByName(headers, matchHeaderName);
        if (!matchValue(matchHeaderValue, headerValue)) {
          return false;
        }
      }
      return true;
    }
    __name(matchHeaders, "matchHeaders");
    function safeUrl(path67) {
      if (typeof path67 !== "string") {
        return path67;
      }
      const pathSegments = path67.split("?");
      if (pathSegments.length !== 2) {
        return path67;
      }
      const qp = new URLSearchParams(pathSegments.pop());
      qp.sort();
      return [...pathSegments, qp.toString()].join("?");
    }
    __name(safeUrl, "safeUrl");
    function matchKey(mockDispatch2, { path: path67, method, body, headers }) {
      const pathMatch = matchValue(mockDispatch2.path, path67);
      const methodMatch = matchValue(mockDispatch2.method, method);
      const bodyMatch = typeof mockDispatch2.body !== "undefined" ? matchValue(mockDispatch2.body, body) : true;
      const headersMatch = matchHeaders(mockDispatch2, headers);
      return pathMatch && methodMatch && bodyMatch && headersMatch;
    }
    __name(matchKey, "matchKey");
    function getResponseData(data) {
      if (Buffer.isBuffer(data)) {
        return data;
      } else if (typeof data === "object") {
        return JSON.stringify(data);
      } else {
        return data.toString();
      }
    }
    __name(getResponseData, "getResponseData");
    function getMockDispatch(mockDispatches, key) {
      const basePath = key.query ? buildURL(key.path, key.query) : key.path;
      const resolvedPath = typeof basePath === "string" ? safeUrl(basePath) : basePath;
      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path67 }) => matchValue(safeUrl(path67), resolvedPath));
      if (matchedMockDispatches.length === 0) {
        throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`);
      }
      matchedMockDispatches = matchedMockDispatches.filter(({ method }) => matchValue(method, key.method));
      if (matchedMockDispatches.length === 0) {
        throw new MockNotMatchedError(`Mock dispatch not matched for method '${key.method}'`);
      }
      matchedMockDispatches = matchedMockDispatches.filter(({ body }) => typeof body !== "undefined" ? matchValue(body, key.body) : true);
      if (matchedMockDispatches.length === 0) {
        throw new MockNotMatchedError(`Mock dispatch not matched for body '${key.body}'`);
      }
      matchedMockDispatches = matchedMockDispatches.filter((mockDispatch2) => matchHeaders(mockDispatch2, key.headers));
      if (matchedMockDispatches.length === 0) {
        throw new MockNotMatchedError(`Mock dispatch not matched for headers '${typeof key.headers === "object" ? JSON.stringify(key.headers) : key.headers}'`);
      }
      return matchedMockDispatches[0];
    }
    __name(getMockDispatch, "getMockDispatch");
    function addMockDispatch(mockDispatches, key, data) {
      const baseData = { timesInvoked: 0, times: 1, persist: false, consumed: false };
      const replyData = typeof data === "function" ? { callback: data } : { ...data };
      const newMockDispatch = { ...baseData, ...key, pending: true, data: { error: null, ...replyData } };
      mockDispatches.push(newMockDispatch);
      return newMockDispatch;
    }
    __name(addMockDispatch, "addMockDispatch");
    function deleteMockDispatch(mockDispatches, key) {
      const index = mockDispatches.findIndex((dispatch) => {
        if (!dispatch.consumed) {
          return false;
        }
        return matchKey(dispatch, key);
      });
      if (index !== -1) {
        mockDispatches.splice(index, 1);
      }
    }
    __name(deleteMockDispatch, "deleteMockDispatch");
    function buildKey(opts) {
      const { path: path67, method, body, headers, query } = opts;
      return {
        path: path67,
        method,
        body,
        headers,
        query
      };
    }
    __name(buildKey, "buildKey");
    function generateKeyValues(data) {
      return Object.entries(data).reduce((keyValuePairs, [key, value]) => [
        ...keyValuePairs,
        Buffer.from(`${key}`),
        Array.isArray(value) ? value.map((x2) => Buffer.from(`${x2}`)) : Buffer.from(`${value}`)
      ], []);
    }
    __name(generateKeyValues, "generateKeyValues");
    function getStatusText(statusCode) {
      return STATUS_CODES[statusCode] || "unknown";
    }
    __name(getStatusText, "getStatusText");
    async function getResponse(body) {
      const buffers = [];
      for await (const data of body) {
        buffers.push(data);
      }
      return Buffer.concat(buffers).toString("utf8");
    }
    __name(getResponse, "getResponse");
    function mockDispatch(opts, handler30) {
      const key = buildKey(opts);
      const mockDispatch2 = getMockDispatch(this[kDispatches], key);
      mockDispatch2.timesInvoked++;
      if (mockDispatch2.data.callback) {
        mockDispatch2.data = { ...mockDispatch2.data, ...mockDispatch2.data.callback(opts) };
      }
      const { data: { statusCode, data, headers, trailers, error: error2 }, delay, persist } = mockDispatch2;
      const { timesInvoked, times } = mockDispatch2;
      mockDispatch2.consumed = !persist && timesInvoked >= times;
      mockDispatch2.pending = timesInvoked < times;
      if (error2 !== null) {
        deleteMockDispatch(this[kDispatches], key);
        handler30.onError(error2);
        return true;
      }
      if (typeof delay === "number" && delay > 0) {
        setTimeout(() => {
          handleReply(this[kDispatches]);
        }, delay);
      } else {
        handleReply(this[kDispatches]);
      }
      function handleReply(mockDispatches, _data = data) {
        const optsHeaders = Array.isArray(opts.headers) ? buildHeadersFromArray(opts.headers) : opts.headers;
        const body = typeof _data === "function" ? _data({ ...opts, headers: optsHeaders }) : _data;
        if (isPromise2(body)) {
          body.then((newData) => handleReply(mockDispatches, newData));
          return;
        }
        const responseData = getResponseData(body);
        const responseHeaders = generateKeyValues(headers);
        const responseTrailers = generateKeyValues(trailers);
        handler30.abort = nop;
        handler30.onHeaders(statusCode, responseHeaders, resume, getStatusText(statusCode));
        handler30.onData(Buffer.from(responseData));
        handler30.onComplete(responseTrailers);
        deleteMockDispatch(mockDispatches, key);
      }
      __name(handleReply, "handleReply");
      function resume() {
      }
      __name(resume, "resume");
      return true;
    }
    __name(mockDispatch, "mockDispatch");
    function buildMockDispatch() {
      const agent = this[kMockAgent];
      const origin = this[kOrigin];
      const originalDispatch = this[kOriginalDispatch];
      return /* @__PURE__ */ __name(function dispatch(opts, handler30) {
        if (agent.isMockActive) {
          try {
            mockDispatch.call(this, opts, handler30);
          } catch (error2) {
            if (error2 instanceof MockNotMatchedError) {
              const netConnect = agent[kGetNetConnect]();
              if (netConnect === false) {
                throw new MockNotMatchedError(`${error2.message}: subsequent request to origin ${origin} was not allowed (net.connect disabled)`);
              }
              if (checkNetConnect(netConnect, origin)) {
                originalDispatch.call(this, opts, handler30);
              } else {
                throw new MockNotMatchedError(`${error2.message}: subsequent request to origin ${origin} was not allowed (net.connect is not enabled for this origin)`);
              }
            } else {
              throw error2;
            }
          }
        } else {
          originalDispatch.call(this, opts, handler30);
        }
      }, "dispatch");
    }
    __name(buildMockDispatch, "buildMockDispatch");
    function checkNetConnect(netConnect, origin) {
      const url4 = new URL(origin);
      if (netConnect === true) {
        return true;
      } else if (Array.isArray(netConnect) && netConnect.some((matcher) => matchValue(matcher, url4.host))) {
        return true;
      }
      return false;
    }
    __name(checkNetConnect, "checkNetConnect");
    function buildMockOptions(opts) {
      if (opts) {
        const { agent, ...mockOptions } = opts;
        return mockOptions;
      }
    }
    __name(buildMockOptions, "buildMockOptions");
    module3.exports = {
      getResponseData,
      getMockDispatch,
      addMockDispatch,
      deleteMockDispatch,
      buildKey,
      generateKeyValues,
      matchValue,
      getResponse,
      getStatusText,
      mockDispatch,
      buildMockDispatch,
      checkNetConnect,
      buildMockOptions,
      getHeaderByName
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/mock/mock-interceptor.js
var require_mock_interceptor = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/mock/mock-interceptor.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { getResponseData, buildKey, addMockDispatch } = require_mock_utils();
    var {
      kDispatches,
      kDispatchKey,
      kDefaultHeaders,
      kDefaultTrailers,
      kContentLength,
      kMockDispatch
    } = require_mock_symbols();
    var { InvalidArgumentError } = require_errors();
    var { buildURL } = require_util();
    var MockScope = class {
      constructor(mockDispatch) {
        this[kMockDispatch] = mockDispatch;
      }
      /**
       * Delay a reply by a set amount in ms.
       */
      delay(waitInMs) {
        if (typeof waitInMs !== "number" || !Number.isInteger(waitInMs) || waitInMs <= 0) {
          throw new InvalidArgumentError("waitInMs must be a valid integer > 0");
        }
        this[kMockDispatch].delay = waitInMs;
        return this;
      }
      /**
       * For a defined reply, never mark as consumed.
       */
      persist() {
        this[kMockDispatch].persist = true;
        return this;
      }
      /**
       * Allow one to define a reply for a set amount of matching requests.
       */
      times(repeatTimes) {
        if (typeof repeatTimes !== "number" || !Number.isInteger(repeatTimes) || repeatTimes <= 0) {
          throw new InvalidArgumentError("repeatTimes must be a valid integer > 0");
        }
        this[kMockDispatch].times = repeatTimes;
        return this;
      }
    };
    __name(MockScope, "MockScope");
    var MockInterceptor = class {
      constructor(opts, mockDispatches) {
        if (typeof opts !== "object") {
          throw new InvalidArgumentError("opts must be an object");
        }
        if (typeof opts.path === "undefined") {
          throw new InvalidArgumentError("opts.path must be defined");
        }
        if (typeof opts.method === "undefined") {
          opts.method = "GET";
        }
        if (typeof opts.path === "string") {
          if (opts.query) {
            opts.path = buildURL(opts.path, opts.query);
          } else {
            const parsedURL = new URL(opts.path, "data://");
            opts.path = parsedURL.pathname + parsedURL.search;
          }
        }
        if (typeof opts.method === "string") {
          opts.method = opts.method.toUpperCase();
        }
        this[kDispatchKey] = buildKey(opts);
        this[kDispatches] = mockDispatches;
        this[kDefaultHeaders] = {};
        this[kDefaultTrailers] = {};
        this[kContentLength] = false;
      }
      createMockScopeDispatchData(statusCode, data, responseOptions = {}) {
        const responseData = getResponseData(data);
        const contentLength = this[kContentLength] ? { "content-length": responseData.length } : {};
        const headers = { ...this[kDefaultHeaders], ...contentLength, ...responseOptions.headers };
        const trailers = { ...this[kDefaultTrailers], ...responseOptions.trailers };
        return { statusCode, data, headers, trailers };
      }
      validateReplyParameters(statusCode, data, responseOptions) {
        if (typeof statusCode === "undefined") {
          throw new InvalidArgumentError("statusCode must be defined");
        }
        if (typeof data === "undefined") {
          throw new InvalidArgumentError("data must be defined");
        }
        if (typeof responseOptions !== "object") {
          throw new InvalidArgumentError("responseOptions must be an object");
        }
      }
      /**
       * Mock an undici request with a defined reply.
       */
      reply(replyData) {
        if (typeof replyData === "function") {
          const wrappedDefaultsCallback = /* @__PURE__ */ __name((opts) => {
            const resolvedData = replyData(opts);
            if (typeof resolvedData !== "object") {
              throw new InvalidArgumentError("reply options callback must return an object");
            }
            const { statusCode: statusCode2, data: data2 = "", responseOptions: responseOptions2 = {} } = resolvedData;
            this.validateReplyParameters(statusCode2, data2, responseOptions2);
            return {
              ...this.createMockScopeDispatchData(statusCode2, data2, responseOptions2)
            };
          }, "wrappedDefaultsCallback");
          const newMockDispatch2 = addMockDispatch(this[kDispatches], this[kDispatchKey], wrappedDefaultsCallback);
          return new MockScope(newMockDispatch2);
        }
        const [statusCode, data = "", responseOptions = {}] = [...arguments];
        this.validateReplyParameters(statusCode, data, responseOptions);
        const dispatchData = this.createMockScopeDispatchData(statusCode, data, responseOptions);
        const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], dispatchData);
        return new MockScope(newMockDispatch);
      }
      /**
       * Mock an undici request with a defined error.
       */
      replyWithError(error2) {
        if (typeof error2 === "undefined") {
          throw new InvalidArgumentError("error must be defined");
        }
        const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], { error: error2 });
        return new MockScope(newMockDispatch);
      }
      /**
       * Set default reply headers on the interceptor for subsequent replies
       */
      defaultReplyHeaders(headers) {
        if (typeof headers === "undefined") {
          throw new InvalidArgumentError("headers must be defined");
        }
        this[kDefaultHeaders] = headers;
        return this;
      }
      /**
       * Set default reply trailers on the interceptor for subsequent replies
       */
      defaultReplyTrailers(trailers) {
        if (typeof trailers === "undefined") {
          throw new InvalidArgumentError("trailers must be defined");
        }
        this[kDefaultTrailers] = trailers;
        return this;
      }
      /**
       * Set reply content length header for replies on the interceptor
       */
      replyContentLength() {
        this[kContentLength] = true;
        return this;
      }
    };
    __name(MockInterceptor, "MockInterceptor");
    module3.exports.MockInterceptor = MockInterceptor;
    module3.exports.MockScope = MockScope;
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/mock/mock-client.js
var require_mock_client = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/mock/mock-client.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { promisify: promisify2 } = require("util");
    var Client = require_client();
    var { buildMockDispatch } = require_mock_utils();
    var {
      kDispatches,
      kMockAgent,
      kClose,
      kOriginalClose,
      kOrigin,
      kOriginalDispatch,
      kConnected
    } = require_mock_symbols();
    var { MockInterceptor } = require_mock_interceptor();
    var Symbols = require_symbols();
    var { InvalidArgumentError } = require_errors();
    var MockClient = class extends Client {
      constructor(origin, opts) {
        super(origin, opts);
        if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") {
          throw new InvalidArgumentError("Argument opts.agent must implement Agent");
        }
        this[kMockAgent] = opts.agent;
        this[kOrigin] = origin;
        this[kDispatches] = [];
        this[kConnected] = 1;
        this[kOriginalDispatch] = this.dispatch;
        this[kOriginalClose] = this.close.bind(this);
        this.dispatch = buildMockDispatch.call(this);
        this.close = this[kClose];
      }
      get [Symbols.kConnected]() {
        return this[kConnected];
      }
      /**
       * Sets up the base interceptor for mocking replies from undici.
       */
      intercept(opts) {
        return new MockInterceptor(opts, this[kDispatches]);
      }
      async [kClose]() {
        await promisify2(this[kOriginalClose])();
        this[kConnected] = 0;
        this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
      }
    };
    __name(MockClient, "MockClient");
    module3.exports = MockClient;
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/mock/mock-pool.js
var require_mock_pool = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/mock/mock-pool.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { promisify: promisify2 } = require("util");
    var Pool = require_pool();
    var { buildMockDispatch } = require_mock_utils();
    var {
      kDispatches,
      kMockAgent,
      kClose,
      kOriginalClose,
      kOrigin,
      kOriginalDispatch,
      kConnected
    } = require_mock_symbols();
    var { MockInterceptor } = require_mock_interceptor();
    var Symbols = require_symbols();
    var { InvalidArgumentError } = require_errors();
    var MockPool = class extends Pool {
      constructor(origin, opts) {
        super(origin, opts);
        if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") {
          throw new InvalidArgumentError("Argument opts.agent must implement Agent");
        }
        this[kMockAgent] = opts.agent;
        this[kOrigin] = origin;
        this[kDispatches] = [];
        this[kConnected] = 1;
        this[kOriginalDispatch] = this.dispatch;
        this[kOriginalClose] = this.close.bind(this);
        this.dispatch = buildMockDispatch.call(this);
        this.close = this[kClose];
      }
      get [Symbols.kConnected]() {
        return this[kConnected];
      }
      /**
       * Sets up the base interceptor for mocking replies from undici.
       */
      intercept(opts) {
        return new MockInterceptor(opts, this[kDispatches]);
      }
      async [kClose]() {
        await promisify2(this[kOriginalClose])();
        this[kConnected] = 0;
        this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
      }
    };
    __name(MockPool, "MockPool");
    module3.exports = MockPool;
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/mock/pluralizer.js
var require_pluralizer = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/mock/pluralizer.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var singulars = {
      pronoun: "it",
      is: "is",
      was: "was",
      this: "this"
    };
    var plurals = {
      pronoun: "they",
      is: "are",
      was: "were",
      this: "these"
    };
    module3.exports = /* @__PURE__ */ __name(class Pluralizer {
      constructor(singular, plural2) {
        this.singular = singular;
        this.plural = plural2;
      }
      pluralize(count) {
        const one = count === 1;
        const keys = one ? singulars : plurals;
        const noun = one ? this.singular : this.plural;
        return { ...keys, count, noun };
      }
    }, "Pluralizer");
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/mock/pending-interceptors-formatter.js
var require_pending_interceptors_formatter = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/mock/pending-interceptors-formatter.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { Transform } = require("stream");
    var { Console: Console2 } = require("console");
    module3.exports = /* @__PURE__ */ __name(class PendingInterceptorsFormatter {
      constructor({ disableColors } = {}) {
        this.transform = new Transform({
          transform(chunk, _enc, cb) {
            cb(null, chunk);
          }
        });
        this.logger = new Console2({
          stdout: this.transform,
          inspectOptions: {
            colors: !disableColors && !process.env.CI
          }
        });
      }
      format(pendingInterceptors) {
        const withPrettyHeaders = pendingInterceptors.map(
          ({ method, path: path67, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
            Method: method,
            Origin: origin,
            Path: path67,
            "Status code": statusCode,
            Persistent: persist ? "\u2705" : "\u274C",
            Invocations: timesInvoked,
            Remaining: persist ? Infinity : times - timesInvoked
          })
        );
        this.logger.table(withPrettyHeaders);
        return this.transform.read().toString();
      }
    }, "PendingInterceptorsFormatter");
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/mock/mock-agent.js
var require_mock_agent = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/mock/mock-agent.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { kClients } = require_symbols();
    var Agent = require_agent();
    var {
      kAgent,
      kMockAgentSet,
      kMockAgentGet,
      kDispatches,
      kIsMockActive,
      kNetConnect,
      kGetNetConnect,
      kOptions,
      kFactory
    } = require_mock_symbols();
    var MockClient = require_mock_client();
    var MockPool = require_mock_pool();
    var { matchValue, buildMockOptions } = require_mock_utils();
    var { InvalidArgumentError, UndiciError } = require_errors();
    var Dispatcher2 = require_dispatcher();
    var Pluralizer = require_pluralizer();
    var PendingInterceptorsFormatter = require_pending_interceptors_formatter();
    var FakeWeakRef = class {
      constructor(value) {
        this.value = value;
      }
      deref() {
        return this.value;
      }
    };
    __name(FakeWeakRef, "FakeWeakRef");
    var MockAgent = class extends Dispatcher2 {
      constructor(opts) {
        super(opts);
        this[kNetConnect] = true;
        this[kIsMockActive] = true;
        if (opts && opts.agent && typeof opts.agent.dispatch !== "function") {
          throw new InvalidArgumentError("Argument opts.agent must implement Agent");
        }
        const agent = opts && opts.agent ? opts.agent : new Agent(opts);
        this[kAgent] = agent;
        this[kClients] = agent[kClients];
        this[kOptions] = buildMockOptions(opts);
      }
      get(origin) {
        let dispatcher = this[kMockAgentGet](origin);
        if (!dispatcher) {
          dispatcher = this[kFactory](origin);
          this[kMockAgentSet](origin, dispatcher);
        }
        return dispatcher;
      }
      dispatch(opts, handler30) {
        this.get(opts.origin);
        return this[kAgent].dispatch(opts, handler30);
      }
      async close() {
        await this[kAgent].close();
        this[kClients].clear();
      }
      deactivate() {
        this[kIsMockActive] = false;
      }
      activate() {
        this[kIsMockActive] = true;
      }
      enableNetConnect(matcher) {
        if (typeof matcher === "string" || typeof matcher === "function" || matcher instanceof RegExp) {
          if (Array.isArray(this[kNetConnect])) {
            this[kNetConnect].push(matcher);
          } else {
            this[kNetConnect] = [matcher];
          }
        } else if (typeof matcher === "undefined") {
          this[kNetConnect] = true;
        } else {
          throw new InvalidArgumentError("Unsupported matcher. Must be one of String|Function|RegExp.");
        }
      }
      disableNetConnect() {
        this[kNetConnect] = false;
      }
      // This is required to bypass issues caused by using global symbols - see:
      // https://github.com/nodejs/undici/issues/1447
      get isMockActive() {
        return this[kIsMockActive];
      }
      [kMockAgentSet](origin, dispatcher) {
        this[kClients].set(origin, new FakeWeakRef(dispatcher));
      }
      [kFactory](origin) {
        const mockOptions = Object.assign({ agent: this }, this[kOptions]);
        return this[kOptions] && this[kOptions].connections === 1 ? new MockClient(origin, mockOptions) : new MockPool(origin, mockOptions);
      }
      [kMockAgentGet](origin) {
        const ref = this[kClients].get(origin);
        if (ref) {
          return ref.deref();
        }
        if (typeof origin !== "string") {
          const dispatcher = this[kFactory]("http://localhost:9999");
          this[kMockAgentSet](origin, dispatcher);
          return dispatcher;
        }
        for (const [keyMatcher, nonExplicitRef] of Array.from(this[kClients])) {
          const nonExplicitDispatcher = nonExplicitRef.deref();
          if (nonExplicitDispatcher && typeof keyMatcher !== "string" && matchValue(keyMatcher, origin)) {
            const dispatcher = this[kFactory](origin);
            this[kMockAgentSet](origin, dispatcher);
            dispatcher[kDispatches] = nonExplicitDispatcher[kDispatches];
            return dispatcher;
          }
        }
      }
      [kGetNetConnect]() {
        return this[kNetConnect];
      }
      pendingInterceptors() {
        const mockAgentClients = this[kClients];
        return Array.from(mockAgentClients.entries()).flatMap(([origin, scope]) => scope.deref()[kDispatches].map((dispatch) => ({ ...dispatch, origin }))).filter(({ pending }) => pending);
      }
      assertNoPendingInterceptors({ pendingInterceptorsFormatter = new PendingInterceptorsFormatter() } = {}) {
        const pending = this.pendingInterceptors();
        if (pending.length === 0) {
          return;
        }
        const pluralizer = new Pluralizer("interceptor", "interceptors").pluralize(pending.length);
        throw new UndiciError(`
${pluralizer.count} ${pluralizer.noun} ${pluralizer.is} pending:

${pendingInterceptorsFormatter.format(pending)}
`.trim());
      }
    };
    __name(MockAgent, "MockAgent");
    module3.exports = MockAgent;
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/proxy-agent.js
var require_proxy_agent = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/proxy-agent.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { kProxy, kClose, kDestroy, kInterceptors } = require_symbols();
    var { URL: URL7 } = require("url");
    var Agent = require_agent();
    var Pool = require_pool();
    var DispatcherBase = require_dispatcher_base();
    var { InvalidArgumentError, RequestAbortedError } = require_errors();
    var buildConnector = require_connect();
    var kAgent = Symbol("proxy agent");
    var kClient = Symbol("proxy client");
    var kProxyHeaders = Symbol("proxy headers");
    var kRequestTls = Symbol("request tls settings");
    var kProxyTls = Symbol("proxy tls settings");
    var kConnectEndpoint = Symbol("connect endpoint function");
    function defaultProtocolPort(protocol) {
      return protocol === "https:" ? 443 : 80;
    }
    __name(defaultProtocolPort, "defaultProtocolPort");
    function buildProxyOptions(opts) {
      if (typeof opts === "string") {
        opts = { uri: opts };
      }
      if (!opts || !opts.uri) {
        throw new InvalidArgumentError("Proxy opts.uri is mandatory");
      }
      return {
        uri: opts.uri,
        protocol: opts.protocol || "https"
      };
    }
    __name(buildProxyOptions, "buildProxyOptions");
    function defaultFactory(origin, opts) {
      return new Pool(origin, opts);
    }
    __name(defaultFactory, "defaultFactory");
    var ProxyAgent2 = class extends DispatcherBase {
      constructor(opts) {
        super(opts);
        this[kProxy] = buildProxyOptions(opts);
        this[kAgent] = new Agent(opts);
        this[kInterceptors] = opts.interceptors && opts.interceptors.ProxyAgent && Array.isArray(opts.interceptors.ProxyAgent) ? opts.interceptors.ProxyAgent : [];
        if (typeof opts === "string") {
          opts = { uri: opts };
        }
        if (!opts || !opts.uri) {
          throw new InvalidArgumentError("Proxy opts.uri is mandatory");
        }
        const { clientFactory = defaultFactory } = opts;
        if (typeof clientFactory !== "function") {
          throw new InvalidArgumentError("Proxy opts.clientFactory must be a function.");
        }
        this[kRequestTls] = opts.requestTls;
        this[kProxyTls] = opts.proxyTls;
        this[kProxyHeaders] = opts.headers || {};
        const resolvedUrl = new URL7(opts.uri);
        const { origin, port: port2, host, username, password } = resolvedUrl;
        if (opts.auth && opts.token) {
          throw new InvalidArgumentError("opts.auth cannot be used in combination with opts.token");
        } else if (opts.auth) {
          this[kProxyHeaders]["proxy-authorization"] = `Basic ${opts.auth}`;
        } else if (opts.token) {
          this[kProxyHeaders]["proxy-authorization"] = opts.token;
        } else if (username && password) {
          this[kProxyHeaders]["proxy-authorization"] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString("base64")}`;
        }
        const connect2 = buildConnector({ ...opts.proxyTls });
        this[kConnectEndpoint] = buildConnector({ ...opts.requestTls });
        this[kClient] = clientFactory(resolvedUrl, { connect: connect2 });
        this[kAgent] = new Agent({
          ...opts,
          connect: async (opts2, callback) => {
            let requestedHost = opts2.host;
            if (!opts2.port) {
              requestedHost += `:${defaultProtocolPort(opts2.protocol)}`;
            }
            try {
              const { socket, statusCode } = await this[kClient].connect({
                origin,
                port: port2,
                path: requestedHost,
                signal: opts2.signal,
                headers: {
                  ...this[kProxyHeaders],
                  host
                }
              });
              if (statusCode !== 200) {
                socket.on("error", () => {
                }).destroy();
                callback(new RequestAbortedError(`Proxy response (${statusCode}) !== 200 when HTTP Tunneling`));
              }
              if (opts2.protocol !== "https:") {
                callback(null, socket);
                return;
              }
              let servername;
              if (this[kRequestTls]) {
                servername = this[kRequestTls].servername;
              } else {
                servername = opts2.servername;
              }
              this[kConnectEndpoint]({ ...opts2, servername, httpSocket: socket }, callback);
            } catch (err) {
              callback(err);
            }
          }
        });
      }
      dispatch(opts, handler30) {
        const { host } = new URL7(opts.origin);
        const headers = buildHeaders(opts.headers);
        throwIfProxyAuthIsSent(headers);
        return this[kAgent].dispatch(
          {
            ...opts,
            headers: {
              ...headers,
              host
            }
          },
          handler30
        );
      }
      async [kClose]() {
        await this[kAgent].close();
        await this[kClient].close();
      }
      async [kDestroy]() {
        await this[kAgent].destroy();
        await this[kClient].destroy();
      }
    };
    __name(ProxyAgent2, "ProxyAgent");
    function buildHeaders(headers) {
      if (Array.isArray(headers)) {
        const headersPair = {};
        for (let i = 0; i < headers.length; i += 2) {
          headersPair[headers[i]] = headers[i + 1];
        }
        return headersPair;
      }
      return headers;
    }
    __name(buildHeaders, "buildHeaders");
    function throwIfProxyAuthIsSent(headers) {
      const existProxyAuth = headers && Object.keys(headers).find((key) => key.toLowerCase() === "proxy-authorization");
      if (existProxyAuth) {
        throw new InvalidArgumentError("Proxy-Authorization should be sent in ProxyAgent constructor");
      }
    }
    __name(throwIfProxyAuthIsSent, "throwIfProxyAuthIsSent");
    module3.exports = ProxyAgent2;
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/handler/RetryHandler.js
var require_RetryHandler = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/handler/RetryHandler.js"(exports2, module3) {
    init_import_meta_url();
    var assert27 = require("assert");
    var { kRetryHandlerDefaultRetry } = require_symbols();
    var { RequestRetryError } = require_errors();
    var { isDisturbed, parseHeaders: parseHeaders2, parseRangeHeader } = require_util();
    function calculateRetryAfterHeader(retryAfter) {
      const current = Date.now();
      const diff = new Date(retryAfter).getTime() - current;
      return diff;
    }
    __name(calculateRetryAfterHeader, "calculateRetryAfterHeader");
    var RetryHandler = class {
      constructor(opts, handlers2) {
        const { retryOptions, ...dispatchOpts } = opts;
        const {
          // Retry scoped
          retry: retryFn,
          maxRetries,
          maxTimeout,
          minTimeout,
          timeoutFactor,
          // Response scoped
          methods,
          errorCodes,
          retryAfter,
          statusCodes
        } = retryOptions ?? {};
        this.dispatch = handlers2.dispatch;
        this.handler = handlers2.handler;
        this.opts = dispatchOpts;
        this.abort = null;
        this.aborted = false;
        this.retryOpts = {
          retry: retryFn ?? RetryHandler[kRetryHandlerDefaultRetry],
          retryAfter: retryAfter ?? true,
          maxTimeout: maxTimeout ?? 30 * 1e3,
          // 30s,
          timeout: minTimeout ?? 500,
          // .5s
          timeoutFactor: timeoutFactor ?? 2,
          maxRetries: maxRetries ?? 5,
          // What errors we should retry
          methods: methods ?? ["GET", "HEAD", "OPTIONS", "PUT", "DELETE", "TRACE"],
          // Indicates which errors to retry
          statusCodes: statusCodes ?? [500, 502, 503, 504, 429],
          // List of errors to retry
          errorCodes: errorCodes ?? [
            "ECONNRESET",
            "ECONNREFUSED",
            "ENOTFOUND",
            "ENETDOWN",
            "ENETUNREACH",
            "EHOSTDOWN",
            "EHOSTUNREACH",
            "EPIPE"
          ]
        };
        this.retryCount = 0;
        this.start = 0;
        this.end = null;
        this.etag = null;
        this.resume = null;
        this.handler.onConnect((reason) => {
          this.aborted = true;
          if (this.abort) {
            this.abort(reason);
          } else {
            this.reason = reason;
          }
        });
      }
      onRequestSent() {
        if (this.handler.onRequestSent) {
          this.handler.onRequestSent();
        }
      }
      onUpgrade(statusCode, headers, socket) {
        if (this.handler.onUpgrade) {
          this.handler.onUpgrade(statusCode, headers, socket);
        }
      }
      onConnect(abort) {
        if (this.aborted) {
          abort(this.reason);
        } else {
          this.abort = abort;
        }
      }
      onBodySent(chunk) {
        if (this.handler.onBodySent)
          return this.handler.onBodySent(chunk);
      }
      static [kRetryHandlerDefaultRetry](err, { state, opts }, cb) {
        const { statusCode, code, headers } = err;
        const { method, retryOptions } = opts;
        const {
          maxRetries,
          timeout,
          maxTimeout,
          timeoutFactor,
          statusCodes,
          errorCodes,
          methods
        } = retryOptions;
        let { counter, currentTimeout } = state;
        currentTimeout = currentTimeout != null && currentTimeout > 0 ? currentTimeout : timeout;
        if (code && code !== "UND_ERR_REQ_RETRY" && code !== "UND_ERR_SOCKET" && !errorCodes.includes(code)) {
          cb(err);
          return;
        }
        if (Array.isArray(methods) && !methods.includes(method)) {
          cb(err);
          return;
        }
        if (statusCode != null && Array.isArray(statusCodes) && !statusCodes.includes(statusCode)) {
          cb(err);
          return;
        }
        if (counter > maxRetries) {
          cb(err);
          return;
        }
        let retryAfterHeader = headers != null && headers["retry-after"];
        if (retryAfterHeader) {
          retryAfterHeader = Number(retryAfterHeader);
          retryAfterHeader = isNaN(retryAfterHeader) ? calculateRetryAfterHeader(retryAfterHeader) : retryAfterHeader * 1e3;
        }
        const retryTimeout = retryAfterHeader > 0 ? Math.min(retryAfterHeader, maxTimeout) : Math.min(currentTimeout * timeoutFactor ** counter, maxTimeout);
        state.currentTimeout = retryTimeout;
        setTimeout(() => cb(null), retryTimeout);
      }
      onHeaders(statusCode, rawHeaders, resume, statusMessage) {
        const headers = parseHeaders2(rawHeaders);
        this.retryCount += 1;
        if (statusCode >= 300) {
          this.abort(
            new RequestRetryError("Request failed", statusCode, {
              headers,
              count: this.retryCount
            })
          );
          return false;
        }
        if (this.resume != null) {
          this.resume = null;
          if (statusCode !== 206) {
            return true;
          }
          const contentRange = parseRangeHeader(headers["content-range"]);
          if (!contentRange) {
            this.abort(
              new RequestRetryError("Content-Range mismatch", statusCode, {
                headers,
                count: this.retryCount
              })
            );
            return false;
          }
          if (this.etag != null && this.etag !== headers.etag) {
            this.abort(
              new RequestRetryError("ETag mismatch", statusCode, {
                headers,
                count: this.retryCount
              })
            );
            return false;
          }
          const { start, size, end = size } = contentRange;
          assert27(this.start === start, "content-range mismatch");
          assert27(this.end == null || this.end === end, "content-range mismatch");
          this.resume = resume;
          return true;
        }
        if (this.end == null) {
          if (statusCode === 206) {
            const range = parseRangeHeader(headers["content-range"]);
            if (range == null) {
              return this.handler.onHeaders(
                statusCode,
                rawHeaders,
                resume,
                statusMessage
              );
            }
            const { start, size, end = size } = range;
            assert27(
              start != null && Number.isFinite(start) && this.start !== start,
              "content-range mismatch"
            );
            assert27(Number.isFinite(start));
            assert27(
              end != null && Number.isFinite(end) && this.end !== end,
              "invalid content-length"
            );
            this.start = start;
            this.end = end;
          }
          if (this.end == null) {
            const contentLength = headers["content-length"];
            this.end = contentLength != null ? Number(contentLength) : null;
          }
          assert27(Number.isFinite(this.start));
          assert27(
            this.end == null || Number.isFinite(this.end),
            "invalid content-length"
          );
          this.resume = resume;
          this.etag = headers.etag != null ? headers.etag : null;
          return this.handler.onHeaders(
            statusCode,
            rawHeaders,
            resume,
            statusMessage
          );
        }
        const err = new RequestRetryError("Request failed", statusCode, {
          headers,
          count: this.retryCount
        });
        this.abort(err);
        return false;
      }
      onData(chunk) {
        this.start += chunk.length;
        return this.handler.onData(chunk);
      }
      onComplete(rawTrailers) {
        this.retryCount = 0;
        return this.handler.onComplete(rawTrailers);
      }
      onError(err) {
        if (this.aborted || isDisturbed(this.opts.body)) {
          return this.handler.onError(err);
        }
        this.retryOpts.retry(
          err,
          {
            state: { counter: this.retryCount++, currentTimeout: this.retryAfter },
            opts: { retryOptions: this.retryOpts, ...this.opts }
          },
          onRetry.bind(this)
        );
        function onRetry(err2) {
          if (err2 != null || this.aborted || isDisturbed(this.opts.body)) {
            return this.handler.onError(err2);
          }
          if (this.start !== 0) {
            this.opts = {
              ...this.opts,
              headers: {
                ...this.opts.headers,
                range: `bytes=${this.start}-${this.end ?? ""}`
              }
            };
          }
          try {
            this.dispatch(this.opts, this);
          } catch (err3) {
            this.handler.onError(err3);
          }
        }
        __name(onRetry, "onRetry");
      }
    };
    __name(RetryHandler, "RetryHandler");
    module3.exports = RetryHandler;
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/global.js
var require_global2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/global.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var globalDispatcher = Symbol.for("undici.globalDispatcher.1");
    var { InvalidArgumentError } = require_errors();
    var Agent = require_agent();
    if (getGlobalDispatcher2() === void 0) {
      setGlobalDispatcher2(new Agent());
    }
    function setGlobalDispatcher2(agent) {
      if (!agent || typeof agent.dispatch !== "function") {
        throw new InvalidArgumentError("Argument agent must implement Agent");
      }
      Object.defineProperty(globalThis, globalDispatcher, {
        value: agent,
        writable: true,
        enumerable: false,
        configurable: false
      });
    }
    __name(setGlobalDispatcher2, "setGlobalDispatcher");
    function getGlobalDispatcher2() {
      return globalThis[globalDispatcher];
    }
    __name(getGlobalDispatcher2, "getGlobalDispatcher");
    module3.exports = {
      setGlobalDispatcher: setGlobalDispatcher2,
      getGlobalDispatcher: getGlobalDispatcher2
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/handler/DecoratorHandler.js
var require_DecoratorHandler = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/handler/DecoratorHandler.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(class DecoratorHandler {
      constructor(handler30) {
        this.handler = handler30;
      }
      onConnect(...args) {
        return this.handler.onConnect(...args);
      }
      onError(...args) {
        return this.handler.onError(...args);
      }
      onUpgrade(...args) {
        return this.handler.onUpgrade(...args);
      }
      onHeaders(...args) {
        return this.handler.onHeaders(...args);
      }
      onData(...args) {
        return this.handler.onData(...args);
      }
      onComplete(...args) {
        return this.handler.onComplete(...args);
      }
      onBodySent(...args) {
        return this.handler.onBodySent(...args);
      }
    }, "DecoratorHandler");
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/headers.js
var require_headers = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/headers.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { kHeadersList, kConstruct } = require_symbols();
    var { kGuard } = require_symbols2();
    var { kEnumerableProperty } = require_util();
    var {
      makeIterator,
      isValidHeaderName,
      isValidHeaderValue
    } = require_util2();
    var { webidl } = require_webidl();
    var assert27 = require("assert");
    var kHeadersMap = Symbol("headers map");
    var kHeadersSortedMap = Symbol("headers map sorted");
    function isHTTPWhiteSpaceCharCode(code) {
      return code === 10 || code === 13 || code === 9 || code === 32;
    }
    __name(isHTTPWhiteSpaceCharCode, "isHTTPWhiteSpaceCharCode");
    function headerValueNormalize(potentialValue) {
      let i = 0;
      let j2 = potentialValue.length;
      while (j2 > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(j2 - 1)))
        --j2;
      while (j2 > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(i)))
        ++i;
      return i === 0 && j2 === potentialValue.length ? potentialValue : potentialValue.substring(i, j2);
    }
    __name(headerValueNormalize, "headerValueNormalize");
    function fill2(headers, object) {
      if (Array.isArray(object)) {
        for (let i = 0; i < object.length; ++i) {
          const header = object[i];
          if (header.length !== 2) {
            throw webidl.errors.exception({
              header: "Headers constructor",
              message: `expected name/value pair to be length 2, found ${header.length}.`
            });
          }
          appendHeader(headers, header[0], header[1]);
        }
      } else if (typeof object === "object" && object !== null) {
        const keys = Object.keys(object);
        for (let i = 0; i < keys.length; ++i) {
          appendHeader(headers, keys[i], object[keys[i]]);
        }
      } else {
        throw webidl.errors.conversionFailed({
          prefix: "Headers constructor",
          argument: "Argument 1",
          types: ["sequence<sequence<ByteString>>", "record<ByteString, ByteString>"]
        });
      }
    }
    __name(fill2, "fill");
    function appendHeader(headers, name, value) {
      value = headerValueNormalize(value);
      if (!isValidHeaderName(name)) {
        throw webidl.errors.invalidArgument({
          prefix: "Headers.append",
          value: name,
          type: "header name"
        });
      } else if (!isValidHeaderValue(value)) {
        throw webidl.errors.invalidArgument({
          prefix: "Headers.append",
          value,
          type: "header value"
        });
      }
      if (headers[kGuard] === "immutable") {
        throw new TypeError("immutable");
      } else if (headers[kGuard] === "request-no-cors") {
      }
      return headers[kHeadersList].append(name, value);
    }
    __name(appendHeader, "appendHeader");
    var HeadersList = class {
      /** @type {[string, string][]|null} */
      cookies = null;
      constructor(init3) {
        if (init3 instanceof HeadersList) {
          this[kHeadersMap] = new Map(init3[kHeadersMap]);
          this[kHeadersSortedMap] = init3[kHeadersSortedMap];
          this.cookies = init3.cookies === null ? null : [...init3.cookies];
        } else {
          this[kHeadersMap] = new Map(init3);
          this[kHeadersSortedMap] = null;
        }
      }
      // https://fetch.spec.whatwg.org/#header-list-contains
      contains(name) {
        name = name.toLowerCase();
        return this[kHeadersMap].has(name);
      }
      clear() {
        this[kHeadersMap].clear();
        this[kHeadersSortedMap] = null;
        this.cookies = null;
      }
      // https://fetch.spec.whatwg.org/#concept-header-list-append
      append(name, value) {
        this[kHeadersSortedMap] = null;
        const lowercaseName = name.toLowerCase();
        const exists = this[kHeadersMap].get(lowercaseName);
        if (exists) {
          const delimiter = lowercaseName === "cookie" ? "; " : ", ";
          this[kHeadersMap].set(lowercaseName, {
            name: exists.name,
            value: `${exists.value}${delimiter}${value}`
          });
        } else {
          this[kHeadersMap].set(lowercaseName, { name, value });
        }
        if (lowercaseName === "set-cookie") {
          this.cookies ??= [];
          this.cookies.push(value);
        }
      }
      // https://fetch.spec.whatwg.org/#concept-header-list-set
      set(name, value) {
        this[kHeadersSortedMap] = null;
        const lowercaseName = name.toLowerCase();
        if (lowercaseName === "set-cookie") {
          this.cookies = [value];
        }
        this[kHeadersMap].set(lowercaseName, { name, value });
      }
      // https://fetch.spec.whatwg.org/#concept-header-list-delete
      delete(name) {
        this[kHeadersSortedMap] = null;
        name = name.toLowerCase();
        if (name === "set-cookie") {
          this.cookies = null;
        }
        this[kHeadersMap].delete(name);
      }
      // https://fetch.spec.whatwg.org/#concept-header-list-get
      get(name) {
        const value = this[kHeadersMap].get(name.toLowerCase());
        return value === void 0 ? null : value.value;
      }
      *[Symbol.iterator]() {
        for (const [name, { value }] of this[kHeadersMap]) {
          yield [name, value];
        }
      }
      get entries() {
        const headers = {};
        if (this[kHeadersMap].size) {
          for (const { name, value } of this[kHeadersMap].values()) {
            headers[name] = value;
          }
        }
        return headers;
      }
    };
    __name(HeadersList, "HeadersList");
    var Headers5 = class {
      constructor(init3 = void 0) {
        if (init3 === kConstruct) {
          return;
        }
        this[kHeadersList] = new HeadersList();
        this[kGuard] = "none";
        if (init3 !== void 0) {
          init3 = webidl.converters.HeadersInit(init3);
          fill2(this, init3);
        }
      }
      // https://fetch.spec.whatwg.org/#dom-headers-append
      append(name, value) {
        webidl.brandCheck(this, Headers5);
        webidl.argumentLengthCheck(arguments, 2, { header: "Headers.append" });
        name = webidl.converters.ByteString(name);
        value = webidl.converters.ByteString(value);
        return appendHeader(this, name, value);
      }
      // https://fetch.spec.whatwg.org/#dom-headers-delete
      delete(name) {
        webidl.brandCheck(this, Headers5);
        webidl.argumentLengthCheck(arguments, 1, { header: "Headers.delete" });
        name = webidl.converters.ByteString(name);
        if (!isValidHeaderName(name)) {
          throw webidl.errors.invalidArgument({
            prefix: "Headers.delete",
            value: name,
            type: "header name"
          });
        }
        if (this[kGuard] === "immutable") {
          throw new TypeError("immutable");
        } else if (this[kGuard] === "request-no-cors") {
        }
        if (!this[kHeadersList].contains(name)) {
          return;
        }
        this[kHeadersList].delete(name);
      }
      // https://fetch.spec.whatwg.org/#dom-headers-get
      get(name) {
        webidl.brandCheck(this, Headers5);
        webidl.argumentLengthCheck(arguments, 1, { header: "Headers.get" });
        name = webidl.converters.ByteString(name);
        if (!isValidHeaderName(name)) {
          throw webidl.errors.invalidArgument({
            prefix: "Headers.get",
            value: name,
            type: "header name"
          });
        }
        return this[kHeadersList].get(name);
      }
      // https://fetch.spec.whatwg.org/#dom-headers-has
      has(name) {
        webidl.brandCheck(this, Headers5);
        webidl.argumentLengthCheck(arguments, 1, { header: "Headers.has" });
        name = webidl.converters.ByteString(name);
        if (!isValidHeaderName(name)) {
          throw webidl.errors.invalidArgument({
            prefix: "Headers.has",
            value: name,
            type: "header name"
          });
        }
        return this[kHeadersList].contains(name);
      }
      // https://fetch.spec.whatwg.org/#dom-headers-set
      set(name, value) {
        webidl.brandCheck(this, Headers5);
        webidl.argumentLengthCheck(arguments, 2, { header: "Headers.set" });
        name = webidl.converters.ByteString(name);
        value = webidl.converters.ByteString(value);
        value = headerValueNormalize(value);
        if (!isValidHeaderName(name)) {
          throw webidl.errors.invalidArgument({
            prefix: "Headers.set",
            value: name,
            type: "header name"
          });
        } else if (!isValidHeaderValue(value)) {
          throw webidl.errors.invalidArgument({
            prefix: "Headers.set",
            value,
            type: "header value"
          });
        }
        if (this[kGuard] === "immutable") {
          throw new TypeError("immutable");
        } else if (this[kGuard] === "request-no-cors") {
        }
        this[kHeadersList].set(name, value);
      }
      // https://fetch.spec.whatwg.org/#dom-headers-getsetcookie
      getSetCookie() {
        webidl.brandCheck(this, Headers5);
        const list = this[kHeadersList].cookies;
        if (list) {
          return [...list];
        }
        return [];
      }
      // https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine
      get [kHeadersSortedMap]() {
        if (this[kHeadersList][kHeadersSortedMap]) {
          return this[kHeadersList][kHeadersSortedMap];
        }
        const headers = [];
        const names = [...this[kHeadersList]].sort((a, b2) => a[0] < b2[0] ? -1 : 1);
        const cookies = this[kHeadersList].cookies;
        for (let i = 0; i < names.length; ++i) {
          const [name, value] = names[i];
          if (name === "set-cookie") {
            for (let j2 = 0; j2 < cookies.length; ++j2) {
              headers.push([name, cookies[j2]]);
            }
          } else {
            assert27(value !== null);
            headers.push([name, value]);
          }
        }
        this[kHeadersList][kHeadersSortedMap] = headers;
        return headers;
      }
      keys() {
        webidl.brandCheck(this, Headers5);
        if (this[kGuard] === "immutable") {
          const value = this[kHeadersSortedMap];
          return makeIterator(
            () => value,
            "Headers",
            "key"
          );
        }
        return makeIterator(
          () => [...this[kHeadersSortedMap].values()],
          "Headers",
          "key"
        );
      }
      values() {
        webidl.brandCheck(this, Headers5);
        if (this[kGuard] === "immutable") {
          const value = this[kHeadersSortedMap];
          return makeIterator(
            () => value,
            "Headers",
            "value"
          );
        }
        return makeIterator(
          () => [...this[kHeadersSortedMap].values()],
          "Headers",
          "value"
        );
      }
      entries() {
        webidl.brandCheck(this, Headers5);
        if (this[kGuard] === "immutable") {
          const value = this[kHeadersSortedMap];
          return makeIterator(
            () => value,
            "Headers",
            "key+value"
          );
        }
        return makeIterator(
          () => [...this[kHeadersSortedMap].values()],
          "Headers",
          "key+value"
        );
      }
      /**
       * @param {(value: string, key: string, self: Headers) => void} callbackFn
       * @param {unknown} thisArg
       */
      forEach(callbackFn, thisArg = globalThis) {
        webidl.brandCheck(this, Headers5);
        webidl.argumentLengthCheck(arguments, 1, { header: "Headers.forEach" });
        if (typeof callbackFn !== "function") {
          throw new TypeError(
            "Failed to execute 'forEach' on 'Headers': parameter 1 is not of type 'Function'."
          );
        }
        for (const [key, value] of this) {
          callbackFn.apply(thisArg, [value, key, this]);
        }
      }
      [Symbol.for("nodejs.util.inspect.custom")]() {
        webidl.brandCheck(this, Headers5);
        return this[kHeadersList];
      }
    };
    __name(Headers5, "Headers");
    Headers5.prototype[Symbol.iterator] = Headers5.prototype.entries;
    Object.defineProperties(Headers5.prototype, {
      append: kEnumerableProperty,
      delete: kEnumerableProperty,
      get: kEnumerableProperty,
      has: kEnumerableProperty,
      set: kEnumerableProperty,
      getSetCookie: kEnumerableProperty,
      keys: kEnumerableProperty,
      values: kEnumerableProperty,
      entries: kEnumerableProperty,
      forEach: kEnumerableProperty,
      [Symbol.iterator]: { enumerable: false },
      [Symbol.toStringTag]: {
        value: "Headers",
        configurable: true
      }
    });
    webidl.converters.HeadersInit = function(V2) {
      if (webidl.util.Type(V2) === "Object") {
        if (V2[Symbol.iterator]) {
          return webidl.converters["sequence<sequence<ByteString>>"](V2);
        }
        return webidl.converters["record<ByteString, ByteString>"](V2);
      }
      throw webidl.errors.conversionFailed({
        prefix: "Headers constructor",
        argument: "Argument 1",
        types: ["sequence<sequence<ByteString>>", "record<ByteString, ByteString>"]
      });
    };
    module3.exports = {
      fill: fill2,
      Headers: Headers5,
      HeadersList
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/response.js
var require_response = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/response.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { Headers: Headers5, HeadersList, fill: fill2 } = require_headers();
    var { extractBody, cloneBody, mixinBody } = require_body();
    var util4 = require_util();
    var { kEnumerableProperty } = util4;
    var {
      isValidReasonPhrase,
      isCancelled,
      isAborted,
      isBlobLike,
      serializeJavascriptValueToJSONString,
      isErrorLike,
      isomorphicEncode
    } = require_util2();
    var {
      redirectStatusSet,
      nullBodyStatus,
      DOMException: DOMException2
    } = require_constants();
    var { kState, kHeaders, kGuard, kRealm } = require_symbols2();
    var { webidl } = require_webidl();
    var { FormData: FormData10 } = require_formdata();
    var { getGlobalOrigin } = require_global();
    var { URLSerializer } = require_dataURL();
    var { kHeadersList, kConstruct } = require_symbols();
    var assert27 = require("assert");
    var { types } = require("util");
    var ReadableStream2 = globalThis.ReadableStream || require("stream/web").ReadableStream;
    var textEncoder = new TextEncoder("utf-8");
    var Response9 = class {
      // Creates network error Response.
      static error() {
        const relevantRealm = { settingsObject: {} };
        const responseObject = new Response9();
        responseObject[kState] = makeNetworkError();
        responseObject[kRealm] = relevantRealm;
        responseObject[kHeaders][kHeadersList] = responseObject[kState].headersList;
        responseObject[kHeaders][kGuard] = "immutable";
        responseObject[kHeaders][kRealm] = relevantRealm;
        return responseObject;
      }
      // https://fetch.spec.whatwg.org/#dom-response-json
      static json(data, init3 = {}) {
        webidl.argumentLengthCheck(arguments, 1, { header: "Response.json" });
        if (init3 !== null) {
          init3 = webidl.converters.ResponseInit(init3);
        }
        const bytes = textEncoder.encode(
          serializeJavascriptValueToJSONString(data)
        );
        const body = extractBody(bytes);
        const relevantRealm = { settingsObject: {} };
        const responseObject = new Response9();
        responseObject[kRealm] = relevantRealm;
        responseObject[kHeaders][kGuard] = "response";
        responseObject[kHeaders][kRealm] = relevantRealm;
        initializeResponse(responseObject, init3, { body: body[0], type: "application/json" });
        return responseObject;
      }
      // Creates a redirect Response that redirects to url with status status.
      static redirect(url4, status2 = 302) {
        const relevantRealm = { settingsObject: {} };
        webidl.argumentLengthCheck(arguments, 1, { header: "Response.redirect" });
        url4 = webidl.converters.USVString(url4);
        status2 = webidl.converters["unsigned short"](status2);
        let parsedURL;
        try {
          parsedURL = new URL(url4, getGlobalOrigin());
        } catch (err) {
          throw Object.assign(new TypeError("Failed to parse URL from " + url4), {
            cause: err
          });
        }
        if (!redirectStatusSet.has(status2)) {
          throw new RangeError("Invalid status code " + status2);
        }
        const responseObject = new Response9();
        responseObject[kRealm] = relevantRealm;
        responseObject[kHeaders][kGuard] = "immutable";
        responseObject[kHeaders][kRealm] = relevantRealm;
        responseObject[kState].status = status2;
        const value = isomorphicEncode(URLSerializer(parsedURL));
        responseObject[kState].headersList.append("location", value);
        return responseObject;
      }
      // https://fetch.spec.whatwg.org/#dom-response
      constructor(body = null, init3 = {}) {
        if (body !== null) {
          body = webidl.converters.BodyInit(body);
        }
        init3 = webidl.converters.ResponseInit(init3);
        this[kRealm] = { settingsObject: {} };
        this[kState] = makeResponse({});
        this[kHeaders] = new Headers5(kConstruct);
        this[kHeaders][kGuard] = "response";
        this[kHeaders][kHeadersList] = this[kState].headersList;
        this[kHeaders][kRealm] = this[kRealm];
        let bodyWithType = null;
        if (body != null) {
          const [extractedBody, type] = extractBody(body);
          bodyWithType = { body: extractedBody, type };
        }
        initializeResponse(this, init3, bodyWithType);
      }
      // Returns response’s type, e.g., "cors".
      get type() {
        webidl.brandCheck(this, Response9);
        return this[kState].type;
      }
      // Returns response’s URL, if it has one; otherwise the empty string.
      get url() {
        webidl.brandCheck(this, Response9);
        const urlList = this[kState].urlList;
        const url4 = urlList[urlList.length - 1] ?? null;
        if (url4 === null) {
          return "";
        }
        return URLSerializer(url4, true);
      }
      // Returns whether response was obtained through a redirect.
      get redirected() {
        webidl.brandCheck(this, Response9);
        return this[kState].urlList.length > 1;
      }
      // Returns response’s status.
      get status() {
        webidl.brandCheck(this, Response9);
        return this[kState].status;
      }
      // Returns whether response’s status is an ok status.
      get ok() {
        webidl.brandCheck(this, Response9);
        return this[kState].status >= 200 && this[kState].status <= 299;
      }
      // Returns response’s status message.
      get statusText() {
        webidl.brandCheck(this, Response9);
        return this[kState].statusText;
      }
      // Returns response’s headers as Headers.
      get headers() {
        webidl.brandCheck(this, Response9);
        return this[kHeaders];
      }
      get body() {
        webidl.brandCheck(this, Response9);
        return this[kState].body ? this[kState].body.stream : null;
      }
      get bodyUsed() {
        webidl.brandCheck(this, Response9);
        return !!this[kState].body && util4.isDisturbed(this[kState].body.stream);
      }
      // Returns a clone of response.
      clone() {
        webidl.brandCheck(this, Response9);
        if (this.bodyUsed || this.body && this.body.locked) {
          throw webidl.errors.exception({
            header: "Response.clone",
            message: "Body has already been consumed."
          });
        }
        const clonedResponse = cloneResponse(this[kState]);
        const clonedResponseObject = new Response9();
        clonedResponseObject[kState] = clonedResponse;
        clonedResponseObject[kRealm] = this[kRealm];
        clonedResponseObject[kHeaders][kHeadersList] = clonedResponse.headersList;
        clonedResponseObject[kHeaders][kGuard] = this[kHeaders][kGuard];
        clonedResponseObject[kHeaders][kRealm] = this[kHeaders][kRealm];
        return clonedResponseObject;
      }
    };
    __name(Response9, "Response");
    mixinBody(Response9);
    Object.defineProperties(Response9.prototype, {
      type: kEnumerableProperty,
      url: kEnumerableProperty,
      status: kEnumerableProperty,
      ok: kEnumerableProperty,
      redirected: kEnumerableProperty,
      statusText: kEnumerableProperty,
      headers: kEnumerableProperty,
      clone: kEnumerableProperty,
      body: kEnumerableProperty,
      bodyUsed: kEnumerableProperty,
      [Symbol.toStringTag]: {
        value: "Response",
        configurable: true
      }
    });
    Object.defineProperties(Response9, {
      json: kEnumerableProperty,
      redirect: kEnumerableProperty,
      error: kEnumerableProperty
    });
    function cloneResponse(response) {
      if (response.internalResponse) {
        return filterResponse(
          cloneResponse(response.internalResponse),
          response.type
        );
      }
      const newResponse = makeResponse({ ...response, body: null });
      if (response.body != null) {
        newResponse.body = cloneBody(response.body);
      }
      return newResponse;
    }
    __name(cloneResponse, "cloneResponse");
    function makeResponse(init3) {
      return {
        aborted: false,
        rangeRequested: false,
        timingAllowPassed: false,
        requestIncludesCredentials: false,
        type: "default",
        status: 200,
        timingInfo: null,
        cacheState: "",
        statusText: "",
        ...init3,
        headersList: init3.headersList ? new HeadersList(init3.headersList) : new HeadersList(),
        urlList: init3.urlList ? [...init3.urlList] : []
      };
    }
    __name(makeResponse, "makeResponse");
    function makeNetworkError(reason) {
      const isError2 = isErrorLike(reason);
      return makeResponse({
        type: "error",
        status: 0,
        error: isError2 ? reason : new Error(reason ? String(reason) : reason),
        aborted: reason && reason.name === "AbortError"
      });
    }
    __name(makeNetworkError, "makeNetworkError");
    function makeFilteredResponse(response, state) {
      state = {
        internalResponse: response,
        ...state
      };
      return new Proxy(response, {
        get(target, p2) {
          return p2 in state ? state[p2] : target[p2];
        },
        set(target, p2, value) {
          assert27(!(p2 in state));
          target[p2] = value;
          return true;
        }
      });
    }
    __name(makeFilteredResponse, "makeFilteredResponse");
    function filterResponse(response, type) {
      if (type === "basic") {
        return makeFilteredResponse(response, {
          type: "basic",
          headersList: response.headersList
        });
      } else if (type === "cors") {
        return makeFilteredResponse(response, {
          type: "cors",
          headersList: response.headersList
        });
      } else if (type === "opaque") {
        return makeFilteredResponse(response, {
          type: "opaque",
          urlList: Object.freeze([]),
          status: 0,
          statusText: "",
          body: null
        });
      } else if (type === "opaqueredirect") {
        return makeFilteredResponse(response, {
          type: "opaqueredirect",
          status: 0,
          statusText: "",
          headersList: [],
          body: null
        });
      } else {
        assert27(false);
      }
    }
    __name(filterResponse, "filterResponse");
    function makeAppropriateNetworkError(fetchParams, err = null) {
      assert27(isCancelled(fetchParams));
      return isAborted(fetchParams) ? makeNetworkError(Object.assign(new DOMException2("The operation was aborted.", "AbortError"), { cause: err })) : makeNetworkError(Object.assign(new DOMException2("Request was cancelled."), { cause: err }));
    }
    __name(makeAppropriateNetworkError, "makeAppropriateNetworkError");
    function initializeResponse(response, init3, body) {
      if (init3.status !== null && (init3.status < 200 || init3.status > 599)) {
        throw new RangeError('init["status"] must be in the range of 200 to 599, inclusive.');
      }
      if ("statusText" in init3 && init3.statusText != null) {
        if (!isValidReasonPhrase(String(init3.statusText))) {
          throw new TypeError("Invalid statusText");
        }
      }
      if ("status" in init3 && init3.status != null) {
        response[kState].status = init3.status;
      }
      if ("statusText" in init3 && init3.statusText != null) {
        response[kState].statusText = init3.statusText;
      }
      if ("headers" in init3 && init3.headers != null) {
        fill2(response[kHeaders], init3.headers);
      }
      if (body) {
        if (nullBodyStatus.includes(response.status)) {
          throw webidl.errors.exception({
            header: "Response constructor",
            message: "Invalid response status code " + response.status
          });
        }
        response[kState].body = body.body;
        if (body.type != null && !response[kState].headersList.contains("Content-Type")) {
          response[kState].headersList.append("content-type", body.type);
        }
      }
    }
    __name(initializeResponse, "initializeResponse");
    webidl.converters.ReadableStream = webidl.interfaceConverter(
      ReadableStream2
    );
    webidl.converters.FormData = webidl.interfaceConverter(
      FormData10
    );
    webidl.converters.URLSearchParams = webidl.interfaceConverter(
      URLSearchParams
    );
    webidl.converters.XMLHttpRequestBodyInit = function(V2) {
      if (typeof V2 === "string") {
        return webidl.converters.USVString(V2);
      }
      if (isBlobLike(V2)) {
        return webidl.converters.Blob(V2, { strict: false });
      }
      if (types.isArrayBuffer(V2) || types.isTypedArray(V2) || types.isDataView(V2)) {
        return webidl.converters.BufferSource(V2);
      }
      if (util4.isFormDataLike(V2)) {
        return webidl.converters.FormData(V2, { strict: false });
      }
      if (V2 instanceof URLSearchParams) {
        return webidl.converters.URLSearchParams(V2);
      }
      return webidl.converters.DOMString(V2);
    };
    webidl.converters.BodyInit = function(V2) {
      if (V2 instanceof ReadableStream2) {
        return webidl.converters.ReadableStream(V2);
      }
      if (V2?.[Symbol.asyncIterator]) {
        return V2;
      }
      return webidl.converters.XMLHttpRequestBodyInit(V2);
    };
    webidl.converters.ResponseInit = webidl.dictionaryConverter([
      {
        key: "status",
        converter: webidl.converters["unsigned short"],
        defaultValue: 200
      },
      {
        key: "statusText",
        converter: webidl.converters.ByteString,
        defaultValue: ""
      },
      {
        key: "headers",
        converter: webidl.converters.HeadersInit
      }
    ]);
    module3.exports = {
      makeNetworkError,
      makeResponse,
      makeAppropriateNetworkError,
      filterResponse,
      Response: Response9,
      cloneResponse
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/request.js
var require_request2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/request.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { extractBody, mixinBody, cloneBody } = require_body();
    var { Headers: Headers5, fill: fillHeaders, HeadersList } = require_headers();
    var { FinalizationRegistry: FinalizationRegistry2 } = require_dispatcher_weakref()();
    var util4 = require_util();
    var {
      isValidHTTPToken,
      sameOrigin,
      normalizeMethod,
      makePolicyContainer,
      normalizeMethodRecord
    } = require_util2();
    var {
      forbiddenMethodsSet,
      corsSafeListedMethodsSet,
      referrerPolicy,
      requestRedirect,
      requestMode,
      requestCredentials,
      requestCache,
      requestDuplex
    } = require_constants();
    var { kEnumerableProperty } = util4;
    var { kHeaders, kSignal, kState, kGuard, kRealm } = require_symbols2();
    var { webidl } = require_webidl();
    var { getGlobalOrigin } = require_global();
    var { URLSerializer } = require_dataURL();
    var { kHeadersList, kConstruct } = require_symbols();
    var assert27 = require("assert");
    var { getMaxListeners, setMaxListeners, getEventListeners, defaultMaxListeners } = require("events");
    var TransformStream = globalThis.TransformStream;
    var kAbortController = Symbol("abortController");
    var requestFinalizer = new FinalizationRegistry2(({ signal, abort }) => {
      signal.removeEventListener("abort", abort);
    });
    var Request3 = class {
      // https://fetch.spec.whatwg.org/#dom-request
      constructor(input, init3 = {}) {
        if (input === kConstruct) {
          return;
        }
        webidl.argumentLengthCheck(arguments, 1, { header: "Request constructor" });
        input = webidl.converters.RequestInfo(input);
        init3 = webidl.converters.RequestInit(init3);
        this[kRealm] = {
          settingsObject: {
            baseUrl: getGlobalOrigin(),
            get origin() {
              return this.baseUrl?.origin;
            },
            policyContainer: makePolicyContainer()
          }
        };
        let request3 = null;
        let fallbackMode = null;
        const baseUrl = this[kRealm].settingsObject.baseUrl;
        let signal = null;
        if (typeof input === "string") {
          let parsedURL;
          try {
            parsedURL = new URL(input, baseUrl);
          } catch (err) {
            throw new TypeError("Failed to parse URL from " + input, { cause: err });
          }
          if (parsedURL.username || parsedURL.password) {
            throw new TypeError(
              "Request cannot be constructed from a URL that includes credentials: " + input
            );
          }
          request3 = makeRequest({ urlList: [parsedURL] });
          fallbackMode = "cors";
        } else {
          assert27(input instanceof Request3);
          request3 = input[kState];
          signal = input[kSignal];
        }
        const origin = this[kRealm].settingsObject.origin;
        let window2 = "client";
        if (request3.window?.constructor?.name === "EnvironmentSettingsObject" && sameOrigin(request3.window, origin)) {
          window2 = request3.window;
        }
        if (init3.window != null) {
          throw new TypeError(`'window' option '${window2}' must be null`);
        }
        if ("window" in init3) {
          window2 = "no-window";
        }
        request3 = makeRequest({
          // URL request’s URL.
          // undici implementation note: this is set as the first item in request's urlList in makeRequest
          // method request’s method.
          method: request3.method,
          // header list A copy of request’s header list.
          // undici implementation note: headersList is cloned in makeRequest
          headersList: request3.headersList,
          // unsafe-request flag Set.
          unsafeRequest: request3.unsafeRequest,
          // client This’s relevant settings object.
          client: this[kRealm].settingsObject,
          // window window.
          window: window2,
          // priority request’s priority.
          priority: request3.priority,
          // origin request’s origin. The propagation of the origin is only significant for navigation requests
          // being handled by a service worker. In this scenario a request can have an origin that is different
          // from the current client.
          origin: request3.origin,
          // referrer request’s referrer.
          referrer: request3.referrer,
          // referrer policy request’s referrer policy.
          referrerPolicy: request3.referrerPolicy,
          // mode request’s mode.
          mode: request3.mode,
          // credentials mode request’s credentials mode.
          credentials: request3.credentials,
          // cache mode request’s cache mode.
          cache: request3.cache,
          // redirect mode request’s redirect mode.
          redirect: request3.redirect,
          // integrity metadata request’s integrity metadata.
          integrity: request3.integrity,
          // keepalive request’s keepalive.
          keepalive: request3.keepalive,
          // reload-navigation flag request’s reload-navigation flag.
          reloadNavigation: request3.reloadNavigation,
          // history-navigation flag request’s history-navigation flag.
          historyNavigation: request3.historyNavigation,
          // URL list A clone of request’s URL list.
          urlList: [...request3.urlList]
        });
        const initHasKey = Object.keys(init3).length !== 0;
        if (initHasKey) {
          if (request3.mode === "navigate") {
            request3.mode = "same-origin";
          }
          request3.reloadNavigation = false;
          request3.historyNavigation = false;
          request3.origin = "client";
          request3.referrer = "client";
          request3.referrerPolicy = "";
          request3.url = request3.urlList[request3.urlList.length - 1];
          request3.urlList = [request3.url];
        }
        if (init3.referrer !== void 0) {
          const referrer = init3.referrer;
          if (referrer === "") {
            request3.referrer = "no-referrer";
          } else {
            let parsedReferrer;
            try {
              parsedReferrer = new URL(referrer, baseUrl);
            } catch (err) {
              throw new TypeError(`Referrer "${referrer}" is not a valid URL.`, { cause: err });
            }
            if (parsedReferrer.protocol === "about:" && parsedReferrer.hostname === "client" || origin && !sameOrigin(parsedReferrer, this[kRealm].settingsObject.baseUrl)) {
              request3.referrer = "client";
            } else {
              request3.referrer = parsedReferrer;
            }
          }
        }
        if (init3.referrerPolicy !== void 0) {
          request3.referrerPolicy = init3.referrerPolicy;
        }
        let mode;
        if (init3.mode !== void 0) {
          mode = init3.mode;
        } else {
          mode = fallbackMode;
        }
        if (mode === "navigate") {
          throw webidl.errors.exception({
            header: "Request constructor",
            message: "invalid request mode navigate."
          });
        }
        if (mode != null) {
          request3.mode = mode;
        }
        if (init3.credentials !== void 0) {
          request3.credentials = init3.credentials;
        }
        if (init3.cache !== void 0) {
          request3.cache = init3.cache;
        }
        if (request3.cache === "only-if-cached" && request3.mode !== "same-origin") {
          throw new TypeError(
            "'only-if-cached' can be set only with 'same-origin' mode"
          );
        }
        if (init3.redirect !== void 0) {
          request3.redirect = init3.redirect;
        }
        if (init3.integrity != null) {
          request3.integrity = String(init3.integrity);
        }
        if (init3.keepalive !== void 0) {
          request3.keepalive = Boolean(init3.keepalive);
        }
        if (init3.method !== void 0) {
          let method = init3.method;
          if (!isValidHTTPToken(method)) {
            throw new TypeError(`'${method}' is not a valid HTTP method.`);
          }
          if (forbiddenMethodsSet.has(method.toUpperCase())) {
            throw new TypeError(`'${method}' HTTP method is unsupported.`);
          }
          method = normalizeMethodRecord[method] ?? normalizeMethod(method);
          request3.method = method;
        }
        if (init3.signal !== void 0) {
          signal = init3.signal;
        }
        this[kState] = request3;
        const ac = new AbortController();
        this[kSignal] = ac.signal;
        this[kSignal][kRealm] = this[kRealm];
        if (signal != null) {
          if (!signal || typeof signal.aborted !== "boolean" || typeof signal.addEventListener !== "function") {
            throw new TypeError(
              "Failed to construct 'Request': member signal is not of type AbortSignal."
            );
          }
          if (signal.aborted) {
            ac.abort(signal.reason);
          } else {
            this[kAbortController] = ac;
            const acRef = new WeakRef(ac);
            const abort = /* @__PURE__ */ __name(function() {
              const ac2 = acRef.deref();
              if (ac2 !== void 0) {
                ac2.abort(this.reason);
              }
            }, "abort");
            try {
              if (typeof getMaxListeners === "function" && getMaxListeners(signal) === defaultMaxListeners) {
                setMaxListeners(100, signal);
              } else if (getEventListeners(signal, "abort").length >= defaultMaxListeners) {
                setMaxListeners(100, signal);
              }
            } catch {
            }
            util4.addAbortListener(signal, abort);
            requestFinalizer.register(ac, { signal, abort });
          }
        }
        this[kHeaders] = new Headers5(kConstruct);
        this[kHeaders][kHeadersList] = request3.headersList;
        this[kHeaders][kGuard] = "request";
        this[kHeaders][kRealm] = this[kRealm];
        if (mode === "no-cors") {
          if (!corsSafeListedMethodsSet.has(request3.method)) {
            throw new TypeError(
              `'${request3.method} is unsupported in no-cors mode.`
            );
          }
          this[kHeaders][kGuard] = "request-no-cors";
        }
        if (initHasKey) {
          const headersList = this[kHeaders][kHeadersList];
          const headers = init3.headers !== void 0 ? init3.headers : new HeadersList(headersList);
          headersList.clear();
          if (headers instanceof HeadersList) {
            for (const [key, val] of headers) {
              headersList.append(key, val);
            }
            headersList.cookies = headers.cookies;
          } else {
            fillHeaders(this[kHeaders], headers);
          }
        }
        const inputBody = input instanceof Request3 ? input[kState].body : null;
        if ((init3.body != null || inputBody != null) && (request3.method === "GET" || request3.method === "HEAD")) {
          throw new TypeError("Request with GET/HEAD method cannot have body.");
        }
        let initBody = null;
        if (init3.body != null) {
          const [extractedBody, contentType] = extractBody(
            init3.body,
            request3.keepalive
          );
          initBody = extractedBody;
          if (contentType && !this[kHeaders][kHeadersList].contains("content-type")) {
            this[kHeaders].append("content-type", contentType);
          }
        }
        const inputOrInitBody = initBody ?? inputBody;
        if (inputOrInitBody != null && inputOrInitBody.source == null) {
          if (initBody != null && init3.duplex == null) {
            throw new TypeError("RequestInit: duplex option is required when sending a body.");
          }
          if (request3.mode !== "same-origin" && request3.mode !== "cors") {
            throw new TypeError(
              'If request is made from ReadableStream, mode should be "same-origin" or "cors"'
            );
          }
          request3.useCORSPreflightFlag = true;
        }
        let finalBody = inputOrInitBody;
        if (initBody == null && inputBody != null) {
          if (util4.isDisturbed(inputBody.stream) || inputBody.stream.locked) {
            throw new TypeError(
              "Cannot construct a Request with a Request object that has already been used."
            );
          }
          if (!TransformStream) {
            TransformStream = require("stream/web").TransformStream;
          }
          const identityTransform = new TransformStream();
          inputBody.stream.pipeThrough(identityTransform);
          finalBody = {
            source: inputBody.source,
            length: inputBody.length,
            stream: identityTransform.readable
          };
        }
        this[kState].body = finalBody;
      }
      // Returns request’s HTTP method, which is "GET" by default.
      get method() {
        webidl.brandCheck(this, Request3);
        return this[kState].method;
      }
      // Returns the URL of request as a string.
      get url() {
        webidl.brandCheck(this, Request3);
        return URLSerializer(this[kState].url);
      }
      // Returns a Headers object consisting of the headers associated with request.
      // Note that headers added in the network layer by the user agent will not
      // be accounted for in this object, e.g., the "Host" header.
      get headers() {
        webidl.brandCheck(this, Request3);
        return this[kHeaders];
      }
      // Returns the kind of resource requested by request, e.g., "document"
      // or "script".
      get destination() {
        webidl.brandCheck(this, Request3);
        return this[kState].destination;
      }
      // Returns the referrer of request. Its value can be a same-origin URL if
      // explicitly set in init, the empty string to indicate no referrer, and
      // "about:client" when defaulting to the global’s default. This is used
      // during fetching to determine the value of the `Referer` header of the
      // request being made.
      get referrer() {
        webidl.brandCheck(this, Request3);
        if (this[kState].referrer === "no-referrer") {
          return "";
        }
        if (this[kState].referrer === "client") {
          return "about:client";
        }
        return this[kState].referrer.toString();
      }
      // Returns the referrer policy associated with request.
      // This is used during fetching to compute the value of the request’s
      // referrer.
      get referrerPolicy() {
        webidl.brandCheck(this, Request3);
        return this[kState].referrerPolicy;
      }
      // Returns the mode associated with request, which is a string indicating
      // whether the request will use CORS, or will be restricted to same-origin
      // URLs.
      get mode() {
        webidl.brandCheck(this, Request3);
        return this[kState].mode;
      }
      // Returns the credentials mode associated with request,
      // which is a string indicating whether credentials will be sent with the
      // request always, never, or only when sent to a same-origin URL.
      get credentials() {
        return this[kState].credentials;
      }
      // Returns the cache mode associated with request,
      // which is a string indicating how the request will
      // interact with the browser’s cache when fetching.
      get cache() {
        webidl.brandCheck(this, Request3);
        return this[kState].cache;
      }
      // Returns the redirect mode associated with request,
      // which is a string indicating how redirects for the
      // request will be handled during fetching. A request
      // will follow redirects by default.
      get redirect() {
        webidl.brandCheck(this, Request3);
        return this[kState].redirect;
      }
      // Returns request’s subresource integrity metadata, which is a
      // cryptographic hash of the resource being fetched. Its value
      // consists of multiple hashes separated by whitespace. [SRI]
      get integrity() {
        webidl.brandCheck(this, Request3);
        return this[kState].integrity;
      }
      // Returns a boolean indicating whether or not request can outlive the
      // global in which it was created.
      get keepalive() {
        webidl.brandCheck(this, Request3);
        return this[kState].keepalive;
      }
      // Returns a boolean indicating whether or not request is for a reload
      // navigation.
      get isReloadNavigation() {
        webidl.brandCheck(this, Request3);
        return this[kState].reloadNavigation;
      }
      // Returns a boolean indicating whether or not request is for a history
      // navigation (a.k.a. back-foward navigation).
      get isHistoryNavigation() {
        webidl.brandCheck(this, Request3);
        return this[kState].historyNavigation;
      }
      // Returns the signal associated with request, which is an AbortSignal
      // object indicating whether or not request has been aborted, and its
      // abort event handler.
      get signal() {
        webidl.brandCheck(this, Request3);
        return this[kSignal];
      }
      get body() {
        webidl.brandCheck(this, Request3);
        return this[kState].body ? this[kState].body.stream : null;
      }
      get bodyUsed() {
        webidl.brandCheck(this, Request3);
        return !!this[kState].body && util4.isDisturbed(this[kState].body.stream);
      }
      get duplex() {
        webidl.brandCheck(this, Request3);
        return "half";
      }
      // Returns a clone of request.
      clone() {
        webidl.brandCheck(this, Request3);
        if (this.bodyUsed || this.body?.locked) {
          throw new TypeError("unusable");
        }
        const clonedRequest = cloneRequest(this[kState]);
        const clonedRequestObject = new Request3(kConstruct);
        clonedRequestObject[kState] = clonedRequest;
        clonedRequestObject[kRealm] = this[kRealm];
        clonedRequestObject[kHeaders] = new Headers5(kConstruct);
        clonedRequestObject[kHeaders][kHeadersList] = clonedRequest.headersList;
        clonedRequestObject[kHeaders][kGuard] = this[kHeaders][kGuard];
        clonedRequestObject[kHeaders][kRealm] = this[kHeaders][kRealm];
        const ac = new AbortController();
        if (this.signal.aborted) {
          ac.abort(this.signal.reason);
        } else {
          util4.addAbortListener(
            this.signal,
            () => {
              ac.abort(this.signal.reason);
            }
          );
        }
        clonedRequestObject[kSignal] = ac.signal;
        return clonedRequestObject;
      }
    };
    __name(Request3, "Request");
    mixinBody(Request3);
    function makeRequest(init3) {
      const request3 = {
        method: "GET",
        localURLsOnly: false,
        unsafeRequest: false,
        body: null,
        client: null,
        reservedClient: null,
        replacesClientId: "",
        window: "client",
        keepalive: false,
        serviceWorkers: "all",
        initiator: "",
        destination: "",
        priority: null,
        origin: "client",
        policyContainer: "client",
        referrer: "client",
        referrerPolicy: "",
        mode: "no-cors",
        useCORSPreflightFlag: false,
        credentials: "same-origin",
        useCredentials: false,
        cache: "default",
        redirect: "follow",
        integrity: "",
        cryptoGraphicsNonceMetadata: "",
        parserMetadata: "",
        reloadNavigation: false,
        historyNavigation: false,
        userActivation: false,
        taintedOrigin: false,
        redirectCount: 0,
        responseTainting: "basic",
        preventNoCacheCacheControlHeaderModification: false,
        done: false,
        timingAllowFailed: false,
        ...init3,
        headersList: init3.headersList ? new HeadersList(init3.headersList) : new HeadersList()
      };
      request3.url = request3.urlList[0];
      return request3;
    }
    __name(makeRequest, "makeRequest");
    function cloneRequest(request3) {
      const newRequest = makeRequest({ ...request3, body: null });
      if (request3.body != null) {
        newRequest.body = cloneBody(request3.body);
      }
      return newRequest;
    }
    __name(cloneRequest, "cloneRequest");
    Object.defineProperties(Request3.prototype, {
      method: kEnumerableProperty,
      url: kEnumerableProperty,
      headers: kEnumerableProperty,
      redirect: kEnumerableProperty,
      clone: kEnumerableProperty,
      signal: kEnumerableProperty,
      duplex: kEnumerableProperty,
      destination: kEnumerableProperty,
      body: kEnumerableProperty,
      bodyUsed: kEnumerableProperty,
      isHistoryNavigation: kEnumerableProperty,
      isReloadNavigation: kEnumerableProperty,
      keepalive: kEnumerableProperty,
      integrity: kEnumerableProperty,
      cache: kEnumerableProperty,
      credentials: kEnumerableProperty,
      attribute: kEnumerableProperty,
      referrerPolicy: kEnumerableProperty,
      referrer: kEnumerableProperty,
      mode: kEnumerableProperty,
      [Symbol.toStringTag]: {
        value: "Request",
        configurable: true
      }
    });
    webidl.converters.Request = webidl.interfaceConverter(
      Request3
    );
    webidl.converters.RequestInfo = function(V2) {
      if (typeof V2 === "string") {
        return webidl.converters.USVString(V2);
      }
      if (V2 instanceof Request3) {
        return webidl.converters.Request(V2);
      }
      return webidl.converters.USVString(V2);
    };
    webidl.converters.AbortSignal = webidl.interfaceConverter(
      AbortSignal
    );
    webidl.converters.RequestInit = webidl.dictionaryConverter([
      {
        key: "method",
        converter: webidl.converters.ByteString
      },
      {
        key: "headers",
        converter: webidl.converters.HeadersInit
      },
      {
        key: "body",
        converter: webidl.nullableConverter(
          webidl.converters.BodyInit
        )
      },
      {
        key: "referrer",
        converter: webidl.converters.USVString
      },
      {
        key: "referrerPolicy",
        converter: webidl.converters.DOMString,
        // https://w3c.github.io/webappsec-referrer-policy/#referrer-policy
        allowedValues: referrerPolicy
      },
      {
        key: "mode",
        converter: webidl.converters.DOMString,
        // https://fetch.spec.whatwg.org/#concept-request-mode
        allowedValues: requestMode
      },
      {
        key: "credentials",
        converter: webidl.converters.DOMString,
        // https://fetch.spec.whatwg.org/#requestcredentials
        allowedValues: requestCredentials
      },
      {
        key: "cache",
        converter: webidl.converters.DOMString,
        // https://fetch.spec.whatwg.org/#requestcache
        allowedValues: requestCache
      },
      {
        key: "redirect",
        converter: webidl.converters.DOMString,
        // https://fetch.spec.whatwg.org/#requestredirect
        allowedValues: requestRedirect
      },
      {
        key: "integrity",
        converter: webidl.converters.DOMString
      },
      {
        key: "keepalive",
        converter: webidl.converters.boolean
      },
      {
        key: "signal",
        converter: webidl.nullableConverter(
          (signal) => webidl.converters.AbortSignal(
            signal,
            { strict: false }
          )
        )
      },
      {
        key: "window",
        converter: webidl.converters.any
      },
      {
        key: "duplex",
        converter: webidl.converters.DOMString,
        allowedValues: requestDuplex
      }
    ]);
    module3.exports = { Request: Request3, makeRequest };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/index.js
var require_fetch = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fetch/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var {
      Response: Response9,
      makeNetworkError,
      makeAppropriateNetworkError,
      filterResponse,
      makeResponse
    } = require_response();
    var { Headers: Headers5 } = require_headers();
    var { Request: Request3, makeRequest } = require_request2();
    var zlib = require("zlib");
    var {
      bytesMatch,
      makePolicyContainer,
      clonePolicyContainer,
      requestBadPort,
      TAOCheck,
      appendRequestOriginHeader,
      responseLocationURL,
      requestCurrentURL,
      setRequestReferrerPolicyOnRedirect,
      tryUpgradeRequestToAPotentiallyTrustworthyURL,
      createOpaqueTimingInfo,
      appendFetchMetadata,
      corsCheck,
      crossOriginResourcePolicyCheck,
      determineRequestsReferrer,
      coarsenedSharedCurrentTime,
      createDeferredPromise,
      isBlobLike,
      sameOrigin,
      isCancelled,
      isAborted,
      isErrorLike,
      fullyReadBody,
      readableStreamClose,
      isomorphicEncode,
      urlIsLocal,
      urlIsHttpHttpsScheme,
      urlHasHttpsScheme
    } = require_util2();
    var { kState, kHeaders, kGuard, kRealm } = require_symbols2();
    var assert27 = require("assert");
    var { safelyExtractBody } = require_body();
    var {
      redirectStatusSet,
      nullBodyStatus,
      safeMethodsSet,
      requestBodyHeader,
      subresourceSet,
      DOMException: DOMException2
    } = require_constants();
    var { kHeadersList } = require_symbols();
    var EE = require("events");
    var { Readable: Readable2, pipeline } = require("stream");
    var { addAbortListener, isErrored, isReadable, nodeMajor, nodeMinor } = require_util();
    var { dataURLProcessor, serializeAMimeType } = require_dataURL();
    var { TransformStream } = require("stream/web");
    var { getGlobalDispatcher: getGlobalDispatcher2 } = require_global2();
    var { webidl } = require_webidl();
    var { STATUS_CODES } = require("http");
    var GET_OR_HEAD = ["GET", "HEAD"];
    var resolveObjectURL;
    var ReadableStream2 = globalThis.ReadableStream;
    var Fetch = class extends EE {
      constructor(dispatcher) {
        super();
        this.dispatcher = dispatcher;
        this.connection = null;
        this.dump = false;
        this.state = "ongoing";
        this.setMaxListeners(21);
      }
      terminate(reason) {
        if (this.state !== "ongoing") {
          return;
        }
        this.state = "terminated";
        this.connection?.destroy(reason);
        this.emit("terminated", reason);
      }
      // https://fetch.spec.whatwg.org/#fetch-controller-abort
      abort(error2) {
        if (this.state !== "ongoing") {
          return;
        }
        this.state = "aborted";
        if (!error2) {
          error2 = new DOMException2("The operation was aborted.", "AbortError");
        }
        this.serializedAbortReason = error2;
        this.connection?.destroy(error2);
        this.emit("terminated", error2);
      }
    };
    __name(Fetch, "Fetch");
    function fetch15(input, init3 = {}) {
      webidl.argumentLengthCheck(arguments, 1, { header: "globalThis.fetch" });
      const p2 = createDeferredPromise();
      let requestObject;
      try {
        requestObject = new Request3(input, init3);
      } catch (e3) {
        p2.reject(e3);
        return p2.promise;
      }
      const request3 = requestObject[kState];
      if (requestObject.signal.aborted) {
        abortFetch(p2, request3, null, requestObject.signal.reason);
        return p2.promise;
      }
      const globalObject = request3.client.globalObject;
      if (globalObject?.constructor?.name === "ServiceWorkerGlobalScope") {
        request3.serviceWorkers = "none";
      }
      let responseObject = null;
      const relevantRealm = null;
      let locallyAborted = false;
      let controller = null;
      addAbortListener(
        requestObject.signal,
        () => {
          locallyAborted = true;
          assert27(controller != null);
          controller.abort(requestObject.signal.reason);
          abortFetch(p2, request3, responseObject, requestObject.signal.reason);
        }
      );
      const handleFetchDone = /* @__PURE__ */ __name((response) => finalizeAndReportTiming(response, "fetch"), "handleFetchDone");
      const processResponse = /* @__PURE__ */ __name((response) => {
        if (locallyAborted) {
          return Promise.resolve();
        }
        if (response.aborted) {
          abortFetch(p2, request3, responseObject, controller.serializedAbortReason);
          return Promise.resolve();
        }
        if (response.type === "error") {
          p2.reject(
            Object.assign(new TypeError("fetch failed"), { cause: response.error })
          );
          return Promise.resolve();
        }
        responseObject = new Response9();
        responseObject[kState] = response;
        responseObject[kRealm] = relevantRealm;
        responseObject[kHeaders][kHeadersList] = response.headersList;
        responseObject[kHeaders][kGuard] = "immutable";
        responseObject[kHeaders][kRealm] = relevantRealm;
        p2.resolve(responseObject);
      }, "processResponse");
      controller = fetching({
        request: request3,
        processResponseEndOfBody: handleFetchDone,
        processResponse,
        dispatcher: init3.dispatcher ?? getGlobalDispatcher2()
        // undici
      });
      return p2.promise;
    }
    __name(fetch15, "fetch");
    function finalizeAndReportTiming(response, initiatorType = "other") {
      if (response.type === "error" && response.aborted) {
        return;
      }
      if (!response.urlList?.length) {
        return;
      }
      const originalURL = response.urlList[0];
      let timingInfo = response.timingInfo;
      let cacheState = response.cacheState;
      if (!urlIsHttpHttpsScheme(originalURL)) {
        return;
      }
      if (timingInfo === null) {
        return;
      }
      if (!response.timingAllowPassed) {
        timingInfo = createOpaqueTimingInfo({
          startTime: timingInfo.startTime
        });
        cacheState = "";
      }
      timingInfo.endTime = coarsenedSharedCurrentTime();
      response.timingInfo = timingInfo;
      markResourceTiming(
        timingInfo,
        originalURL,
        initiatorType,
        globalThis,
        cacheState
      );
    }
    __name(finalizeAndReportTiming, "finalizeAndReportTiming");
    function markResourceTiming(timingInfo, originalURL, initiatorType, globalThis2, cacheState) {
      if (nodeMajor > 18 || nodeMajor === 18 && nodeMinor >= 2) {
        performance.markResourceTiming(timingInfo, originalURL.href, initiatorType, globalThis2, cacheState);
      }
    }
    __name(markResourceTiming, "markResourceTiming");
    function abortFetch(p2, request3, responseObject, error2) {
      if (!error2) {
        error2 = new DOMException2("The operation was aborted.", "AbortError");
      }
      p2.reject(error2);
      if (request3.body != null && isReadable(request3.body?.stream)) {
        request3.body.stream.cancel(error2).catch((err) => {
          if (err.code === "ERR_INVALID_STATE") {
            return;
          }
          throw err;
        });
      }
      if (responseObject == null) {
        return;
      }
      const response = responseObject[kState];
      if (response.body != null && isReadable(response.body?.stream)) {
        response.body.stream.cancel(error2).catch((err) => {
          if (err.code === "ERR_INVALID_STATE") {
            return;
          }
          throw err;
        });
      }
    }
    __name(abortFetch, "abortFetch");
    function fetching({
      request: request3,
      processRequestBodyChunkLength,
      processRequestEndOfBody,
      processResponse,
      processResponseEndOfBody,
      processResponseConsumeBody,
      useParallelQueue = false,
      dispatcher
      // undici
    }) {
      let taskDestination = null;
      let crossOriginIsolatedCapability = false;
      if (request3.client != null) {
        taskDestination = request3.client.globalObject;
        crossOriginIsolatedCapability = request3.client.crossOriginIsolatedCapability;
      }
      const currenTime = coarsenedSharedCurrentTime(crossOriginIsolatedCapability);
      const timingInfo = createOpaqueTimingInfo({
        startTime: currenTime
      });
      const fetchParams = {
        controller: new Fetch(dispatcher),
        request: request3,
        timingInfo,
        processRequestBodyChunkLength,
        processRequestEndOfBody,
        processResponse,
        processResponseConsumeBody,
        processResponseEndOfBody,
        taskDestination,
        crossOriginIsolatedCapability
      };
      assert27(!request3.body || request3.body.stream);
      if (request3.window === "client") {
        request3.window = request3.client?.globalObject?.constructor?.name === "Window" ? request3.client : "no-window";
      }
      if (request3.origin === "client") {
        request3.origin = request3.client?.origin;
      }
      if (request3.policyContainer === "client") {
        if (request3.client != null) {
          request3.policyContainer = clonePolicyContainer(
            request3.client.policyContainer
          );
        } else {
          request3.policyContainer = makePolicyContainer();
        }
      }
      if (!request3.headersList.contains("accept")) {
        const value = "*/*";
        request3.headersList.append("accept", value);
      }
      if (!request3.headersList.contains("accept-language")) {
        request3.headersList.append("accept-language", "*");
      }
      if (request3.priority === null) {
      }
      if (subresourceSet.has(request3.destination)) {
      }
      mainFetch(fetchParams).catch((err) => {
        fetchParams.controller.terminate(err);
      });
      return fetchParams.controller;
    }
    __name(fetching, "fetching");
    async function mainFetch(fetchParams, recursive = false) {
      const request3 = fetchParams.request;
      let response = null;
      if (request3.localURLsOnly && !urlIsLocal(requestCurrentURL(request3))) {
        response = makeNetworkError("local URLs only");
      }
      tryUpgradeRequestToAPotentiallyTrustworthyURL(request3);
      if (requestBadPort(request3) === "blocked") {
        response = makeNetworkError("bad port");
      }
      if (request3.referrerPolicy === "") {
        request3.referrerPolicy = request3.policyContainer.referrerPolicy;
      }
      if (request3.referrer !== "no-referrer") {
        request3.referrer = determineRequestsReferrer(request3);
      }
      if (response === null) {
        response = await (async () => {
          const currentURL = requestCurrentURL(request3);
          if (
            // - request’s current URL’s origin is same origin with request’s origin,
            //   and request’s response tainting is "basic"
            sameOrigin(currentURL, request3.url) && request3.responseTainting === "basic" || // request’s current URL’s scheme is "data"
            currentURL.protocol === "data:" || // - request’s mode is "navigate" or "websocket"
            (request3.mode === "navigate" || request3.mode === "websocket")
          ) {
            request3.responseTainting = "basic";
            return await schemeFetch(fetchParams);
          }
          if (request3.mode === "same-origin") {
            return makeNetworkError('request mode cannot be "same-origin"');
          }
          if (request3.mode === "no-cors") {
            if (request3.redirect !== "follow") {
              return makeNetworkError(
                'redirect mode cannot be "follow" for "no-cors" request'
              );
            }
            request3.responseTainting = "opaque";
            return await schemeFetch(fetchParams);
          }
          if (!urlIsHttpHttpsScheme(requestCurrentURL(request3))) {
            return makeNetworkError("URL scheme must be a HTTP(S) scheme");
          }
          request3.responseTainting = "cors";
          return await httpFetch(fetchParams);
        })();
      }
      if (recursive) {
        return response;
      }
      if (response.status !== 0 && !response.internalResponse) {
        if (request3.responseTainting === "cors") {
        }
        if (request3.responseTainting === "basic") {
          response = filterResponse(response, "basic");
        } else if (request3.responseTainting === "cors") {
          response = filterResponse(response, "cors");
        } else if (request3.responseTainting === "opaque") {
          response = filterResponse(response, "opaque");
        } else {
          assert27(false);
        }
      }
      let internalResponse = response.status === 0 ? response : response.internalResponse;
      if (internalResponse.urlList.length === 0) {
        internalResponse.urlList.push(...request3.urlList);
      }
      if (!request3.timingAllowFailed) {
        response.timingAllowPassed = true;
      }
      if (response.type === "opaque" && internalResponse.status === 206 && internalResponse.rangeRequested && !request3.headers.contains("range")) {
        response = internalResponse = makeNetworkError();
      }
      if (response.status !== 0 && (request3.method === "HEAD" || request3.method === "CONNECT" || nullBodyStatus.includes(internalResponse.status))) {
        internalResponse.body = null;
        fetchParams.controller.dump = true;
      }
      if (request3.integrity) {
        const processBodyError = /* @__PURE__ */ __name((reason) => fetchFinale(fetchParams, makeNetworkError(reason)), "processBodyError");
        if (request3.responseTainting === "opaque" || response.body == null) {
          processBodyError(response.error);
          return;
        }
        const processBody = /* @__PURE__ */ __name((bytes) => {
          if (!bytesMatch(bytes, request3.integrity)) {
            processBodyError("integrity mismatch");
            return;
          }
          response.body = safelyExtractBody(bytes)[0];
          fetchFinale(fetchParams, response);
        }, "processBody");
        await fullyReadBody(response.body, processBody, processBodyError);
      } else {
        fetchFinale(fetchParams, response);
      }
    }
    __name(mainFetch, "mainFetch");
    function schemeFetch(fetchParams) {
      if (isCancelled(fetchParams) && fetchParams.request.redirectCount === 0) {
        return Promise.resolve(makeAppropriateNetworkError(fetchParams));
      }
      const { request: request3 } = fetchParams;
      const { protocol: scheme } = requestCurrentURL(request3);
      switch (scheme) {
        case "about:": {
          return Promise.resolve(makeNetworkError("about scheme is not supported"));
        }
        case "blob:": {
          if (!resolveObjectURL) {
            resolveObjectURL = require("buffer").resolveObjectURL;
          }
          const blobURLEntry = requestCurrentURL(request3);
          if (blobURLEntry.search.length !== 0) {
            return Promise.resolve(makeNetworkError("NetworkError when attempting to fetch resource."));
          }
          const blobURLEntryObject = resolveObjectURL(blobURLEntry.toString());
          if (request3.method !== "GET" || !isBlobLike(blobURLEntryObject)) {
            return Promise.resolve(makeNetworkError("invalid method"));
          }
          const bodyWithType = safelyExtractBody(blobURLEntryObject);
          const body = bodyWithType[0];
          const length = isomorphicEncode(`${body.length}`);
          const type = bodyWithType[1] ?? "";
          const response = makeResponse({
            statusText: "OK",
            headersList: [
              ["content-length", { name: "Content-Length", value: length }],
              ["content-type", { name: "Content-Type", value: type }]
            ]
          });
          response.body = body;
          return Promise.resolve(response);
        }
        case "data:": {
          const currentURL = requestCurrentURL(request3);
          const dataURLStruct = dataURLProcessor(currentURL);
          if (dataURLStruct === "failure") {
            return Promise.resolve(makeNetworkError("failed to fetch the data URL"));
          }
          const mimeType = serializeAMimeType(dataURLStruct.mimeType);
          return Promise.resolve(makeResponse({
            statusText: "OK",
            headersList: [
              ["content-type", { name: "Content-Type", value: mimeType }]
            ],
            body: safelyExtractBody(dataURLStruct.body)[0]
          }));
        }
        case "file:": {
          return Promise.resolve(makeNetworkError("not implemented... yet..."));
        }
        case "http:":
        case "https:": {
          return httpFetch(fetchParams).catch((err) => makeNetworkError(err));
        }
        default: {
          return Promise.resolve(makeNetworkError("unknown scheme"));
        }
      }
    }
    __name(schemeFetch, "schemeFetch");
    function finalizeResponse(fetchParams, response) {
      fetchParams.request.done = true;
      if (fetchParams.processResponseDone != null) {
        queueMicrotask(() => fetchParams.processResponseDone(response));
      }
    }
    __name(finalizeResponse, "finalizeResponse");
    function fetchFinale(fetchParams, response) {
      if (response.type === "error") {
        response.urlList = [fetchParams.request.urlList[0]];
        response.timingInfo = createOpaqueTimingInfo({
          startTime: fetchParams.timingInfo.startTime
        });
      }
      const processResponseEndOfBody = /* @__PURE__ */ __name(() => {
        fetchParams.request.done = true;
        if (fetchParams.processResponseEndOfBody != null) {
          queueMicrotask(() => fetchParams.processResponseEndOfBody(response));
        }
      }, "processResponseEndOfBody");
      if (fetchParams.processResponse != null) {
        queueMicrotask(() => fetchParams.processResponse(response));
      }
      if (response.body == null) {
        processResponseEndOfBody();
      } else {
        const identityTransformAlgorithm = /* @__PURE__ */ __name((chunk, controller) => {
          controller.enqueue(chunk);
        }, "identityTransformAlgorithm");
        const transformStream = new TransformStream({
          start() {
          },
          transform: identityTransformAlgorithm,
          flush: processResponseEndOfBody
        }, {
          size() {
            return 1;
          }
        }, {
          size() {
            return 1;
          }
        });
        response.body = { stream: response.body.stream.pipeThrough(transformStream) };
      }
      if (fetchParams.processResponseConsumeBody != null) {
        const processBody = /* @__PURE__ */ __name((nullOrBytes) => fetchParams.processResponseConsumeBody(response, nullOrBytes), "processBody");
        const processBodyError = /* @__PURE__ */ __name((failure) => fetchParams.processResponseConsumeBody(response, failure), "processBodyError");
        if (response.body == null) {
          queueMicrotask(() => processBody(null));
        } else {
          return fullyReadBody(response.body, processBody, processBodyError);
        }
        return Promise.resolve();
      }
    }
    __name(fetchFinale, "fetchFinale");
    async function httpFetch(fetchParams) {
      const request3 = fetchParams.request;
      let response = null;
      let actualResponse = null;
      const timingInfo = fetchParams.timingInfo;
      if (request3.serviceWorkers === "all") {
      }
      if (response === null) {
        if (request3.redirect === "follow") {
          request3.serviceWorkers = "none";
        }
        actualResponse = response = await httpNetworkOrCacheFetch(fetchParams);
        if (request3.responseTainting === "cors" && corsCheck(request3, response) === "failure") {
          return makeNetworkError("cors failure");
        }
        if (TAOCheck(request3, response) === "failure") {
          request3.timingAllowFailed = true;
        }
      }
      if ((request3.responseTainting === "opaque" || response.type === "opaque") && crossOriginResourcePolicyCheck(
        request3.origin,
        request3.client,
        request3.destination,
        actualResponse
      ) === "blocked") {
        return makeNetworkError("blocked");
      }
      if (redirectStatusSet.has(actualResponse.status)) {
        if (request3.redirect !== "manual") {
          fetchParams.controller.connection.destroy();
        }
        if (request3.redirect === "error") {
          response = makeNetworkError("unexpected redirect");
        } else if (request3.redirect === "manual") {
          response = actualResponse;
        } else if (request3.redirect === "follow") {
          response = await httpRedirectFetch(fetchParams, response);
        } else {
          assert27(false);
        }
      }
      response.timingInfo = timingInfo;
      return response;
    }
    __name(httpFetch, "httpFetch");
    function httpRedirectFetch(fetchParams, response) {
      const request3 = fetchParams.request;
      const actualResponse = response.internalResponse ? response.internalResponse : response;
      let locationURL;
      try {
        locationURL = responseLocationURL(
          actualResponse,
          requestCurrentURL(request3).hash
        );
        if (locationURL == null) {
          return response;
        }
      } catch (err) {
        return Promise.resolve(makeNetworkError(err));
      }
      if (!urlIsHttpHttpsScheme(locationURL)) {
        return Promise.resolve(makeNetworkError("URL scheme must be a HTTP(S) scheme"));
      }
      if (request3.redirectCount === 20) {
        return Promise.resolve(makeNetworkError("redirect count exceeded"));
      }
      request3.redirectCount += 1;
      if (request3.mode === "cors" && (locationURL.username || locationURL.password) && !sameOrigin(request3, locationURL)) {
        return Promise.resolve(makeNetworkError('cross origin not allowed for request mode "cors"'));
      }
      if (request3.responseTainting === "cors" && (locationURL.username || locationURL.password)) {
        return Promise.resolve(makeNetworkError(
          'URL cannot contain credentials for request mode "cors"'
        ));
      }
      if (actualResponse.status !== 303 && request3.body != null && request3.body.source == null) {
        return Promise.resolve(makeNetworkError());
      }
      if ([301, 302].includes(actualResponse.status) && request3.method === "POST" || actualResponse.status === 303 && !GET_OR_HEAD.includes(request3.method)) {
        request3.method = "GET";
        request3.body = null;
        for (const headerName of requestBodyHeader) {
          request3.headersList.delete(headerName);
        }
      }
      if (!sameOrigin(requestCurrentURL(request3), locationURL)) {
        request3.headersList.delete("authorization");
        request3.headersList.delete("proxy-authorization", true);
        request3.headersList.delete("cookie");
        request3.headersList.delete("host");
      }
      if (request3.body != null) {
        assert27(request3.body.source != null);
        request3.body = safelyExtractBody(request3.body.source)[0];
      }
      const timingInfo = fetchParams.timingInfo;
      timingInfo.redirectEndTime = timingInfo.postRedirectStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability);
      if (timingInfo.redirectStartTime === 0) {
        timingInfo.redirectStartTime = timingInfo.startTime;
      }
      request3.urlList.push(locationURL);
      setRequestReferrerPolicyOnRedirect(request3, actualResponse);
      return mainFetch(fetchParams, true);
    }
    __name(httpRedirectFetch, "httpRedirectFetch");
    async function httpNetworkOrCacheFetch(fetchParams, isAuthenticationFetch = false, isNewConnectionFetch = false) {
      const request3 = fetchParams.request;
      let httpFetchParams = null;
      let httpRequest = null;
      let response = null;
      const httpCache = null;
      const revalidatingFlag = false;
      if (request3.window === "no-window" && request3.redirect === "error") {
        httpFetchParams = fetchParams;
        httpRequest = request3;
      } else {
        httpRequest = makeRequest(request3);
        httpFetchParams = { ...fetchParams };
        httpFetchParams.request = httpRequest;
      }
      const includeCredentials = request3.credentials === "include" || request3.credentials === "same-origin" && request3.responseTainting === "basic";
      const contentLength = httpRequest.body ? httpRequest.body.length : null;
      let contentLengthHeaderValue = null;
      if (httpRequest.body == null && ["POST", "PUT"].includes(httpRequest.method)) {
        contentLengthHeaderValue = "0";
      }
      if (contentLength != null) {
        contentLengthHeaderValue = isomorphicEncode(`${contentLength}`);
      }
      if (contentLengthHeaderValue != null) {
        httpRequest.headersList.append("content-length", contentLengthHeaderValue);
      }
      if (contentLength != null && httpRequest.keepalive) {
      }
      if (httpRequest.referrer instanceof URL) {
        httpRequest.headersList.append("referer", isomorphicEncode(httpRequest.referrer.href));
      }
      appendRequestOriginHeader(httpRequest);
      appendFetchMetadata(httpRequest);
      if (!httpRequest.headersList.contains("user-agent")) {
        httpRequest.headersList.append("user-agent", typeof esbuildDetection === "undefined" ? "undici" : "node");
      }
      if (httpRequest.cache === "default" && (httpRequest.headersList.contains("if-modified-since") || httpRequest.headersList.contains("if-none-match") || httpRequest.headersList.contains("if-unmodified-since") || httpRequest.headersList.contains("if-match") || httpRequest.headersList.contains("if-range"))) {
        httpRequest.cache = "no-store";
      }
      if (httpRequest.cache === "no-cache" && !httpRequest.preventNoCacheCacheControlHeaderModification && !httpRequest.headersList.contains("cache-control")) {
        httpRequest.headersList.append("cache-control", "max-age=0");
      }
      if (httpRequest.cache === "no-store" || httpRequest.cache === "reload") {
        if (!httpRequest.headersList.contains("pragma")) {
          httpRequest.headersList.append("pragma", "no-cache");
        }
        if (!httpRequest.headersList.contains("cache-control")) {
          httpRequest.headersList.append("cache-control", "no-cache");
        }
      }
      if (httpRequest.headersList.contains("range")) {
        httpRequest.headersList.append("accept-encoding", "identity");
      }
      if (!httpRequest.headersList.contains("accept-encoding")) {
        if (urlHasHttpsScheme(requestCurrentURL(httpRequest))) {
          httpRequest.headersList.append("accept-encoding", "br, gzip, deflate");
        } else {
          httpRequest.headersList.append("accept-encoding", "gzip, deflate");
        }
      }
      httpRequest.headersList.delete("host");
      if (includeCredentials) {
      }
      if (httpCache == null) {
        httpRequest.cache = "no-store";
      }
      if (httpRequest.mode !== "no-store" && httpRequest.mode !== "reload") {
      }
      if (response == null) {
        if (httpRequest.mode === "only-if-cached") {
          return makeNetworkError("only if cached");
        }
        const forwardResponse = await httpNetworkFetch(
          httpFetchParams,
          includeCredentials,
          isNewConnectionFetch
        );
        if (!safeMethodsSet.has(httpRequest.method) && forwardResponse.status >= 200 && forwardResponse.status <= 399) {
        }
        if (revalidatingFlag && forwardResponse.status === 304) {
        }
        if (response == null) {
          response = forwardResponse;
        }
      }
      response.urlList = [...httpRequest.urlList];
      if (httpRequest.headersList.contains("range")) {
        response.rangeRequested = true;
      }
      response.requestIncludesCredentials = includeCredentials;
      if (response.status === 407) {
        if (request3.window === "no-window") {
          return makeNetworkError();
        }
        if (isCancelled(fetchParams)) {
          return makeAppropriateNetworkError(fetchParams);
        }
        return makeNetworkError("proxy authentication required");
      }
      if (
        // response’s status is 421
        response.status === 421 && // isNewConnectionFetch is false
        !isNewConnectionFetch && // request’s body is null, or request’s body is non-null and request’s body’s source is non-null
        (request3.body == null || request3.body.source != null)
      ) {
        if (isCancelled(fetchParams)) {
          return makeAppropriateNetworkError(fetchParams);
        }
        fetchParams.controller.connection.destroy();
        response = await httpNetworkOrCacheFetch(
          fetchParams,
          isAuthenticationFetch,
          true
        );
      }
      if (isAuthenticationFetch) {
      }
      return response;
    }
    __name(httpNetworkOrCacheFetch, "httpNetworkOrCacheFetch");
    async function httpNetworkFetch(fetchParams, includeCredentials = false, forceNewConnection = false) {
      assert27(!fetchParams.controller.connection || fetchParams.controller.connection.destroyed);
      fetchParams.controller.connection = {
        abort: null,
        destroyed: false,
        destroy(err) {
          if (!this.destroyed) {
            this.destroyed = true;
            this.abort?.(err ?? new DOMException2("The operation was aborted.", "AbortError"));
          }
        }
      };
      const request3 = fetchParams.request;
      let response = null;
      const timingInfo = fetchParams.timingInfo;
      const httpCache = null;
      if (httpCache == null) {
        request3.cache = "no-store";
      }
      const newConnection = forceNewConnection ? "yes" : "no";
      if (request3.mode === "websocket") {
      } else {
      }
      let requestBody = null;
      if (request3.body == null && fetchParams.processRequestEndOfBody) {
        queueMicrotask(() => fetchParams.processRequestEndOfBody());
      } else if (request3.body != null) {
        const processBodyChunk = /* @__PURE__ */ __name(async function* (bytes) {
          if (isCancelled(fetchParams)) {
            return;
          }
          yield bytes;
          fetchParams.processRequestBodyChunkLength?.(bytes.byteLength);
        }, "processBodyChunk");
        const processEndOfBody = /* @__PURE__ */ __name(() => {
          if (isCancelled(fetchParams)) {
            return;
          }
          if (fetchParams.processRequestEndOfBody) {
            fetchParams.processRequestEndOfBody();
          }
        }, "processEndOfBody");
        const processBodyError = /* @__PURE__ */ __name((e3) => {
          if (isCancelled(fetchParams)) {
            return;
          }
          if (e3.name === "AbortError") {
            fetchParams.controller.abort();
          } else {
            fetchParams.controller.terminate(e3);
          }
        }, "processBodyError");
        requestBody = async function* () {
          try {
            for await (const bytes of request3.body.stream) {
              yield* processBodyChunk(bytes);
            }
            processEndOfBody();
          } catch (err) {
            processBodyError(err);
          }
        }();
      }
      try {
        const { body, status: status2, statusText, headersList, socket } = await dispatch({ body: requestBody });
        if (socket) {
          response = makeResponse({ status: status2, statusText, headersList, socket });
        } else {
          const iterator = body[Symbol.asyncIterator]();
          fetchParams.controller.next = () => iterator.next();
          response = makeResponse({ status: status2, statusText, headersList });
        }
      } catch (err) {
        if (err.name === "AbortError") {
          fetchParams.controller.connection.destroy();
          return makeAppropriateNetworkError(fetchParams, err);
        }
        return makeNetworkError(err);
      }
      const pullAlgorithm = /* @__PURE__ */ __name(() => {
        fetchParams.controller.resume();
      }, "pullAlgorithm");
      const cancelAlgorithm = /* @__PURE__ */ __name((reason) => {
        fetchParams.controller.abort(reason);
      }, "cancelAlgorithm");
      if (!ReadableStream2) {
        ReadableStream2 = require("stream/web").ReadableStream;
      }
      const stream2 = new ReadableStream2(
        {
          async start(controller) {
            fetchParams.controller.controller = controller;
          },
          async pull(controller) {
            await pullAlgorithm(controller);
          },
          async cancel(reason) {
            await cancelAlgorithm(reason);
          }
        },
        {
          highWaterMark: 0,
          size() {
            return 1;
          }
        }
      );
      response.body = { stream: stream2 };
      fetchParams.controller.on("terminated", onAborted);
      fetchParams.controller.resume = async () => {
        while (true) {
          let bytes;
          let isFailure;
          try {
            const { done, value } = await fetchParams.controller.next();
            if (isAborted(fetchParams)) {
              break;
            }
            bytes = done ? void 0 : value;
          } catch (err) {
            if (fetchParams.controller.ended && !timingInfo.encodedBodySize) {
              bytes = void 0;
            } else {
              bytes = err;
              isFailure = true;
            }
          }
          if (bytes === void 0) {
            readableStreamClose(fetchParams.controller.controller);
            finalizeResponse(fetchParams, response);
            return;
          }
          timingInfo.decodedBodySize += bytes?.byteLength ?? 0;
          if (isFailure) {
            fetchParams.controller.terminate(bytes);
            return;
          }
          fetchParams.controller.controller.enqueue(new Uint8Array(bytes));
          if (isErrored(stream2)) {
            fetchParams.controller.terminate();
            return;
          }
          if (!fetchParams.controller.controller.desiredSize) {
            return;
          }
        }
      };
      function onAborted(reason) {
        if (isAborted(fetchParams)) {
          response.aborted = true;
          if (isReadable(stream2)) {
            fetchParams.controller.controller.error(
              fetchParams.controller.serializedAbortReason
            );
          }
        } else {
          if (isReadable(stream2)) {
            fetchParams.controller.controller.error(new TypeError("terminated", {
              cause: isErrorLike(reason) ? reason : void 0
            }));
          }
        }
        fetchParams.controller.connection.destroy();
      }
      __name(onAborted, "onAborted");
      return response;
      async function dispatch({ body }) {
        const url4 = requestCurrentURL(request3);
        const agent = fetchParams.controller.dispatcher;
        return new Promise((resolve19, reject) => agent.dispatch(
          {
            path: url4.pathname + url4.search,
            origin: url4.origin,
            method: request3.method,
            body: fetchParams.controller.dispatcher.isMockActive ? request3.body && (request3.body.source || request3.body.stream) : body,
            headers: request3.headersList.entries,
            maxRedirections: 0,
            upgrade: request3.mode === "websocket" ? "websocket" : void 0
          },
          {
            body: null,
            abort: null,
            onConnect(abort) {
              const { connection } = fetchParams.controller;
              if (connection.destroyed) {
                abort(new DOMException2("The operation was aborted.", "AbortError"));
              } else {
                fetchParams.controller.on("terminated", abort);
                this.abort = connection.abort = abort;
              }
            },
            onHeaders(status2, headersList, resume, statusText) {
              if (status2 < 200) {
                return;
              }
              let codings = [];
              let location = "";
              const headers = new Headers5();
              if (Array.isArray(headersList)) {
                for (let n2 = 0; n2 < headersList.length; n2 += 2) {
                  const key = headersList[n2 + 0].toString("latin1");
                  const val = headersList[n2 + 1].toString("latin1");
                  if (key.toLowerCase() === "content-encoding") {
                    codings = val.toLowerCase().split(",").map((x2) => x2.trim());
                  } else if (key.toLowerCase() === "location") {
                    location = val;
                  }
                  headers[kHeadersList].append(key, val);
                }
              } else {
                const keys = Object.keys(headersList);
                for (const key of keys) {
                  const val = headersList[key];
                  if (key.toLowerCase() === "content-encoding") {
                    codings = val.toLowerCase().split(",").map((x2) => x2.trim()).reverse();
                  } else if (key.toLowerCase() === "location") {
                    location = val;
                  }
                  headers[kHeadersList].append(key, val);
                }
              }
              this.body = new Readable2({ read: resume });
              const decoders = [];
              const willFollow = request3.redirect === "follow" && location && redirectStatusSet.has(status2);
              if (request3.method !== "HEAD" && request3.method !== "CONNECT" && !nullBodyStatus.includes(status2) && !willFollow) {
                for (const coding of codings) {
                  if (coding === "x-gzip" || coding === "gzip") {
                    decoders.push(zlib.createGunzip({
                      // Be less strict when decoding compressed responses, since sometimes
                      // servers send slightly invalid responses that are still accepted
                      // by common browsers.
                      // Always using Z_SYNC_FLUSH is what cURL does.
                      flush: zlib.constants.Z_SYNC_FLUSH,
                      finishFlush: zlib.constants.Z_SYNC_FLUSH
                    }));
                  } else if (coding === "deflate") {
                    decoders.push(zlib.createInflate());
                  } else if (coding === "br") {
                    decoders.push(zlib.createBrotliDecompress());
                  } else {
                    decoders.length = 0;
                    break;
                  }
                }
              }
              resolve19({
                status: status2,
                statusText,
                headersList: headers[kHeadersList],
                body: decoders.length ? pipeline(this.body, ...decoders, () => {
                }) : this.body.on("error", () => {
                })
              });
              return true;
            },
            onData(chunk) {
              if (fetchParams.controller.dump) {
                return;
              }
              const bytes = chunk;
              timingInfo.encodedBodySize += bytes.byteLength;
              return this.body.push(bytes);
            },
            onComplete() {
              if (this.abort) {
                fetchParams.controller.off("terminated", this.abort);
              }
              fetchParams.controller.ended = true;
              this.body.push(null);
            },
            onError(error2) {
              if (this.abort) {
                fetchParams.controller.off("terminated", this.abort);
              }
              this.body?.destroy(error2);
              fetchParams.controller.terminate(error2);
              reject(error2);
            },
            onUpgrade(status2, headersList, socket) {
              if (status2 !== 101) {
                return;
              }
              const headers = new Headers5();
              for (let n2 = 0; n2 < headersList.length; n2 += 2) {
                const key = headersList[n2 + 0].toString("latin1");
                const val = headersList[n2 + 1].toString("latin1");
                headers[kHeadersList].append(key, val);
              }
              resolve19({
                status: status2,
                statusText: STATUS_CODES[status2],
                headersList: headers[kHeadersList],
                socket
              });
              return true;
            }
          }
        ));
      }
      __name(dispatch, "dispatch");
    }
    __name(httpNetworkFetch, "httpNetworkFetch");
    module3.exports = {
      fetch: fetch15,
      Fetch,
      fetching,
      finalizeAndReportTiming
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fileapi/symbols.js
var require_symbols3 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fileapi/symbols.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = {
      kState: Symbol("FileReader state"),
      kResult: Symbol("FileReader result"),
      kError: Symbol("FileReader error"),
      kLastProgressEventFired: Symbol("FileReader last progress event fired timestamp"),
      kEvents: Symbol("FileReader events"),
      kAborted: Symbol("FileReader aborted")
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fileapi/progressevent.js
var require_progressevent = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fileapi/progressevent.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { webidl } = require_webidl();
    var kState = Symbol("ProgressEvent state");
    var ProgressEvent = class extends Event {
      constructor(type, eventInitDict = {}) {
        type = webidl.converters.DOMString(type);
        eventInitDict = webidl.converters.ProgressEventInit(eventInitDict ?? {});
        super(type, eventInitDict);
        this[kState] = {
          lengthComputable: eventInitDict.lengthComputable,
          loaded: eventInitDict.loaded,
          total: eventInitDict.total
        };
      }
      get lengthComputable() {
        webidl.brandCheck(this, ProgressEvent);
        return this[kState].lengthComputable;
      }
      get loaded() {
        webidl.brandCheck(this, ProgressEvent);
        return this[kState].loaded;
      }
      get total() {
        webidl.brandCheck(this, ProgressEvent);
        return this[kState].total;
      }
    };
    __name(ProgressEvent, "ProgressEvent");
    webidl.converters.ProgressEventInit = webidl.dictionaryConverter([
      {
        key: "lengthComputable",
        converter: webidl.converters.boolean,
        defaultValue: false
      },
      {
        key: "loaded",
        converter: webidl.converters["unsigned long long"],
        defaultValue: 0
      },
      {
        key: "total",
        converter: webidl.converters["unsigned long long"],
        defaultValue: 0
      },
      {
        key: "bubbles",
        converter: webidl.converters.boolean,
        defaultValue: false
      },
      {
        key: "cancelable",
        converter: webidl.converters.boolean,
        defaultValue: false
      },
      {
        key: "composed",
        converter: webidl.converters.boolean,
        defaultValue: false
      }
    ]);
    module3.exports = {
      ProgressEvent
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fileapi/encoding.js
var require_encoding = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fileapi/encoding.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    function getEncoding(label) {
      if (!label) {
        return "failure";
      }
      switch (label.trim().toLowerCase()) {
        case "unicode-1-1-utf-8":
        case "unicode11utf8":
        case "unicode20utf8":
        case "utf-8":
        case "utf8":
        case "x-unicode20utf8":
          return "UTF-8";
        case "866":
        case "cp866":
        case "csibm866":
        case "ibm866":
          return "IBM866";
        case "csisolatin2":
        case "iso-8859-2":
        case "iso-ir-101":
        case "iso8859-2":
        case "iso88592":
        case "iso_8859-2":
        case "iso_8859-2:1987":
        case "l2":
        case "latin2":
          return "ISO-8859-2";
        case "csisolatin3":
        case "iso-8859-3":
        case "iso-ir-109":
        case "iso8859-3":
        case "iso88593":
        case "iso_8859-3":
        case "iso_8859-3:1988":
        case "l3":
        case "latin3":
          return "ISO-8859-3";
        case "csisolatin4":
        case "iso-8859-4":
        case "iso-ir-110":
        case "iso8859-4":
        case "iso88594":
        case "iso_8859-4":
        case "iso_8859-4:1988":
        case "l4":
        case "latin4":
          return "ISO-8859-4";
        case "csisolatincyrillic":
        case "cyrillic":
        case "iso-8859-5":
        case "iso-ir-144":
        case "iso8859-5":
        case "iso88595":
        case "iso_8859-5":
        case "iso_8859-5:1988":
          return "ISO-8859-5";
        case "arabic":
        case "asmo-708":
        case "csiso88596e":
        case "csiso88596i":
        case "csisolatinarabic":
        case "ecma-114":
        case "iso-8859-6":
        case "iso-8859-6-e":
        case "iso-8859-6-i":
        case "iso-ir-127":
        case "iso8859-6":
        case "iso88596":
        case "iso_8859-6":
        case "iso_8859-6:1987":
          return "ISO-8859-6";
        case "csisolatingreek":
        case "ecma-118":
        case "elot_928":
        case "greek":
        case "greek8":
        case "iso-8859-7":
        case "iso-ir-126":
        case "iso8859-7":
        case "iso88597":
        case "iso_8859-7":
        case "iso_8859-7:1987":
        case "sun_eu_greek":
          return "ISO-8859-7";
        case "csiso88598e":
        case "csisolatinhebrew":
        case "hebrew":
        case "iso-8859-8":
        case "iso-8859-8-e":
        case "iso-ir-138":
        case "iso8859-8":
        case "iso88598":
        case "iso_8859-8":
        case "iso_8859-8:1988":
        case "visual":
          return "ISO-8859-8";
        case "csiso88598i":
        case "iso-8859-8-i":
        case "logical":
          return "ISO-8859-8-I";
        case "csisolatin6":
        case "iso-8859-10":
        case "iso-ir-157":
        case "iso8859-10":
        case "iso885910":
        case "l6":
        case "latin6":
          return "ISO-8859-10";
        case "iso-8859-13":
        case "iso8859-13":
        case "iso885913":
          return "ISO-8859-13";
        case "iso-8859-14":
        case "iso8859-14":
        case "iso885914":
          return "ISO-8859-14";
        case "csisolatin9":
        case "iso-8859-15":
        case "iso8859-15":
        case "iso885915":
        case "iso_8859-15":
        case "l9":
          return "ISO-8859-15";
        case "iso-8859-16":
          return "ISO-8859-16";
        case "cskoi8r":
        case "koi":
        case "koi8":
        case "koi8-r":
        case "koi8_r":
          return "KOI8-R";
        case "koi8-ru":
        case "koi8-u":
          return "KOI8-U";
        case "csmacintosh":
        case "mac":
        case "macintosh":
        case "x-mac-roman":
          return "macintosh";
        case "iso-8859-11":
        case "iso8859-11":
        case "iso885911":
        case "tis-620":
        case "windows-874":
          return "windows-874";
        case "cp1250":
        case "windows-1250":
        case "x-cp1250":
          return "windows-1250";
        case "cp1251":
        case "windows-1251":
        case "x-cp1251":
          return "windows-1251";
        case "ansi_x3.4-1968":
        case "ascii":
        case "cp1252":
        case "cp819":
        case "csisolatin1":
        case "ibm819":
        case "iso-8859-1":
        case "iso-ir-100":
        case "iso8859-1":
        case "iso88591":
        case "iso_8859-1":
        case "iso_8859-1:1987":
        case "l1":
        case "latin1":
        case "us-ascii":
        case "windows-1252":
        case "x-cp1252":
          return "windows-1252";
        case "cp1253":
        case "windows-1253":
        case "x-cp1253":
          return "windows-1253";
        case "cp1254":
        case "csisolatin5":
        case "iso-8859-9":
        case "iso-ir-148":
        case "iso8859-9":
        case "iso88599":
        case "iso_8859-9":
        case "iso_8859-9:1989":
        case "l5":
        case "latin5":
        case "windows-1254":
        case "x-cp1254":
          return "windows-1254";
        case "cp1255":
        case "windows-1255":
        case "x-cp1255":
          return "windows-1255";
        case "cp1256":
        case "windows-1256":
        case "x-cp1256":
          return "windows-1256";
        case "cp1257":
        case "windows-1257":
        case "x-cp1257":
          return "windows-1257";
        case "cp1258":
        case "windows-1258":
        case "x-cp1258":
          return "windows-1258";
        case "x-mac-cyrillic":
        case "x-mac-ukrainian":
          return "x-mac-cyrillic";
        case "chinese":
        case "csgb2312":
        case "csiso58gb231280":
        case "gb2312":
        case "gb_2312":
        case "gb_2312-80":
        case "gbk":
        case "iso-ir-58":
        case "x-gbk":
          return "GBK";
        case "gb18030":
          return "gb18030";
        case "big5":
        case "big5-hkscs":
        case "cn-big5":
        case "csbig5":
        case "x-x-big5":
          return "Big5";
        case "cseucpkdfmtjapanese":
        case "euc-jp":
        case "x-euc-jp":
          return "EUC-JP";
        case "csiso2022jp":
        case "iso-2022-jp":
          return "ISO-2022-JP";
        case "csshiftjis":
        case "ms932":
        case "ms_kanji":
        case "shift-jis":
        case "shift_jis":
        case "sjis":
        case "windows-31j":
        case "x-sjis":
          return "Shift_JIS";
        case "cseuckr":
        case "csksc56011987":
        case "euc-kr":
        case "iso-ir-149":
        case "korean":
        case "ks_c_5601-1987":
        case "ks_c_5601-1989":
        case "ksc5601":
        case "ksc_5601":
        case "windows-949":
          return "EUC-KR";
        case "csiso2022kr":
        case "hz-gb-2312":
        case "iso-2022-cn":
        case "iso-2022-cn-ext":
        case "iso-2022-kr":
        case "replacement":
          return "replacement";
        case "unicodefffe":
        case "utf-16be":
          return "UTF-16BE";
        case "csunicode":
        case "iso-10646-ucs-2":
        case "ucs-2":
        case "unicode":
        case "unicodefeff":
        case "utf-16":
        case "utf-16le":
          return "UTF-16LE";
        case "x-user-defined":
          return "x-user-defined";
        default:
          return "failure";
      }
    }
    __name(getEncoding, "getEncoding");
    module3.exports = {
      getEncoding
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fileapi/util.js
var require_util4 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fileapi/util.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var {
      kState,
      kError,
      kResult,
      kAborted,
      kLastProgressEventFired
    } = require_symbols3();
    var { ProgressEvent } = require_progressevent();
    var { getEncoding } = require_encoding();
    var { DOMException: DOMException2 } = require_constants();
    var { serializeAMimeType, parseMIMEType } = require_dataURL();
    var { types } = require("util");
    var { StringDecoder: StringDecoder2 } = require("string_decoder");
    var { btoa: btoa2 } = require("buffer");
    var staticPropertyDescriptors = {
      enumerable: true,
      writable: false,
      configurable: false
    };
    function readOperation(fr2, blob, type, encodingName) {
      if (fr2[kState] === "loading") {
        throw new DOMException2("Invalid state", "InvalidStateError");
      }
      fr2[kState] = "loading";
      fr2[kResult] = null;
      fr2[kError] = null;
      const stream2 = blob.stream();
      const reader = stream2.getReader();
      const bytes = [];
      let chunkPromise = reader.read();
      let isFirstChunk = true;
      (async () => {
        while (!fr2[kAborted]) {
          try {
            const { done, value } = await chunkPromise;
            if (isFirstChunk && !fr2[kAborted]) {
              queueMicrotask(() => {
                fireAProgressEvent("loadstart", fr2);
              });
            }
            isFirstChunk = false;
            if (!done && types.isUint8Array(value)) {
              bytes.push(value);
              if ((fr2[kLastProgressEventFired] === void 0 || Date.now() - fr2[kLastProgressEventFired] >= 50) && !fr2[kAborted]) {
                fr2[kLastProgressEventFired] = Date.now();
                queueMicrotask(() => {
                  fireAProgressEvent("progress", fr2);
                });
              }
              chunkPromise = reader.read();
            } else if (done) {
              queueMicrotask(() => {
                fr2[kState] = "done";
                try {
                  const result = packageData(bytes, type, blob.type, encodingName);
                  if (fr2[kAborted]) {
                    return;
                  }
                  fr2[kResult] = result;
                  fireAProgressEvent("load", fr2);
                } catch (error2) {
                  fr2[kError] = error2;
                  fireAProgressEvent("error", fr2);
                }
                if (fr2[kState] !== "loading") {
                  fireAProgressEvent("loadend", fr2);
                }
              });
              break;
            }
          } catch (error2) {
            if (fr2[kAborted]) {
              return;
            }
            queueMicrotask(() => {
              fr2[kState] = "done";
              fr2[kError] = error2;
              fireAProgressEvent("error", fr2);
              if (fr2[kState] !== "loading") {
                fireAProgressEvent("loadend", fr2);
              }
            });
            break;
          }
        }
      })();
    }
    __name(readOperation, "readOperation");
    function fireAProgressEvent(e3, reader) {
      const event = new ProgressEvent(e3, {
        bubbles: false,
        cancelable: false
      });
      reader.dispatchEvent(event);
    }
    __name(fireAProgressEvent, "fireAProgressEvent");
    function packageData(bytes, type, mimeType, encodingName) {
      switch (type) {
        case "DataURL": {
          let dataURL = "data:";
          const parsed = parseMIMEType(mimeType || "application/octet-stream");
          if (parsed !== "failure") {
            dataURL += serializeAMimeType(parsed);
          }
          dataURL += ";base64,";
          const decoder = new StringDecoder2("latin1");
          for (const chunk of bytes) {
            dataURL += btoa2(decoder.write(chunk));
          }
          dataURL += btoa2(decoder.end());
          return dataURL;
        }
        case "Text": {
          let encoding = "failure";
          if (encodingName) {
            encoding = getEncoding(encodingName);
          }
          if (encoding === "failure" && mimeType) {
            const type2 = parseMIMEType(mimeType);
            if (type2 !== "failure") {
              encoding = getEncoding(type2.parameters.get("charset"));
            }
          }
          if (encoding === "failure") {
            encoding = "UTF-8";
          }
          return decode(bytes, encoding);
        }
        case "ArrayBuffer": {
          const sequence = combineByteSequences(bytes);
          return sequence.buffer;
        }
        case "BinaryString": {
          let binaryString = "";
          const decoder = new StringDecoder2("latin1");
          for (const chunk of bytes) {
            binaryString += decoder.write(chunk);
          }
          binaryString += decoder.end();
          return binaryString;
        }
      }
    }
    __name(packageData, "packageData");
    function decode(ioQueue, encoding) {
      const bytes = combineByteSequences(ioQueue);
      const BOMEncoding = BOMSniffing(bytes);
      let slice = 0;
      if (BOMEncoding !== null) {
        encoding = BOMEncoding;
        slice = BOMEncoding === "UTF-8" ? 3 : 2;
      }
      const sliced = bytes.slice(slice);
      return new TextDecoder(encoding).decode(sliced);
    }
    __name(decode, "decode");
    function BOMSniffing(ioQueue) {
      const [a, b2, c2] = ioQueue;
      if (a === 239 && b2 === 187 && c2 === 191) {
        return "UTF-8";
      } else if (a === 254 && b2 === 255) {
        return "UTF-16BE";
      } else if (a === 255 && b2 === 254) {
        return "UTF-16LE";
      }
      return null;
    }
    __name(BOMSniffing, "BOMSniffing");
    function combineByteSequences(sequences) {
      const size = sequences.reduce((a, b2) => {
        return a + b2.byteLength;
      }, 0);
      let offset = 0;
      return sequences.reduce((a, b2) => {
        a.set(b2, offset);
        offset += b2.byteLength;
        return a;
      }, new Uint8Array(size));
    }
    __name(combineByteSequences, "combineByteSequences");
    module3.exports = {
      staticPropertyDescriptors,
      readOperation,
      fireAProgressEvent
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fileapi/filereader.js
var require_filereader = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/fileapi/filereader.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var {
      staticPropertyDescriptors,
      readOperation,
      fireAProgressEvent
    } = require_util4();
    var {
      kState,
      kError,
      kResult,
      kEvents,
      kAborted
    } = require_symbols3();
    var { webidl } = require_webidl();
    var { kEnumerableProperty } = require_util();
    var FileReader = class extends EventTarget {
      constructor() {
        super();
        this[kState] = "empty";
        this[kResult] = null;
        this[kError] = null;
        this[kEvents] = {
          loadend: null,
          error: null,
          abort: null,
          load: null,
          progress: null,
          loadstart: null
        };
      }
      /**
       * @see https://w3c.github.io/FileAPI/#dfn-readAsArrayBuffer
       * @param {import('buffer').Blob} blob
       */
      readAsArrayBuffer(blob) {
        webidl.brandCheck(this, FileReader);
        webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsArrayBuffer" });
        blob = webidl.converters.Blob(blob, { strict: false });
        readOperation(this, blob, "ArrayBuffer");
      }
      /**
       * @see https://w3c.github.io/FileAPI/#readAsBinaryString
       * @param {import('buffer').Blob} blob
       */
      readAsBinaryString(blob) {
        webidl.brandCheck(this, FileReader);
        webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsBinaryString" });
        blob = webidl.converters.Blob(blob, { strict: false });
        readOperation(this, blob, "BinaryString");
      }
      /**
       * @see https://w3c.github.io/FileAPI/#readAsDataText
       * @param {import('buffer').Blob} blob
       * @param {string?} encoding
       */
      readAsText(blob, encoding = void 0) {
        webidl.brandCheck(this, FileReader);
        webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsText" });
        blob = webidl.converters.Blob(blob, { strict: false });
        if (encoding !== void 0) {
          encoding = webidl.converters.DOMString(encoding);
        }
        readOperation(this, blob, "Text", encoding);
      }
      /**
       * @see https://w3c.github.io/FileAPI/#dfn-readAsDataURL
       * @param {import('buffer').Blob} blob
       */
      readAsDataURL(blob) {
        webidl.brandCheck(this, FileReader);
        webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsDataURL" });
        blob = webidl.converters.Blob(blob, { strict: false });
        readOperation(this, blob, "DataURL");
      }
      /**
       * @see https://w3c.github.io/FileAPI/#dfn-abort
       */
      abort() {
        if (this[kState] === "empty" || this[kState] === "done") {
          this[kResult] = null;
          return;
        }
        if (this[kState] === "loading") {
          this[kState] = "done";
          this[kResult] = null;
        }
        this[kAborted] = true;
        fireAProgressEvent("abort", this);
        if (this[kState] !== "loading") {
          fireAProgressEvent("loadend", this);
        }
      }
      /**
       * @see https://w3c.github.io/FileAPI/#dom-filereader-readystate
       */
      get readyState() {
        webidl.brandCheck(this, FileReader);
        switch (this[kState]) {
          case "empty":
            return this.EMPTY;
          case "loading":
            return this.LOADING;
          case "done":
            return this.DONE;
        }
      }
      /**
       * @see https://w3c.github.io/FileAPI/#dom-filereader-result
       */
      get result() {
        webidl.brandCheck(this, FileReader);
        return this[kResult];
      }
      /**
       * @see https://w3c.github.io/FileAPI/#dom-filereader-error
       */
      get error() {
        webidl.brandCheck(this, FileReader);
        return this[kError];
      }
      get onloadend() {
        webidl.brandCheck(this, FileReader);
        return this[kEvents].loadend;
      }
      set onloadend(fn2) {
        webidl.brandCheck(this, FileReader);
        if (this[kEvents].loadend) {
          this.removeEventListener("loadend", this[kEvents].loadend);
        }
        if (typeof fn2 === "function") {
          this[kEvents].loadend = fn2;
          this.addEventListener("loadend", fn2);
        } else {
          this[kEvents].loadend = null;
        }
      }
      get onerror() {
        webidl.brandCheck(this, FileReader);
        return this[kEvents].error;
      }
      set onerror(fn2) {
        webidl.brandCheck(this, FileReader);
        if (this[kEvents].error) {
          this.removeEventListener("error", this[kEvents].error);
        }
        if (typeof fn2 === "function") {
          this[kEvents].error = fn2;
          this.addEventListener("error", fn2);
        } else {
          this[kEvents].error = null;
        }
      }
      get onloadstart() {
        webidl.brandCheck(this, FileReader);
        return this[kEvents].loadstart;
      }
      set onloadstart(fn2) {
        webidl.brandCheck(this, FileReader);
        if (this[kEvents].loadstart) {
          this.removeEventListener("loadstart", this[kEvents].loadstart);
        }
        if (typeof fn2 === "function") {
          this[kEvents].loadstart = fn2;
          this.addEventListener("loadstart", fn2);
        } else {
          this[kEvents].loadstart = null;
        }
      }
      get onprogress() {
        webidl.brandCheck(this, FileReader);
        return this[kEvents].progress;
      }
      set onprogress(fn2) {
        webidl.brandCheck(this, FileReader);
        if (this[kEvents].progress) {
          this.removeEventListener("progress", this[kEvents].progress);
        }
        if (typeof fn2 === "function") {
          this[kEvents].progress = fn2;
          this.addEventListener("progress", fn2);
        } else {
          this[kEvents].progress = null;
        }
      }
      get onload() {
        webidl.brandCheck(this, FileReader);
        return this[kEvents].load;
      }
      set onload(fn2) {
        webidl.brandCheck(this, FileReader);
        if (this[kEvents].load) {
          this.removeEventListener("load", this[kEvents].load);
        }
        if (typeof fn2 === "function") {
          this[kEvents].load = fn2;
          this.addEventListener("load", fn2);
        } else {
          this[kEvents].load = null;
        }
      }
      get onabort() {
        webidl.brandCheck(this, FileReader);
        return this[kEvents].abort;
      }
      set onabort(fn2) {
        webidl.brandCheck(this, FileReader);
        if (this[kEvents].abort) {
          this.removeEventListener("abort", this[kEvents].abort);
        }
        if (typeof fn2 === "function") {
          this[kEvents].abort = fn2;
          this.addEventListener("abort", fn2);
        } else {
          this[kEvents].abort = null;
        }
      }
    };
    __name(FileReader, "FileReader");
    FileReader.EMPTY = FileReader.prototype.EMPTY = 0;
    FileReader.LOADING = FileReader.prototype.LOADING = 1;
    FileReader.DONE = FileReader.prototype.DONE = 2;
    Object.defineProperties(FileReader.prototype, {
      EMPTY: staticPropertyDescriptors,
      LOADING: staticPropertyDescriptors,
      DONE: staticPropertyDescriptors,
      readAsArrayBuffer: kEnumerableProperty,
      readAsBinaryString: kEnumerableProperty,
      readAsText: kEnumerableProperty,
      readAsDataURL: kEnumerableProperty,
      abort: kEnumerableProperty,
      readyState: kEnumerableProperty,
      result: kEnumerableProperty,
      error: kEnumerableProperty,
      onloadstart: kEnumerableProperty,
      onprogress: kEnumerableProperty,
      onload: kEnumerableProperty,
      onabort: kEnumerableProperty,
      onerror: kEnumerableProperty,
      onloadend: kEnumerableProperty,
      [Symbol.toStringTag]: {
        value: "FileReader",
        writable: false,
        enumerable: false,
        configurable: true
      }
    });
    Object.defineProperties(FileReader, {
      EMPTY: staticPropertyDescriptors,
      LOADING: staticPropertyDescriptors,
      DONE: staticPropertyDescriptors
    });
    module3.exports = {
      FileReader
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/cache/symbols.js
var require_symbols4 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/cache/symbols.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = {
      kConstruct: require_symbols().kConstruct
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/cache/util.js
var require_util5 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/cache/util.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var assert27 = require("assert");
    var { URLSerializer } = require_dataURL();
    var { isValidHeaderName } = require_util2();
    function urlEquals(A2, B2, excludeFragment = false) {
      const serializedA = URLSerializer(A2, excludeFragment);
      const serializedB = URLSerializer(B2, excludeFragment);
      return serializedA === serializedB;
    }
    __name(urlEquals, "urlEquals");
    function fieldValues(header) {
      assert27(header !== null);
      const values = [];
      for (let value of header.split(",")) {
        value = value.trim();
        if (!value.length) {
          continue;
        } else if (!isValidHeaderName(value)) {
          continue;
        }
        values.push(value);
      }
      return values;
    }
    __name(fieldValues, "fieldValues");
    module3.exports = {
      urlEquals,
      fieldValues
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/cache/cache.js
var require_cache = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/cache/cache.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { kConstruct } = require_symbols4();
    var { urlEquals, fieldValues: getFieldValues } = require_util5();
    var { kEnumerableProperty, isDisturbed } = require_util();
    var { kHeadersList } = require_symbols();
    var { webidl } = require_webidl();
    var { Response: Response9, cloneResponse } = require_response();
    var { Request: Request3 } = require_request2();
    var { kState, kHeaders, kGuard, kRealm } = require_symbols2();
    var { fetching } = require_fetch();
    var { urlIsHttpHttpsScheme, createDeferredPromise, readAllBytes } = require_util2();
    var assert27 = require("assert");
    var { getGlobalDispatcher: getGlobalDispatcher2 } = require_global2();
    var Cache3 = class {
      /**
       * @see https://w3c.github.io/ServiceWorker/#dfn-relevant-request-response-list
       * @type {requestResponseList}
       */
      #relevantRequestResponseList;
      constructor() {
        if (arguments[0] !== kConstruct) {
          webidl.illegalConstructor();
        }
        this.#relevantRequestResponseList = arguments[1];
      }
      async match(request3, options29 = {}) {
        webidl.brandCheck(this, Cache3);
        webidl.argumentLengthCheck(arguments, 1, { header: "Cache.match" });
        request3 = webidl.converters.RequestInfo(request3);
        options29 = webidl.converters.CacheQueryOptions(options29);
        const p2 = await this.matchAll(request3, options29);
        if (p2.length === 0) {
          return;
        }
        return p2[0];
      }
      async matchAll(request3 = void 0, options29 = {}) {
        webidl.brandCheck(this, Cache3);
        if (request3 !== void 0)
          request3 = webidl.converters.RequestInfo(request3);
        options29 = webidl.converters.CacheQueryOptions(options29);
        let r3 = null;
        if (request3 !== void 0) {
          if (request3 instanceof Request3) {
            r3 = request3[kState];
            if (r3.method !== "GET" && !options29.ignoreMethod) {
              return [];
            }
          } else if (typeof request3 === "string") {
            r3 = new Request3(request3)[kState];
          }
        }
        const responses = [];
        if (request3 === void 0) {
          for (const requestResponse of this.#relevantRequestResponseList) {
            responses.push(requestResponse[1]);
          }
        } else {
          const requestResponses = this.#queryCache(r3, options29);
          for (const requestResponse of requestResponses) {
            responses.push(requestResponse[1]);
          }
        }
        const responseList = [];
        for (const response of responses) {
          const responseObject = new Response9(response.body?.source ?? null);
          const body = responseObject[kState].body;
          responseObject[kState] = response;
          responseObject[kState].body = body;
          responseObject[kHeaders][kHeadersList] = response.headersList;
          responseObject[kHeaders][kGuard] = "immutable";
          responseList.push(responseObject);
        }
        return Object.freeze(responseList);
      }
      async add(request3) {
        webidl.brandCheck(this, Cache3);
        webidl.argumentLengthCheck(arguments, 1, { header: "Cache.add" });
        request3 = webidl.converters.RequestInfo(request3);
        const requests = [request3];
        const responseArrayPromise = this.addAll(requests);
        return await responseArrayPromise;
      }
      async addAll(requests) {
        webidl.brandCheck(this, Cache3);
        webidl.argumentLengthCheck(arguments, 1, { header: "Cache.addAll" });
        requests = webidl.converters["sequence<RequestInfo>"](requests);
        const responsePromises = [];
        const requestList = [];
        for (const request3 of requests) {
          if (typeof request3 === "string") {
            continue;
          }
          const r3 = request3[kState];
          if (!urlIsHttpHttpsScheme(r3.url) || r3.method !== "GET") {
            throw webidl.errors.exception({
              header: "Cache.addAll",
              message: "Expected http/s scheme when method is not GET."
            });
          }
        }
        const fetchControllers = [];
        for (const request3 of requests) {
          const r3 = new Request3(request3)[kState];
          if (!urlIsHttpHttpsScheme(r3.url)) {
            throw webidl.errors.exception({
              header: "Cache.addAll",
              message: "Expected http/s scheme."
            });
          }
          r3.initiator = "fetch";
          r3.destination = "subresource";
          requestList.push(r3);
          const responsePromise = createDeferredPromise();
          fetchControllers.push(fetching({
            request: r3,
            dispatcher: getGlobalDispatcher2(),
            processResponse(response) {
              if (response.type === "error" || response.status === 206 || response.status < 200 || response.status > 299) {
                responsePromise.reject(webidl.errors.exception({
                  header: "Cache.addAll",
                  message: "Received an invalid status code or the request failed."
                }));
              } else if (response.headersList.contains("vary")) {
                const fieldValues = getFieldValues(response.headersList.get("vary"));
                for (const fieldValue of fieldValues) {
                  if (fieldValue === "*") {
                    responsePromise.reject(webidl.errors.exception({
                      header: "Cache.addAll",
                      message: "invalid vary field value"
                    }));
                    for (const controller of fetchControllers) {
                      controller.abort();
                    }
                    return;
                  }
                }
              }
            },
            processResponseEndOfBody(response) {
              if (response.aborted) {
                responsePromise.reject(new DOMException("aborted", "AbortError"));
                return;
              }
              responsePromise.resolve(response);
            }
          }));
          responsePromises.push(responsePromise.promise);
        }
        const p2 = Promise.all(responsePromises);
        const responses = await p2;
        const operations = [];
        let index = 0;
        for (const response of responses) {
          const operation = {
            type: "put",
            // 7.3.2
            request: requestList[index],
            // 7.3.3
            response
            // 7.3.4
          };
          operations.push(operation);
          index++;
        }
        const cacheJobPromise = createDeferredPromise();
        let errorData = null;
        try {
          this.#batchCacheOperations(operations);
        } catch (e3) {
          errorData = e3;
        }
        queueMicrotask(() => {
          if (errorData === null) {
            cacheJobPromise.resolve(void 0);
          } else {
            cacheJobPromise.reject(errorData);
          }
        });
        return cacheJobPromise.promise;
      }
      async put(request3, response) {
        webidl.brandCheck(this, Cache3);
        webidl.argumentLengthCheck(arguments, 2, { header: "Cache.put" });
        request3 = webidl.converters.RequestInfo(request3);
        response = webidl.converters.Response(response);
        let innerRequest = null;
        if (request3 instanceof Request3) {
          innerRequest = request3[kState];
        } else {
          innerRequest = new Request3(request3)[kState];
        }
        if (!urlIsHttpHttpsScheme(innerRequest.url) || innerRequest.method !== "GET") {
          throw webidl.errors.exception({
            header: "Cache.put",
            message: "Expected an http/s scheme when method is not GET"
          });
        }
        const innerResponse = response[kState];
        if (innerResponse.status === 206) {
          throw webidl.errors.exception({
            header: "Cache.put",
            message: "Got 206 status"
          });
        }
        if (innerResponse.headersList.contains("vary")) {
          const fieldValues = getFieldValues(innerResponse.headersList.get("vary"));
          for (const fieldValue of fieldValues) {
            if (fieldValue === "*") {
              throw webidl.errors.exception({
                header: "Cache.put",
                message: "Got * vary field value"
              });
            }
          }
        }
        if (innerResponse.body && (isDisturbed(innerResponse.body.stream) || innerResponse.body.stream.locked)) {
          throw webidl.errors.exception({
            header: "Cache.put",
            message: "Response body is locked or disturbed"
          });
        }
        const clonedResponse = cloneResponse(innerResponse);
        const bodyReadPromise = createDeferredPromise();
        if (innerResponse.body != null) {
          const stream2 = innerResponse.body.stream;
          const reader = stream2.getReader();
          readAllBytes(reader).then(bodyReadPromise.resolve, bodyReadPromise.reject);
        } else {
          bodyReadPromise.resolve(void 0);
        }
        const operations = [];
        const operation = {
          type: "put",
          // 14.
          request: innerRequest,
          // 15.
          response: clonedResponse
          // 16.
        };
        operations.push(operation);
        const bytes = await bodyReadPromise.promise;
        if (clonedResponse.body != null) {
          clonedResponse.body.source = bytes;
        }
        const cacheJobPromise = createDeferredPromise();
        let errorData = null;
        try {
          this.#batchCacheOperations(operations);
        } catch (e3) {
          errorData = e3;
        }
        queueMicrotask(() => {
          if (errorData === null) {
            cacheJobPromise.resolve();
          } else {
            cacheJobPromise.reject(errorData);
          }
        });
        return cacheJobPromise.promise;
      }
      async delete(request3, options29 = {}) {
        webidl.brandCheck(this, Cache3);
        webidl.argumentLengthCheck(arguments, 1, { header: "Cache.delete" });
        request3 = webidl.converters.RequestInfo(request3);
        options29 = webidl.converters.CacheQueryOptions(options29);
        let r3 = null;
        if (request3 instanceof Request3) {
          r3 = request3[kState];
          if (r3.method !== "GET" && !options29.ignoreMethod) {
            return false;
          }
        } else {
          assert27(typeof request3 === "string");
          r3 = new Request3(request3)[kState];
        }
        const operations = [];
        const operation = {
          type: "delete",
          request: r3,
          options: options29
        };
        operations.push(operation);
        const cacheJobPromise = createDeferredPromise();
        let errorData = null;
        let requestResponses;
        try {
          requestResponses = this.#batchCacheOperations(operations);
        } catch (e3) {
          errorData = e3;
        }
        queueMicrotask(() => {
          if (errorData === null) {
            cacheJobPromise.resolve(!!requestResponses?.length);
          } else {
            cacheJobPromise.reject(errorData);
          }
        });
        return cacheJobPromise.promise;
      }
      /**
       * @see https://w3c.github.io/ServiceWorker/#dom-cache-keys
       * @param {any} request
       * @param {import('../../types/cache').CacheQueryOptions} options
       * @returns {readonly Request[]}
       */
      async keys(request3 = void 0, options29 = {}) {
        webidl.brandCheck(this, Cache3);
        if (request3 !== void 0)
          request3 = webidl.converters.RequestInfo(request3);
        options29 = webidl.converters.CacheQueryOptions(options29);
        let r3 = null;
        if (request3 !== void 0) {
          if (request3 instanceof Request3) {
            r3 = request3[kState];
            if (r3.method !== "GET" && !options29.ignoreMethod) {
              return [];
            }
          } else if (typeof request3 === "string") {
            r3 = new Request3(request3)[kState];
          }
        }
        const promise = createDeferredPromise();
        const requests = [];
        if (request3 === void 0) {
          for (const requestResponse of this.#relevantRequestResponseList) {
            requests.push(requestResponse[0]);
          }
        } else {
          const requestResponses = this.#queryCache(r3, options29);
          for (const requestResponse of requestResponses) {
            requests.push(requestResponse[0]);
          }
        }
        queueMicrotask(() => {
          const requestList = [];
          for (const request4 of requests) {
            const requestObject = new Request3("https://a");
            requestObject[kState] = request4;
            requestObject[kHeaders][kHeadersList] = request4.headersList;
            requestObject[kHeaders][kGuard] = "immutable";
            requestObject[kRealm] = request4.client;
            requestList.push(requestObject);
          }
          promise.resolve(Object.freeze(requestList));
        });
        return promise.promise;
      }
      /**
       * @see https://w3c.github.io/ServiceWorker/#batch-cache-operations-algorithm
       * @param {CacheBatchOperation[]} operations
       * @returns {requestResponseList}
       */
      #batchCacheOperations(operations) {
        const cache2 = this.#relevantRequestResponseList;
        const backupCache = [...cache2];
        const addedItems = [];
        const resultList = [];
        try {
          for (const operation of operations) {
            if (operation.type !== "delete" && operation.type !== "put") {
              throw webidl.errors.exception({
                header: "Cache.#batchCacheOperations",
                message: 'operation type does not match "delete" or "put"'
              });
            }
            if (operation.type === "delete" && operation.response != null) {
              throw webidl.errors.exception({
                header: "Cache.#batchCacheOperations",
                message: "delete operation should not have an associated response"
              });
            }
            if (this.#queryCache(operation.request, operation.options, addedItems).length) {
              throw new DOMException("???", "InvalidStateError");
            }
            let requestResponses;
            if (operation.type === "delete") {
              requestResponses = this.#queryCache(operation.request, operation.options);
              if (requestResponses.length === 0) {
                return [];
              }
              for (const requestResponse of requestResponses) {
                const idx = cache2.indexOf(requestResponse);
                assert27(idx !== -1);
                cache2.splice(idx, 1);
              }
            } else if (operation.type === "put") {
              if (operation.response == null) {
                throw webidl.errors.exception({
                  header: "Cache.#batchCacheOperations",
                  message: "put operation should have an associated response"
                });
              }
              const r3 = operation.request;
              if (!urlIsHttpHttpsScheme(r3.url)) {
                throw webidl.errors.exception({
                  header: "Cache.#batchCacheOperations",
                  message: "expected http or https scheme"
                });
              }
              if (r3.method !== "GET") {
                throw webidl.errors.exception({
                  header: "Cache.#batchCacheOperations",
                  message: "not get method"
                });
              }
              if (operation.options != null) {
                throw webidl.errors.exception({
                  header: "Cache.#batchCacheOperations",
                  message: "options must not be defined"
                });
              }
              requestResponses = this.#queryCache(operation.request);
              for (const requestResponse of requestResponses) {
                const idx = cache2.indexOf(requestResponse);
                assert27(idx !== -1);
                cache2.splice(idx, 1);
              }
              cache2.push([operation.request, operation.response]);
              addedItems.push([operation.request, operation.response]);
            }
            resultList.push([operation.request, operation.response]);
          }
          return resultList;
        } catch (e3) {
          this.#relevantRequestResponseList.length = 0;
          this.#relevantRequestResponseList = backupCache;
          throw e3;
        }
      }
      /**
       * @see https://w3c.github.io/ServiceWorker/#query-cache
       * @param {any} requestQuery
       * @param {import('../../types/cache').CacheQueryOptions} options
       * @param {requestResponseList} targetStorage
       * @returns {requestResponseList}
       */
      #queryCache(requestQuery, options29, targetStorage) {
        const resultList = [];
        const storage = targetStorage ?? this.#relevantRequestResponseList;
        for (const requestResponse of storage) {
          const [cachedRequest, cachedResponse] = requestResponse;
          if (this.#requestMatchesCachedItem(requestQuery, cachedRequest, cachedResponse, options29)) {
            resultList.push(requestResponse);
          }
        }
        return resultList;
      }
      /**
       * @see https://w3c.github.io/ServiceWorker/#request-matches-cached-item-algorithm
       * @param {any} requestQuery
       * @param {any} request
       * @param {any | null} response
       * @param {import('../../types/cache').CacheQueryOptions | undefined} options
       * @returns {boolean}
       */
      #requestMatchesCachedItem(requestQuery, request3, response = null, options29) {
        const queryURL = new URL(requestQuery.url);
        const cachedURL = new URL(request3.url);
        if (options29?.ignoreSearch) {
          cachedURL.search = "";
          queryURL.search = "";
        }
        if (!urlEquals(queryURL, cachedURL, true)) {
          return false;
        }
        if (response == null || options29?.ignoreVary || !response.headersList.contains("vary")) {
          return true;
        }
        const fieldValues = getFieldValues(response.headersList.get("vary"));
        for (const fieldValue of fieldValues) {
          if (fieldValue === "*") {
            return false;
          }
          const requestValue = request3.headersList.get(fieldValue);
          const queryValue = requestQuery.headersList.get(fieldValue);
          if (requestValue !== queryValue) {
            return false;
          }
        }
        return true;
      }
    };
    __name(Cache3, "Cache");
    Object.defineProperties(Cache3.prototype, {
      [Symbol.toStringTag]: {
        value: "Cache",
        configurable: true
      },
      match: kEnumerableProperty,
      matchAll: kEnumerableProperty,
      add: kEnumerableProperty,
      addAll: kEnumerableProperty,
      put: kEnumerableProperty,
      delete: kEnumerableProperty,
      keys: kEnumerableProperty
    });
    var cacheQueryOptionConverters = [
      {
        key: "ignoreSearch",
        converter: webidl.converters.boolean,
        defaultValue: false
      },
      {
        key: "ignoreMethod",
        converter: webidl.converters.boolean,
        defaultValue: false
      },
      {
        key: "ignoreVary",
        converter: webidl.converters.boolean,
        defaultValue: false
      }
    ];
    webidl.converters.CacheQueryOptions = webidl.dictionaryConverter(cacheQueryOptionConverters);
    webidl.converters.MultiCacheQueryOptions = webidl.dictionaryConverter([
      ...cacheQueryOptionConverters,
      {
        key: "cacheName",
        converter: webidl.converters.DOMString
      }
    ]);
    webidl.converters.Response = webidl.interfaceConverter(Response9);
    webidl.converters["sequence<RequestInfo>"] = webidl.sequenceConverter(
      webidl.converters.RequestInfo
    );
    module3.exports = {
      Cache: Cache3
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/cache/cachestorage.js
var require_cachestorage = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/cache/cachestorage.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { kConstruct } = require_symbols4();
    var { Cache: Cache3 } = require_cache();
    var { webidl } = require_webidl();
    var { kEnumerableProperty } = require_util();
    var CacheStorage2 = class {
      /**
       * @see https://w3c.github.io/ServiceWorker/#dfn-relevant-name-to-cache-map
       * @type {Map<string, import('./cache').requestResponseList}
       */
      #caches = /* @__PURE__ */ new Map();
      constructor() {
        if (arguments[0] !== kConstruct) {
          webidl.illegalConstructor();
        }
      }
      async match(request3, options29 = {}) {
        webidl.brandCheck(this, CacheStorage2);
        webidl.argumentLengthCheck(arguments, 1, { header: "CacheStorage.match" });
        request3 = webidl.converters.RequestInfo(request3);
        options29 = webidl.converters.MultiCacheQueryOptions(options29);
        if (options29.cacheName != null) {
          if (this.#caches.has(options29.cacheName)) {
            const cacheList = this.#caches.get(options29.cacheName);
            const cache2 = new Cache3(kConstruct, cacheList);
            return await cache2.match(request3, options29);
          }
        } else {
          for (const cacheList of this.#caches.values()) {
            const cache2 = new Cache3(kConstruct, cacheList);
            const response = await cache2.match(request3, options29);
            if (response !== void 0) {
              return response;
            }
          }
        }
      }
      /**
       * @see https://w3c.github.io/ServiceWorker/#cache-storage-has
       * @param {string} cacheName
       * @returns {Promise<boolean>}
       */
      async has(cacheName) {
        webidl.brandCheck(this, CacheStorage2);
        webidl.argumentLengthCheck(arguments, 1, { header: "CacheStorage.has" });
        cacheName = webidl.converters.DOMString(cacheName);
        return this.#caches.has(cacheName);
      }
      /**
       * @see https://w3c.github.io/ServiceWorker/#dom-cachestorage-open
       * @param {string} cacheName
       * @returns {Promise<Cache>}
       */
      async open(cacheName) {
        webidl.brandCheck(this, CacheStorage2);
        webidl.argumentLengthCheck(arguments, 1, { header: "CacheStorage.open" });
        cacheName = webidl.converters.DOMString(cacheName);
        if (this.#caches.has(cacheName)) {
          const cache3 = this.#caches.get(cacheName);
          return new Cache3(kConstruct, cache3);
        }
        const cache2 = [];
        this.#caches.set(cacheName, cache2);
        return new Cache3(kConstruct, cache2);
      }
      /**
       * @see https://w3c.github.io/ServiceWorker/#cache-storage-delete
       * @param {string} cacheName
       * @returns {Promise<boolean>}
       */
      async delete(cacheName) {
        webidl.brandCheck(this, CacheStorage2);
        webidl.argumentLengthCheck(arguments, 1, { header: "CacheStorage.delete" });
        cacheName = webidl.converters.DOMString(cacheName);
        return this.#caches.delete(cacheName);
      }
      /**
       * @see https://w3c.github.io/ServiceWorker/#cache-storage-keys
       * @returns {string[]}
       */
      async keys() {
        webidl.brandCheck(this, CacheStorage2);
        const keys = this.#caches.keys();
        return [...keys];
      }
    };
    __name(CacheStorage2, "CacheStorage");
    Object.defineProperties(CacheStorage2.prototype, {
      [Symbol.toStringTag]: {
        value: "CacheStorage",
        configurable: true
      },
      match: kEnumerableProperty,
      has: kEnumerableProperty,
      open: kEnumerableProperty,
      delete: kEnumerableProperty,
      keys: kEnumerableProperty
    });
    module3.exports = {
      CacheStorage: CacheStorage2
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/cookies/constants.js
var require_constants3 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/cookies/constants.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var maxAttributeValueSize = 1024;
    var maxNameValuePairSize = 4096;
    module3.exports = {
      maxAttributeValueSize,
      maxNameValuePairSize
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/cookies/util.js
var require_util6 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/cookies/util.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var assert27 = require("assert");
    var { kHeadersList } = require_symbols();
    function isCTLExcludingHtab(value) {
      if (value.length === 0) {
        return false;
      }
      for (const char of value) {
        const code = char.charCodeAt(0);
        if (code >= 0 || code <= 8 || (code >= 10 || code <= 31) || code === 127) {
          return false;
        }
      }
    }
    __name(isCTLExcludingHtab, "isCTLExcludingHtab");
    function validateCookieName(name) {
      for (const char of name) {
        const code = char.charCodeAt(0);
        if (code <= 32 || code > 127 || char === "(" || char === ")" || char === ">" || char === "<" || char === "@" || char === "," || char === ";" || char === ":" || char === "\\" || char === '"' || char === "/" || char === "[" || char === "]" || char === "?" || char === "=" || char === "{" || char === "}") {
          throw new Error("Invalid cookie name");
        }
      }
    }
    __name(validateCookieName, "validateCookieName");
    function validateCookieValue(value) {
      for (const char of value) {
        const code = char.charCodeAt(0);
        if (code < 33 || // exclude CTLs (0-31)
        code === 34 || code === 44 || code === 59 || code === 92 || code > 126) {
          throw new Error("Invalid header value");
        }
      }
    }
    __name(validateCookieValue, "validateCookieValue");
    function validateCookiePath(path67) {
      for (const char of path67) {
        const code = char.charCodeAt(0);
        if (code < 33 || char === ";") {
          throw new Error("Invalid cookie path");
        }
      }
    }
    __name(validateCookiePath, "validateCookiePath");
    function validateCookieDomain(domain2) {
      if (domain2.startsWith("-") || domain2.endsWith(".") || domain2.endsWith("-")) {
        throw new Error("Invalid cookie domain");
      }
    }
    __name(validateCookieDomain, "validateCookieDomain");
    function toIMFDate(date) {
      if (typeof date === "number") {
        date = new Date(date);
      }
      const days = [
        "Sun",
        "Mon",
        "Tue",
        "Wed",
        "Thu",
        "Fri",
        "Sat"
      ];
      const months = [
        "Jan",
        "Feb",
        "Mar",
        "Apr",
        "May",
        "Jun",
        "Jul",
        "Aug",
        "Sep",
        "Oct",
        "Nov",
        "Dec"
      ];
      const dayName = days[date.getUTCDay()];
      const day2 = date.getUTCDate().toString().padStart(2, "0");
      const month2 = months[date.getUTCMonth()];
      const year2 = date.getUTCFullYear();
      const hour2 = date.getUTCHours().toString().padStart(2, "0");
      const minute2 = date.getUTCMinutes().toString().padStart(2, "0");
      const second = date.getUTCSeconds().toString().padStart(2, "0");
      return `${dayName}, ${day2} ${month2} ${year2} ${hour2}:${minute2}:${second} GMT`;
    }
    __name(toIMFDate, "toIMFDate");
    function validateCookieMaxAge(maxAge) {
      if (maxAge < 0) {
        throw new Error("Invalid cookie max-age");
      }
    }
    __name(validateCookieMaxAge, "validateCookieMaxAge");
    function stringify(cookie) {
      if (cookie.name.length === 0) {
        return null;
      }
      validateCookieName(cookie.name);
      validateCookieValue(cookie.value);
      const out = [`${cookie.name}=${cookie.value}`];
      if (cookie.name.startsWith("__Secure-")) {
        cookie.secure = true;
      }
      if (cookie.name.startsWith("__Host-")) {
        cookie.secure = true;
        cookie.domain = null;
        cookie.path = "/";
      }
      if (cookie.secure) {
        out.push("Secure");
      }
      if (cookie.httpOnly) {
        out.push("HttpOnly");
      }
      if (typeof cookie.maxAge === "number") {
        validateCookieMaxAge(cookie.maxAge);
        out.push(`Max-Age=${cookie.maxAge}`);
      }
      if (cookie.domain) {
        validateCookieDomain(cookie.domain);
        out.push(`Domain=${cookie.domain}`);
      }
      if (cookie.path) {
        validateCookiePath(cookie.path);
        out.push(`Path=${cookie.path}`);
      }
      if (cookie.expires && cookie.expires.toString() !== "Invalid Date") {
        out.push(`Expires=${toIMFDate(cookie.expires)}`);
      }
      if (cookie.sameSite) {
        out.push(`SameSite=${cookie.sameSite}`);
      }
      for (const part of cookie.unparsed) {
        if (!part.includes("=")) {
          throw new Error("Invalid unparsed");
        }
        const [key, ...value] = part.split("=");
        out.push(`${key.trim()}=${value.join("=")}`);
      }
      return out.join("; ");
    }
    __name(stringify, "stringify");
    var kHeadersListNode;
    function getHeadersList(headers) {
      if (headers[kHeadersList]) {
        return headers[kHeadersList];
      }
      if (!kHeadersListNode) {
        kHeadersListNode = Object.getOwnPropertySymbols(headers).find(
          (symbol) => symbol.description === "headers list"
        );
        assert27(kHeadersListNode, "Headers cannot be parsed");
      }
      const headersList = headers[kHeadersListNode];
      assert27(headersList);
      return headersList;
    }
    __name(getHeadersList, "getHeadersList");
    module3.exports = {
      isCTLExcludingHtab,
      stringify,
      getHeadersList
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/cookies/parse.js
var require_parse = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/cookies/parse.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { maxNameValuePairSize, maxAttributeValueSize } = require_constants3();
    var { isCTLExcludingHtab } = require_util6();
    var { collectASequenceOfCodePointsFast } = require_dataURL();
    var assert27 = require("assert");
    function parseSetCookie(header) {
      if (isCTLExcludingHtab(header)) {
        return null;
      }
      let nameValuePair = "";
      let unparsedAttributes = "";
      let name = "";
      let value = "";
      if (header.includes(";")) {
        const position = { position: 0 };
        nameValuePair = collectASequenceOfCodePointsFast(";", header, position);
        unparsedAttributes = header.slice(position.position);
      } else {
        nameValuePair = header;
      }
      if (!nameValuePair.includes("=")) {
        value = nameValuePair;
      } else {
        const position = { position: 0 };
        name = collectASequenceOfCodePointsFast(
          "=",
          nameValuePair,
          position
        );
        value = nameValuePair.slice(position.position + 1);
      }
      name = name.trim();
      value = value.trim();
      if (name.length + value.length > maxNameValuePairSize) {
        return null;
      }
      return {
        name,
        value,
        ...parseUnparsedAttributes(unparsedAttributes)
      };
    }
    __name(parseSetCookie, "parseSetCookie");
    function parseUnparsedAttributes(unparsedAttributes, cookieAttributeList = {}) {
      if (unparsedAttributes.length === 0) {
        return cookieAttributeList;
      }
      assert27(unparsedAttributes[0] === ";");
      unparsedAttributes = unparsedAttributes.slice(1);
      let cookieAv = "";
      if (unparsedAttributes.includes(";")) {
        cookieAv = collectASequenceOfCodePointsFast(
          ";",
          unparsedAttributes,
          { position: 0 }
        );
        unparsedAttributes = unparsedAttributes.slice(cookieAv.length);
      } else {
        cookieAv = unparsedAttributes;
        unparsedAttributes = "";
      }
      let attributeName = "";
      let attributeValue = "";
      if (cookieAv.includes("=")) {
        const position = { position: 0 };
        attributeName = collectASequenceOfCodePointsFast(
          "=",
          cookieAv,
          position
        );
        attributeValue = cookieAv.slice(position.position + 1);
      } else {
        attributeName = cookieAv;
      }
      attributeName = attributeName.trim();
      attributeValue = attributeValue.trim();
      if (attributeValue.length > maxAttributeValueSize) {
        return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
      }
      const attributeNameLowercase = attributeName.toLowerCase();
      if (attributeNameLowercase === "expires") {
        const expiryTime = new Date(attributeValue);
        cookieAttributeList.expires = expiryTime;
      } else if (attributeNameLowercase === "max-age") {
        const charCode = attributeValue.charCodeAt(0);
        if ((charCode < 48 || charCode > 57) && attributeValue[0] !== "-") {
          return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
        }
        if (!/^\d+$/.test(attributeValue)) {
          return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
        }
        const deltaSeconds = Number(attributeValue);
        cookieAttributeList.maxAge = deltaSeconds;
      } else if (attributeNameLowercase === "domain") {
        let cookieDomain = attributeValue;
        if (cookieDomain[0] === ".") {
          cookieDomain = cookieDomain.slice(1);
        }
        cookieDomain = cookieDomain.toLowerCase();
        cookieAttributeList.domain = cookieDomain;
      } else if (attributeNameLowercase === "path") {
        let cookiePath = "";
        if (attributeValue.length === 0 || attributeValue[0] !== "/") {
          cookiePath = "/";
        } else {
          cookiePath = attributeValue;
        }
        cookieAttributeList.path = cookiePath;
      } else if (attributeNameLowercase === "secure") {
        cookieAttributeList.secure = true;
      } else if (attributeNameLowercase === "httponly") {
        cookieAttributeList.httpOnly = true;
      } else if (attributeNameLowercase === "samesite") {
        let enforcement = "Default";
        const attributeValueLowercase = attributeValue.toLowerCase();
        if (attributeValueLowercase.includes("none")) {
          enforcement = "None";
        }
        if (attributeValueLowercase.includes("strict")) {
          enforcement = "Strict";
        }
        if (attributeValueLowercase.includes("lax")) {
          enforcement = "Lax";
        }
        cookieAttributeList.sameSite = enforcement;
      } else {
        cookieAttributeList.unparsed ??= [];
        cookieAttributeList.unparsed.push(`${attributeName}=${attributeValue}`);
      }
      return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
    }
    __name(parseUnparsedAttributes, "parseUnparsedAttributes");
    module3.exports = {
      parseSetCookie,
      parseUnparsedAttributes
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/cookies/index.js
var require_cookies = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/cookies/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { parseSetCookie } = require_parse();
    var { stringify, getHeadersList } = require_util6();
    var { webidl } = require_webidl();
    var { Headers: Headers5 } = require_headers();
    function getCookies(headers) {
      webidl.argumentLengthCheck(arguments, 1, { header: "getCookies" });
      webidl.brandCheck(headers, Headers5, { strict: false });
      const cookie = headers.get("cookie");
      const out = {};
      if (!cookie) {
        return out;
      }
      for (const piece of cookie.split(";")) {
        const [name, ...value] = piece.split("=");
        out[name.trim()] = value.join("=");
      }
      return out;
    }
    __name(getCookies, "getCookies");
    function deleteCookie(headers, name, attributes) {
      webidl.argumentLengthCheck(arguments, 2, { header: "deleteCookie" });
      webidl.brandCheck(headers, Headers5, { strict: false });
      name = webidl.converters.DOMString(name);
      attributes = webidl.converters.DeleteCookieAttributes(attributes);
      setCookie(headers, {
        name,
        value: "",
        expires: /* @__PURE__ */ new Date(0),
        ...attributes
      });
    }
    __name(deleteCookie, "deleteCookie");
    function getSetCookies(headers) {
      webidl.argumentLengthCheck(arguments, 1, { header: "getSetCookies" });
      webidl.brandCheck(headers, Headers5, { strict: false });
      const cookies = getHeadersList(headers).cookies;
      if (!cookies) {
        return [];
      }
      return cookies.map((pair) => parseSetCookie(Array.isArray(pair) ? pair[1] : pair));
    }
    __name(getSetCookies, "getSetCookies");
    function setCookie(headers, cookie) {
      webidl.argumentLengthCheck(arguments, 2, { header: "setCookie" });
      webidl.brandCheck(headers, Headers5, { strict: false });
      cookie = webidl.converters.Cookie(cookie);
      const str = stringify(cookie);
      if (str) {
        headers.append("Set-Cookie", stringify(cookie));
      }
    }
    __name(setCookie, "setCookie");
    webidl.converters.DeleteCookieAttributes = webidl.dictionaryConverter([
      {
        converter: webidl.nullableConverter(webidl.converters.DOMString),
        key: "path",
        defaultValue: null
      },
      {
        converter: webidl.nullableConverter(webidl.converters.DOMString),
        key: "domain",
        defaultValue: null
      }
    ]);
    webidl.converters.Cookie = webidl.dictionaryConverter([
      {
        converter: webidl.converters.DOMString,
        key: "name"
      },
      {
        converter: webidl.converters.DOMString,
        key: "value"
      },
      {
        converter: webidl.nullableConverter((value) => {
          if (typeof value === "number") {
            return webidl.converters["unsigned long long"](value);
          }
          return new Date(value);
        }),
        key: "expires",
        defaultValue: null
      },
      {
        converter: webidl.nullableConverter(webidl.converters["long long"]),
        key: "maxAge",
        defaultValue: null
      },
      {
        converter: webidl.nullableConverter(webidl.converters.DOMString),
        key: "domain",
        defaultValue: null
      },
      {
        converter: webidl.nullableConverter(webidl.converters.DOMString),
        key: "path",
        defaultValue: null
      },
      {
        converter: webidl.nullableConverter(webidl.converters.boolean),
        key: "secure",
        defaultValue: null
      },
      {
        converter: webidl.nullableConverter(webidl.converters.boolean),
        key: "httpOnly",
        defaultValue: null
      },
      {
        converter: webidl.converters.USVString,
        key: "sameSite",
        allowedValues: ["Strict", "Lax", "None"]
      },
      {
        converter: webidl.sequenceConverter(webidl.converters.DOMString),
        key: "unparsed",
        defaultValue: []
      }
    ]);
    module3.exports = {
      getCookies,
      deleteCookie,
      getSetCookies,
      setCookie
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/websocket/constants.js
var require_constants4 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/websocket/constants.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var uid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
    var staticPropertyDescriptors = {
      enumerable: true,
      writable: false,
      configurable: false
    };
    var states = {
      CONNECTING: 0,
      OPEN: 1,
      CLOSING: 2,
      CLOSED: 3
    };
    var opcodes = {
      CONTINUATION: 0,
      TEXT: 1,
      BINARY: 2,
      CLOSE: 8,
      PING: 9,
      PONG: 10
    };
    var maxUnsigned16Bit = 2 ** 16 - 1;
    var parserStates = {
      INFO: 0,
      PAYLOADLENGTH_16: 2,
      PAYLOADLENGTH_64: 3,
      READ_DATA: 4
    };
    var emptyBuffer = Buffer.allocUnsafe(0);
    module3.exports = {
      uid,
      staticPropertyDescriptors,
      states,
      opcodes,
      maxUnsigned16Bit,
      parserStates,
      emptyBuffer
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/websocket/symbols.js
var require_symbols5 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/websocket/symbols.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = {
      kWebSocketURL: Symbol("url"),
      kReadyState: Symbol("ready state"),
      kController: Symbol("controller"),
      kResponse: Symbol("response"),
      kBinaryType: Symbol("binary type"),
      kSentClose: Symbol("sent close"),
      kReceivedClose: Symbol("received close"),
      kByteParser: Symbol("byte parser")
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/websocket/events.js
var require_events = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/websocket/events.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { webidl } = require_webidl();
    var { kEnumerableProperty } = require_util();
    var { MessagePort } = require("worker_threads");
    var MessageEvent = class extends Event {
      #eventInit;
      constructor(type, eventInitDict = {}) {
        webidl.argumentLengthCheck(arguments, 1, { header: "MessageEvent constructor" });
        type = webidl.converters.DOMString(type);
        eventInitDict = webidl.converters.MessageEventInit(eventInitDict);
        super(type, eventInitDict);
        this.#eventInit = eventInitDict;
      }
      get data() {
        webidl.brandCheck(this, MessageEvent);
        return this.#eventInit.data;
      }
      get origin() {
        webidl.brandCheck(this, MessageEvent);
        return this.#eventInit.origin;
      }
      get lastEventId() {
        webidl.brandCheck(this, MessageEvent);
        return this.#eventInit.lastEventId;
      }
      get source() {
        webidl.brandCheck(this, MessageEvent);
        return this.#eventInit.source;
      }
      get ports() {
        webidl.brandCheck(this, MessageEvent);
        if (!Object.isFrozen(this.#eventInit.ports)) {
          Object.freeze(this.#eventInit.ports);
        }
        return this.#eventInit.ports;
      }
      initMessageEvent(type, bubbles = false, cancelable = false, data = null, origin = "", lastEventId2 = "", source = null, ports = []) {
        webidl.brandCheck(this, MessageEvent);
        webidl.argumentLengthCheck(arguments, 1, { header: "MessageEvent.initMessageEvent" });
        return new MessageEvent(type, {
          bubbles,
          cancelable,
          data,
          origin,
          lastEventId: lastEventId2,
          source,
          ports
        });
      }
    };
    __name(MessageEvent, "MessageEvent");
    var CloseEvent = class extends Event {
      #eventInit;
      constructor(type, eventInitDict = {}) {
        webidl.argumentLengthCheck(arguments, 1, { header: "CloseEvent constructor" });
        type = webidl.converters.DOMString(type);
        eventInitDict = webidl.converters.CloseEventInit(eventInitDict);
        super(type, eventInitDict);
        this.#eventInit = eventInitDict;
      }
      get wasClean() {
        webidl.brandCheck(this, CloseEvent);
        return this.#eventInit.wasClean;
      }
      get code() {
        webidl.brandCheck(this, CloseEvent);
        return this.#eventInit.code;
      }
      get reason() {
        webidl.brandCheck(this, CloseEvent);
        return this.#eventInit.reason;
      }
    };
    __name(CloseEvent, "CloseEvent");
    var ErrorEvent2 = class extends Event {
      #eventInit;
      constructor(type, eventInitDict) {
        webidl.argumentLengthCheck(arguments, 1, { header: "ErrorEvent constructor" });
        super(type, eventInitDict);
        type = webidl.converters.DOMString(type);
        eventInitDict = webidl.converters.ErrorEventInit(eventInitDict ?? {});
        this.#eventInit = eventInitDict;
      }
      get message() {
        webidl.brandCheck(this, ErrorEvent2);
        return this.#eventInit.message;
      }
      get filename() {
        webidl.brandCheck(this, ErrorEvent2);
        return this.#eventInit.filename;
      }
      get lineno() {
        webidl.brandCheck(this, ErrorEvent2);
        return this.#eventInit.lineno;
      }
      get colno() {
        webidl.brandCheck(this, ErrorEvent2);
        return this.#eventInit.colno;
      }
      get error() {
        webidl.brandCheck(this, ErrorEvent2);
        return this.#eventInit.error;
      }
    };
    __name(ErrorEvent2, "ErrorEvent");
    Object.defineProperties(MessageEvent.prototype, {
      [Symbol.toStringTag]: {
        value: "MessageEvent",
        configurable: true
      },
      data: kEnumerableProperty,
      origin: kEnumerableProperty,
      lastEventId: kEnumerableProperty,
      source: kEnumerableProperty,
      ports: kEnumerableProperty,
      initMessageEvent: kEnumerableProperty
    });
    Object.defineProperties(CloseEvent.prototype, {
      [Symbol.toStringTag]: {
        value: "CloseEvent",
        configurable: true
      },
      reason: kEnumerableProperty,
      code: kEnumerableProperty,
      wasClean: kEnumerableProperty
    });
    Object.defineProperties(ErrorEvent2.prototype, {
      [Symbol.toStringTag]: {
        value: "ErrorEvent",
        configurable: true
      },
      message: kEnumerableProperty,
      filename: kEnumerableProperty,
      lineno: kEnumerableProperty,
      colno: kEnumerableProperty,
      error: kEnumerableProperty
    });
    webidl.converters.MessagePort = webidl.interfaceConverter(MessagePort);
    webidl.converters["sequence<MessagePort>"] = webidl.sequenceConverter(
      webidl.converters.MessagePort
    );
    var eventInit = [
      {
        key: "bubbles",
        converter: webidl.converters.boolean,
        defaultValue: false
      },
      {
        key: "cancelable",
        converter: webidl.converters.boolean,
        defaultValue: false
      },
      {
        key: "composed",
        converter: webidl.converters.boolean,
        defaultValue: false
      }
    ];
    webidl.converters.MessageEventInit = webidl.dictionaryConverter([
      ...eventInit,
      {
        key: "data",
        converter: webidl.converters.any,
        defaultValue: null
      },
      {
        key: "origin",
        converter: webidl.converters.USVString,
        defaultValue: ""
      },
      {
        key: "lastEventId",
        converter: webidl.converters.DOMString,
        defaultValue: ""
      },
      {
        key: "source",
        // Node doesn't implement WindowProxy or ServiceWorker, so the only
        // valid value for source is a MessagePort.
        converter: webidl.nullableConverter(webidl.converters.MessagePort),
        defaultValue: null
      },
      {
        key: "ports",
        converter: webidl.converters["sequence<MessagePort>"],
        get defaultValue() {
          return [];
        }
      }
    ]);
    webidl.converters.CloseEventInit = webidl.dictionaryConverter([
      ...eventInit,
      {
        key: "wasClean",
        converter: webidl.converters.boolean,
        defaultValue: false
      },
      {
        key: "code",
        converter: webidl.converters["unsigned short"],
        defaultValue: 0
      },
      {
        key: "reason",
        converter: webidl.converters.USVString,
        defaultValue: ""
      }
    ]);
    webidl.converters.ErrorEventInit = webidl.dictionaryConverter([
      ...eventInit,
      {
        key: "message",
        converter: webidl.converters.DOMString,
        defaultValue: ""
      },
      {
        key: "filename",
        converter: webidl.converters.USVString,
        defaultValue: ""
      },
      {
        key: "lineno",
        converter: webidl.converters["unsigned long"],
        defaultValue: 0
      },
      {
        key: "colno",
        converter: webidl.converters["unsigned long"],
        defaultValue: 0
      },
      {
        key: "error",
        converter: webidl.converters.any
      }
    ]);
    module3.exports = {
      MessageEvent,
      CloseEvent,
      ErrorEvent: ErrorEvent2
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/websocket/util.js
var require_util7 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/websocket/util.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = require_symbols5();
    var { states, opcodes } = require_constants4();
    var { MessageEvent, ErrorEvent: ErrorEvent2 } = require_events();
    function isEstablished(ws) {
      return ws[kReadyState] === states.OPEN;
    }
    __name(isEstablished, "isEstablished");
    function isClosing(ws) {
      return ws[kReadyState] === states.CLOSING;
    }
    __name(isClosing, "isClosing");
    function isClosed(ws) {
      return ws[kReadyState] === states.CLOSED;
    }
    __name(isClosed, "isClosed");
    function fireEvent(e3, target, eventConstructor = Event, eventInitDict) {
      const event = new eventConstructor(e3, eventInitDict);
      target.dispatchEvent(event);
    }
    __name(fireEvent, "fireEvent");
    function websocketMessageReceived(ws, type, data) {
      if (ws[kReadyState] !== states.OPEN) {
        return;
      }
      let dataForEvent;
      if (type === opcodes.TEXT) {
        try {
          dataForEvent = new TextDecoder("utf-8", { fatal: true }).decode(data);
        } catch {
          failWebsocketConnection(ws, "Received invalid UTF-8 in text frame.");
          return;
        }
      } else if (type === opcodes.BINARY) {
        if (ws[kBinaryType] === "blob") {
          dataForEvent = new Blob([data]);
        } else {
          dataForEvent = new Uint8Array(data).buffer;
        }
      }
      fireEvent("message", ws, MessageEvent, {
        origin: ws[kWebSocketURL].origin,
        data: dataForEvent
      });
    }
    __name(websocketMessageReceived, "websocketMessageReceived");
    function isValidSubprotocol(protocol) {
      if (protocol.length === 0) {
        return false;
      }
      for (const char of protocol) {
        const code = char.charCodeAt(0);
        if (code < 33 || code > 126 || char === "(" || char === ")" || char === "<" || char === ">" || char === "@" || char === "," || char === ";" || char === ":" || char === "\\" || char === '"' || char === "/" || char === "[" || char === "]" || char === "?" || char === "=" || char === "{" || char === "}" || code === 32 || // SP
        code === 9) {
          return false;
        }
      }
      return true;
    }
    __name(isValidSubprotocol, "isValidSubprotocol");
    function isValidStatusCode(code) {
      if (code >= 1e3 && code < 1015) {
        return code !== 1004 && // reserved
        code !== 1005 && // "MUST NOT be set as a status code"
        code !== 1006;
      }
      return code >= 3e3 && code <= 4999;
    }
    __name(isValidStatusCode, "isValidStatusCode");
    function failWebsocketConnection(ws, reason) {
      const { [kController]: controller, [kResponse]: response } = ws;
      controller.abort();
      if (response?.socket && !response.socket.destroyed) {
        response.socket.destroy();
      }
      if (reason) {
        fireEvent("error", ws, ErrorEvent2, {
          error: new Error(reason)
        });
      }
    }
    __name(failWebsocketConnection, "failWebsocketConnection");
    module3.exports = {
      isEstablished,
      isClosing,
      isClosed,
      fireEvent,
      isValidSubprotocol,
      isValidStatusCode,
      failWebsocketConnection,
      websocketMessageReceived
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/websocket/connection.js
var require_connection = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/websocket/connection.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var diagnosticsChannel = require("diagnostics_channel");
    var { uid, states } = require_constants4();
    var {
      kReadyState,
      kSentClose,
      kByteParser,
      kReceivedClose
    } = require_symbols5();
    var { fireEvent, failWebsocketConnection } = require_util7();
    var { CloseEvent } = require_events();
    var { makeRequest } = require_request2();
    var { fetching } = require_fetch();
    var { Headers: Headers5 } = require_headers();
    var { getGlobalDispatcher: getGlobalDispatcher2 } = require_global2();
    var { kHeadersList } = require_symbols();
    var channels = {};
    channels.open = diagnosticsChannel.channel("undici:websocket:open");
    channels.close = diagnosticsChannel.channel("undici:websocket:close");
    channels.socketError = diagnosticsChannel.channel("undici:websocket:socket_error");
    var crypto5;
    try {
      crypto5 = require("crypto");
    } catch {
    }
    function establishWebSocketConnection(url4, protocols, ws, onEstablish, options29) {
      const requestURL = url4;
      requestURL.protocol = url4.protocol === "ws:" ? "http:" : "https:";
      const request3 = makeRequest({
        urlList: [requestURL],
        serviceWorkers: "none",
        referrer: "no-referrer",
        mode: "websocket",
        credentials: "include",
        cache: "no-store",
        redirect: "error"
      });
      if (options29.headers) {
        const headersList = new Headers5(options29.headers)[kHeadersList];
        request3.headersList = headersList;
      }
      const keyValue = crypto5.randomBytes(16).toString("base64");
      request3.headersList.append("sec-websocket-key", keyValue);
      request3.headersList.append("sec-websocket-version", "13");
      for (const protocol of protocols) {
        request3.headersList.append("sec-websocket-protocol", protocol);
      }
      const permessageDeflate = "";
      const controller = fetching({
        request: request3,
        useParallelQueue: true,
        dispatcher: options29.dispatcher ?? getGlobalDispatcher2(),
        processResponse(response) {
          if (response.type === "error" || response.status !== 101) {
            failWebsocketConnection(ws, "Received network error or non-101 status code.");
            return;
          }
          if (protocols.length !== 0 && !response.headersList.get("Sec-WebSocket-Protocol")) {
            failWebsocketConnection(ws, "Server did not respond with sent protocols.");
            return;
          }
          if (response.headersList.get("Upgrade")?.toLowerCase() !== "websocket") {
            failWebsocketConnection(ws, 'Server did not set Upgrade header to "websocket".');
            return;
          }
          if (response.headersList.get("Connection")?.toLowerCase() !== "upgrade") {
            failWebsocketConnection(ws, 'Server did not set Connection header to "upgrade".');
            return;
          }
          const secWSAccept = response.headersList.get("Sec-WebSocket-Accept");
          const digest = crypto5.createHash("sha1").update(keyValue + uid).digest("base64");
          if (secWSAccept !== digest) {
            failWebsocketConnection(ws, "Incorrect hash received in Sec-WebSocket-Accept header.");
            return;
          }
          const secExtension = response.headersList.get("Sec-WebSocket-Extensions");
          if (secExtension !== null && secExtension !== permessageDeflate) {
            failWebsocketConnection(ws, "Received different permessage-deflate than the one set.");
            return;
          }
          const secProtocol = response.headersList.get("Sec-WebSocket-Protocol");
          if (secProtocol !== null && secProtocol !== request3.headersList.get("Sec-WebSocket-Protocol")) {
            failWebsocketConnection(ws, "Protocol was not set in the opening handshake.");
            return;
          }
          response.socket.on("data", onSocketData);
          response.socket.on("close", onSocketClose);
          response.socket.on("error", onSocketError);
          if (channels.open.hasSubscribers) {
            channels.open.publish({
              address: response.socket.address(),
              protocol: secProtocol,
              extensions: secExtension
            });
          }
          onEstablish(response);
        }
      });
      return controller;
    }
    __name(establishWebSocketConnection, "establishWebSocketConnection");
    function onSocketData(chunk) {
      if (!this.ws[kByteParser].write(chunk)) {
        this.pause();
      }
    }
    __name(onSocketData, "onSocketData");
    function onSocketClose() {
      const { ws } = this;
      const wasClean = ws[kSentClose] && ws[kReceivedClose];
      let code = 1005;
      let reason = "";
      const result = ws[kByteParser].closingInfo;
      if (result) {
        code = result.code ?? 1005;
        reason = result.reason;
      } else if (!ws[kSentClose]) {
        code = 1006;
      }
      ws[kReadyState] = states.CLOSED;
      fireEvent("close", ws, CloseEvent, {
        wasClean,
        code,
        reason
      });
      if (channels.close.hasSubscribers) {
        channels.close.publish({
          websocket: ws,
          code,
          reason
        });
      }
    }
    __name(onSocketClose, "onSocketClose");
    function onSocketError(error2) {
      const { ws } = this;
      ws[kReadyState] = states.CLOSING;
      if (channels.socketError.hasSubscribers) {
        channels.socketError.publish(error2);
      }
      this.destroy();
    }
    __name(onSocketError, "onSocketError");
    module3.exports = {
      establishWebSocketConnection
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/websocket/frame.js
var require_frame = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/websocket/frame.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { maxUnsigned16Bit } = require_constants4();
    var crypto5;
    try {
      crypto5 = require("crypto");
    } catch {
    }
    var WebsocketFrameSend = class {
      /**
       * @param {Buffer|undefined} data
       */
      constructor(data) {
        this.frameData = data;
        this.maskKey = crypto5.randomBytes(4);
      }
      createFrame(opcode) {
        const bodyLength = this.frameData?.byteLength ?? 0;
        let payloadLength = bodyLength;
        let offset = 6;
        if (bodyLength > maxUnsigned16Bit) {
          offset += 8;
          payloadLength = 127;
        } else if (bodyLength > 125) {
          offset += 2;
          payloadLength = 126;
        }
        const buffer = Buffer.allocUnsafe(bodyLength + offset);
        buffer[0] = buffer[1] = 0;
        buffer[0] |= 128;
        buffer[0] = (buffer[0] & 240) + opcode;
        buffer[offset - 4] = this.maskKey[0];
        buffer[offset - 3] = this.maskKey[1];
        buffer[offset - 2] = this.maskKey[2];
        buffer[offset - 1] = this.maskKey[3];
        buffer[1] = payloadLength;
        if (payloadLength === 126) {
          buffer.writeUInt16BE(bodyLength, 2);
        } else if (payloadLength === 127) {
          buffer[2] = buffer[3] = 0;
          buffer.writeUIntBE(bodyLength, 4, 6);
        }
        buffer[1] |= 128;
        for (let i = 0; i < bodyLength; i++) {
          buffer[offset + i] = this.frameData[i] ^ this.maskKey[i % 4];
        }
        return buffer;
      }
    };
    __name(WebsocketFrameSend, "WebsocketFrameSend");
    module3.exports = {
      WebsocketFrameSend
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/websocket/receiver.js
var require_receiver = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/websocket/receiver.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { Writable } = require("stream");
    var diagnosticsChannel = require("diagnostics_channel");
    var { parserStates, opcodes, states, emptyBuffer } = require_constants4();
    var { kReadyState, kSentClose, kResponse, kReceivedClose } = require_symbols5();
    var { isValidStatusCode, failWebsocketConnection, websocketMessageReceived } = require_util7();
    var { WebsocketFrameSend } = require_frame();
    var channels = {};
    channels.ping = diagnosticsChannel.channel("undici:websocket:ping");
    channels.pong = diagnosticsChannel.channel("undici:websocket:pong");
    var ByteParser = class extends Writable {
      #buffers = [];
      #byteOffset = 0;
      #state = parserStates.INFO;
      #info = {};
      #fragments = [];
      constructor(ws) {
        super();
        this.ws = ws;
      }
      /**
       * @param {Buffer} chunk
       * @param {() => void} callback
       */
      _write(chunk, _3, callback) {
        this.#buffers.push(chunk);
        this.#byteOffset += chunk.length;
        this.run(callback);
      }
      /**
       * Runs whenever a new chunk is received.
       * Callback is called whenever there are no more chunks buffering,
       * or not enough bytes are buffered to parse.
       */
      run(callback) {
        while (true) {
          if (this.#state === parserStates.INFO) {
            if (this.#byteOffset < 2) {
              return callback();
            }
            const buffer = this.consume(2);
            this.#info.fin = (buffer[0] & 128) !== 0;
            this.#info.opcode = buffer[0] & 15;
            this.#info.originalOpcode ??= this.#info.opcode;
            this.#info.fragmented = !this.#info.fin && this.#info.opcode !== opcodes.CONTINUATION;
            if (this.#info.fragmented && this.#info.opcode !== opcodes.BINARY && this.#info.opcode !== opcodes.TEXT) {
              failWebsocketConnection(this.ws, "Invalid frame type was fragmented.");
              return;
            }
            const payloadLength = buffer[1] & 127;
            if (payloadLength <= 125) {
              this.#info.payloadLength = payloadLength;
              this.#state = parserStates.READ_DATA;
            } else if (payloadLength === 126) {
              this.#state = parserStates.PAYLOADLENGTH_16;
            } else if (payloadLength === 127) {
              this.#state = parserStates.PAYLOADLENGTH_64;
            }
            if (this.#info.fragmented && payloadLength > 125) {
              failWebsocketConnection(this.ws, "Fragmented frame exceeded 125 bytes.");
              return;
            } else if ((this.#info.opcode === opcodes.PING || this.#info.opcode === opcodes.PONG || this.#info.opcode === opcodes.CLOSE) && payloadLength > 125) {
              failWebsocketConnection(this.ws, "Payload length for control frame exceeded 125 bytes.");
              return;
            } else if (this.#info.opcode === opcodes.CLOSE) {
              if (payloadLength === 1) {
                failWebsocketConnection(this.ws, "Received close frame with a 1-byte body.");
                return;
              }
              const body = this.consume(payloadLength);
              this.#info.closeInfo = this.parseCloseBody(false, body);
              if (!this.ws[kSentClose]) {
                const body2 = Buffer.allocUnsafe(2);
                body2.writeUInt16BE(this.#info.closeInfo.code, 0);
                const closeFrame = new WebsocketFrameSend(body2);
                this.ws[kResponse].socket.write(
                  closeFrame.createFrame(opcodes.CLOSE),
                  (err) => {
                    if (!err) {
                      this.ws[kSentClose] = true;
                    }
                  }
                );
              }
              this.ws[kReadyState] = states.CLOSING;
              this.ws[kReceivedClose] = true;
              this.end();
              return;
            } else if (this.#info.opcode === opcodes.PING) {
              const body = this.consume(payloadLength);
              if (!this.ws[kReceivedClose]) {
                const frame = new WebsocketFrameSend(body);
                this.ws[kResponse].socket.write(frame.createFrame(opcodes.PONG));
                if (channels.ping.hasSubscribers) {
                  channels.ping.publish({
                    payload: body
                  });
                }
              }
              this.#state = parserStates.INFO;
              if (this.#byteOffset > 0) {
                continue;
              } else {
                callback();
                return;
              }
            } else if (this.#info.opcode === opcodes.PONG) {
              const body = this.consume(payloadLength);
              if (channels.pong.hasSubscribers) {
                channels.pong.publish({
                  payload: body
                });
              }
              if (this.#byteOffset > 0) {
                continue;
              } else {
                callback();
                return;
              }
            }
          } else if (this.#state === parserStates.PAYLOADLENGTH_16) {
            if (this.#byteOffset < 2) {
              return callback();
            }
            const buffer = this.consume(2);
            this.#info.payloadLength = buffer.readUInt16BE(0);
            this.#state = parserStates.READ_DATA;
          } else if (this.#state === parserStates.PAYLOADLENGTH_64) {
            if (this.#byteOffset < 8) {
              return callback();
            }
            const buffer = this.consume(8);
            const upper = buffer.readUInt32BE(0);
            if (upper > 2 ** 31 - 1) {
              failWebsocketConnection(this.ws, "Received payload length > 2^31 bytes.");
              return;
            }
            const lower = buffer.readUInt32BE(4);
            this.#info.payloadLength = (upper << 8) + lower;
            this.#state = parserStates.READ_DATA;
          } else if (this.#state === parserStates.READ_DATA) {
            if (this.#byteOffset < this.#info.payloadLength) {
              return callback();
            } else if (this.#byteOffset >= this.#info.payloadLength) {
              const body = this.consume(this.#info.payloadLength);
              this.#fragments.push(body);
              if (!this.#info.fragmented || this.#info.fin && this.#info.opcode === opcodes.CONTINUATION) {
                const fullMessage = Buffer.concat(this.#fragments);
                websocketMessageReceived(this.ws, this.#info.originalOpcode, fullMessage);
                this.#info = {};
                this.#fragments.length = 0;
              }
              this.#state = parserStates.INFO;
            }
          }
          if (this.#byteOffset > 0) {
            continue;
          } else {
            callback();
            break;
          }
        }
      }
      /**
       * Take n bytes from the buffered Buffers
       * @param {number} n
       * @returns {Buffer|null}
       */
      consume(n2) {
        if (n2 > this.#byteOffset) {
          return null;
        } else if (n2 === 0) {
          return emptyBuffer;
        }
        if (this.#buffers[0].length === n2) {
          this.#byteOffset -= this.#buffers[0].length;
          return this.#buffers.shift();
        }
        const buffer = Buffer.allocUnsafe(n2);
        let offset = 0;
        while (offset !== n2) {
          const next = this.#buffers[0];
          const { length } = next;
          if (length + offset === n2) {
            buffer.set(this.#buffers.shift(), offset);
            break;
          } else if (length + offset > n2) {
            buffer.set(next.subarray(0, n2 - offset), offset);
            this.#buffers[0] = next.subarray(n2 - offset);
            break;
          } else {
            buffer.set(this.#buffers.shift(), offset);
            offset += next.length;
          }
        }
        this.#byteOffset -= n2;
        return buffer;
      }
      parseCloseBody(onlyCode, data) {
        let code;
        if (data.length >= 2) {
          code = data.readUInt16BE(0);
        }
        if (onlyCode) {
          if (!isValidStatusCode(code)) {
            return null;
          }
          return { code };
        }
        let reason = data.subarray(2);
        if (reason[0] === 239 && reason[1] === 187 && reason[2] === 191) {
          reason = reason.subarray(3);
        }
        if (code !== void 0 && !isValidStatusCode(code)) {
          return null;
        }
        try {
          reason = new TextDecoder("utf-8", { fatal: true }).decode(reason);
        } catch {
          return null;
        }
        return { code, reason };
      }
      get closingInfo() {
        return this.#info.closeInfo;
      }
    };
    __name(ByteParser, "ByteParser");
    module3.exports = {
      ByteParser
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/websocket/websocket.js
var require_websocket = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/lib/websocket/websocket.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { webidl } = require_webidl();
    var { DOMException: DOMException2 } = require_constants();
    var { URLSerializer } = require_dataURL();
    var { getGlobalOrigin } = require_global();
    var { staticPropertyDescriptors, states, opcodes, emptyBuffer } = require_constants4();
    var {
      kWebSocketURL,
      kReadyState,
      kController,
      kBinaryType,
      kResponse,
      kSentClose,
      kByteParser
    } = require_symbols5();
    var { isEstablished, isClosing, isValidSubprotocol, failWebsocketConnection, fireEvent } = require_util7();
    var { establishWebSocketConnection } = require_connection();
    var { WebsocketFrameSend } = require_frame();
    var { ByteParser } = require_receiver();
    var { kEnumerableProperty, isBlobLike } = require_util();
    var { getGlobalDispatcher: getGlobalDispatcher2 } = require_global2();
    var { types } = require("util");
    var experimentalWarned = false;
    var WebSocket3 = class extends EventTarget {
      #events = {
        open: null,
        error: null,
        close: null,
        message: null
      };
      #bufferedAmount = 0;
      #protocol = "";
      #extensions = "";
      /**
       * @param {string} url
       * @param {string|string[]} protocols
       */
      constructor(url4, protocols = []) {
        super();
        webidl.argumentLengthCheck(arguments, 1, { header: "WebSocket constructor" });
        if (!experimentalWarned) {
          experimentalWarned = true;
          process.emitWarning("WebSockets are experimental, expect them to change at any time.", {
            code: "UNDICI-WS"
          });
        }
        const options29 = webidl.converters["DOMString or sequence<DOMString> or WebSocketInit"](protocols);
        url4 = webidl.converters.USVString(url4);
        protocols = options29.protocols;
        const baseURL = getGlobalOrigin();
        let urlRecord;
        try {
          urlRecord = new URL(url4, baseURL);
        } catch (e3) {
          throw new DOMException2(e3, "SyntaxError");
        }
        if (urlRecord.protocol === "http:") {
          urlRecord.protocol = "ws:";
        } else if (urlRecord.protocol === "https:") {
          urlRecord.protocol = "wss:";
        }
        if (urlRecord.protocol !== "ws:" && urlRecord.protocol !== "wss:") {
          throw new DOMException2(
            `Expected a ws: or wss: protocol, got ${urlRecord.protocol}`,
            "SyntaxError"
          );
        }
        if (urlRecord.hash || urlRecord.href.endsWith("#")) {
          throw new DOMException2("Got fragment", "SyntaxError");
        }
        if (typeof protocols === "string") {
          protocols = [protocols];
        }
        if (protocols.length !== new Set(protocols.map((p2) => p2.toLowerCase())).size) {
          throw new DOMException2("Invalid Sec-WebSocket-Protocol value", "SyntaxError");
        }
        if (protocols.length > 0 && !protocols.every((p2) => isValidSubprotocol(p2))) {
          throw new DOMException2("Invalid Sec-WebSocket-Protocol value", "SyntaxError");
        }
        this[kWebSocketURL] = new URL(urlRecord.href);
        this[kController] = establishWebSocketConnection(
          urlRecord,
          protocols,
          this,
          (response) => this.#onConnectionEstablished(response),
          options29
        );
        this[kReadyState] = WebSocket3.CONNECTING;
        this[kBinaryType] = "blob";
      }
      /**
       * @see https://websockets.spec.whatwg.org/#dom-websocket-close
       * @param {number|undefined} code
       * @param {string|undefined} reason
       */
      close(code = void 0, reason = void 0) {
        webidl.brandCheck(this, WebSocket3);
        if (code !== void 0) {
          code = webidl.converters["unsigned short"](code, { clamp: true });
        }
        if (reason !== void 0) {
          reason = webidl.converters.USVString(reason);
        }
        if (code !== void 0) {
          if (code !== 1e3 && (code < 3e3 || code > 4999)) {
            throw new DOMException2("invalid code", "InvalidAccessError");
          }
        }
        let reasonByteLength = 0;
        if (reason !== void 0) {
          reasonByteLength = Buffer.byteLength(reason);
          if (reasonByteLength > 123) {
            throw new DOMException2(
              `Reason must be less than 123 bytes; received ${reasonByteLength}`,
              "SyntaxError"
            );
          }
        }
        if (this[kReadyState] === WebSocket3.CLOSING || this[kReadyState] === WebSocket3.CLOSED) {
        } else if (!isEstablished(this)) {
          failWebsocketConnection(this, "Connection was closed before it was established.");
          this[kReadyState] = WebSocket3.CLOSING;
        } else if (!isClosing(this)) {
          const frame = new WebsocketFrameSend();
          if (code !== void 0 && reason === void 0) {
            frame.frameData = Buffer.allocUnsafe(2);
            frame.frameData.writeUInt16BE(code, 0);
          } else if (code !== void 0 && reason !== void 0) {
            frame.frameData = Buffer.allocUnsafe(2 + reasonByteLength);
            frame.frameData.writeUInt16BE(code, 0);
            frame.frameData.write(reason, 2, "utf-8");
          } else {
            frame.frameData = emptyBuffer;
          }
          const socket = this[kResponse].socket;
          socket.write(frame.createFrame(opcodes.CLOSE), (err) => {
            if (!err) {
              this[kSentClose] = true;
            }
          });
          this[kReadyState] = states.CLOSING;
        } else {
          this[kReadyState] = WebSocket3.CLOSING;
        }
      }
      /**
       * @see https://websockets.spec.whatwg.org/#dom-websocket-send
       * @param {NodeJS.TypedArray|ArrayBuffer|Blob|string} data
       */
      send(data) {
        webidl.brandCheck(this, WebSocket3);
        webidl.argumentLengthCheck(arguments, 1, { header: "WebSocket.send" });
        data = webidl.converters.WebSocketSendData(data);
        if (this[kReadyState] === WebSocket3.CONNECTING) {
          throw new DOMException2("Sent before connected.", "InvalidStateError");
        }
        if (!isEstablished(this) || isClosing(this)) {
          return;
        }
        const socket = this[kResponse].socket;
        if (typeof data === "string") {
          const value = Buffer.from(data);
          const frame = new WebsocketFrameSend(value);
          const buffer = frame.createFrame(opcodes.TEXT);
          this.#bufferedAmount += value.byteLength;
          socket.write(buffer, () => {
            this.#bufferedAmount -= value.byteLength;
          });
        } else if (types.isArrayBuffer(data)) {
          const value = Buffer.from(data);
          const frame = new WebsocketFrameSend(value);
          const buffer = frame.createFrame(opcodes.BINARY);
          this.#bufferedAmount += value.byteLength;
          socket.write(buffer, () => {
            this.#bufferedAmount -= value.byteLength;
          });
        } else if (ArrayBuffer.isView(data)) {
          const ab = Buffer.from(data, data.byteOffset, data.byteLength);
          const frame = new WebsocketFrameSend(ab);
          const buffer = frame.createFrame(opcodes.BINARY);
          this.#bufferedAmount += ab.byteLength;
          socket.write(buffer, () => {
            this.#bufferedAmount -= ab.byteLength;
          });
        } else if (isBlobLike(data)) {
          const frame = new WebsocketFrameSend();
          data.arrayBuffer().then((ab) => {
            const value = Buffer.from(ab);
            frame.frameData = value;
            const buffer = frame.createFrame(opcodes.BINARY);
            this.#bufferedAmount += value.byteLength;
            socket.write(buffer, () => {
              this.#bufferedAmount -= value.byteLength;
            });
          });
        }
      }
      get readyState() {
        webidl.brandCheck(this, WebSocket3);
        return this[kReadyState];
      }
      get bufferedAmount() {
        webidl.brandCheck(this, WebSocket3);
        return this.#bufferedAmount;
      }
      get url() {
        webidl.brandCheck(this, WebSocket3);
        return URLSerializer(this[kWebSocketURL]);
      }
      get extensions() {
        webidl.brandCheck(this, WebSocket3);
        return this.#extensions;
      }
      get protocol() {
        webidl.brandCheck(this, WebSocket3);
        return this.#protocol;
      }
      get onopen() {
        webidl.brandCheck(this, WebSocket3);
        return this.#events.open;
      }
      set onopen(fn2) {
        webidl.brandCheck(this, WebSocket3);
        if (this.#events.open) {
          this.removeEventListener("open", this.#events.open);
        }
        if (typeof fn2 === "function") {
          this.#events.open = fn2;
          this.addEventListener("open", fn2);
        } else {
          this.#events.open = null;
        }
      }
      get onerror() {
        webidl.brandCheck(this, WebSocket3);
        return this.#events.error;
      }
      set onerror(fn2) {
        webidl.brandCheck(this, WebSocket3);
        if (this.#events.error) {
          this.removeEventListener("error", this.#events.error);
        }
        if (typeof fn2 === "function") {
          this.#events.error = fn2;
          this.addEventListener("error", fn2);
        } else {
          this.#events.error = null;
        }
      }
      get onclose() {
        webidl.brandCheck(this, WebSocket3);
        return this.#events.close;
      }
      set onclose(fn2) {
        webidl.brandCheck(this, WebSocket3);
        if (this.#events.close) {
          this.removeEventListener("close", this.#events.close);
        }
        if (typeof fn2 === "function") {
          this.#events.close = fn2;
          this.addEventListener("close", fn2);
        } else {
          this.#events.close = null;
        }
      }
      get onmessage() {
        webidl.brandCheck(this, WebSocket3);
        return this.#events.message;
      }
      set onmessage(fn2) {
        webidl.brandCheck(this, WebSocket3);
        if (this.#events.message) {
          this.removeEventListener("message", this.#events.message);
        }
        if (typeof fn2 === "function") {
          this.#events.message = fn2;
          this.addEventListener("message", fn2);
        } else {
          this.#events.message = null;
        }
      }
      get binaryType() {
        webidl.brandCheck(this, WebSocket3);
        return this[kBinaryType];
      }
      set binaryType(type) {
        webidl.brandCheck(this, WebSocket3);
        if (type !== "blob" && type !== "arraybuffer") {
          this[kBinaryType] = "blob";
        } else {
          this[kBinaryType] = type;
        }
      }
      /**
       * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
       */
      #onConnectionEstablished(response) {
        this[kResponse] = response;
        const parser2 = new ByteParser(this);
        parser2.on("drain", /* @__PURE__ */ __name(function onParserDrain() {
          this.ws[kResponse].socket.resume();
        }, "onParserDrain"));
        response.socket.ws = this;
        this[kByteParser] = parser2;
        this[kReadyState] = states.OPEN;
        const extensions = response.headersList.get("sec-websocket-extensions");
        if (extensions !== null) {
          this.#extensions = extensions;
        }
        const protocol = response.headersList.get("sec-websocket-protocol");
        if (protocol !== null) {
          this.#protocol = protocol;
        }
        fireEvent("open", this);
      }
    };
    __name(WebSocket3, "WebSocket");
    WebSocket3.CONNECTING = WebSocket3.prototype.CONNECTING = states.CONNECTING;
    WebSocket3.OPEN = WebSocket3.prototype.OPEN = states.OPEN;
    WebSocket3.CLOSING = WebSocket3.prototype.CLOSING = states.CLOSING;
    WebSocket3.CLOSED = WebSocket3.prototype.CLOSED = states.CLOSED;
    Object.defineProperties(WebSocket3.prototype, {
      CONNECTING: staticPropertyDescriptors,
      OPEN: staticPropertyDescriptors,
      CLOSING: staticPropertyDescriptors,
      CLOSED: staticPropertyDescriptors,
      url: kEnumerableProperty,
      readyState: kEnumerableProperty,
      bufferedAmount: kEnumerableProperty,
      onopen: kEnumerableProperty,
      onerror: kEnumerableProperty,
      onclose: kEnumerableProperty,
      close: kEnumerableProperty,
      onmessage: kEnumerableProperty,
      binaryType: kEnumerableProperty,
      send: kEnumerableProperty,
      extensions: kEnumerableProperty,
      protocol: kEnumerableProperty,
      [Symbol.toStringTag]: {
        value: "WebSocket",
        writable: false,
        enumerable: false,
        configurable: true
      }
    });
    Object.defineProperties(WebSocket3, {
      CONNECTING: staticPropertyDescriptors,
      OPEN: staticPropertyDescriptors,
      CLOSING: staticPropertyDescriptors,
      CLOSED: staticPropertyDescriptors
    });
    webidl.converters["sequence<DOMString>"] = webidl.sequenceConverter(
      webidl.converters.DOMString
    );
    webidl.converters["DOMString or sequence<DOMString>"] = function(V2) {
      if (webidl.util.Type(V2) === "Object" && Symbol.iterator in V2) {
        return webidl.converters["sequence<DOMString>"](V2);
      }
      return webidl.converters.DOMString(V2);
    };
    webidl.converters.WebSocketInit = webidl.dictionaryConverter([
      {
        key: "protocols",
        converter: webidl.converters["DOMString or sequence<DOMString>"],
        get defaultValue() {
          return [];
        }
      },
      {
        key: "dispatcher",
        converter: (V2) => V2,
        get defaultValue() {
          return getGlobalDispatcher2();
        }
      },
      {
        key: "headers",
        converter: webidl.nullableConverter(webidl.converters.HeadersInit)
      }
    ]);
    webidl.converters["DOMString or sequence<DOMString> or WebSocketInit"] = function(V2) {
      if (webidl.util.Type(V2) === "Object" && !(Symbol.iterator in V2)) {
        return webidl.converters.WebSocketInit(V2);
      }
      return { protocols: webidl.converters["DOMString or sequence<DOMString>"](V2) };
    };
    webidl.converters.WebSocketSendData = function(V2) {
      if (webidl.util.Type(V2) === "Object") {
        if (isBlobLike(V2)) {
          return webidl.converters.Blob(V2, { strict: false });
        }
        if (ArrayBuffer.isView(V2) || types.isAnyArrayBuffer(V2)) {
          return webidl.converters.BufferSource(V2);
        }
      }
      return webidl.converters.USVString(V2);
    };
    module3.exports = {
      WebSocket: WebSocket3
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/index.js
var require_undici = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.3/node_modules/undici/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var Client = require_client();
    var Dispatcher2 = require_dispatcher();
    var errors = require_errors();
    var Pool = require_pool();
    var BalancedPool = require_balanced_pool();
    var Agent = require_agent();
    var util4 = require_util();
    var { InvalidArgumentError } = errors;
    var api = require_api();
    var buildConnector = require_connect();
    var MockClient = require_mock_client();
    var MockAgent = require_mock_agent();
    var MockPool = require_mock_pool();
    var mockErrors = require_mock_errors();
    var ProxyAgent2 = require_proxy_agent();
    var RetryHandler = require_RetryHandler();
    var { getGlobalDispatcher: getGlobalDispatcher2, setGlobalDispatcher: setGlobalDispatcher2 } = require_global2();
    var DecoratorHandler = require_DecoratorHandler();
    var RedirectHandler = require_RedirectHandler();
    var createRedirectInterceptor = require_redirectInterceptor();
    var hasCrypto;
    try {
      require("crypto");
      hasCrypto = true;
    } catch {
      hasCrypto = false;
    }
    Object.assign(Dispatcher2.prototype, api);
    module3.exports.Dispatcher = Dispatcher2;
    module3.exports.Client = Client;
    module3.exports.Pool = Pool;
    module3.exports.BalancedPool = BalancedPool;
    module3.exports.Agent = Agent;
    module3.exports.ProxyAgent = ProxyAgent2;
    module3.exports.RetryHandler = RetryHandler;
    module3.exports.DecoratorHandler = DecoratorHandler;
    module3.exports.RedirectHandler = RedirectHandler;
    module3.exports.createRedirectInterceptor = createRedirectInterceptor;
    module3.exports.buildConnector = buildConnector;
    module3.exports.errors = errors;
    function makeDispatcher(fn2) {
      return (url4, opts, handler30) => {
        if (typeof opts === "function") {
          handler30 = opts;
          opts = null;
        }
        if (!url4 || typeof url4 !== "string" && typeof url4 !== "object" && !(url4 instanceof URL)) {
          throw new InvalidArgumentError("invalid url");
        }
        if (opts != null && typeof opts !== "object") {
          throw new InvalidArgumentError("invalid opts");
        }
        if (opts && opts.path != null) {
          if (typeof opts.path !== "string") {
            throw new InvalidArgumentError("invalid opts.path");
          }
          let path67 = opts.path;
          if (!opts.path.startsWith("/")) {
            path67 = `/${path67}`;
          }
          url4 = new URL(util4.parseOrigin(url4).origin + path67);
        } else {
          if (!opts) {
            opts = typeof url4 === "object" ? url4 : {};
          }
          url4 = util4.parseURL(url4);
        }
        const { agent, dispatcher = getGlobalDispatcher2() } = opts;
        if (agent) {
          throw new InvalidArgumentError("unsupported opts.agent. Did you mean opts.client?");
        }
        return fn2.call(dispatcher, {
          ...opts,
          origin: url4.origin,
          path: url4.search ? `${url4.pathname}${url4.search}` : url4.pathname,
          method: opts.method || (opts.body ? "PUT" : "GET")
        }, handler30);
      };
    }
    __name(makeDispatcher, "makeDispatcher");
    module3.exports.setGlobalDispatcher = setGlobalDispatcher2;
    module3.exports.getGlobalDispatcher = getGlobalDispatcher2;
    if (util4.nodeMajor > 16 || util4.nodeMajor === 16 && util4.nodeMinor >= 8) {
      let fetchImpl = null;
      module3.exports.fetch = /* @__PURE__ */ __name(async function fetch15(resource) {
        if (!fetchImpl) {
          fetchImpl = require_fetch().fetch;
        }
        try {
          return await fetchImpl(...arguments);
        } catch (err) {
          if (typeof err === "object") {
            Error.captureStackTrace(err, this);
          }
          throw err;
        }
      }, "fetch");
      module3.exports.Headers = require_headers().Headers;
      module3.exports.Response = require_response().Response;
      module3.exports.Request = require_request2().Request;
      module3.exports.FormData = require_formdata().FormData;
      module3.exports.File = require_file().File;
      module3.exports.FileReader = require_filereader().FileReader;
      const { setGlobalOrigin, getGlobalOrigin } = require_global();
      module3.exports.setGlobalOrigin = setGlobalOrigin;
      module3.exports.getGlobalOrigin = getGlobalOrigin;
      const { CacheStorage: CacheStorage2 } = require_cachestorage();
      const { kConstruct } = require_symbols4();
      module3.exports.caches = new CacheStorage2(kConstruct);
    }
    if (util4.nodeMajor >= 16) {
      const { deleteCookie, getCookies, getSetCookies, setCookie } = require_cookies();
      module3.exports.deleteCookie = deleteCookie;
      module3.exports.getCookies = getCookies;
      module3.exports.getSetCookies = getSetCookies;
      module3.exports.setCookie = setCookie;
      const { parseMIMEType, serializeAMimeType } = require_dataURL();
      module3.exports.parseMIMEType = parseMIMEType;
      module3.exports.serializeAMimeType = serializeAMimeType;
    }
    if (util4.nodeMajor >= 18 && hasCrypto) {
      const { WebSocket: WebSocket3 } = require_websocket();
      module3.exports.WebSocket = WebSocket3;
    }
    module3.exports.request = makeDispatcher(api.request);
    module3.exports.stream = makeDispatcher(api.stream);
    module3.exports.pipeline = makeDispatcher(api.pipeline);
    module3.exports.connect = makeDispatcher(api.connect);
    module3.exports.upgrade = makeDispatcher(api.upgrade);
    module3.exports.MockClient = MockClient;
    module3.exports.MockPool = MockPool;
    module3.exports.MockAgent = MockAgent;
    module3.exports.mockErrors = mockErrors;
  }
});

// ../../node_modules/.pnpm/@webcontainer+env@1.1.0/node_modules/@webcontainer/env/dist/index.js
var require_dist = __commonJS({
  "../../node_modules/.pnpm/@webcontainer+env@1.1.0/node_modules/@webcontainer/env/dist/index.js"(exports2, module3) {
    init_import_meta_url();
    var c2 = Object.defineProperty;
    var g2 = Object.getOwnPropertyDescriptor;
    var y2 = Object.getOwnPropertyNames;
    var d2 = Object.prototype.hasOwnProperty;
    var a = /* @__PURE__ */ __name((e3, t3) => c2(e3, "name", { value: t3, configurable: true }), "a");
    var b2 = /* @__PURE__ */ __name((e3, t3) => {
      for (var o2 in t3)
        c2(e3, o2, { get: t3[o2], enumerable: true });
    }, "b");
    var P2 = /* @__PURE__ */ __name((e3, t3, o2, u) => {
      if (t3 && typeof t3 == "object" || typeof t3 == "function")
        for (let s of y2(t3))
          !d2.call(e3, s) && s !== o2 && c2(e3, s, { get: () => t3[s], enumerable: !(u = g2(t3, s)) || u.enumerable });
      return e3;
    }, "P");
    var U2 = /* @__PURE__ */ __name((e3) => P2(c2({}, "__esModule", { value: true }), e3), "U");
    var x2 = {};
    b2(x2, { HostURL: () => n2, isWebContainer: () => h2 });
    module3.exports = U2(x2);
    var r3;
    try {
      r3 = require("@blitz/internal/env");
    } catch (e3) {
    }
    function h2() {
      return r3 != null && process.versions.webcontainer != null;
    }
    __name(h2, "h");
    a(h2, "isWebContainer");
    function p2(e3) {
      let t3 = r3 == null ? void 0 : r3.createServiceHostname(e3);
      if (!t3)
        throw new Error("Failed to construct service hostname");
      return t3;
    }
    __name(p2, "p");
    a(p2, "_createServiceHostname");
    function f(e3) {
      return r3 == null ? void 0 : r3.isServiceUrl(e3);
    }
    __name(f, "f");
    a(f, "_isServiceUrl");
    function l2(e3) {
      return r3 == null ? void 0 : r3.isLocalhost(e3);
    }
    __name(l2, "l");
    a(l2, "_isLocalhost");
    var n2 = /* @__PURE__ */ __name(class {
      constructor(t3) {
        this._url = t3;
        if (this._port = this._url.port, h2() && l2(this._url.hostname)) {
          let o2 = p2(this._port);
          this._url.host = o2, this._port === this._url.port && (this._url.port = "");
        }
      }
      static parse(t3) {
        return t3 = typeof t3 == "string" ? new URL(t3) : t3, new n2(t3);
      }
      get port() {
        return h2() ? this._port : this._url.port;
      }
      get hash() {
        return this._url.hash;
      }
      get host() {
        return this._url.host;
      }
      get hostname() {
        return this._url.hostname;
      }
      get href() {
        return this._url.href;
      }
      get origin() {
        return this._url.origin;
      }
      get username() {
        return this._url.username;
      }
      get password() {
        return this._url.password;
      }
      get pathname() {
        return this._url.pathname;
      }
      get protocol() {
        return this._url.protocol;
      }
      get search() {
        return this._url.search;
      }
      get searchParams() {
        return this._url.searchParams;
      }
      update(t3) {
        var u;
        let o2 = h2();
        for (let s in t3) {
          let i = (u = t3[s]) != null ? u : "";
          if (o2)
            switch (s) {
              case "port": {
                if (this._port = i, (l2(this._url.hostname) || f(this._url.hostname)) && (this._url.host = p2(i), this._port !== this._url.port))
                  continue;
                break;
              }
              case "host": {
                let [m2, _3 = this._port] = i.split(":");
                this._port = _3, l2(m2) && (i = p2(_3));
                break;
              }
              case "hostname": {
                if (l2(i)) {
                  if (/\/|:/.test(i))
                    continue;
                  i = p2(this._port);
                } else
                  this._url.port = this._port;
                break;
              }
              case "href": {
                this._url = n2.parse(i);
                continue;
              }
            }
          this._url[s] = i;
        }
        return this;
      }
      toString() {
        return this._url.toString();
      }
      toJSON() {
        return this._url.toJSON();
      }
    }, "n");
    a(n2, "HostURL");
  }
});

// ../../node_modules/.pnpm/object-assign@4.1.1/node_modules/object-assign/index.js
var require_object_assign = __commonJS({
  "../../node_modules/.pnpm/object-assign@4.1.1/node_modules/object-assign/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var getOwnPropertySymbols = Object.getOwnPropertySymbols;
    var hasOwnProperty2 = 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);
    }
    __name(toObject, "toObject");
    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(n2) {
          return test2[n2];
        });
        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;
      }
    }
    __name(shouldUseNative, "shouldUseNative");
    module3.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 (hasOwnProperty2.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/.pnpm/react@17.0.2/node_modules/react/cjs/react.production.min.js
var require_react_production_min = __commonJS({
  "../../node_modules/.pnpm/react@17.0.2/node_modules/react/cjs/react.production.min.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var l2 = require_object_assign();
    var n2 = 60103;
    var p2 = 60106;
    exports2.Fragment = 60107;
    exports2.StrictMode = 60108;
    exports2.Profiler = 60114;
    var q2 = 60109;
    var r3 = 60110;
    var t3 = 60112;
    exports2.Suspense = 60113;
    var u = 60115;
    var v2 = 60116;
    if ("function" === typeof Symbol && Symbol.for) {
      w2 = Symbol.for;
      n2 = w2("react.element");
      p2 = w2("react.portal");
      exports2.Fragment = w2("react.fragment");
      exports2.StrictMode = w2("react.strict_mode");
      exports2.Profiler = w2("react.profiler");
      q2 = w2("react.provider");
      r3 = w2("react.context");
      t3 = w2("react.forward_ref");
      exports2.Suspense = w2("react.suspense");
      u = w2("react.memo");
      v2 = w2("react.lazy");
    }
    var w2;
    var x2 = "function" === typeof Symbol && Symbol.iterator;
    function y2(a) {
      if (null === a || "object" !== typeof a)
        return null;
      a = x2 && a[x2] || a["@@iterator"];
      return "function" === typeof a ? a : null;
    }
    __name(y2, "y");
    function z2(a) {
      for (var b2 = "https://reactjs.org/docs/error-decoder.html?invariant=" + a, c2 = 1; c2 < arguments.length; c2++)
        b2 += "&args[]=" + encodeURIComponent(arguments[c2]);
      return "Minified React error #" + a + "; visit " + b2 + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
    }
    __name(z2, "z");
    var A2 = { isMounted: function() {
      return false;
    }, enqueueForceUpdate: function() {
    }, enqueueReplaceState: function() {
    }, enqueueSetState: function() {
    } };
    var B2 = {};
    function C2(a, b2, c2) {
      this.props = a;
      this.context = b2;
      this.refs = B2;
      this.updater = c2 || A2;
    }
    __name(C2, "C");
    C2.prototype.isReactComponent = {};
    C2.prototype.setState = function(a, b2) {
      if ("object" !== typeof a && "function" !== typeof a && null != a)
        throw Error(z2(85));
      this.updater.enqueueSetState(this, a, b2, "setState");
    };
    C2.prototype.forceUpdate = function(a) {
      this.updater.enqueueForceUpdate(this, a, "forceUpdate");
    };
    function D() {
    }
    __name(D, "D");
    D.prototype = C2.prototype;
    function E2(a, b2, c2) {
      this.props = a;
      this.context = b2;
      this.refs = B2;
      this.updater = c2 || A2;
    }
    __name(E2, "E");
    var F = E2.prototype = new D();
    F.constructor = E2;
    l2(F, C2.prototype);
    F.isPureReactComponent = true;
    var G2 = { current: null };
    var H2 = Object.prototype.hasOwnProperty;
    var I2 = { key: true, ref: true, __self: true, __source: true };
    function J2(a, b2, c2) {
      var e3, d2 = {}, k2 = null, h2 = null;
      if (null != b2)
        for (e3 in void 0 !== b2.ref && (h2 = b2.ref), void 0 !== b2.key && (k2 = "" + b2.key), b2)
          H2.call(b2, e3) && !I2.hasOwnProperty(e3) && (d2[e3] = b2[e3]);
      var g2 = arguments.length - 2;
      if (1 === g2)
        d2.children = c2;
      else if (1 < g2) {
        for (var f = Array(g2), m2 = 0; m2 < g2; m2++)
          f[m2] = arguments[m2 + 2];
        d2.children = f;
      }
      if (a && a.defaultProps)
        for (e3 in g2 = a.defaultProps, g2)
          void 0 === d2[e3] && (d2[e3] = g2[e3]);
      return { $$typeof: n2, type: a, key: k2, ref: h2, props: d2, _owner: G2.current };
    }
    __name(J2, "J");
    function K2(a, b2) {
      return { $$typeof: n2, type: a.type, key: b2, ref: a.ref, props: a.props, _owner: a._owner };
    }
    __name(K2, "K");
    function L2(a) {
      return "object" === typeof a && null !== a && a.$$typeof === n2;
    }
    __name(L2, "L");
    function escape2(a) {
      var b2 = { "=": "=0", ":": "=2" };
      return "$" + a.replace(/[=:]/g, function(a2) {
        return b2[a2];
      });
    }
    __name(escape2, "escape");
    var M2 = /\/+/g;
    function N2(a, b2) {
      return "object" === typeof a && null !== a && null != a.key ? escape2("" + a.key) : b2.toString(36);
    }
    __name(N2, "N");
    function O2(a, b2, c2, e3, d2) {
      var k2 = typeof a;
      if ("undefined" === k2 || "boolean" === k2)
        a = null;
      var h2 = false;
      if (null === a)
        h2 = true;
      else
        switch (k2) {
          case "string":
          case "number":
            h2 = true;
            break;
          case "object":
            switch (a.$$typeof) {
              case n2:
              case p2:
                h2 = true;
            }
        }
      if (h2)
        return h2 = a, d2 = d2(h2), a = "" === e3 ? "." + N2(h2, 0) : e3, Array.isArray(d2) ? (c2 = "", null != a && (c2 = a.replace(M2, "$&/") + "/"), O2(d2, b2, c2, "", function(a2) {
          return a2;
        })) : null != d2 && (L2(d2) && (d2 = K2(d2, c2 + (!d2.key || h2 && h2.key === d2.key ? "" : ("" + d2.key).replace(M2, "$&/") + "/") + a)), b2.push(d2)), 1;
      h2 = 0;
      e3 = "" === e3 ? "." : e3 + ":";
      if (Array.isArray(a))
        for (var g2 = 0; g2 < a.length; g2++) {
          k2 = a[g2];
          var f = e3 + N2(k2, g2);
          h2 += O2(k2, b2, c2, f, d2);
        }
      else if (f = y2(a), "function" === typeof f)
        for (a = f.call(a), g2 = 0; !(k2 = a.next()).done; )
          k2 = k2.value, f = e3 + N2(k2, g2++), h2 += O2(k2, b2, c2, f, d2);
      else if ("object" === k2)
        throw b2 = "" + a, Error(z2(31, "[object Object]" === b2 ? "object with keys {" + Object.keys(a).join(", ") + "}" : b2));
      return h2;
    }
    __name(O2, "O");
    function P2(a, b2, c2) {
      if (null == a)
        return a;
      var e3 = [], d2 = 0;
      O2(a, e3, "", "", function(a2) {
        return b2.call(c2, a2, d2++);
      });
      return e3;
    }
    __name(P2, "P");
    function Q3(a) {
      if (-1 === a._status) {
        var b2 = a._result;
        b2 = b2();
        a._status = 0;
        a._result = b2;
        b2.then(function(b3) {
          0 === a._status && (b3 = b3.default, a._status = 1, a._result = b3);
        }, function(b3) {
          0 === a._status && (a._status = 2, a._result = b3);
        });
      }
      if (1 === a._status)
        return a._result;
      throw a._result;
    }
    __name(Q3, "Q");
    var R2 = { current: null };
    function S2() {
      var a = R2.current;
      if (null === a)
        throw Error(z2(321));
      return a;
    }
    __name(S2, "S");
    var T2 = { ReactCurrentDispatcher: R2, ReactCurrentBatchConfig: { transition: 0 }, ReactCurrentOwner: G2, IsSomeRendererActing: { current: false }, assign: l2 };
    exports2.Children = { map: P2, forEach: function(a, b2, c2) {
      P2(a, function() {
        b2.apply(this, arguments);
      }, c2);
    }, count: function(a) {
      var b2 = 0;
      P2(a, function() {
        b2++;
      });
      return b2;
    }, toArray: function(a) {
      return P2(a, function(a2) {
        return a2;
      }) || [];
    }, only: function(a) {
      if (!L2(a))
        throw Error(z2(143));
      return a;
    } };
    exports2.Component = C2;
    exports2.PureComponent = E2;
    exports2.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = T2;
    exports2.cloneElement = function(a, b2, c2) {
      if (null === a || void 0 === a)
        throw Error(z2(267, a));
      var e3 = l2({}, a.props), d2 = a.key, k2 = a.ref, h2 = a._owner;
      if (null != b2) {
        void 0 !== b2.ref && (k2 = b2.ref, h2 = G2.current);
        void 0 !== b2.key && (d2 = "" + b2.key);
        if (a.type && a.type.defaultProps)
          var g2 = a.type.defaultProps;
        for (f in b2)
          H2.call(b2, f) && !I2.hasOwnProperty(f) && (e3[f] = void 0 === b2[f] && void 0 !== g2 ? g2[f] : b2[f]);
      }
      var f = arguments.length - 2;
      if (1 === f)
        e3.children = c2;
      else if (1 < f) {
        g2 = Array(f);
        for (var m2 = 0; m2 < f; m2++)
          g2[m2] = arguments[m2 + 2];
        e3.children = g2;
      }
      return {
        $$typeof: n2,
        type: a.type,
        key: d2,
        ref: k2,
        props: e3,
        _owner: h2
      };
    };
    exports2.createContext = function(a, b2) {
      void 0 === b2 && (b2 = null);
      a = { $$typeof: r3, _calculateChangedBits: b2, _currentValue: a, _currentValue2: a, _threadCount: 0, Provider: null, Consumer: null };
      a.Provider = { $$typeof: q2, _context: a };
      return a.Consumer = a;
    };
    exports2.createElement = J2;
    exports2.createFactory = function(a) {
      var b2 = J2.bind(null, a);
      b2.type = a;
      return b2;
    };
    exports2.createRef = function() {
      return { current: null };
    };
    exports2.forwardRef = function(a) {
      return { $$typeof: t3, render: a };
    };
    exports2.isValidElement = L2;
    exports2.lazy = function(a) {
      return { $$typeof: v2, _payload: { _status: -1, _result: a }, _init: Q3 };
    };
    exports2.memo = function(a, b2) {
      return { $$typeof: u, type: a, compare: void 0 === b2 ? null : b2 };
    };
    exports2.useCallback = function(a, b2) {
      return S2().useCallback(a, b2);
    };
    exports2.useContext = function(a, b2) {
      return S2().useContext(a, b2);
    };
    exports2.useDebugValue = function() {
    };
    exports2.useEffect = function(a, b2) {
      return S2().useEffect(a, b2);
    };
    exports2.useImperativeHandle = function(a, b2, c2) {
      return S2().useImperativeHandle(a, b2, c2);
    };
    exports2.useLayoutEffect = function(a, b2) {
      return S2().useLayoutEffect(a, b2);
    };
    exports2.useMemo = function(a, b2) {
      return S2().useMemo(a, b2);
    };
    exports2.useReducer = function(a, b2, c2) {
      return S2().useReducer(a, b2, c2);
    };
    exports2.useRef = function(a) {
      return S2().useRef(a);
    };
    exports2.useState = function(a) {
      return S2().useState(a);
    };
    exports2.version = "17.0.2";
  }
});

// ../../node_modules/.pnpm/react@17.0.2/node_modules/react/index.js
var require_react = __commonJS({
  "../../node_modules/.pnpm/react@17.0.2/node_modules/react/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    if (true) {
      module3.exports = require_react_production_min();
    } else {
      module3.exports = null;
    }
  }
});

// ../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/lodash.js
var require_lodash = __commonJS({
  "../../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/lodash.js"(exports2, module3) {
    init_import_meta_url();
    (function() {
      var undefined2;
      var VERSION = "4.17.21";
      var LARGE_ARRAY_SIZE = 200;
      var CORE_ERROR_TEXT = "Unsupported core-js use. Try https://npms.io/search?q=ponyfill.", FUNC_ERROR_TEXT = "Expected a function", INVALID_TEMPL_VAR_ERROR_TEXT = "Invalid `variable` option passed into `_.template`";
      var HASH_UNDEFINED = "__lodash_hash_undefined__";
      var MAX_MEMOIZE_SIZE = 500;
      var PLACEHOLDER = "__lodash_placeholder__";
      var CLONE_DEEP_FLAG = 1, CLONE_FLAT_FLAG = 2, CLONE_SYMBOLS_FLAG = 4;
      var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
      var WRAP_BIND_FLAG = 1, WRAP_BIND_KEY_FLAG = 2, WRAP_CURRY_BOUND_FLAG = 4, WRAP_CURRY_FLAG = 8, WRAP_CURRY_RIGHT_FLAG = 16, WRAP_PARTIAL_FLAG = 32, WRAP_PARTIAL_RIGHT_FLAG = 64, WRAP_ARY_FLAG = 128, WRAP_REARG_FLAG = 256, WRAP_FLIP_FLAG = 512;
      var DEFAULT_TRUNC_LENGTH = 30, DEFAULT_TRUNC_OMISSION = "...";
      var HOT_COUNT = 800, HOT_SPAN = 16;
      var LAZY_FILTER_FLAG = 1, LAZY_MAP_FLAG = 2, LAZY_WHILE_FLAG = 3;
      var INFINITY2 = 1 / 0, MAX_SAFE_INTEGER = 9007199254740991, MAX_INTEGER = 17976931348623157e292, NAN = 0 / 0;
      var MAX_ARRAY_LENGTH = 4294967295, MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1, HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;
      var wrapFlags = [
        ["ary", WRAP_ARY_FLAG],
        ["bind", WRAP_BIND_FLAG],
        ["bindKey", WRAP_BIND_KEY_FLAG],
        ["curry", WRAP_CURRY_FLAG],
        ["curryRight", WRAP_CURRY_RIGHT_FLAG],
        ["flip", WRAP_FLIP_FLAG],
        ["partial", WRAP_PARTIAL_FLAG],
        ["partialRight", WRAP_PARTIAL_RIGHT_FLAG],
        ["rearg", WRAP_REARG_FLAG]
      ];
      var argsTag = "[object Arguments]", arrayTag = "[object Array]", asyncTag = "[object AsyncFunction]", boolTag = "[object Boolean]", dateTag = "[object Date]", domExcTag = "[object DOMException]", errorTag = "[object Error]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", mapTag = "[object Map]", numberTag = "[object Number]", nullTag = "[object Null]", objectTag = "[object Object]", promiseTag = "[object Promise]", proxyTag = "[object Proxy]", regexpTag = "[object RegExp]", setTag2 = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]", undefinedTag = "[object Undefined]", weakMapTag = "[object WeakMap]", weakSetTag = "[object WeakSet]";
      var 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]";
      var reEmptyStringLeading = /\b__p \+= '';/g, reEmptyStringMiddle = /\b(__p \+=) '' \+/g, reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
      var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g, reUnescapedHtml = /[&<>"']/g, reHasEscapedHtml = RegExp(reEscapedHtml.source), reHasUnescapedHtml = RegExp(reUnescapedHtml.source);
      var reEscape = /<%-([\s\S]+?)%>/g, reEvaluate = /<%([\s\S]+?)%>/g, reInterpolate = /<%=([\s\S]+?)%>/g;
      var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/, rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
      var reRegExpChar = /[\\^$.*+?()[\]{}|]/g, reHasRegExpChar = RegExp(reRegExpChar.source);
      var reTrimStart = /^\s+/;
      var reWhitespace = /\s/;
      var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/, reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/, reSplitDetails = /,? & /;
      var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
      var reForbiddenIdentifierChars = /[()=,{}\[\]\/\s]/;
      var reEscapeChar = /\\(\\)?/g;
      var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;
      var reFlags = /\w*$/;
      var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
      var reIsBinary = /^0b[01]+$/i;
      var reIsHostCtor = /^\[object .+?Constructor\]$/;
      var reIsOctal = /^0o[0-7]+$/i;
      var reIsUint = /^(?:0|[1-9]\d*)$/;
      var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
      var reNoMatch = /($^)/;
      var reUnescapedString = /['\n\r\u2028\u2029\\]/g;
      var rsAstralRange = "\\ud800-\\udfff", rsComboMarksRange = "\\u0300-\\u036f", reComboHalfMarksRange = "\\ufe20-\\ufe2f", rsComboSymbolsRange = "\\u20d0-\\u20ff", rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, rsDingbatRange = "\\u2700-\\u27bf", rsLowerRange = "a-z\\xdf-\\xf6\\xf8-\\xff", rsMathOpRange = "\\xac\\xb1\\xd7\\xf7", rsNonCharRange = "\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf", rsPunctuationRange = "\\u2000-\\u206f", rsSpaceRange = " \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000", rsUpperRange = "A-Z\\xc0-\\xd6\\xd8-\\xde", rsVarRange = "\\ufe0e\\ufe0f", rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
      var rsApos = "['\u2019]", rsAstral = "[" + rsAstralRange + "]", rsBreak = "[" + rsBreakRange + "]", rsCombo = "[" + rsComboRange + "]", rsDigits = "\\d+", rsDingbat = "[" + rsDingbatRange + "]", rsLower = "[" + rsLowerRange + "]", rsMisc = "[^" + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + "]", rsFitz = "\\ud83c[\\udffb-\\udfff]", rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")", rsNonAstral = "[^" + rsAstralRange + "]", rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}", rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]", rsUpper = "[" + rsUpperRange + "]", rsZWJ = "\\u200d";
      var rsMiscLower = "(?:" + rsLower + "|" + rsMisc + ")", rsMiscUpper = "(?:" + rsUpper + "|" + rsMisc + ")", rsOptContrLower = "(?:" + rsApos + "(?:d|ll|m|re|s|t|ve))?", rsOptContrUpper = "(?:" + rsApos + "(?:D|LL|M|RE|S|T|VE))?", reOptMod = rsModifier + "?", rsOptVar = "[" + rsVarRange + "]?", rsOptJoin = "(?:" + rsZWJ + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*", rsOrdLower = "\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])", rsOrdUpper = "\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])", rsSeq = rsOptVar + reOptMod + rsOptJoin, rsEmoji = "(?:" + [rsDingbat, rsRegional, rsSurrPair].join("|") + ")" + rsSeq, rsSymbol = "(?:" + [rsNonAstral + rsCombo + "?", rsCombo, rsRegional, rsSurrPair, rsAstral].join("|") + ")";
      var reApos = RegExp(rsApos, "g");
      var reComboMark = RegExp(rsCombo, "g");
      var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
      var reUnicodeWord = RegExp([
        rsUpper + "?" + rsLower + "+" + rsOptContrLower + "(?=" + [rsBreak, rsUpper, "$"].join("|") + ")",
        rsMiscUpper + "+" + rsOptContrUpper + "(?=" + [rsBreak, rsUpper + rsMiscLower, "$"].join("|") + ")",
        rsUpper + "?" + rsMiscLower + "+" + rsOptContrLower,
        rsUpper + "+" + rsOptContrUpper,
        rsOrdUpper,
        rsOrdLower,
        rsDigits,
        rsEmoji
      ].join("|"), "g");
      var reHasUnicode = RegExp("[" + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + "]");
      var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
      var contextProps = [
        "Array",
        "Buffer",
        "DataView",
        "Date",
        "Error",
        "Float32Array",
        "Float64Array",
        "Function",
        "Int8Array",
        "Int16Array",
        "Int32Array",
        "Map",
        "Math",
        "Object",
        "Promise",
        "RegExp",
        "Set",
        "String",
        "Symbol",
        "TypeError",
        "Uint8Array",
        "Uint8ClampedArray",
        "Uint16Array",
        "Uint32Array",
        "WeakMap",
        "_",
        "clearTimeout",
        "isFinite",
        "parseInt",
        "setTimeout"
      ];
      var templateCounter = -1;
      var typedArrayTags = {};
      typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
      typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag2] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
      var cloneableTags = {};
      cloneableTags[argsTag] = cloneableTags[arrayTag] = cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = cloneableTags[boolTag] = cloneableTags[dateTag] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag] = cloneableTags[numberTag] = cloneableTags[objectTag] = cloneableTags[regexpTag] = cloneableTags[setTag2] = cloneableTags[stringTag] = cloneableTags[symbolTag] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
      cloneableTags[errorTag] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = false;
      var deburredLetters = {
        // Latin-1 Supplement block.
        "\xC0": "A",
        "\xC1": "A",
        "\xC2": "A",
        "\xC3": "A",
        "\xC4": "A",
        "\xC5": "A",
        "\xE0": "a",
        "\xE1": "a",
        "\xE2": "a",
        "\xE3": "a",
        "\xE4": "a",
        "\xE5": "a",
        "\xC7": "C",
        "\xE7": "c",
        "\xD0": "D",
        "\xF0": "d",
        "\xC8": "E",
        "\xC9": "E",
        "\xCA": "E",
        "\xCB": "E",
        "\xE8": "e",
        "\xE9": "e",
        "\xEA": "e",
        "\xEB": "e",
        "\xCC": "I",
        "\xCD": "I",
        "\xCE": "I",
        "\xCF": "I",
        "\xEC": "i",
        "\xED": "i",
        "\xEE": "i",
        "\xEF": "i",
        "\xD1": "N",
        "\xF1": "n",
        "\xD2": "O",
        "\xD3": "O",
        "\xD4": "O",
        "\xD5": "O",
        "\xD6": "O",
        "\xD8": "O",
        "\xF2": "o",
        "\xF3": "o",
        "\xF4": "o",
        "\xF5": "o",
        "\xF6": "o",
        "\xF8": "o",
        "\xD9": "U",
        "\xDA": "U",
        "\xDB": "U",
        "\xDC": "U",
        "\xF9": "u",
        "\xFA": "u",
        "\xFB": "u",
        "\xFC": "u",
        "\xDD": "Y",
        "\xFD": "y",
        "\xFF": "y",
        "\xC6": "Ae",
        "\xE6": "ae",
        "\xDE": "Th",
        "\xFE": "th",
        "\xDF": "ss",
        // Latin Extended-A block.
        "\u0100": "A",
        "\u0102": "A",
        "\u0104": "A",
        "\u0101": "a",
        "\u0103": "a",
        "\u0105": "a",
        "\u0106": "C",
        "\u0108": "C",
        "\u010A": "C",
        "\u010C": "C",
        "\u0107": "c",
        "\u0109": "c",
        "\u010B": "c",
        "\u010D": "c",
        "\u010E": "D",
        "\u0110": "D",
        "\u010F": "d",
        "\u0111": "d",
        "\u0112": "E",
        "\u0114": "E",
        "\u0116": "E",
        "\u0118": "E",
        "\u011A": "E",
        "\u0113": "e",
        "\u0115": "e",
        "\u0117": "e",
        "\u0119": "e",
        "\u011B": "e",
        "\u011C": "G",
        "\u011E": "G",
        "\u0120": "G",
        "\u0122": "G",
        "\u011D": "g",
        "\u011F": "g",
        "\u0121": "g",
        "\u0123": "g",
        "\u0124": "H",
        "\u0126": "H",
        "\u0125": "h",
        "\u0127": "h",
        "\u0128": "I",
        "\u012A": "I",
        "\u012C": "I",
        "\u012E": "I",
        "\u0130": "I",
        "\u0129": "i",
        "\u012B": "i",
        "\u012D": "i",
        "\u012F": "i",
        "\u0131": "i",
        "\u0134": "J",
        "\u0135": "j",
        "\u0136": "K",
        "\u0137": "k",
        "\u0138": "k",
        "\u0139": "L",
        "\u013B": "L",
        "\u013D": "L",
        "\u013F": "L",
        "\u0141": "L",
        "\u013A": "l",
        "\u013C": "l",
        "\u013E": "l",
        "\u0140": "l",
        "\u0142": "l",
        "\u0143": "N",
        "\u0145": "N",
        "\u0147": "N",
        "\u014A": "N",
        "\u0144": "n",
        "\u0146": "n",
        "\u0148": "n",
        "\u014B": "n",
        "\u014C": "O",
        "\u014E": "O",
        "\u0150": "O",
        "\u014D": "o",
        "\u014F": "o",
        "\u0151": "o",
        "\u0154": "R",
        "\u0156": "R",
        "\u0158": "R",
        "\u0155": "r",
        "\u0157": "r",
        "\u0159": "r",
        "\u015A": "S",
        "\u015C": "S",
        "\u015E": "S",
        "\u0160": "S",
        "\u015B": "s",
        "\u015D": "s",
        "\u015F": "s",
        "\u0161": "s",
        "\u0162": "T",
        "\u0164": "T",
        "\u0166": "T",
        "\u0163": "t",
        "\u0165": "t",
        "\u0167": "t",
        "\u0168": "U",
        "\u016A": "U",
        "\u016C": "U",
        "\u016E": "U",
        "\u0170": "U",
        "\u0172": "U",
        "\u0169": "u",
        "\u016B": "u",
        "\u016D": "u",
        "\u016F": "u",
        "\u0171": "u",
        "\u0173": "u",
        "\u0174": "W",
        "\u0175": "w",
        "\u0176": "Y",
        "\u0177": "y",
        "\u0178": "Y",
        "\u0179": "Z",
        "\u017B": "Z",
        "\u017D": "Z",
        "\u017A": "z",
        "\u017C": "z",
        "\u017E": "z",
        "\u0132": "IJ",
        "\u0133": "ij",
        "\u0152": "Oe",
        "\u0153": "oe",
        "\u0149": "'n",
        "\u017F": "s"
      };
      var htmlEscapes = {
        "&": "&amp;",
        "<": "&lt;",
        ">": "&gt;",
        '"': "&quot;",
        "'": "&#39;"
      };
      var htmlUnescapes = {
        "&amp;": "&",
        "&lt;": "<",
        "&gt;": ">",
        "&quot;": '"',
        "&#39;": "'"
      };
      var stringEscapes = {
        "\\": "\\",
        "'": "'",
        "\n": "n",
        "\r": "r",
        "\u2028": "u2028",
        "\u2029": "u2029"
      };
      var freeParseFloat = parseFloat, freeParseInt = parseInt;
      var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
      var freeSelf = typeof self == "object" && self && self.Object === Object && self;
      var root = freeGlobal || freeSelf || Function("return this")();
      var freeExports = typeof exports2 == "object" && exports2 && !exports2.nodeType && exports2;
      var freeModule = freeExports && typeof module3 == "object" && module3 && !module3.nodeType && module3;
      var moduleExports = freeModule && freeModule.exports === freeExports;
      var freeProcess = moduleExports && freeGlobal.process;
      var nodeUtil = function() {
        try {
          var types = freeModule && freeModule.require && freeModule.require("util").types;
          if (types) {
            return types;
          }
          return freeProcess && freeProcess.binding && freeProcess.binding("util");
        } catch (e3) {
        }
      }();
      var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer, nodeIsDate = nodeUtil && nodeUtil.isDate, nodeIsMap = nodeUtil && nodeUtil.isMap, nodeIsRegExp = nodeUtil && nodeUtil.isRegExp, nodeIsSet = nodeUtil && nodeUtil.isSet, nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
      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);
      }
      __name(apply, "apply");
      function arrayAggregator(array, setter, iteratee, accumulator) {
        var index = -1, length = array == null ? 0 : array.length;
        while (++index < length) {
          var value = array[index];
          setter(accumulator, value, iteratee(value), array);
        }
        return accumulator;
      }
      __name(arrayAggregator, "arrayAggregator");
      function arrayEach(array, iteratee) {
        var index = -1, length = array == null ? 0 : array.length;
        while (++index < length) {
          if (iteratee(array[index], index, array) === false) {
            break;
          }
        }
        return array;
      }
      __name(arrayEach, "arrayEach");
      function arrayEachRight(array, iteratee) {
        var length = array == null ? 0 : array.length;
        while (length--) {
          if (iteratee(array[length], length, array) === false) {
            break;
          }
        }
        return array;
      }
      __name(arrayEachRight, "arrayEachRight");
      function arrayEvery(array, predicate) {
        var index = -1, length = array == null ? 0 : array.length;
        while (++index < length) {
          if (!predicate(array[index], index, array)) {
            return false;
          }
        }
        return true;
      }
      __name(arrayEvery, "arrayEvery");
      function arrayFilter(array, predicate) {
        var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
        while (++index < length) {
          var value = array[index];
          if (predicate(value, index, array)) {
            result[resIndex++] = value;
          }
        }
        return result;
      }
      __name(arrayFilter, "arrayFilter");
      function arrayIncludes(array, value) {
        var length = array == null ? 0 : array.length;
        return !!length && baseIndexOf(array, value, 0) > -1;
      }
      __name(arrayIncludes, "arrayIncludes");
      function arrayIncludesWith(array, value, comparator) {
        var index = -1, length = array == null ? 0 : array.length;
        while (++index < length) {
          if (comparator(value, array[index])) {
            return true;
          }
        }
        return false;
      }
      __name(arrayIncludesWith, "arrayIncludesWith");
      function arrayMap(array, iteratee) {
        var index = -1, length = array == null ? 0 : array.length, result = Array(length);
        while (++index < length) {
          result[index] = iteratee(array[index], index, array);
        }
        return result;
      }
      __name(arrayMap, "arrayMap");
      function arrayPush(array, values) {
        var index = -1, length = values.length, offset = array.length;
        while (++index < length) {
          array[offset + index] = values[index];
        }
        return array;
      }
      __name(arrayPush, "arrayPush");
      function arrayReduce(array, iteratee, accumulator, initAccum) {
        var index = -1, length = array == null ? 0 : array.length;
        if (initAccum && length) {
          accumulator = array[++index];
        }
        while (++index < length) {
          accumulator = iteratee(accumulator, array[index], index, array);
        }
        return accumulator;
      }
      __name(arrayReduce, "arrayReduce");
      function arrayReduceRight(array, iteratee, accumulator, initAccum) {
        var length = array == null ? 0 : array.length;
        if (initAccum && length) {
          accumulator = array[--length];
        }
        while (length--) {
          accumulator = iteratee(accumulator, array[length], length, array);
        }
        return accumulator;
      }
      __name(arrayReduceRight, "arrayReduceRight");
      function arraySome(array, predicate) {
        var index = -1, length = array == null ? 0 : array.length;
        while (++index < length) {
          if (predicate(array[index], index, array)) {
            return true;
          }
        }
        return false;
      }
      __name(arraySome, "arraySome");
      var asciiSize = baseProperty("length");
      function asciiToArray(string) {
        return string.split("");
      }
      __name(asciiToArray, "asciiToArray");
      function asciiWords(string) {
        return string.match(reAsciiWord) || [];
      }
      __name(asciiWords, "asciiWords");
      function baseFindKey(collection, predicate, eachFunc) {
        var result;
        eachFunc(collection, function(value, key, collection2) {
          if (predicate(value, key, collection2)) {
            result = key;
            return false;
          }
        });
        return result;
      }
      __name(baseFindKey, "baseFindKey");
      function baseFindIndex(array, predicate, fromIndex, fromRight) {
        var length = array.length, index = fromIndex + (fromRight ? 1 : -1);
        while (fromRight ? index-- : ++index < length) {
          if (predicate(array[index], index, array)) {
            return index;
          }
        }
        return -1;
      }
      __name(baseFindIndex, "baseFindIndex");
      function baseIndexOf(array, value, fromIndex) {
        return value === value ? strictIndexOf(array, value, fromIndex) : baseFindIndex(array, baseIsNaN, fromIndex);
      }
      __name(baseIndexOf, "baseIndexOf");
      function baseIndexOfWith(array, value, fromIndex, comparator) {
        var index = fromIndex - 1, length = array.length;
        while (++index < length) {
          if (comparator(array[index], value)) {
            return index;
          }
        }
        return -1;
      }
      __name(baseIndexOfWith, "baseIndexOfWith");
      function baseIsNaN(value) {
        return value !== value;
      }
      __name(baseIsNaN, "baseIsNaN");
      function baseMean(array, iteratee) {
        var length = array == null ? 0 : array.length;
        return length ? baseSum(array, iteratee) / length : NAN;
      }
      __name(baseMean, "baseMean");
      function baseProperty(key) {
        return function(object) {
          return object == null ? undefined2 : object[key];
        };
      }
      __name(baseProperty, "baseProperty");
      function basePropertyOf(object) {
        return function(key) {
          return object == null ? undefined2 : object[key];
        };
      }
      __name(basePropertyOf, "basePropertyOf");
      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;
      }
      __name(baseReduce, "baseReduce");
      function baseSortBy(array, comparer) {
        var length = array.length;
        array.sort(comparer);
        while (length--) {
          array[length] = array[length].value;
        }
        return array;
      }
      __name(baseSortBy, "baseSortBy");
      function baseSum(array, iteratee) {
        var result, index = -1, length = array.length;
        while (++index < length) {
          var current = iteratee(array[index]);
          if (current !== undefined2) {
            result = result === undefined2 ? current : result + current;
          }
        }
        return result;
      }
      __name(baseSum, "baseSum");
      function baseTimes(n2, iteratee) {
        var index = -1, result = Array(n2);
        while (++index < n2) {
          result[index] = iteratee(index);
        }
        return result;
      }
      __name(baseTimes, "baseTimes");
      function baseToPairs(object, props) {
        return arrayMap(props, function(key) {
          return [key, object[key]];
        });
      }
      __name(baseToPairs, "baseToPairs");
      function baseTrim(string) {
        return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
      }
      __name(baseTrim, "baseTrim");
      function baseUnary(func) {
        return function(value) {
          return func(value);
        };
      }
      __name(baseUnary, "baseUnary");
      function baseValues(object, props) {
        return arrayMap(props, function(key) {
          return object[key];
        });
      }
      __name(baseValues, "baseValues");
      function cacheHas(cache2, key) {
        return cache2.has(key);
      }
      __name(cacheHas, "cacheHas");
      function charsStartIndex(strSymbols, chrSymbols) {
        var index = -1, length = strSymbols.length;
        while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {
        }
        return index;
      }
      __name(charsStartIndex, "charsStartIndex");
      function charsEndIndex(strSymbols, chrSymbols) {
        var index = strSymbols.length;
        while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {
        }
        return index;
      }
      __name(charsEndIndex, "charsEndIndex");
      function countHolders(array, placeholder) {
        var length = array.length, result = 0;
        while (length--) {
          if (array[length] === placeholder) {
            ++result;
          }
        }
        return result;
      }
      __name(countHolders, "countHolders");
      var deburrLetter = basePropertyOf(deburredLetters);
      var escapeHtmlChar = basePropertyOf(htmlEscapes);
      function escapeStringChar(chr) {
        return "\\" + stringEscapes[chr];
      }
      __name(escapeStringChar, "escapeStringChar");
      function getValue(object, key) {
        return object == null ? undefined2 : object[key];
      }
      __name(getValue, "getValue");
      function hasUnicode(string) {
        return reHasUnicode.test(string);
      }
      __name(hasUnicode, "hasUnicode");
      function hasUnicodeWord(string) {
        return reHasUnicodeWord.test(string);
      }
      __name(hasUnicodeWord, "hasUnicodeWord");
      function iteratorToArray(iterator) {
        var data, result = [];
        while (!(data = iterator.next()).done) {
          result.push(data.value);
        }
        return result;
      }
      __name(iteratorToArray, "iteratorToArray");
      function mapToArray(map) {
        var index = -1, result = Array(map.size);
        map.forEach(function(value, key) {
          result[++index] = [key, value];
        });
        return result;
      }
      __name(mapToArray, "mapToArray");
      function overArg(func, transform) {
        return function(arg) {
          return func(transform(arg));
        };
      }
      __name(overArg, "overArg");
      function replaceHolders(array, placeholder) {
        var index = -1, length = array.length, resIndex = 0, result = [];
        while (++index < length) {
          var value = array[index];
          if (value === placeholder || value === PLACEHOLDER) {
            array[index] = PLACEHOLDER;
            result[resIndex++] = index;
          }
        }
        return result;
      }
      __name(replaceHolders, "replaceHolders");
      function setToArray(set) {
        var index = -1, result = Array(set.size);
        set.forEach(function(value) {
          result[++index] = value;
        });
        return result;
      }
      __name(setToArray, "setToArray");
      function setToPairs(set) {
        var index = -1, result = Array(set.size);
        set.forEach(function(value) {
          result[++index] = [value, value];
        });
        return result;
      }
      __name(setToPairs, "setToPairs");
      function strictIndexOf(array, value, fromIndex) {
        var index = fromIndex - 1, length = array.length;
        while (++index < length) {
          if (array[index] === value) {
            return index;
          }
        }
        return -1;
      }
      __name(strictIndexOf, "strictIndexOf");
      function strictLastIndexOf(array, value, fromIndex) {
        var index = fromIndex + 1;
        while (index--) {
          if (array[index] === value) {
            return index;
          }
        }
        return index;
      }
      __name(strictLastIndexOf, "strictLastIndexOf");
      function stringSize(string) {
        return hasUnicode(string) ? unicodeSize(string) : asciiSize(string);
      }
      __name(stringSize, "stringSize");
      function stringToArray(string) {
        return hasUnicode(string) ? unicodeToArray(string) : asciiToArray(string);
      }
      __name(stringToArray, "stringToArray");
      function trimmedEndIndex(string) {
        var index = string.length;
        while (index-- && reWhitespace.test(string.charAt(index))) {
        }
        return index;
      }
      __name(trimmedEndIndex, "trimmedEndIndex");
      var unescapeHtmlChar = basePropertyOf(htmlUnescapes);
      function unicodeSize(string) {
        var result = reUnicode.lastIndex = 0;
        while (reUnicode.test(string)) {
          ++result;
        }
        return result;
      }
      __name(unicodeSize, "unicodeSize");
      function unicodeToArray(string) {
        return string.match(reUnicode) || [];
      }
      __name(unicodeToArray, "unicodeToArray");
      function unicodeWords(string) {
        return string.match(reUnicodeWord) || [];
      }
      __name(unicodeWords, "unicodeWords");
      var runInContext = /* @__PURE__ */ __name(function runInContext2(context2) {
        context2 = context2 == null ? root : _3.defaults(root.Object(), context2, _3.pick(root, contextProps));
        var Array2 = context2.Array, Date2 = context2.Date, Error2 = context2.Error, Function2 = context2.Function, Math2 = context2.Math, Object2 = context2.Object, RegExp2 = context2.RegExp, String2 = context2.String, TypeError2 = context2.TypeError;
        var arrayProto = Array2.prototype, funcProto = Function2.prototype, objectProto = Object2.prototype;
        var coreJsData = context2["__core-js_shared__"];
        var funcToString = funcProto.toString;
        var hasOwnProperty2 = objectProto.hasOwnProperty;
        var idCounter = 0;
        var maskSrcKey = function() {
          var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
          return uid ? "Symbol(src)_1." + uid : "";
        }();
        var nativeObjectToString = objectProto.toString;
        var objectCtorString = funcToString.call(Object2);
        var oldDash = root._;
        var reIsNative = RegExp2(
          "^" + funcToString.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
        );
        var Buffer3 = moduleExports ? context2.Buffer : undefined2, Symbol2 = context2.Symbol, Uint8Array2 = context2.Uint8Array, allocUnsafe = Buffer3 ? Buffer3.allocUnsafe : undefined2, getPrototype = overArg(Object2.getPrototypeOf, Object2), objectCreate = Object2.create, propertyIsEnumerable = objectProto.propertyIsEnumerable, splice = arrayProto.splice, spreadableSymbol = Symbol2 ? Symbol2.isConcatSpreadable : undefined2, symIterator = Symbol2 ? Symbol2.iterator : undefined2, symToStringTag = Symbol2 ? Symbol2.toStringTag : undefined2;
        var defineProperty2 = function() {
          try {
            var func = getNative(Object2, "defineProperty");
            func({}, "", {});
            return func;
          } catch (e3) {
          }
        }();
        var ctxClearTimeout = context2.clearTimeout !== root.clearTimeout && context2.clearTimeout, ctxNow = Date2 && Date2.now !== root.Date.now && Date2.now, ctxSetTimeout = context2.setTimeout !== root.setTimeout && context2.setTimeout;
        var nativeCeil = Math2.ceil, nativeFloor = Math2.floor, nativeGetSymbols = Object2.getOwnPropertySymbols, nativeIsBuffer = Buffer3 ? Buffer3.isBuffer : undefined2, nativeIsFinite = context2.isFinite, nativeJoin = arrayProto.join, nativeKeys = overArg(Object2.keys, Object2), nativeMax = Math2.max, nativeMin = Math2.min, nativeNow = Date2.now, nativeParseInt = context2.parseInt, nativeRandom = Math2.random, nativeReverse = arrayProto.reverse;
        var DataView2 = getNative(context2, "DataView"), Map2 = getNative(context2, "Map"), Promise2 = getNative(context2, "Promise"), Set2 = getNative(context2, "Set"), WeakMap2 = getNative(context2, "WeakMap"), nativeCreate = getNative(Object2, "create");
        var metaMap = WeakMap2 && new WeakMap2();
        var realNames = {};
        var dataViewCtorString = toSource(DataView2), mapCtorString = toSource(Map2), promiseCtorString = toSource(Promise2), setCtorString = toSource(Set2), weakMapCtorString = toSource(WeakMap2);
        var symbolProto = Symbol2 ? Symbol2.prototype : undefined2, symbolValueOf = symbolProto ? symbolProto.valueOf : undefined2, symbolToString = symbolProto ? symbolProto.toString : undefined2;
        function lodash(value) {
          if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {
            if (value instanceof LodashWrapper) {
              return value;
            }
            if (hasOwnProperty2.call(value, "__wrapped__")) {
              return wrapperClone(value);
            }
          }
          return new LodashWrapper(value);
        }
        __name(lodash, "lodash");
        var baseCreate = function() {
          function object() {
          }
          __name(object, "object");
          return function(proto) {
            if (!isObject2(proto)) {
              return {};
            }
            if (objectCreate) {
              return objectCreate(proto);
            }
            object.prototype = proto;
            var result2 = new object();
            object.prototype = undefined2;
            return result2;
          };
        }();
        function baseLodash() {
        }
        __name(baseLodash, "baseLodash");
        function LodashWrapper(value, chainAll) {
          this.__wrapped__ = value;
          this.__actions__ = [];
          this.__chain__ = !!chainAll;
          this.__index__ = 0;
          this.__values__ = undefined2;
        }
        __name(LodashWrapper, "LodashWrapper");
        lodash.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}
             */
            "_": lodash
          }
        };
        lodash.prototype = baseLodash.prototype;
        lodash.prototype.constructor = lodash;
        LodashWrapper.prototype = baseCreate(baseLodash.prototype);
        LodashWrapper.prototype.constructor = LodashWrapper;
        function LazyWrapper(value) {
          this.__wrapped__ = value;
          this.__actions__ = [];
          this.__dir__ = 1;
          this.__filtered__ = false;
          this.__iteratees__ = [];
          this.__takeCount__ = MAX_ARRAY_LENGTH;
          this.__views__ = [];
        }
        __name(LazyWrapper, "LazyWrapper");
        function lazyClone() {
          var result2 = new LazyWrapper(this.__wrapped__);
          result2.__actions__ = copyArray(this.__actions__);
          result2.__dir__ = this.__dir__;
          result2.__filtered__ = this.__filtered__;
          result2.__iteratees__ = copyArray(this.__iteratees__);
          result2.__takeCount__ = this.__takeCount__;
          result2.__views__ = copyArray(this.__views__);
          return result2;
        }
        __name(lazyClone, "lazyClone");
        function lazyReverse() {
          if (this.__filtered__) {
            var result2 = new LazyWrapper(this);
            result2.__dir__ = -1;
            result2.__filtered__ = true;
          } else {
            result2 = this.clone();
            result2.__dir__ *= -1;
          }
          return result2;
        }
        __name(lazyReverse, "lazyReverse");
        function lazyValue() {
          var array = this.__wrapped__.value(), dir = this.__dir__, isArr = isArray(array), isRight = dir < 0, arrLength = isArr ? array.length : 0, view = getView(0, arrLength, this.__views__), start = view.start, end = view.end, length = end - start, index = isRight ? end : start - 1, iteratees = this.__iteratees__, iterLength = iteratees.length, resIndex = 0, takeCount = nativeMin(length, this.__takeCount__);
          if (!isArr || !isRight && arrLength == length && takeCount == length) {
            return baseWrapperValue(array, this.__actions__);
          }
          var result2 = [];
          outer:
            while (length-- && resIndex < takeCount) {
              index += dir;
              var iterIndex = -1, value = array[index];
              while (++iterIndex < iterLength) {
                var data = iteratees[iterIndex], iteratee2 = data.iteratee, type = data.type, computed = iteratee2(value);
                if (type == LAZY_MAP_FLAG) {
                  value = computed;
                } else if (!computed) {
                  if (type == LAZY_FILTER_FLAG) {
                    continue outer;
                  } else {
                    break outer;
                  }
                }
              }
              result2[resIndex++] = value;
            }
          return result2;
        }
        __name(lazyValue, "lazyValue");
        LazyWrapper.prototype = baseCreate(baseLodash.prototype);
        LazyWrapper.prototype.constructor = LazyWrapper;
        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]);
          }
        }
        __name(Hash, "Hash");
        function hashClear() {
          this.__data__ = nativeCreate ? nativeCreate(null) : {};
          this.size = 0;
        }
        __name(hashClear, "hashClear");
        function hashDelete(key) {
          var result2 = this.has(key) && delete this.__data__[key];
          this.size -= result2 ? 1 : 0;
          return result2;
        }
        __name(hashDelete, "hashDelete");
        function hashGet(key) {
          var data = this.__data__;
          if (nativeCreate) {
            var result2 = data[key];
            return result2 === HASH_UNDEFINED ? undefined2 : result2;
          }
          return hasOwnProperty2.call(data, key) ? data[key] : undefined2;
        }
        __name(hashGet, "hashGet");
        function hashHas(key) {
          var data = this.__data__;
          return nativeCreate ? data[key] !== undefined2 : hasOwnProperty2.call(data, key);
        }
        __name(hashHas, "hashHas");
        function hashSet(key, value) {
          var data = this.__data__;
          this.size += this.has(key) ? 0 : 1;
          data[key] = nativeCreate && value === undefined2 ? HASH_UNDEFINED : value;
          return this;
        }
        __name(hashSet, "hashSet");
        Hash.prototype.clear = hashClear;
        Hash.prototype["delete"] = hashDelete;
        Hash.prototype.get = hashGet;
        Hash.prototype.has = hashHas;
        Hash.prototype.set = hashSet;
        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]);
          }
        }
        __name(ListCache, "ListCache");
        function listCacheClear() {
          this.__data__ = [];
          this.size = 0;
        }
        __name(listCacheClear, "listCacheClear");
        function listCacheDelete(key) {
          var data = this.__data__, index = assocIndexOf(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;
        }
        __name(listCacheDelete, "listCacheDelete");
        function listCacheGet(key) {
          var data = this.__data__, index = assocIndexOf(data, key);
          return index < 0 ? undefined2 : data[index][1];
        }
        __name(listCacheGet, "listCacheGet");
        function listCacheHas(key) {
          return assocIndexOf(this.__data__, key) > -1;
        }
        __name(listCacheHas, "listCacheHas");
        function listCacheSet(key, value) {
          var data = this.__data__, index = assocIndexOf(data, key);
          if (index < 0) {
            ++this.size;
            data.push([key, value]);
          } else {
            data[index][1] = value;
          }
          return this;
        }
        __name(listCacheSet, "listCacheSet");
        ListCache.prototype.clear = listCacheClear;
        ListCache.prototype["delete"] = listCacheDelete;
        ListCache.prototype.get = listCacheGet;
        ListCache.prototype.has = listCacheHas;
        ListCache.prototype.set = listCacheSet;
        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]);
          }
        }
        __name(MapCache, "MapCache");
        function mapCacheClear() {
          this.size = 0;
          this.__data__ = {
            "hash": new Hash(),
            "map": new (Map2 || ListCache)(),
            "string": new Hash()
          };
        }
        __name(mapCacheClear, "mapCacheClear");
        function mapCacheDelete(key) {
          var result2 = getMapData(this, key)["delete"](key);
          this.size -= result2 ? 1 : 0;
          return result2;
        }
        __name(mapCacheDelete, "mapCacheDelete");
        function mapCacheGet(key) {
          return getMapData(this, key).get(key);
        }
        __name(mapCacheGet, "mapCacheGet");
        function mapCacheHas(key) {
          return getMapData(this, key).has(key);
        }
        __name(mapCacheHas, "mapCacheHas");
        function mapCacheSet(key, value) {
          var data = getMapData(this, key), size2 = data.size;
          data.set(key, value);
          this.size += data.size == size2 ? 0 : 1;
          return this;
        }
        __name(mapCacheSet, "mapCacheSet");
        MapCache.prototype.clear = mapCacheClear;
        MapCache.prototype["delete"] = mapCacheDelete;
        MapCache.prototype.get = mapCacheGet;
        MapCache.prototype.has = mapCacheHas;
        MapCache.prototype.set = mapCacheSet;
        function SetCache(values2) {
          var index = -1, length = values2 == null ? 0 : values2.length;
          this.__data__ = new MapCache();
          while (++index < length) {
            this.add(values2[index]);
          }
        }
        __name(SetCache, "SetCache");
        function setCacheAdd(value) {
          this.__data__.set(value, HASH_UNDEFINED);
          return this;
        }
        __name(setCacheAdd, "setCacheAdd");
        function setCacheHas(value) {
          return this.__data__.has(value);
        }
        __name(setCacheHas, "setCacheHas");
        SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
        SetCache.prototype.has = setCacheHas;
        function Stack(entries) {
          var data = this.__data__ = new ListCache(entries);
          this.size = data.size;
        }
        __name(Stack, "Stack");
        function stackClear() {
          this.__data__ = new ListCache();
          this.size = 0;
        }
        __name(stackClear, "stackClear");
        function stackDelete(key) {
          var data = this.__data__, result2 = data["delete"](key);
          this.size = data.size;
          return result2;
        }
        __name(stackDelete, "stackDelete");
        function stackGet(key) {
          return this.__data__.get(key);
        }
        __name(stackGet, "stackGet");
        function stackHas(key) {
          return this.__data__.has(key);
        }
        __name(stackHas, "stackHas");
        function stackSet(key, value) {
          var data = this.__data__;
          if (data instanceof ListCache) {
            var pairs = data.__data__;
            if (!Map2 || pairs.length < LARGE_ARRAY_SIZE - 1) {
              pairs.push([key, value]);
              this.size = ++data.size;
              return this;
            }
            data = this.__data__ = new MapCache(pairs);
          }
          data.set(key, value);
          this.size = data.size;
          return this;
        }
        __name(stackSet, "stackSet");
        Stack.prototype.clear = stackClear;
        Stack.prototype["delete"] = stackDelete;
        Stack.prototype.get = stackGet;
        Stack.prototype.has = stackHas;
        Stack.prototype.set = stackSet;
        function arrayLikeKeys(value, inherited) {
          var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result2 = skipIndexes ? baseTimes(value.length, String2) : [], length = result2.length;
          for (var key in value) {
            if ((inherited || hasOwnProperty2.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(key, length)))) {
              result2.push(key);
            }
          }
          return result2;
        }
        __name(arrayLikeKeys, "arrayLikeKeys");
        function arraySample(array) {
          var length = array.length;
          return length ? array[baseRandom(0, length - 1)] : undefined2;
        }
        __name(arraySample, "arraySample");
        function arraySampleSize(array, n2) {
          return shuffleSelf(copyArray(array), baseClamp(n2, 0, array.length));
        }
        __name(arraySampleSize, "arraySampleSize");
        function arrayShuffle(array) {
          return shuffleSelf(copyArray(array));
        }
        __name(arrayShuffle, "arrayShuffle");
        function assignMergeValue(object, key, value) {
          if (value !== undefined2 && !eq(object[key], value) || value === undefined2 && !(key in object)) {
            baseAssignValue(object, key, value);
          }
        }
        __name(assignMergeValue, "assignMergeValue");
        function assignValue(object, key, value) {
          var objValue = object[key];
          if (!(hasOwnProperty2.call(object, key) && eq(objValue, value)) || value === undefined2 && !(key in object)) {
            baseAssignValue(object, key, value);
          }
        }
        __name(assignValue, "assignValue");
        function assocIndexOf(array, key) {
          var length = array.length;
          while (length--) {
            if (eq(array[length][0], key)) {
              return length;
            }
          }
          return -1;
        }
        __name(assocIndexOf, "assocIndexOf");
        function baseAggregator(collection, setter, iteratee2, accumulator) {
          baseEach(collection, function(value, key, collection2) {
            setter(accumulator, value, iteratee2(value), collection2);
          });
          return accumulator;
        }
        __name(baseAggregator, "baseAggregator");
        function baseAssign(object, source) {
          return object && copyObject(source, keys(source), object);
        }
        __name(baseAssign, "baseAssign");
        function baseAssignIn(object, source) {
          return object && copyObject(source, keysIn(source), object);
        }
        __name(baseAssignIn, "baseAssignIn");
        function baseAssignValue(object, key, value) {
          if (key == "__proto__" && defineProperty2) {
            defineProperty2(object, key, {
              "configurable": true,
              "enumerable": true,
              "value": value,
              "writable": true
            });
          } else {
            object[key] = value;
          }
        }
        __name(baseAssignValue, "baseAssignValue");
        function baseAt(object, paths) {
          var index = -1, length = paths.length, result2 = Array2(length), skip = object == null;
          while (++index < length) {
            result2[index] = skip ? undefined2 : get(object, paths[index]);
          }
          return result2;
        }
        __name(baseAt, "baseAt");
        function baseClamp(number, lower, upper) {
          if (number === number) {
            if (upper !== undefined2) {
              number = number <= upper ? number : upper;
            }
            if (lower !== undefined2) {
              number = number >= lower ? number : lower;
            }
          }
          return number;
        }
        __name(baseClamp, "baseClamp");
        function baseClone(value, bitmask, customizer, key, object, stack) {
          var result2, isDeep = bitmask & CLONE_DEEP_FLAG, isFlat = bitmask & CLONE_FLAT_FLAG, isFull = bitmask & CLONE_SYMBOLS_FLAG;
          if (customizer) {
            result2 = object ? customizer(value, key, object, stack) : customizer(value);
          }
          if (result2 !== undefined2) {
            return result2;
          }
          if (!isObject2(value)) {
            return value;
          }
          var isArr = isArray(value);
          if (isArr) {
            result2 = initCloneArray(value);
            if (!isDeep) {
              return copyArray(value, result2);
            }
          } else {
            var tag = getTag(value), isFunc = tag == funcTag || tag == genTag;
            if (isBuffer(value)) {
              return cloneBuffer(value, isDeep);
            }
            if (tag == objectTag || tag == argsTag || isFunc && !object) {
              result2 = isFlat || isFunc ? {} : initCloneObject(value);
              if (!isDeep) {
                return isFlat ? copySymbolsIn(value, baseAssignIn(result2, value)) : copySymbols(value, baseAssign(result2, value));
              }
            } else {
              if (!cloneableTags[tag]) {
                return object ? value : {};
              }
              result2 = initCloneByTag(value, tag, isDeep);
            }
          }
          stack || (stack = new Stack());
          var stacked = stack.get(value);
          if (stacked) {
            return stacked;
          }
          stack.set(value, result2);
          if (isSet(value)) {
            value.forEach(function(subValue) {
              result2.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
            });
          } else if (isMap(value)) {
            value.forEach(function(subValue, key2) {
              result2.set(key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
            });
          }
          var keysFunc = isFull ? isFlat ? getAllKeysIn : getAllKeys : isFlat ? keysIn : keys;
          var props = isArr ? undefined2 : keysFunc(value);
          arrayEach(props || value, function(subValue, key2) {
            if (props) {
              key2 = subValue;
              subValue = value[key2];
            }
            assignValue(result2, key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
          });
          return result2;
        }
        __name(baseClone, "baseClone");
        function baseConforms(source) {
          var props = keys(source);
          return function(object) {
            return baseConformsTo(object, source, props);
          };
        }
        __name(baseConforms, "baseConforms");
        function baseConformsTo(object, source, props) {
          var length = props.length;
          if (object == null) {
            return !length;
          }
          object = Object2(object);
          while (length--) {
            var key = props[length], predicate = source[key], value = object[key];
            if (value === undefined2 && !(key in object) || !predicate(value)) {
              return false;
            }
          }
          return true;
        }
        __name(baseConformsTo, "baseConformsTo");
        function baseDelay(func, wait, args) {
          if (typeof func != "function") {
            throw new TypeError2(FUNC_ERROR_TEXT);
          }
          return setTimeout4(function() {
            func.apply(undefined2, args);
          }, wait);
        }
        __name(baseDelay, "baseDelay");
        function baseDifference(array, values2, iteratee2, comparator) {
          var index = -1, includes2 = arrayIncludes, isCommon = true, length = array.length, result2 = [], valuesLength = values2.length;
          if (!length) {
            return result2;
          }
          if (iteratee2) {
            values2 = arrayMap(values2, baseUnary(iteratee2));
          }
          if (comparator) {
            includes2 = arrayIncludesWith;
            isCommon = false;
          } else if (values2.length >= LARGE_ARRAY_SIZE) {
            includes2 = cacheHas;
            isCommon = false;
            values2 = new SetCache(values2);
          }
          outer:
            while (++index < length) {
              var value = array[index], computed = iteratee2 == null ? value : iteratee2(value);
              value = comparator || value !== 0 ? value : 0;
              if (isCommon && computed === computed) {
                var valuesIndex = valuesLength;
                while (valuesIndex--) {
                  if (values2[valuesIndex] === computed) {
                    continue outer;
                  }
                }
                result2.push(value);
              } else if (!includes2(values2, computed, comparator)) {
                result2.push(value);
              }
            }
          return result2;
        }
        __name(baseDifference, "baseDifference");
        var baseEach = createBaseEach(baseForOwn);
        var baseEachRight = createBaseEach(baseForOwnRight, true);
        function baseEvery(collection, predicate) {
          var result2 = true;
          baseEach(collection, function(value, index, collection2) {
            result2 = !!predicate(value, index, collection2);
            return result2;
          });
          return result2;
        }
        __name(baseEvery, "baseEvery");
        function baseExtremum(array, iteratee2, comparator) {
          var index = -1, length = array.length;
          while (++index < length) {
            var value = array[index], current = iteratee2(value);
            if (current != null && (computed === undefined2 ? current === current && !isSymbol(current) : comparator(current, computed))) {
              var computed = current, result2 = value;
            }
          }
          return result2;
        }
        __name(baseExtremum, "baseExtremum");
        function baseFill(array, value, start, end) {
          var length = array.length;
          start = toInteger(start);
          if (start < 0) {
            start = -start > length ? 0 : length + start;
          }
          end = end === undefined2 || end > length ? length : toInteger(end);
          if (end < 0) {
            end += length;
          }
          end = start > end ? 0 : toLength(end);
          while (start < end) {
            array[start++] = value;
          }
          return array;
        }
        __name(baseFill, "baseFill");
        function baseFilter(collection, predicate) {
          var result2 = [];
          baseEach(collection, function(value, index, collection2) {
            if (predicate(value, index, collection2)) {
              result2.push(value);
            }
          });
          return result2;
        }
        __name(baseFilter, "baseFilter");
        function baseFlatten(array, depth, predicate, isStrict, result2) {
          var index = -1, length = array.length;
          predicate || (predicate = isFlattenable);
          result2 || (result2 = []);
          while (++index < length) {
            var value = array[index];
            if (depth > 0 && predicate(value)) {
              if (depth > 1) {
                baseFlatten(value, depth - 1, predicate, isStrict, result2);
              } else {
                arrayPush(result2, value);
              }
            } else if (!isStrict) {
              result2[result2.length] = value;
            }
          }
          return result2;
        }
        __name(baseFlatten, "baseFlatten");
        var baseFor = createBaseFor();
        var baseForRight = createBaseFor(true);
        function baseForOwn(object, iteratee2) {
          return object && baseFor(object, iteratee2, keys);
        }
        __name(baseForOwn, "baseForOwn");
        function baseForOwnRight(object, iteratee2) {
          return object && baseForRight(object, iteratee2, keys);
        }
        __name(baseForOwnRight, "baseForOwnRight");
        function baseFunctions(object, props) {
          return arrayFilter(props, function(key) {
            return isFunction2(object[key]);
          });
        }
        __name(baseFunctions, "baseFunctions");
        function baseGet(object, path67) {
          path67 = castPath(path67, object);
          var index = 0, length = path67.length;
          while (object != null && index < length) {
            object = object[toKey(path67[index++])];
          }
          return index && index == length ? object : undefined2;
        }
        __name(baseGet, "baseGet");
        function baseGetAllKeys(object, keysFunc, symbolsFunc) {
          var result2 = keysFunc(object);
          return isArray(object) ? result2 : arrayPush(result2, symbolsFunc(object));
        }
        __name(baseGetAllKeys, "baseGetAllKeys");
        function baseGetTag(value) {
          if (value == null) {
            return value === undefined2 ? undefinedTag : nullTag;
          }
          return symToStringTag && symToStringTag in Object2(value) ? getRawTag(value) : objectToString2(value);
        }
        __name(baseGetTag, "baseGetTag");
        function baseGt(value, other) {
          return value > other;
        }
        __name(baseGt, "baseGt");
        function baseHas(object, key) {
          return object != null && hasOwnProperty2.call(object, key);
        }
        __name(baseHas, "baseHas");
        function baseHasIn(object, key) {
          return object != null && key in Object2(object);
        }
        __name(baseHasIn, "baseHasIn");
        function baseInRange(number, start, end) {
          return number >= nativeMin(start, end) && number < nativeMax(start, end);
        }
        __name(baseInRange, "baseInRange");
        function baseIntersection(arrays, iteratee2, comparator) {
          var includes2 = comparator ? arrayIncludesWith : arrayIncludes, length = arrays[0].length, othLength = arrays.length, othIndex = othLength, caches = Array2(othLength), maxLength = Infinity, result2 = [];
          while (othIndex--) {
            var array = arrays[othIndex];
            if (othIndex && iteratee2) {
              array = arrayMap(array, baseUnary(iteratee2));
            }
            maxLength = nativeMin(array.length, maxLength);
            caches[othIndex] = !comparator && (iteratee2 || length >= 120 && array.length >= 120) ? new SetCache(othIndex && array) : undefined2;
          }
          array = arrays[0];
          var index = -1, seen = caches[0];
          outer:
            while (++index < length && result2.length < maxLength) {
              var value = array[index], computed = iteratee2 ? iteratee2(value) : value;
              value = comparator || value !== 0 ? value : 0;
              if (!(seen ? cacheHas(seen, computed) : includes2(result2, computed, comparator))) {
                othIndex = othLength;
                while (--othIndex) {
                  var cache2 = caches[othIndex];
                  if (!(cache2 ? cacheHas(cache2, computed) : includes2(arrays[othIndex], computed, comparator))) {
                    continue outer;
                  }
                }
                if (seen) {
                  seen.push(computed);
                }
                result2.push(value);
              }
            }
          return result2;
        }
        __name(baseIntersection, "baseIntersection");
        function baseInverter(object, setter, iteratee2, accumulator) {
          baseForOwn(object, function(value, key, object2) {
            setter(accumulator, iteratee2(value), key, object2);
          });
          return accumulator;
        }
        __name(baseInverter, "baseInverter");
        function baseInvoke(object, path67, args) {
          path67 = castPath(path67, object);
          object = parent(object, path67);
          var func = object == null ? object : object[toKey(last(path67))];
          return func == null ? undefined2 : apply(func, object, args);
        }
        __name(baseInvoke, "baseInvoke");
        function baseIsArguments(value) {
          return isObjectLike(value) && baseGetTag(value) == argsTag;
        }
        __name(baseIsArguments, "baseIsArguments");
        function baseIsArrayBuffer(value) {
          return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;
        }
        __name(baseIsArrayBuffer, "baseIsArrayBuffer");
        function baseIsDate(value) {
          return isObjectLike(value) && baseGetTag(value) == dateTag;
        }
        __name(baseIsDate, "baseIsDate");
        function baseIsEqual(value, other, bitmask, customizer, stack) {
          if (value === other) {
            return true;
          }
          if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
            return value !== value && other !== other;
          }
          return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
        }
        __name(baseIsEqual, "baseIsEqual");
        function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
          var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other);
          objTag = objTag == argsTag ? objectTag : objTag;
          othTag = othTag == argsTag ? objectTag : othTag;
          var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
          if (isSameTag && isBuffer(object)) {
            if (!isBuffer(other)) {
              return false;
            }
            objIsArr = true;
            objIsObj = false;
          }
          if (isSameTag && !objIsObj) {
            stack || (stack = new Stack());
            return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
          }
          if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
            var objIsWrapped = objIsObj && hasOwnProperty2.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty2.call(other, "__wrapped__");
            if (objIsWrapped || othIsWrapped) {
              var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
              stack || (stack = new Stack());
              return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
            }
          }
          if (!isSameTag) {
            return false;
          }
          stack || (stack = new Stack());
          return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
        }
        __name(baseIsEqualDeep, "baseIsEqualDeep");
        function baseIsMap(value) {
          return isObjectLike(value) && getTag(value) == mapTag;
        }
        __name(baseIsMap, "baseIsMap");
        function baseIsMatch(object, source, matchData, customizer) {
          var index = matchData.length, length = index, noCustomizer = !customizer;
          if (object == null) {
            return !length;
          }
          object = Object2(object);
          while (index--) {
            var data = matchData[index];
            if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
              return false;
            }
          }
          while (++index < length) {
            data = matchData[index];
            var key = data[0], objValue = object[key], srcValue = data[1];
            if (noCustomizer && data[2]) {
              if (objValue === undefined2 && !(key in object)) {
                return false;
              }
            } else {
              var stack = new Stack();
              if (customizer) {
                var result2 = customizer(objValue, srcValue, key, object, source, stack);
              }
              if (!(result2 === undefined2 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack) : result2)) {
                return false;
              }
            }
          }
          return true;
        }
        __name(baseIsMatch, "baseIsMatch");
        function baseIsNative(value) {
          if (!isObject2(value) || isMasked(value)) {
            return false;
          }
          var pattern = isFunction2(value) ? reIsNative : reIsHostCtor;
          return pattern.test(toSource(value));
        }
        __name(baseIsNative, "baseIsNative");
        function baseIsRegExp(value) {
          return isObjectLike(value) && baseGetTag(value) == regexpTag;
        }
        __name(baseIsRegExp, "baseIsRegExp");
        function baseIsSet(value) {
          return isObjectLike(value) && getTag(value) == setTag2;
        }
        __name(baseIsSet, "baseIsSet");
        function baseIsTypedArray(value) {
          return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
        }
        __name(baseIsTypedArray, "baseIsTypedArray");
        function baseIteratee(value) {
          if (typeof value == "function") {
            return value;
          }
          if (value == null) {
            return identity;
          }
          if (typeof value == "object") {
            return isArray(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);
          }
          return property(value);
        }
        __name(baseIteratee, "baseIteratee");
        function baseKeys(object) {
          if (!isPrototype(object)) {
            return nativeKeys(object);
          }
          var result2 = [];
          for (var key in Object2(object)) {
            if (hasOwnProperty2.call(object, key) && key != "constructor") {
              result2.push(key);
            }
          }
          return result2;
        }
        __name(baseKeys, "baseKeys");
        function baseKeysIn(object) {
          if (!isObject2(object)) {
            return nativeKeysIn(object);
          }
          var isProto = isPrototype(object), result2 = [];
          for (var key in object) {
            if (!(key == "constructor" && (isProto || !hasOwnProperty2.call(object, key)))) {
              result2.push(key);
            }
          }
          return result2;
        }
        __name(baseKeysIn, "baseKeysIn");
        function baseLt(value, other) {
          return value < other;
        }
        __name(baseLt, "baseLt");
        function baseMap(collection, iteratee2) {
          var index = -1, result2 = isArrayLike(collection) ? Array2(collection.length) : [];
          baseEach(collection, function(value, key, collection2) {
            result2[++index] = iteratee2(value, key, collection2);
          });
          return result2;
        }
        __name(baseMap, "baseMap");
        function baseMatches(source) {
          var matchData = getMatchData(source);
          if (matchData.length == 1 && matchData[0][2]) {
            return matchesStrictComparable(matchData[0][0], matchData[0][1]);
          }
          return function(object) {
            return object === source || baseIsMatch(object, source, matchData);
          };
        }
        __name(baseMatches, "baseMatches");
        function baseMatchesProperty(path67, srcValue) {
          if (isKey(path67) && isStrictComparable(srcValue)) {
            return matchesStrictComparable(toKey(path67), srcValue);
          }
          return function(object) {
            var objValue = get(object, path67);
            return objValue === undefined2 && objValue === srcValue ? hasIn(object, path67) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
          };
        }
        __name(baseMatchesProperty, "baseMatchesProperty");
        function baseMerge(object, source, srcIndex, customizer, stack) {
          if (object === source) {
            return;
          }
          baseFor(source, function(srcValue, key) {
            stack || (stack = new Stack());
            if (isObject2(srcValue)) {
              baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
            } else {
              var newValue = customizer ? customizer(safeGet(object, key), srcValue, key + "", object, source, stack) : undefined2;
              if (newValue === undefined2) {
                newValue = srcValue;
              }
              assignMergeValue(object, key, newValue);
            }
          }, keysIn);
        }
        __name(baseMerge, "baseMerge");
        function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
          var objValue = safeGet(object, key), srcValue = safeGet(source, key), stacked = stack.get(srcValue);
          if (stacked) {
            assignMergeValue(object, key, stacked);
            return;
          }
          var newValue = customizer ? customizer(objValue, srcValue, key + "", object, source, stack) : undefined2;
          var isCommon = newValue === undefined2;
          if (isCommon) {
            var isArr = isArray(srcValue), isBuff = !isArr && isBuffer(srcValue), isTyped = !isArr && !isBuff && isTypedArray(srcValue);
            newValue = srcValue;
            if (isArr || isBuff || isTyped) {
              if (isArray(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 (isPlainObject2(srcValue) || isArguments(srcValue)) {
              newValue = objValue;
              if (isArguments(objValue)) {
                newValue = toPlainObject(objValue);
              } else if (!isObject2(objValue) || isFunction2(objValue)) {
                newValue = initCloneObject(srcValue);
              }
            } else {
              isCommon = false;
            }
          }
          if (isCommon) {
            stack.set(srcValue, newValue);
            mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
            stack["delete"](srcValue);
          }
          assignMergeValue(object, key, newValue);
        }
        __name(baseMergeDeep, "baseMergeDeep");
        function baseNth(array, n2) {
          var length = array.length;
          if (!length) {
            return;
          }
          n2 += n2 < 0 ? length : 0;
          return isIndex(n2, length) ? array[n2] : undefined2;
        }
        __name(baseNth, "baseNth");
        function baseOrderBy(collection, iteratees, orders) {
          if (iteratees.length) {
            iteratees = arrayMap(iteratees, function(iteratee2) {
              if (isArray(iteratee2)) {
                return function(value) {
                  return baseGet(value, iteratee2.length === 1 ? iteratee2[0] : iteratee2);
                };
              }
              return iteratee2;
            });
          } else {
            iteratees = [identity];
          }
          var index = -1;
          iteratees = arrayMap(iteratees, baseUnary(getIteratee()));
          var result2 = baseMap(collection, function(value, key, collection2) {
            var criteria = arrayMap(iteratees, function(iteratee2) {
              return iteratee2(value);
            });
            return { "criteria": criteria, "index": ++index, "value": value };
          });
          return baseSortBy(result2, function(object, other) {
            return compareMultiple(object, other, orders);
          });
        }
        __name(baseOrderBy, "baseOrderBy");
        function basePick(object, paths) {
          return basePickBy(object, paths, function(value, path67) {
            return hasIn(object, path67);
          });
        }
        __name(basePick, "basePick");
        function basePickBy(object, paths, predicate) {
          var index = -1, length = paths.length, result2 = {};
          while (++index < length) {
            var path67 = paths[index], value = baseGet(object, path67);
            if (predicate(value, path67)) {
              baseSet(result2, castPath(path67, object), value);
            }
          }
          return result2;
        }
        __name(basePickBy, "basePickBy");
        function basePropertyDeep(path67) {
          return function(object) {
            return baseGet(object, path67);
          };
        }
        __name(basePropertyDeep, "basePropertyDeep");
        function basePullAll(array, values2, iteratee2, comparator) {
          var indexOf2 = comparator ? baseIndexOfWith : baseIndexOf, index = -1, length = values2.length, seen = array;
          if (array === values2) {
            values2 = copyArray(values2);
          }
          if (iteratee2) {
            seen = arrayMap(array, baseUnary(iteratee2));
          }
          while (++index < length) {
            var fromIndex = 0, value = values2[index], computed = iteratee2 ? iteratee2(value) : value;
            while ((fromIndex = indexOf2(seen, computed, fromIndex, comparator)) > -1) {
              if (seen !== array) {
                splice.call(seen, fromIndex, 1);
              }
              splice.call(array, fromIndex, 1);
            }
          }
          return array;
        }
        __name(basePullAll, "basePullAll");
        function basePullAt(array, indexes) {
          var length = array ? indexes.length : 0, lastIndex = length - 1;
          while (length--) {
            var index = indexes[length];
            if (length == lastIndex || index !== previous) {
              var previous = index;
              if (isIndex(index)) {
                splice.call(array, index, 1);
              } else {
                baseUnset(array, index);
              }
            }
          }
          return array;
        }
        __name(basePullAt, "basePullAt");
        function baseRandom(lower, upper) {
          return lower + nativeFloor(nativeRandom() * (upper - lower + 1));
        }
        __name(baseRandom, "baseRandom");
        function baseRange(start, end, step, fromRight) {
          var index = -1, length = nativeMax(nativeCeil((end - start) / (step || 1)), 0), result2 = Array2(length);
          while (length--) {
            result2[fromRight ? length : ++index] = start;
            start += step;
          }
          return result2;
        }
        __name(baseRange, "baseRange");
        function baseRepeat(string, n2) {
          var result2 = "";
          if (!string || n2 < 1 || n2 > MAX_SAFE_INTEGER) {
            return result2;
          }
          do {
            if (n2 % 2) {
              result2 += string;
            }
            n2 = nativeFloor(n2 / 2);
            if (n2) {
              string += string;
            }
          } while (n2);
          return result2;
        }
        __name(baseRepeat, "baseRepeat");
        function baseRest(func, start) {
          return setToString(overRest(func, start, identity), func + "");
        }
        __name(baseRest, "baseRest");
        function baseSample(collection) {
          return arraySample(values(collection));
        }
        __name(baseSample, "baseSample");
        function baseSampleSize(collection, n2) {
          var array = values(collection);
          return shuffleSelf(array, baseClamp(n2, 0, array.length));
        }
        __name(baseSampleSize, "baseSampleSize");
        function baseSet(object, path67, value, customizer) {
          if (!isObject2(object)) {
            return object;
          }
          path67 = castPath(path67, object);
          var index = -1, length = path67.length, lastIndex = length - 1, nested = object;
          while (nested != null && ++index < length) {
            var key = toKey(path67[index]), newValue = value;
            if (key === "__proto__" || key === "constructor" || key === "prototype") {
              return object;
            }
            if (index != lastIndex) {
              var objValue = nested[key];
              newValue = customizer ? customizer(objValue, key, nested) : undefined2;
              if (newValue === undefined2) {
                newValue = isObject2(objValue) ? objValue : isIndex(path67[index + 1]) ? [] : {};
              }
            }
            assignValue(nested, key, newValue);
            nested = nested[key];
          }
          return object;
        }
        __name(baseSet, "baseSet");
        var baseSetData = !metaMap ? identity : function(func, data) {
          metaMap.set(func, data);
          return func;
        };
        var baseSetToString = !defineProperty2 ? identity : function(func, string) {
          return defineProperty2(func, "toString", {
            "configurable": true,
            "enumerable": false,
            "value": constant(string),
            "writable": true
          });
        };
        function baseShuffle(collection) {
          return shuffleSelf(values(collection));
        }
        __name(baseShuffle, "baseShuffle");
        function baseSlice(array, start, end) {
          var index = -1, length = array.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 result2 = Array2(length);
          while (++index < length) {
            result2[index] = array[index + start];
          }
          return result2;
        }
        __name(baseSlice, "baseSlice");
        function baseSome(collection, predicate) {
          var result2;
          baseEach(collection, function(value, index, collection2) {
            result2 = predicate(value, index, collection2);
            return !result2;
          });
          return !!result2;
        }
        __name(baseSome, "baseSome");
        function baseSortedIndex(array, value, retHighest) {
          var low = 0, high = array == null ? low : array.length;
          if (typeof value == "number" && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
            while (low < high) {
              var mid = low + high >>> 1, computed = array[mid];
              if (computed !== null && !isSymbol(computed) && (retHighest ? computed <= value : computed < value)) {
                low = mid + 1;
              } else {
                high = mid;
              }
            }
            return high;
          }
          return baseSortedIndexBy(array, value, identity, retHighest);
        }
        __name(baseSortedIndex, "baseSortedIndex");
        function baseSortedIndexBy(array, value, iteratee2, retHighest) {
          var low = 0, high = array == null ? 0 : array.length;
          if (high === 0) {
            return 0;
          }
          value = iteratee2(value);
          var valIsNaN = value !== value, valIsNull = value === null, valIsSymbol = isSymbol(value), valIsUndefined = value === undefined2;
          while (low < high) {
            var mid = nativeFloor((low + high) / 2), computed = iteratee2(array[mid]), othIsDefined = computed !== undefined2, othIsNull = computed === null, othIsReflexive = computed === computed, othIsSymbol = isSymbol(computed);
            if (valIsNaN) {
              var setLow = retHighest || othIsReflexive;
            } else if (valIsUndefined) {
              setLow = othIsReflexive && (retHighest || othIsDefined);
            } else if (valIsNull) {
              setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
            } else if (valIsSymbol) {
              setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
            } else if (othIsNull || othIsSymbol) {
              setLow = false;
            } else {
              setLow = retHighest ? computed <= value : computed < value;
            }
            if (setLow) {
              low = mid + 1;
            } else {
              high = mid;
            }
          }
          return nativeMin(high, MAX_ARRAY_INDEX);
        }
        __name(baseSortedIndexBy, "baseSortedIndexBy");
        function baseSortedUniq(array, iteratee2) {
          var index = -1, length = array.length, resIndex = 0, result2 = [];
          while (++index < length) {
            var value = array[index], computed = iteratee2 ? iteratee2(value) : value;
            if (!index || !eq(computed, seen)) {
              var seen = computed;
              result2[resIndex++] = value === 0 ? 0 : value;
            }
          }
          return result2;
        }
        __name(baseSortedUniq, "baseSortedUniq");
        function baseToNumber(value) {
          if (typeof value == "number") {
            return value;
          }
          if (isSymbol(value)) {
            return NAN;
          }
          return +value;
        }
        __name(baseToNumber, "baseToNumber");
        function baseToString(value) {
          if (typeof value == "string") {
            return value;
          }
          if (isArray(value)) {
            return arrayMap(value, baseToString) + "";
          }
          if (isSymbol(value)) {
            return symbolToString ? symbolToString.call(value) : "";
          }
          var result2 = value + "";
          return result2 == "0" && 1 / value == -INFINITY2 ? "-0" : result2;
        }
        __name(baseToString, "baseToString");
        function baseUniq(array, iteratee2, comparator) {
          var index = -1, includes2 = arrayIncludes, length = array.length, isCommon = true, result2 = [], seen = result2;
          if (comparator) {
            isCommon = false;
            includes2 = arrayIncludesWith;
          } else if (length >= LARGE_ARRAY_SIZE) {
            var set2 = iteratee2 ? null : createSet(array);
            if (set2) {
              return setToArray(set2);
            }
            isCommon = false;
            includes2 = cacheHas;
            seen = new SetCache();
          } else {
            seen = iteratee2 ? [] : result2;
          }
          outer:
            while (++index < length) {
              var value = array[index], computed = iteratee2 ? iteratee2(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 (iteratee2) {
                  seen.push(computed);
                }
                result2.push(value);
              } else if (!includes2(seen, computed, comparator)) {
                if (seen !== result2) {
                  seen.push(computed);
                }
                result2.push(value);
              }
            }
          return result2;
        }
        __name(baseUniq, "baseUniq");
        function baseUnset(object, path67) {
          path67 = castPath(path67, object);
          object = parent(object, path67);
          return object == null || delete object[toKey(last(path67))];
        }
        __name(baseUnset, "baseUnset");
        function baseUpdate(object, path67, updater, customizer) {
          return baseSet(object, path67, updater(baseGet(object, path67)), customizer);
        }
        __name(baseUpdate, "baseUpdate");
        function baseWhile(array, predicate, isDrop, fromRight) {
          var length = array.length, index = fromRight ? length : -1;
          while ((fromRight ? index-- : ++index < length) && predicate(array[index], index, array)) {
          }
          return isDrop ? baseSlice(array, fromRight ? 0 : index, fromRight ? index + 1 : length) : baseSlice(array, fromRight ? index + 1 : 0, fromRight ? length : index);
        }
        __name(baseWhile, "baseWhile");
        function baseWrapperValue(value, actions) {
          var result2 = value;
          if (result2 instanceof LazyWrapper) {
            result2 = result2.value();
          }
          return arrayReduce(actions, function(result3, action) {
            return action.func.apply(action.thisArg, arrayPush([result3], action.args));
          }, result2);
        }
        __name(baseWrapperValue, "baseWrapperValue");
        function baseXor(arrays, iteratee2, comparator) {
          var length = arrays.length;
          if (length < 2) {
            return length ? baseUniq(arrays[0]) : [];
          }
          var index = -1, result2 = Array2(length);
          while (++index < length) {
            var array = arrays[index], othIndex = -1;
            while (++othIndex < length) {
              if (othIndex != index) {
                result2[index] = baseDifference(result2[index] || array, arrays[othIndex], iteratee2, comparator);
              }
            }
          }
          return baseUniq(baseFlatten(result2, 1), iteratee2, comparator);
        }
        __name(baseXor, "baseXor");
        function baseZipObject(props, values2, assignFunc) {
          var index = -1, length = props.length, valsLength = values2.length, result2 = {};
          while (++index < length) {
            var value = index < valsLength ? values2[index] : undefined2;
            assignFunc(result2, props[index], value);
          }
          return result2;
        }
        __name(baseZipObject, "baseZipObject");
        function castArrayLikeObject(value) {
          return isArrayLikeObject(value) ? value : [];
        }
        __name(castArrayLikeObject, "castArrayLikeObject");
        function castFunction(value) {
          return typeof value == "function" ? value : identity;
        }
        __name(castFunction, "castFunction");
        function castPath(value, object) {
          if (isArray(value)) {
            return value;
          }
          return isKey(value, object) ? [value] : stringToPath(toString2(value));
        }
        __name(castPath, "castPath");
        var castRest = baseRest;
        function castSlice(array, start, end) {
          var length = array.length;
          end = end === undefined2 ? length : end;
          return !start && end >= length ? array : baseSlice(array, start, end);
        }
        __name(castSlice, "castSlice");
        var clearTimeout2 = ctxClearTimeout || function(id) {
          return root.clearTimeout(id);
        };
        function cloneBuffer(buffer, isDeep) {
          if (isDeep) {
            return buffer.slice();
          }
          var length = buffer.length, result2 = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
          buffer.copy(result2);
          return result2;
        }
        __name(cloneBuffer, "cloneBuffer");
        function cloneArrayBuffer(arrayBuffer2) {
          var result2 = new arrayBuffer2.constructor(arrayBuffer2.byteLength);
          new Uint8Array2(result2).set(new Uint8Array2(arrayBuffer2));
          return result2;
        }
        __name(cloneArrayBuffer, "cloneArrayBuffer");
        function cloneDataView(dataView, isDeep) {
          var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
          return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
        }
        __name(cloneDataView, "cloneDataView");
        function cloneRegExp(regexp) {
          var result2 = new regexp.constructor(regexp.source, reFlags.exec(regexp));
          result2.lastIndex = regexp.lastIndex;
          return result2;
        }
        __name(cloneRegExp, "cloneRegExp");
        function cloneSymbol(symbol) {
          return symbolValueOf ? Object2(symbolValueOf.call(symbol)) : {};
        }
        __name(cloneSymbol, "cloneSymbol");
        function cloneTypedArray(typedArray, isDeep) {
          var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
          return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
        }
        __name(cloneTypedArray, "cloneTypedArray");
        function compareAscending(value, other) {
          if (value !== other) {
            var valIsDefined = value !== undefined2, valIsNull = value === null, valIsReflexive = value === value, valIsSymbol = isSymbol(value);
            var othIsDefined = other !== undefined2, othIsNull = other === null, othIsReflexive = other === other, othIsSymbol = isSymbol(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;
        }
        __name(compareAscending, "compareAscending");
        function compareMultiple(object, other, orders) {
          var index = -1, objCriteria = object.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length;
          while (++index < length) {
            var result2 = compareAscending(objCriteria[index], othCriteria[index]);
            if (result2) {
              if (index >= ordersLength) {
                return result2;
              }
              var order = orders[index];
              return result2 * (order == "desc" ? -1 : 1);
            }
          }
          return object.index - other.index;
        }
        __name(compareMultiple, "compareMultiple");
        function composeArgs(args, partials, holders, isCurried) {
          var argsIndex = -1, argsLength = args.length, holdersLength = holders.length, leftIndex = -1, leftLength = partials.length, rangeLength = nativeMax(argsLength - holdersLength, 0), result2 = Array2(leftLength + rangeLength), isUncurried = !isCurried;
          while (++leftIndex < leftLength) {
            result2[leftIndex] = partials[leftIndex];
          }
          while (++argsIndex < holdersLength) {
            if (isUncurried || argsIndex < argsLength) {
              result2[holders[argsIndex]] = args[argsIndex];
            }
          }
          while (rangeLength--) {
            result2[leftIndex++] = args[argsIndex++];
          }
          return result2;
        }
        __name(composeArgs, "composeArgs");
        function composeArgsRight(args, partials, holders, isCurried) {
          var argsIndex = -1, argsLength = args.length, holdersIndex = -1, holdersLength = holders.length, rightIndex = -1, rightLength = partials.length, rangeLength = nativeMax(argsLength - holdersLength, 0), result2 = Array2(rangeLength + rightLength), isUncurried = !isCurried;
          while (++argsIndex < rangeLength) {
            result2[argsIndex] = args[argsIndex];
          }
          var offset = argsIndex;
          while (++rightIndex < rightLength) {
            result2[offset + rightIndex] = partials[rightIndex];
          }
          while (++holdersIndex < holdersLength) {
            if (isUncurried || argsIndex < argsLength) {
              result2[offset + holders[holdersIndex]] = args[argsIndex++];
            }
          }
          return result2;
        }
        __name(composeArgsRight, "composeArgsRight");
        function copyArray(source, array) {
          var index = -1, length = source.length;
          array || (array = Array2(length));
          while (++index < length) {
            array[index] = source[index];
          }
          return array;
        }
        __name(copyArray, "copyArray");
        function copyObject(source, props, object, customizer) {
          var isNew = !object;
          object || (object = {});
          var index = -1, length = props.length;
          while (++index < length) {
            var key = props[index];
            var newValue = customizer ? customizer(object[key], source[key], key, object, source) : undefined2;
            if (newValue === undefined2) {
              newValue = source[key];
            }
            if (isNew) {
              baseAssignValue(object, key, newValue);
            } else {
              assignValue(object, key, newValue);
            }
          }
          return object;
        }
        __name(copyObject, "copyObject");
        function copySymbols(source, object) {
          return copyObject(source, getSymbols(source), object);
        }
        __name(copySymbols, "copySymbols");
        function copySymbolsIn(source, object) {
          return copyObject(source, getSymbolsIn(source), object);
        }
        __name(copySymbolsIn, "copySymbolsIn");
        function createAggregator(setter, initializer) {
          return function(collection, iteratee2) {
            var func = isArray(collection) ? arrayAggregator : baseAggregator, accumulator = initializer ? initializer() : {};
            return func(collection, setter, getIteratee(iteratee2, 2), accumulator);
          };
        }
        __name(createAggregator, "createAggregator");
        function createAssigner(assigner) {
          return baseRest(function(object, sources) {
            var index = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : undefined2, guard = length > 2 ? sources[2] : undefined2;
            customizer = assigner.length > 3 && typeof customizer == "function" ? (length--, customizer) : undefined2;
            if (guard && isIterateeCall(sources[0], sources[1], guard)) {
              customizer = length < 3 ? undefined2 : customizer;
              length = 1;
            }
            object = Object2(object);
            while (++index < length) {
              var source = sources[index];
              if (source) {
                assigner(object, source, index, customizer);
              }
            }
            return object;
          });
        }
        __name(createAssigner, "createAssigner");
        function createBaseEach(eachFunc, fromRight) {
          return function(collection, iteratee2) {
            if (collection == null) {
              return collection;
            }
            if (!isArrayLike(collection)) {
              return eachFunc(collection, iteratee2);
            }
            var length = collection.length, index = fromRight ? length : -1, iterable = Object2(collection);
            while (fromRight ? index-- : ++index < length) {
              if (iteratee2(iterable[index], index, iterable) === false) {
                break;
              }
            }
            return collection;
          };
        }
        __name(createBaseEach, "createBaseEach");
        function createBaseFor(fromRight) {
          return function(object, iteratee2, keysFunc) {
            var index = -1, iterable = Object2(object), props = keysFunc(object), length = props.length;
            while (length--) {
              var key = props[fromRight ? length : ++index];
              if (iteratee2(iterable[key], key, iterable) === false) {
                break;
              }
            }
            return object;
          };
        }
        __name(createBaseFor, "createBaseFor");
        function createBind(func, bitmask, thisArg) {
          var isBind = bitmask & WRAP_BIND_FLAG, Ctor = createCtor(func);
          function wrapper() {
            var fn2 = this && this !== root && this instanceof wrapper ? Ctor : func;
            return fn2.apply(isBind ? thisArg : this, arguments);
          }
          __name(wrapper, "wrapper");
          return wrapper;
        }
        __name(createBind, "createBind");
        function createCaseFirst(methodName) {
          return function(string) {
            string = toString2(string);
            var strSymbols = hasUnicode(string) ? stringToArray(string) : undefined2;
            var chr = strSymbols ? strSymbols[0] : string.charAt(0);
            var trailing = strSymbols ? castSlice(strSymbols, 1).join("") : string.slice(1);
            return chr[methodName]() + trailing;
          };
        }
        __name(createCaseFirst, "createCaseFirst");
        function createCompounder(callback) {
          return function(string) {
            return arrayReduce(words(deburr(string).replace(reApos, "")), callback, "");
          };
        }
        __name(createCompounder, "createCompounder");
        function createCtor(Ctor) {
          return function() {
            var args = arguments;
            switch (args.length) {
              case 0:
                return new Ctor();
              case 1:
                return new Ctor(args[0]);
              case 2:
                return new Ctor(args[0], args[1]);
              case 3:
                return new Ctor(args[0], args[1], args[2]);
              case 4:
                return new Ctor(args[0], args[1], args[2], args[3]);
              case 5:
                return new Ctor(args[0], args[1], args[2], args[3], args[4]);
              case 6:
                return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);
              case 7:
                return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
            }
            var thisBinding = baseCreate(Ctor.prototype), result2 = Ctor.apply(thisBinding, args);
            return isObject2(result2) ? result2 : thisBinding;
          };
        }
        __name(createCtor, "createCtor");
        function createCurry(func, bitmask, arity) {
          var Ctor = createCtor(func);
          function wrapper() {
            var length = arguments.length, args = Array2(length), index = length, placeholder = getHolder(wrapper);
            while (index--) {
              args[index] = arguments[index];
            }
            var holders = length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder ? [] : replaceHolders(args, placeholder);
            length -= holders.length;
            if (length < arity) {
              return createRecurry(
                func,
                bitmask,
                createHybrid,
                wrapper.placeholder,
                undefined2,
                args,
                holders,
                undefined2,
                undefined2,
                arity - length
              );
            }
            var fn2 = this && this !== root && this instanceof wrapper ? Ctor : func;
            return apply(fn2, this, args);
          }
          __name(wrapper, "wrapper");
          return wrapper;
        }
        __name(createCurry, "createCurry");
        function createFind(findIndexFunc) {
          return function(collection, predicate, fromIndex) {
            var iterable = Object2(collection);
            if (!isArrayLike(collection)) {
              var iteratee2 = getIteratee(predicate, 3);
              collection = keys(collection);
              predicate = /* @__PURE__ */ __name(function(key) {
                return iteratee2(iterable[key], key, iterable);
              }, "predicate");
            }
            var index = findIndexFunc(collection, predicate, fromIndex);
            return index > -1 ? iterable[iteratee2 ? collection[index] : index] : undefined2;
          };
        }
        __name(createFind, "createFind");
        function createFlow(fromRight) {
          return flatRest(function(funcs) {
            var length = funcs.length, index = length, prereq = LodashWrapper.prototype.thru;
            if (fromRight) {
              funcs.reverse();
            }
            while (index--) {
              var func = funcs[index];
              if (typeof func != "function") {
                throw new TypeError2(FUNC_ERROR_TEXT);
              }
              if (prereq && !wrapper && getFuncName(func) == "wrapper") {
                var wrapper = new LodashWrapper([], true);
              }
            }
            index = wrapper ? index : length;
            while (++index < length) {
              func = funcs[index];
              var funcName = getFuncName(func), data = funcName == "wrapper" ? getData(func) : undefined2;
              if (data && isLaziable(data[0]) && data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) && !data[4].length && data[9] == 1) {
                wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
              } else {
                wrapper = func.length == 1 && isLaziable(func) ? wrapper[funcName]() : wrapper.thru(func);
              }
            }
            return function() {
              var args = arguments, value = args[0];
              if (wrapper && args.length == 1 && isArray(value)) {
                return wrapper.plant(value).value();
              }
              var index2 = 0, result2 = length ? funcs[index2].apply(this, args) : value;
              while (++index2 < length) {
                result2 = funcs[index2].call(this, result2);
              }
              return result2;
            };
          });
        }
        __name(createFlow, "createFlow");
        function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary2, arity) {
          var isAry = bitmask & WRAP_ARY_FLAG, isBind = bitmask & WRAP_BIND_FLAG, isBindKey = bitmask & WRAP_BIND_KEY_FLAG, isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG), isFlip = bitmask & WRAP_FLIP_FLAG, Ctor = isBindKey ? undefined2 : createCtor(func);
          function wrapper() {
            var length = arguments.length, args = Array2(length), index = length;
            while (index--) {
              args[index] = arguments[index];
            }
            if (isCurried) {
              var placeholder = getHolder(wrapper), holdersCount = countHolders(args, placeholder);
            }
            if (partials) {
              args = composeArgs(args, partials, holders, isCurried);
            }
            if (partialsRight) {
              args = composeArgsRight(args, partialsRight, holdersRight, isCurried);
            }
            length -= holdersCount;
            if (isCurried && length < arity) {
              var newHolders = replaceHolders(args, placeholder);
              return createRecurry(
                func,
                bitmask,
                createHybrid,
                wrapper.placeholder,
                thisArg,
                args,
                newHolders,
                argPos,
                ary2,
                arity - length
              );
            }
            var thisBinding = isBind ? thisArg : this, fn2 = isBindKey ? thisBinding[func] : func;
            length = args.length;
            if (argPos) {
              args = reorder(args, argPos);
            } else if (isFlip && length > 1) {
              args.reverse();
            }
            if (isAry && ary2 < length) {
              args.length = ary2;
            }
            if (this && this !== root && this instanceof wrapper) {
              fn2 = Ctor || createCtor(fn2);
            }
            return fn2.apply(thisBinding, args);
          }
          __name(wrapper, "wrapper");
          return wrapper;
        }
        __name(createHybrid, "createHybrid");
        function createInverter(setter, toIteratee) {
          return function(object, iteratee2) {
            return baseInverter(object, setter, toIteratee(iteratee2), {});
          };
        }
        __name(createInverter, "createInverter");
        function createMathOperation(operator, defaultValue) {
          return function(value, other) {
            var result2;
            if (value === undefined2 && other === undefined2) {
              return defaultValue;
            }
            if (value !== undefined2) {
              result2 = value;
            }
            if (other !== undefined2) {
              if (result2 === undefined2) {
                return other;
              }
              if (typeof value == "string" || typeof other == "string") {
                value = baseToString(value);
                other = baseToString(other);
              } else {
                value = baseToNumber(value);
                other = baseToNumber(other);
              }
              result2 = operator(value, other);
            }
            return result2;
          };
        }
        __name(createMathOperation, "createMathOperation");
        function createOver(arrayFunc) {
          return flatRest(function(iteratees) {
            iteratees = arrayMap(iteratees, baseUnary(getIteratee()));
            return baseRest(function(args) {
              var thisArg = this;
              return arrayFunc(iteratees, function(iteratee2) {
                return apply(iteratee2, thisArg, args);
              });
            });
          });
        }
        __name(createOver, "createOver");
        function createPadding(length, chars) {
          chars = chars === undefined2 ? " " : baseToString(chars);
          var charsLength = chars.length;
          if (charsLength < 2) {
            return charsLength ? baseRepeat(chars, length) : chars;
          }
          var result2 = baseRepeat(chars, nativeCeil(length / stringSize(chars)));
          return hasUnicode(chars) ? castSlice(stringToArray(result2), 0, length).join("") : result2.slice(0, length);
        }
        __name(createPadding, "createPadding");
        function createPartial(func, bitmask, thisArg, partials) {
          var isBind = bitmask & WRAP_BIND_FLAG, Ctor = createCtor(func);
          function wrapper() {
            var argsIndex = -1, argsLength = arguments.length, leftIndex = -1, leftLength = partials.length, args = Array2(leftLength + argsLength), fn2 = this && this !== root && this instanceof wrapper ? Ctor : func;
            while (++leftIndex < leftLength) {
              args[leftIndex] = partials[leftIndex];
            }
            while (argsLength--) {
              args[leftIndex++] = arguments[++argsIndex];
            }
            return apply(fn2, isBind ? thisArg : this, args);
          }
          __name(wrapper, "wrapper");
          return wrapper;
        }
        __name(createPartial, "createPartial");
        function createRange(fromRight) {
          return function(start, end, step) {
            if (step && typeof step != "number" && isIterateeCall(start, end, step)) {
              end = step = undefined2;
            }
            start = toFinite(start);
            if (end === undefined2) {
              end = start;
              start = 0;
            } else {
              end = toFinite(end);
            }
            step = step === undefined2 ? start < end ? 1 : -1 : toFinite(step);
            return baseRange(start, end, step, fromRight);
          };
        }
        __name(createRange, "createRange");
        function createRelationalOperation(operator) {
          return function(value, other) {
            if (!(typeof value == "string" && typeof other == "string")) {
              value = toNumber(value);
              other = toNumber(other);
            }
            return operator(value, other);
          };
        }
        __name(createRelationalOperation, "createRelationalOperation");
        function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary2, arity) {
          var isCurry = bitmask & WRAP_CURRY_FLAG, newHolders = isCurry ? holders : undefined2, newHoldersRight = isCurry ? undefined2 : holders, newPartials = isCurry ? partials : undefined2, newPartialsRight = isCurry ? undefined2 : partials;
          bitmask |= isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG;
          bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);
          if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {
            bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);
          }
          var newData = [
            func,
            bitmask,
            thisArg,
            newPartials,
            newHolders,
            newPartialsRight,
            newHoldersRight,
            argPos,
            ary2,
            arity
          ];
          var result2 = wrapFunc.apply(undefined2, newData);
          if (isLaziable(func)) {
            setData(result2, newData);
          }
          result2.placeholder = placeholder;
          return setWrapToString(result2, func, bitmask);
        }
        __name(createRecurry, "createRecurry");
        function createRound(methodName) {
          var func = Math2[methodName];
          return function(number, precision) {
            number = toNumber(number);
            precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);
            if (precision && nativeIsFinite(number)) {
              var pair = (toString2(number) + "e").split("e"), value = func(pair[0] + "e" + (+pair[1] + precision));
              pair = (toString2(value) + "e").split("e");
              return +(pair[0] + "e" + (+pair[1] - precision));
            }
            return func(number);
          };
        }
        __name(createRound, "createRound");
        var createSet = !(Set2 && 1 / setToArray(new Set2([, -0]))[1] == INFINITY2) ? noop : function(values2) {
          return new Set2(values2);
        };
        function createToPairs(keysFunc) {
          return function(object) {
            var tag = getTag(object);
            if (tag == mapTag) {
              return mapToArray(object);
            }
            if (tag == setTag2) {
              return setToPairs(object);
            }
            return baseToPairs(object, keysFunc(object));
          };
        }
        __name(createToPairs, "createToPairs");
        function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary2, arity) {
          var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;
          if (!isBindKey && typeof func != "function") {
            throw new TypeError2(FUNC_ERROR_TEXT);
          }
          var length = partials ? partials.length : 0;
          if (!length) {
            bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);
            partials = holders = undefined2;
          }
          ary2 = ary2 === undefined2 ? ary2 : nativeMax(toInteger(ary2), 0);
          arity = arity === undefined2 ? arity : toInteger(arity);
          length -= holders ? holders.length : 0;
          if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {
            var partialsRight = partials, holdersRight = holders;
            partials = holders = undefined2;
          }
          var data = isBindKey ? undefined2 : getData(func);
          var newData = [
            func,
            bitmask,
            thisArg,
            partials,
            holders,
            partialsRight,
            holdersRight,
            argPos,
            ary2,
            arity
          ];
          if (data) {
            mergeData(newData, data);
          }
          func = newData[0];
          bitmask = newData[1];
          thisArg = newData[2];
          partials = newData[3];
          holders = newData[4];
          arity = newData[9] = newData[9] === undefined2 ? isBindKey ? 0 : func.length : nativeMax(newData[9] - length, 0);
          if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {
            bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);
          }
          if (!bitmask || bitmask == WRAP_BIND_FLAG) {
            var result2 = createBind(func, bitmask, thisArg);
          } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {
            result2 = createCurry(func, bitmask, arity);
          } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {
            result2 = createPartial(func, bitmask, thisArg, partials);
          } else {
            result2 = createHybrid.apply(undefined2, newData);
          }
          var setter = data ? baseSetData : setData;
          return setWrapToString(setter(result2, newData), func, bitmask);
        }
        __name(createWrap, "createWrap");
        function customDefaultsAssignIn(objValue, srcValue, key, object) {
          if (objValue === undefined2 || eq(objValue, objectProto[key]) && !hasOwnProperty2.call(object, key)) {
            return srcValue;
          }
          return objValue;
        }
        __name(customDefaultsAssignIn, "customDefaultsAssignIn");
        function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {
          if (isObject2(objValue) && isObject2(srcValue)) {
            stack.set(srcValue, objValue);
            baseMerge(objValue, srcValue, undefined2, customDefaultsMerge, stack);
            stack["delete"](srcValue);
          }
          return objValue;
        }
        __name(customDefaultsMerge, "customDefaultsMerge");
        function customOmitClone(value) {
          return isPlainObject2(value) ? undefined2 : value;
        }
        __name(customOmitClone, "customOmitClone");
        function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
          var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length;
          if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
            return false;
          }
          var arrStacked = stack.get(array);
          var othStacked = stack.get(other);
          if (arrStacked && othStacked) {
            return arrStacked == other && othStacked == array;
          }
          var index = -1, result2 = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : undefined2;
          stack.set(array, other);
          stack.set(other, array);
          while (++index < arrLength) {
            var arrValue = array[index], othValue = other[index];
            if (customizer) {
              var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
            }
            if (compared !== undefined2) {
              if (compared) {
                continue;
              }
              result2 = false;
              break;
            }
            if (seen) {
              if (!arraySome(other, function(othValue2, othIndex) {
                if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
                  return seen.push(othIndex);
                }
              })) {
                result2 = false;
                break;
              }
            } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
              result2 = false;
              break;
            }
          }
          stack["delete"](array);
          stack["delete"](other);
          return result2;
        }
        __name(equalArrays, "equalArrays");
        function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
          switch (tag) {
            case dataViewTag:
              if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
                return false;
              }
              object = object.buffer;
              other = other.buffer;
            case arrayBufferTag:
              if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) {
                return false;
              }
              return true;
            case boolTag:
            case dateTag:
            case numberTag:
              return eq(+object, +other);
            case errorTag:
              return object.name == other.name && object.message == other.message;
            case regexpTag:
            case stringTag:
              return object == other + "";
            case mapTag:
              var convert = mapToArray;
            case setTag2:
              var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
              convert || (convert = setToArray);
              if (object.size != other.size && !isPartial) {
                return false;
              }
              var stacked = stack.get(object);
              if (stacked) {
                return stacked == other;
              }
              bitmask |= COMPARE_UNORDERED_FLAG;
              stack.set(object, other);
              var result2 = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
              stack["delete"](object);
              return result2;
            case symbolTag:
              if (symbolValueOf) {
                return symbolValueOf.call(object) == symbolValueOf.call(other);
              }
          }
          return false;
        }
        __name(equalByTag, "equalByTag");
        function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
          var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
          if (objLength != othLength && !isPartial) {
            return false;
          }
          var index = objLength;
          while (index--) {
            var key = objProps[index];
            if (!(isPartial ? key in other : hasOwnProperty2.call(other, key))) {
              return false;
            }
          }
          var objStacked = stack.get(object);
          var othStacked = stack.get(other);
          if (objStacked && othStacked) {
            return objStacked == other && othStacked == object;
          }
          var result2 = true;
          stack.set(object, other);
          stack.set(other, object);
          var skipCtor = isPartial;
          while (++index < objLength) {
            key = objProps[index];
            var objValue = object[key], othValue = other[key];
            if (customizer) {
              var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
            }
            if (!(compared === undefined2 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
              result2 = false;
              break;
            }
            skipCtor || (skipCtor = key == "constructor");
          }
          if (result2 && !skipCtor) {
            var objCtor = object.constructor, othCtor = other.constructor;
            if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
              result2 = false;
            }
          }
          stack["delete"](object);
          stack["delete"](other);
          return result2;
        }
        __name(equalObjects, "equalObjects");
        function flatRest(func) {
          return setToString(overRest(func, undefined2, flatten), func + "");
        }
        __name(flatRest, "flatRest");
        function getAllKeys(object) {
          return baseGetAllKeys(object, keys, getSymbols);
        }
        __name(getAllKeys, "getAllKeys");
        function getAllKeysIn(object) {
          return baseGetAllKeys(object, keysIn, getSymbolsIn);
        }
        __name(getAllKeysIn, "getAllKeysIn");
        var getData = !metaMap ? noop : function(func) {
          return metaMap.get(func);
        };
        function getFuncName(func) {
          var result2 = func.name + "", array = realNames[result2], length = hasOwnProperty2.call(realNames, result2) ? array.length : 0;
          while (length--) {
            var data = array[length], otherFunc = data.func;
            if (otherFunc == null || otherFunc == func) {
              return data.name;
            }
          }
          return result2;
        }
        __name(getFuncName, "getFuncName");
        function getHolder(func) {
          var object = hasOwnProperty2.call(lodash, "placeholder") ? lodash : func;
          return object.placeholder;
        }
        __name(getHolder, "getHolder");
        function getIteratee() {
          var result2 = lodash.iteratee || iteratee;
          result2 = result2 === iteratee ? baseIteratee : result2;
          return arguments.length ? result2(arguments[0], arguments[1]) : result2;
        }
        __name(getIteratee, "getIteratee");
        function getMapData(map2, key) {
          var data = map2.__data__;
          return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
        }
        __name(getMapData, "getMapData");
        function getMatchData(object) {
          var result2 = keys(object), length = result2.length;
          while (length--) {
            var key = result2[length], value = object[key];
            result2[length] = [key, value, isStrictComparable(value)];
          }
          return result2;
        }
        __name(getMatchData, "getMatchData");
        function getNative(object, key) {
          var value = getValue(object, key);
          return baseIsNative(value) ? value : undefined2;
        }
        __name(getNative, "getNative");
        function getRawTag(value) {
          var isOwn = hasOwnProperty2.call(value, symToStringTag), tag = value[symToStringTag];
          try {
            value[symToStringTag] = undefined2;
            var unmasked = true;
          } catch (e3) {
          }
          var result2 = nativeObjectToString.call(value);
          if (unmasked) {
            if (isOwn) {
              value[symToStringTag] = tag;
            } else {
              delete value[symToStringTag];
            }
          }
          return result2;
        }
        __name(getRawTag, "getRawTag");
        var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
          if (object == null) {
            return [];
          }
          object = Object2(object);
          return arrayFilter(nativeGetSymbols(object), function(symbol) {
            return propertyIsEnumerable.call(object, symbol);
          });
        };
        var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
          var result2 = [];
          while (object) {
            arrayPush(result2, getSymbols(object));
            object = getPrototype(object);
          }
          return result2;
        };
        var getTag = baseGetTag;
        if (DataView2 && getTag(new DataView2(new ArrayBuffer(1))) != dataViewTag || Map2 && getTag(new Map2()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set2 && getTag(new Set2()) != setTag2 || WeakMap2 && getTag(new WeakMap2()) != weakMapTag) {
          getTag = /* @__PURE__ */ __name(function(value) {
            var result2 = baseGetTag(value), Ctor = result2 == objectTag ? value.constructor : undefined2, ctorString = Ctor ? toSource(Ctor) : "";
            if (ctorString) {
              switch (ctorString) {
                case dataViewCtorString:
                  return dataViewTag;
                case mapCtorString:
                  return mapTag;
                case promiseCtorString:
                  return promiseTag;
                case setCtorString:
                  return setTag2;
                case weakMapCtorString:
                  return weakMapTag;
              }
            }
            return result2;
          }, "getTag");
        }
        function getView(start, end, transforms) {
          var index = -1, length = transforms.length;
          while (++index < length) {
            var data = transforms[index], size2 = data.size;
            switch (data.type) {
              case "drop":
                start += size2;
                break;
              case "dropRight":
                end -= size2;
                break;
              case "take":
                end = nativeMin(end, start + size2);
                break;
              case "takeRight":
                start = nativeMax(start, end - size2);
                break;
            }
          }
          return { "start": start, "end": end };
        }
        __name(getView, "getView");
        function getWrapDetails(source) {
          var match = source.match(reWrapDetails);
          return match ? match[1].split(reSplitDetails) : [];
        }
        __name(getWrapDetails, "getWrapDetails");
        function hasPath(object, path67, hasFunc) {
          path67 = castPath(path67, object);
          var index = -1, length = path67.length, result2 = false;
          while (++index < length) {
            var key = toKey(path67[index]);
            if (!(result2 = object != null && hasFunc(object, key))) {
              break;
            }
            object = object[key];
          }
          if (result2 || ++index != length) {
            return result2;
          }
          length = object == null ? 0 : object.length;
          return !!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object));
        }
        __name(hasPath, "hasPath");
        function initCloneArray(array) {
          var length = array.length, result2 = new array.constructor(length);
          if (length && typeof array[0] == "string" && hasOwnProperty2.call(array, "index")) {
            result2.index = array.index;
            result2.input = array.input;
          }
          return result2;
        }
        __name(initCloneArray, "initCloneArray");
        function initCloneObject(object) {
          return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};
        }
        __name(initCloneObject, "initCloneObject");
        function initCloneByTag(object, tag, isDeep) {
          var Ctor = object.constructor;
          switch (tag) {
            case arrayBufferTag:
              return cloneArrayBuffer(object);
            case boolTag:
            case dateTag:
              return new Ctor(+object);
            case dataViewTag:
              return cloneDataView(object, isDeep);
            case float32Tag:
            case float64Tag:
            case int8Tag:
            case int16Tag:
            case int32Tag:
            case uint8Tag:
            case uint8ClampedTag:
            case uint16Tag:
            case uint32Tag:
              return cloneTypedArray(object, isDeep);
            case mapTag:
              return new Ctor();
            case numberTag:
            case stringTag:
              return new Ctor(object);
            case regexpTag:
              return cloneRegExp(object);
            case setTag2:
              return new Ctor();
            case symbolTag:
              return cloneSymbol(object);
          }
        }
        __name(initCloneByTag, "initCloneByTag");
        function insertWrapDetails(source, details) {
          var length = details.length;
          if (!length) {
            return source;
          }
          var lastIndex = length - 1;
          details[lastIndex] = (length > 1 ? "& " : "") + details[lastIndex];
          details = details.join(length > 2 ? ", " : " ");
          return source.replace(reWrapComment, "{\n/* [wrapped with " + details + "] */\n");
        }
        __name(insertWrapDetails, "insertWrapDetails");
        function isFlattenable(value) {
          return isArray(value) || isArguments(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);
        }
        __name(isFlattenable, "isFlattenable");
        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);
        }
        __name(isIndex, "isIndex");
        function isIterateeCall(value, index, object) {
          if (!isObject2(object)) {
            return false;
          }
          var type = typeof index;
          if (type == "number" ? isArrayLike(object) && isIndex(index, object.length) : type == "string" && index in object) {
            return eq(object[index], value);
          }
          return false;
        }
        __name(isIterateeCall, "isIterateeCall");
        function isKey(value, object) {
          if (isArray(value)) {
            return false;
          }
          var type = typeof value;
          if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol(value)) {
            return true;
          }
          return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object2(object);
        }
        __name(isKey, "isKey");
        function isKeyable(value) {
          var type = typeof value;
          return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
        }
        __name(isKeyable, "isKeyable");
        function isLaziable(func) {
          var funcName = getFuncName(func), other = lodash[funcName];
          if (typeof other != "function" || !(funcName in LazyWrapper.prototype)) {
            return false;
          }
          if (func === other) {
            return true;
          }
          var data = getData(other);
          return !!data && func === data[0];
        }
        __name(isLaziable, "isLaziable");
        function isMasked(func) {
          return !!maskSrcKey && maskSrcKey in func;
        }
        __name(isMasked, "isMasked");
        var isMaskable = coreJsData ? isFunction2 : stubFalse;
        function isPrototype(value) {
          var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto;
          return value === proto;
        }
        __name(isPrototype, "isPrototype");
        function isStrictComparable(value) {
          return value === value && !isObject2(value);
        }
        __name(isStrictComparable, "isStrictComparable");
        function matchesStrictComparable(key, srcValue) {
          return function(object) {
            if (object == null) {
              return false;
            }
            return object[key] === srcValue && (srcValue !== undefined2 || key in Object2(object));
          };
        }
        __name(matchesStrictComparable, "matchesStrictComparable");
        function memoizeCapped(func) {
          var result2 = memoize(func, function(key) {
            if (cache2.size === MAX_MEMOIZE_SIZE) {
              cache2.clear();
            }
            return key;
          });
          var cache2 = result2.cache;
          return result2;
        }
        __name(memoizeCapped, "memoizeCapped");
        function mergeData(data, source) {
          var bitmask = data[1], srcBitmask = source[1], newBitmask = bitmask | srcBitmask, isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);
          var isCombo = srcBitmask == WRAP_ARY_FLAG && bitmask == WRAP_CURRY_FLAG || srcBitmask == WRAP_ARY_FLAG && bitmask == WRAP_REARG_FLAG && data[7].length <= source[8] || srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG) && source[7].length <= source[8] && bitmask == WRAP_CURRY_FLAG;
          if (!(isCommon || isCombo)) {
            return data;
          }
          if (srcBitmask & WRAP_BIND_FLAG) {
            data[2] = source[2];
            newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;
          }
          var value = source[3];
          if (value) {
            var partials = data[3];
            data[3] = partials ? composeArgs(partials, value, source[4]) : value;
            data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];
          }
          value = source[5];
          if (value) {
            partials = data[5];
            data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;
            data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];
          }
          value = source[7];
          if (value) {
            data[7] = value;
          }
          if (srcBitmask & WRAP_ARY_FLAG) {
            data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);
          }
          if (data[9] == null) {
            data[9] = source[9];
          }
          data[0] = source[0];
          data[1] = newBitmask;
          return data;
        }
        __name(mergeData, "mergeData");
        function nativeKeysIn(object) {
          var result2 = [];
          if (object != null) {
            for (var key in Object2(object)) {
              result2.push(key);
            }
          }
          return result2;
        }
        __name(nativeKeysIn, "nativeKeysIn");
        function objectToString2(value) {
          return nativeObjectToString.call(value);
        }
        __name(objectToString2, "objectToString");
        function overRest(func, start, transform2) {
          start = nativeMax(start === undefined2 ? func.length - 1 : start, 0);
          return function() {
            var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array2(length);
            while (++index < length) {
              array[index] = args[start + index];
            }
            index = -1;
            var otherArgs = Array2(start + 1);
            while (++index < start) {
              otherArgs[index] = args[index];
            }
            otherArgs[start] = transform2(array);
            return apply(func, this, otherArgs);
          };
        }
        __name(overRest, "overRest");
        function parent(object, path67) {
          return path67.length < 2 ? object : baseGet(object, baseSlice(path67, 0, -1));
        }
        __name(parent, "parent");
        function reorder(array, indexes) {
          var arrLength = array.length, length = nativeMin(indexes.length, arrLength), oldArray = copyArray(array);
          while (length--) {
            var index = indexes[length];
            array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined2;
          }
          return array;
        }
        __name(reorder, "reorder");
        function safeGet(object, key) {
          if (key === "constructor" && typeof object[key] === "function") {
            return;
          }
          if (key == "__proto__") {
            return;
          }
          return object[key];
        }
        __name(safeGet, "safeGet");
        var setData = shortOut(baseSetData);
        var setTimeout4 = ctxSetTimeout || function(func, wait) {
          return root.setTimeout(func, wait);
        };
        var setToString = shortOut(baseSetToString);
        function setWrapToString(wrapper, reference, bitmask) {
          var source = reference + "";
          return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));
        }
        __name(setWrapToString, "setWrapToString");
        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(undefined2, arguments);
          };
        }
        __name(shortOut, "shortOut");
        function shuffleSelf(array, size2) {
          var index = -1, length = array.length, lastIndex = length - 1;
          size2 = size2 === undefined2 ? length : size2;
          while (++index < size2) {
            var rand = baseRandom(index, lastIndex), value = array[rand];
            array[rand] = array[index];
            array[index] = value;
          }
          array.length = size2;
          return array;
        }
        __name(shuffleSelf, "shuffleSelf");
        var stringToPath = memoizeCapped(function(string) {
          var result2 = [];
          if (string.charCodeAt(0) === 46) {
            result2.push("");
          }
          string.replace(rePropName, function(match, number, quote2, subString) {
            result2.push(quote2 ? subString.replace(reEscapeChar, "$1") : number || match);
          });
          return result2;
        });
        function toKey(value) {
          if (typeof value == "string" || isSymbol(value)) {
            return value;
          }
          var result2 = value + "";
          return result2 == "0" && 1 / value == -INFINITY2 ? "-0" : result2;
        }
        __name(toKey, "toKey");
        function toSource(func) {
          if (func != null) {
            try {
              return funcToString.call(func);
            } catch (e3) {
            }
            try {
              return func + "";
            } catch (e3) {
            }
          }
          return "";
        }
        __name(toSource, "toSource");
        function updateWrapDetails(details, bitmask) {
          arrayEach(wrapFlags, function(pair) {
            var value = "_." + pair[0];
            if (bitmask & pair[1] && !arrayIncludes(details, value)) {
              details.push(value);
            }
          });
          return details.sort();
        }
        __name(updateWrapDetails, "updateWrapDetails");
        function wrapperClone(wrapper) {
          if (wrapper instanceof LazyWrapper) {
            return wrapper.clone();
          }
          var result2 = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);
          result2.__actions__ = copyArray(wrapper.__actions__);
          result2.__index__ = wrapper.__index__;
          result2.__values__ = wrapper.__values__;
          return result2;
        }
        __name(wrapperClone, "wrapperClone");
        function chunk(array, size2, guard) {
          if (guard ? isIterateeCall(array, size2, guard) : size2 === undefined2) {
            size2 = 1;
          } else {
            size2 = nativeMax(toInteger(size2), 0);
          }
          var length = array == null ? 0 : array.length;
          if (!length || size2 < 1) {
            return [];
          }
          var index = 0, resIndex = 0, result2 = Array2(nativeCeil(length / size2));
          while (index < length) {
            result2[resIndex++] = baseSlice(array, index, index += size2);
          }
          return result2;
        }
        __name(chunk, "chunk");
        function compact(array) {
          var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result2 = [];
          while (++index < length) {
            var value = array[index];
            if (value) {
              result2[resIndex++] = value;
            }
          }
          return result2;
        }
        __name(compact, "compact");
        function concat() {
          var length = arguments.length;
          if (!length) {
            return [];
          }
          var args = Array2(length - 1), array = arguments[0], index = length;
          while (index--) {
            args[index - 1] = arguments[index];
          }
          return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1));
        }
        __name(concat, "concat");
        var difference = baseRest(function(array, values2) {
          return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values2, 1, isArrayLikeObject, true)) : [];
        });
        var differenceBy = baseRest(function(array, values2) {
          var iteratee2 = last(values2);
          if (isArrayLikeObject(iteratee2)) {
            iteratee2 = undefined2;
          }
          return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values2, 1, isArrayLikeObject, true), getIteratee(iteratee2, 2)) : [];
        });
        var differenceWith = baseRest(function(array, values2) {
          var comparator = last(values2);
          if (isArrayLikeObject(comparator)) {
            comparator = undefined2;
          }
          return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values2, 1, isArrayLikeObject, true), undefined2, comparator) : [];
        });
        function drop(array, n2, guard) {
          var length = array == null ? 0 : array.length;
          if (!length) {
            return [];
          }
          n2 = guard || n2 === undefined2 ? 1 : toInteger(n2);
          return baseSlice(array, n2 < 0 ? 0 : n2, length);
        }
        __name(drop, "drop");
        function dropRight(array, n2, guard) {
          var length = array == null ? 0 : array.length;
          if (!length) {
            return [];
          }
          n2 = guard || n2 === undefined2 ? 1 : toInteger(n2);
          n2 = length - n2;
          return baseSlice(array, 0, n2 < 0 ? 0 : n2);
        }
        __name(dropRight, "dropRight");
        function dropRightWhile(array, predicate) {
          return array && array.length ? baseWhile(array, getIteratee(predicate, 3), true, true) : [];
        }
        __name(dropRightWhile, "dropRightWhile");
        function dropWhile(array, predicate) {
          return array && array.length ? baseWhile(array, getIteratee(predicate, 3), true) : [];
        }
        __name(dropWhile, "dropWhile");
        function fill2(array, value, start, end) {
          var length = array == null ? 0 : array.length;
          if (!length) {
            return [];
          }
          if (start && typeof start != "number" && isIterateeCall(array, value, start)) {
            start = 0;
            end = length;
          }
          return baseFill(array, value, start, end);
        }
        __name(fill2, "fill");
        function findIndex2(array, predicate, fromIndex) {
          var length = array == null ? 0 : array.length;
          if (!length) {
            return -1;
          }
          var index = fromIndex == null ? 0 : toInteger(fromIndex);
          if (index < 0) {
            index = nativeMax(length + index, 0);
          }
          return baseFindIndex(array, getIteratee(predicate, 3), index);
        }
        __name(findIndex2, "findIndex");
        function findLastIndex(array, predicate, fromIndex) {
          var length = array == null ? 0 : array.length;
          if (!length) {
            return -1;
          }
          var index = length - 1;
          if (fromIndex !== undefined2) {
            index = toInteger(fromIndex);
            index = fromIndex < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);
          }
          return baseFindIndex(array, getIteratee(predicate, 3), index, true);
        }
        __name(findLastIndex, "findLastIndex");
        function flatten(array) {
          var length = array == null ? 0 : array.length;
          return length ? baseFlatten(array, 1) : [];
        }
        __name(flatten, "flatten");
        function flattenDeep(array) {
          var length = array == null ? 0 : array.length;
          return length ? baseFlatten(array, INFINITY2) : [];
        }
        __name(flattenDeep, "flattenDeep");
        function flattenDepth(array, depth) {
          var length = array == null ? 0 : array.length;
          if (!length) {
            return [];
          }
          depth = depth === undefined2 ? 1 : toInteger(depth);
          return baseFlatten(array, depth);
        }
        __name(flattenDepth, "flattenDepth");
        function fromPairs(pairs) {
          var index = -1, length = pairs == null ? 0 : pairs.length, result2 = {};
          while (++index < length) {
            var pair = pairs[index];
            result2[pair[0]] = pair[1];
          }
          return result2;
        }
        __name(fromPairs, "fromPairs");
        function head(array) {
          return array && array.length ? array[0] : undefined2;
        }
        __name(head, "head");
        function indexOf(array, value, fromIndex) {
          var length = array == null ? 0 : array.length;
          if (!length) {
            return -1;
          }
          var index = fromIndex == null ? 0 : toInteger(fromIndex);
          if (index < 0) {
            index = nativeMax(length + index, 0);
          }
          return baseIndexOf(array, value, index);
        }
        __name(indexOf, "indexOf");
        function initial(array) {
          var length = array == null ? 0 : array.length;
          return length ? baseSlice(array, 0, -1) : [];
        }
        __name(initial, "initial");
        var intersection = baseRest(function(arrays) {
          var mapped = arrayMap(arrays, castArrayLikeObject);
          return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped) : [];
        });
        var intersectionBy = baseRest(function(arrays) {
          var iteratee2 = last(arrays), mapped = arrayMap(arrays, castArrayLikeObject);
          if (iteratee2 === last(mapped)) {
            iteratee2 = undefined2;
          } else {
            mapped.pop();
          }
          return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, getIteratee(iteratee2, 2)) : [];
        });
        var intersectionWith = baseRest(function(arrays) {
          var comparator = last(arrays), mapped = arrayMap(arrays, castArrayLikeObject);
          comparator = typeof comparator == "function" ? comparator : undefined2;
          if (comparator) {
            mapped.pop();
          }
          return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, undefined2, comparator) : [];
        });
        function join15(array, separator) {
          return array == null ? "" : nativeJoin.call(array, separator);
        }
        __name(join15, "join");
        function last(array) {
          var length = array == null ? 0 : array.length;
          return length ? array[length - 1] : undefined2;
        }
        __name(last, "last");
        function lastIndexOf(array, value, fromIndex) {
          var length = array == null ? 0 : array.length;
          if (!length) {
            return -1;
          }
          var index = length;
          if (fromIndex !== undefined2) {
            index = toInteger(fromIndex);
            index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);
          }
          return value === value ? strictLastIndexOf(array, value, index) : baseFindIndex(array, baseIsNaN, index, true);
        }
        __name(lastIndexOf, "lastIndexOf");
        function nth(array, n2) {
          return array && array.length ? baseNth(array, toInteger(n2)) : undefined2;
        }
        __name(nth, "nth");
        var pull = baseRest(pullAll);
        function pullAll(array, values2) {
          return array && array.length && values2 && values2.length ? basePullAll(array, values2) : array;
        }
        __name(pullAll, "pullAll");
        function pullAllBy(array, values2, iteratee2) {
          return array && array.length && values2 && values2.length ? basePullAll(array, values2, getIteratee(iteratee2, 2)) : array;
        }
        __name(pullAllBy, "pullAllBy");
        function pullAllWith(array, values2, comparator) {
          return array && array.length && values2 && values2.length ? basePullAll(array, values2, undefined2, comparator) : array;
        }
        __name(pullAllWith, "pullAllWith");
        var pullAt = flatRest(function(array, indexes) {
          var length = array == null ? 0 : array.length, result2 = baseAt(array, indexes);
          basePullAt(array, arrayMap(indexes, function(index) {
            return isIndex(index, length) ? +index : index;
          }).sort(compareAscending));
          return result2;
        });
        function remove(array, predicate) {
          var result2 = [];
          if (!(array && array.length)) {
            return result2;
          }
          var index = -1, indexes = [], length = array.length;
          predicate = getIteratee(predicate, 3);
          while (++index < length) {
            var value = array[index];
            if (predicate(value, index, array)) {
              result2.push(value);
              indexes.push(index);
            }
          }
          basePullAt(array, indexes);
          return result2;
        }
        __name(remove, "remove");
        function reverse(array) {
          return array == null ? array : nativeReverse.call(array);
        }
        __name(reverse, "reverse");
        function slice(array, start, end) {
          var length = array == null ? 0 : array.length;
          if (!length) {
            return [];
          }
          if (end && typeof end != "number" && isIterateeCall(array, start, end)) {
            start = 0;
            end = length;
          } else {
            start = start == null ? 0 : toInteger(start);
            end = end === undefined2 ? length : toInteger(end);
          }
          return baseSlice(array, start, end);
        }
        __name(slice, "slice");
        function sortedIndex(array, value) {
          return baseSortedIndex(array, value);
        }
        __name(sortedIndex, "sortedIndex");
        function sortedIndexBy(array, value, iteratee2) {
          return baseSortedIndexBy(array, value, getIteratee(iteratee2, 2));
        }
        __name(sortedIndexBy, "sortedIndexBy");
        function sortedIndexOf(array, value) {
          var length = array == null ? 0 : array.length;
          if (length) {
            var index = baseSortedIndex(array, value);
            if (index < length && eq(array[index], value)) {
              return index;
            }
          }
          return -1;
        }
        __name(sortedIndexOf, "sortedIndexOf");
        function sortedLastIndex(array, value) {
          return baseSortedIndex(array, value, true);
        }
        __name(sortedLastIndex, "sortedLastIndex");
        function sortedLastIndexBy(array, value, iteratee2) {
          return baseSortedIndexBy(array, value, getIteratee(iteratee2, 2), true);
        }
        __name(sortedLastIndexBy, "sortedLastIndexBy");
        function sortedLastIndexOf(array, value) {
          var length = array == null ? 0 : array.length;
          if (length) {
            var index = baseSortedIndex(array, value, true) - 1;
            if (eq(array[index], value)) {
              return index;
            }
          }
          return -1;
        }
        __name(sortedLastIndexOf, "sortedLastIndexOf");
        function sortedUniq(array) {
          return array && array.length ? baseSortedUniq(array) : [];
        }
        __name(sortedUniq, "sortedUniq");
        function sortedUniqBy(array, iteratee2) {
          return array && array.length ? baseSortedUniq(array, getIteratee(iteratee2, 2)) : [];
        }
        __name(sortedUniqBy, "sortedUniqBy");
        function tail(array) {
          var length = array == null ? 0 : array.length;
          return length ? baseSlice(array, 1, length) : [];
        }
        __name(tail, "tail");
        function take(array, n2, guard) {
          if (!(array && array.length)) {
            return [];
          }
          n2 = guard || n2 === undefined2 ? 1 : toInteger(n2);
          return baseSlice(array, 0, n2 < 0 ? 0 : n2);
        }
        __name(take, "take");
        function takeRight(array, n2, guard) {
          var length = array == null ? 0 : array.length;
          if (!length) {
            return [];
          }
          n2 = guard || n2 === undefined2 ? 1 : toInteger(n2);
          n2 = length - n2;
          return baseSlice(array, n2 < 0 ? 0 : n2, length);
        }
        __name(takeRight, "takeRight");
        function takeRightWhile(array, predicate) {
          return array && array.length ? baseWhile(array, getIteratee(predicate, 3), false, true) : [];
        }
        __name(takeRightWhile, "takeRightWhile");
        function takeWhile(array, predicate) {
          return array && array.length ? baseWhile(array, getIteratee(predicate, 3)) : [];
        }
        __name(takeWhile, "takeWhile");
        var union = baseRest(function(arrays) {
          return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));
        });
        var unionBy = baseRest(function(arrays) {
          var iteratee2 = last(arrays);
          if (isArrayLikeObject(iteratee2)) {
            iteratee2 = undefined2;
          }
          return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee2, 2));
        });
        var unionWith = baseRest(function(arrays) {
          var comparator = last(arrays);
          comparator = typeof comparator == "function" ? comparator : undefined2;
          return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined2, comparator);
        });
        function uniq(array) {
          return array && array.length ? baseUniq(array) : [];
        }
        __name(uniq, "uniq");
        function uniqBy(array, iteratee2) {
          return array && array.length ? baseUniq(array, getIteratee(iteratee2, 2)) : [];
        }
        __name(uniqBy, "uniqBy");
        function uniqWith(array, comparator) {
          comparator = typeof comparator == "function" ? comparator : undefined2;
          return array && array.length ? baseUniq(array, undefined2, comparator) : [];
        }
        __name(uniqWith, "uniqWith");
        function unzip(array) {
          if (!(array && array.length)) {
            return [];
          }
          var length = 0;
          array = arrayFilter(array, function(group) {
            if (isArrayLikeObject(group)) {
              length = nativeMax(group.length, length);
              return true;
            }
          });
          return baseTimes(length, function(index) {
            return arrayMap(array, baseProperty(index));
          });
        }
        __name(unzip, "unzip");
        function unzipWith(array, iteratee2) {
          if (!(array && array.length)) {
            return [];
          }
          var result2 = unzip(array);
          if (iteratee2 == null) {
            return result2;
          }
          return arrayMap(result2, function(group) {
            return apply(iteratee2, undefined2, group);
          });
        }
        __name(unzipWith, "unzipWith");
        var without = baseRest(function(array, values2) {
          return isArrayLikeObject(array) ? baseDifference(array, values2) : [];
        });
        var xor = baseRest(function(arrays) {
          return baseXor(arrayFilter(arrays, isArrayLikeObject));
        });
        var xorBy = baseRest(function(arrays) {
          var iteratee2 = last(arrays);
          if (isArrayLikeObject(iteratee2)) {
            iteratee2 = undefined2;
          }
          return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee2, 2));
        });
        var xorWith = baseRest(function(arrays) {
          var comparator = last(arrays);
          comparator = typeof comparator == "function" ? comparator : undefined2;
          return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined2, comparator);
        });
        var zip = baseRest(unzip);
        function zipObject(props, values2) {
          return baseZipObject(props || [], values2 || [], assignValue);
        }
        __name(zipObject, "zipObject");
        function zipObjectDeep(props, values2) {
          return baseZipObject(props || [], values2 || [], baseSet);
        }
        __name(zipObjectDeep, "zipObjectDeep");
        var zipWith = baseRest(function(arrays) {
          var length = arrays.length, iteratee2 = length > 1 ? arrays[length - 1] : undefined2;
          iteratee2 = typeof iteratee2 == "function" ? (arrays.pop(), iteratee2) : undefined2;
          return unzipWith(arrays, iteratee2);
        });
        function chain(value) {
          var result2 = lodash(value);
          result2.__chain__ = true;
          return result2;
        }
        __name(chain, "chain");
        function tap(value, interceptor) {
          interceptor(value);
          return value;
        }
        __name(tap, "tap");
        function thru(value, interceptor) {
          return interceptor(value);
        }
        __name(thru, "thru");
        var wrapperAt = flatRest(function(paths) {
          var length = paths.length, start = length ? paths[0] : 0, value = this.__wrapped__, interceptor = /* @__PURE__ */ __name(function(object) {
            return baseAt(object, paths);
          }, "interceptor");
          if (length > 1 || this.__actions__.length || !(value instanceof LazyWrapper) || !isIndex(start)) {
            return this.thru(interceptor);
          }
          value = value.slice(start, +start + (length ? 1 : 0));
          value.__actions__.push({
            "func": thru,
            "args": [interceptor],
            "thisArg": undefined2
          });
          return new LodashWrapper(value, this.__chain__).thru(function(array) {
            if (length && !array.length) {
              array.push(undefined2);
            }
            return array;
          });
        });
        function wrapperChain() {
          return chain(this);
        }
        __name(wrapperChain, "wrapperChain");
        function wrapperCommit() {
          return new LodashWrapper(this.value(), this.__chain__);
        }
        __name(wrapperCommit, "wrapperCommit");
        function wrapperNext() {
          if (this.__values__ === undefined2) {
            this.__values__ = toArray(this.value());
          }
          var done = this.__index__ >= this.__values__.length, value = done ? undefined2 : this.__values__[this.__index__++];
          return { "done": done, "value": value };
        }
        __name(wrapperNext, "wrapperNext");
        function wrapperToIterator() {
          return this;
        }
        __name(wrapperToIterator, "wrapperToIterator");
        function wrapperPlant(value) {
          var result2, parent2 = this;
          while (parent2 instanceof baseLodash) {
            var clone2 = wrapperClone(parent2);
            clone2.__index__ = 0;
            clone2.__values__ = undefined2;
            if (result2) {
              previous.__wrapped__ = clone2;
            } else {
              result2 = clone2;
            }
            var previous = clone2;
            parent2 = parent2.__wrapped__;
          }
          previous.__wrapped__ = value;
          return result2;
        }
        __name(wrapperPlant, "wrapperPlant");
        function wrapperReverse() {
          var value = this.__wrapped__;
          if (value instanceof LazyWrapper) {
            var wrapped = value;
            if (this.__actions__.length) {
              wrapped = new LazyWrapper(this);
            }
            wrapped = wrapped.reverse();
            wrapped.__actions__.push({
              "func": thru,
              "args": [reverse],
              "thisArg": undefined2
            });
            return new LodashWrapper(wrapped, this.__chain__);
          }
          return this.thru(reverse);
        }
        __name(wrapperReverse, "wrapperReverse");
        function wrapperValue() {
          return baseWrapperValue(this.__wrapped__, this.__actions__);
        }
        __name(wrapperValue, "wrapperValue");
        var countBy = createAggregator(function(result2, value, key) {
          if (hasOwnProperty2.call(result2, key)) {
            ++result2[key];
          } else {
            baseAssignValue(result2, key, 1);
          }
        });
        function every(collection, predicate, guard) {
          var func = isArray(collection) ? arrayEvery : baseEvery;
          if (guard && isIterateeCall(collection, predicate, guard)) {
            predicate = undefined2;
          }
          return func(collection, getIteratee(predicate, 3));
        }
        __name(every, "every");
        function filter(collection, predicate) {
          var func = isArray(collection) ? arrayFilter : baseFilter;
          return func(collection, getIteratee(predicate, 3));
        }
        __name(filter, "filter");
        var find = createFind(findIndex2);
        var findLast = createFind(findLastIndex);
        function flatMap(collection, iteratee2) {
          return baseFlatten(map(collection, iteratee2), 1);
        }
        __name(flatMap, "flatMap");
        function flatMapDeep(collection, iteratee2) {
          return baseFlatten(map(collection, iteratee2), INFINITY2);
        }
        __name(flatMapDeep, "flatMapDeep");
        function flatMapDepth(collection, iteratee2, depth) {
          depth = depth === undefined2 ? 1 : toInteger(depth);
          return baseFlatten(map(collection, iteratee2), depth);
        }
        __name(flatMapDepth, "flatMapDepth");
        function forEach(collection, iteratee2) {
          var func = isArray(collection) ? arrayEach : baseEach;
          return func(collection, getIteratee(iteratee2, 3));
        }
        __name(forEach, "forEach");
        function forEachRight(collection, iteratee2) {
          var func = isArray(collection) ? arrayEachRight : baseEachRight;
          return func(collection, getIteratee(iteratee2, 3));
        }
        __name(forEachRight, "forEachRight");
        var groupBy = createAggregator(function(result2, value, key) {
          if (hasOwnProperty2.call(result2, key)) {
            result2[key].push(value);
          } else {
            baseAssignValue(result2, key, [value]);
          }
        });
        function includes(collection, value, fromIndex, guard) {
          collection = isArrayLike(collection) ? collection : values(collection);
          fromIndex = fromIndex && !guard ? toInteger(fromIndex) : 0;
          var length = collection.length;
          if (fromIndex < 0) {
            fromIndex = nativeMax(length + fromIndex, 0);
          }
          return isString4(collection) ? fromIndex <= length && collection.indexOf(value, fromIndex) > -1 : !!length && baseIndexOf(collection, value, fromIndex) > -1;
        }
        __name(includes, "includes");
        var invokeMap = baseRest(function(collection, path67, args) {
          var index = -1, isFunc = typeof path67 == "function", result2 = isArrayLike(collection) ? Array2(collection.length) : [];
          baseEach(collection, function(value) {
            result2[++index] = isFunc ? apply(path67, value, args) : baseInvoke(value, path67, args);
          });
          return result2;
        });
        var keyBy = createAggregator(function(result2, value, key) {
          baseAssignValue(result2, key, value);
        });
        function map(collection, iteratee2) {
          var func = isArray(collection) ? arrayMap : baseMap;
          return func(collection, getIteratee(iteratee2, 3));
        }
        __name(map, "map");
        function orderBy(collection, iteratees, orders, guard) {
          if (collection == null) {
            return [];
          }
          if (!isArray(iteratees)) {
            iteratees = iteratees == null ? [] : [iteratees];
          }
          orders = guard ? undefined2 : orders;
          if (!isArray(orders)) {
            orders = orders == null ? [] : [orders];
          }
          return baseOrderBy(collection, iteratees, orders);
        }
        __name(orderBy, "orderBy");
        var partition = createAggregator(function(result2, value, key) {
          result2[key ? 0 : 1].push(value);
        }, function() {
          return [[], []];
        });
        function reduce(collection, iteratee2, accumulator) {
          var func = isArray(collection) ? arrayReduce : baseReduce, initAccum = arguments.length < 3;
          return func(collection, getIteratee(iteratee2, 4), accumulator, initAccum, baseEach);
        }
        __name(reduce, "reduce");
        function reduceRight(collection, iteratee2, accumulator) {
          var func = isArray(collection) ? arrayReduceRight : baseReduce, initAccum = arguments.length < 3;
          return func(collection, getIteratee(iteratee2, 4), accumulator, initAccum, baseEachRight);
        }
        __name(reduceRight, "reduceRight");
        function reject(collection, predicate) {
          var func = isArray(collection) ? arrayFilter : baseFilter;
          return func(collection, negate(getIteratee(predicate, 3)));
        }
        __name(reject, "reject");
        function sample(collection) {
          var func = isArray(collection) ? arraySample : baseSample;
          return func(collection);
        }
        __name(sample, "sample");
        function sampleSize(collection, n2, guard) {
          if (guard ? isIterateeCall(collection, n2, guard) : n2 === undefined2) {
            n2 = 1;
          } else {
            n2 = toInteger(n2);
          }
          var func = isArray(collection) ? arraySampleSize : baseSampleSize;
          return func(collection, n2);
        }
        __name(sampleSize, "sampleSize");
        function shuffle(collection) {
          var func = isArray(collection) ? arrayShuffle : baseShuffle;
          return func(collection);
        }
        __name(shuffle, "shuffle");
        function size(collection) {
          if (collection == null) {
            return 0;
          }
          if (isArrayLike(collection)) {
            return isString4(collection) ? stringSize(collection) : collection.length;
          }
          var tag = getTag(collection);
          if (tag == mapTag || tag == setTag2) {
            return collection.size;
          }
          return baseKeys(collection).length;
        }
        __name(size, "size");
        function some(collection, predicate, guard) {
          var func = isArray(collection) ? arraySome : baseSome;
          if (guard && isIterateeCall(collection, predicate, guard)) {
            predicate = undefined2;
          }
          return func(collection, getIteratee(predicate, 3));
        }
        __name(some, "some");
        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), []);
        });
        var now = ctxNow || function() {
          return root.Date.now();
        };
        function after(n2, func) {
          if (typeof func != "function") {
            throw new TypeError2(FUNC_ERROR_TEXT);
          }
          n2 = toInteger(n2);
          return function() {
            if (--n2 < 1) {
              return func.apply(this, arguments);
            }
          };
        }
        __name(after, "after");
        function ary(func, n2, guard) {
          n2 = guard ? undefined2 : n2;
          n2 = func && n2 == null ? func.length : n2;
          return createWrap(func, WRAP_ARY_FLAG, undefined2, undefined2, undefined2, undefined2, n2);
        }
        __name(ary, "ary");
        function before(n2, func) {
          var result2;
          if (typeof func != "function") {
            throw new TypeError2(FUNC_ERROR_TEXT);
          }
          n2 = toInteger(n2);
          return function() {
            if (--n2 > 0) {
              result2 = func.apply(this, arguments);
            }
            if (n2 <= 1) {
              func = undefined2;
            }
            return result2;
          };
        }
        __name(before, "before");
        var bind = baseRest(function(func, thisArg, partials) {
          var bitmask = WRAP_BIND_FLAG;
          if (partials.length) {
            var holders = replaceHolders(partials, getHolder(bind));
            bitmask |= WRAP_PARTIAL_FLAG;
          }
          return createWrap(func, bitmask, thisArg, partials, holders);
        });
        var bindKey = baseRest(function(object, key, partials) {
          var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;
          if (partials.length) {
            var holders = replaceHolders(partials, getHolder(bindKey));
            bitmask |= WRAP_PARTIAL_FLAG;
          }
          return createWrap(key, bitmask, object, partials, holders);
        });
        function curry(func, arity, guard) {
          arity = guard ? undefined2 : arity;
          var result2 = createWrap(func, WRAP_CURRY_FLAG, undefined2, undefined2, undefined2, undefined2, undefined2, arity);
          result2.placeholder = curry.placeholder;
          return result2;
        }
        __name(curry, "curry");
        function curryRight(func, arity, guard) {
          arity = guard ? undefined2 : arity;
          var result2 = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined2, undefined2, undefined2, undefined2, undefined2, arity);
          result2.placeholder = curryRight.placeholder;
          return result2;
        }
        __name(curryRight, "curryRight");
        function debounce(func, wait, options29) {
          var lastArgs, lastThis, maxWait, result2, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
          if (typeof func != "function") {
            throw new TypeError2(FUNC_ERROR_TEXT);
          }
          wait = toNumber(wait) || 0;
          if (isObject2(options29)) {
            leading = !!options29.leading;
            maxing = "maxWait" in options29;
            maxWait = maxing ? nativeMax(toNumber(options29.maxWait) || 0, wait) : maxWait;
            trailing = "trailing" in options29 ? !!options29.trailing : trailing;
          }
          function invokeFunc(time) {
            var args = lastArgs, thisArg = lastThis;
            lastArgs = lastThis = undefined2;
            lastInvokeTime = time;
            result2 = func.apply(thisArg, args);
            return result2;
          }
          __name(invokeFunc, "invokeFunc");
          function leadingEdge(time) {
            lastInvokeTime = time;
            timerId = setTimeout4(timerExpired, wait);
            return leading ? invokeFunc(time) : result2;
          }
          __name(leadingEdge, "leadingEdge");
          function remainingWait(time) {
            var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
            return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
          }
          __name(remainingWait, "remainingWait");
          function shouldInvoke(time) {
            var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
            return lastCallTime === undefined2 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
          }
          __name(shouldInvoke, "shouldInvoke");
          function timerExpired() {
            var time = now();
            if (shouldInvoke(time)) {
              return trailingEdge(time);
            }
            timerId = setTimeout4(timerExpired, remainingWait(time));
          }
          __name(timerExpired, "timerExpired");
          function trailingEdge(time) {
            timerId = undefined2;
            if (trailing && lastArgs) {
              return invokeFunc(time);
            }
            lastArgs = lastThis = undefined2;
            return result2;
          }
          __name(trailingEdge, "trailingEdge");
          function cancel3() {
            if (timerId !== undefined2) {
              clearTimeout2(timerId);
            }
            lastInvokeTime = 0;
            lastArgs = lastCallTime = lastThis = timerId = undefined2;
          }
          __name(cancel3, "cancel");
          function flush2() {
            return timerId === undefined2 ? result2 : trailingEdge(now());
          }
          __name(flush2, "flush");
          function debounced() {
            var time = now(), isInvoking = shouldInvoke(time);
            lastArgs = arguments;
            lastThis = this;
            lastCallTime = time;
            if (isInvoking) {
              if (timerId === undefined2) {
                return leadingEdge(lastCallTime);
              }
              if (maxing) {
                clearTimeout2(timerId);
                timerId = setTimeout4(timerExpired, wait);
                return invokeFunc(lastCallTime);
              }
            }
            if (timerId === undefined2) {
              timerId = setTimeout4(timerExpired, wait);
            }
            return result2;
          }
          __name(debounced, "debounced");
          debounced.cancel = cancel3;
          debounced.flush = flush2;
          return debounced;
        }
        __name(debounce, "debounce");
        var defer = baseRest(function(func, args) {
          return baseDelay(func, 1, args);
        });
        var delay = baseRest(function(func, wait, args) {
          return baseDelay(func, toNumber(wait) || 0, args);
        });
        function flip(func) {
          return createWrap(func, WRAP_FLIP_FLAG);
        }
        __name(flip, "flip");
        function memoize(func, resolver) {
          if (typeof func != "function" || resolver != null && typeof resolver != "function") {
            throw new TypeError2(FUNC_ERROR_TEXT);
          }
          var memoized = /* @__PURE__ */ __name(function() {
            var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache2 = memoized.cache;
            if (cache2.has(key)) {
              return cache2.get(key);
            }
            var result2 = func.apply(this, args);
            memoized.cache = cache2.set(key, result2) || cache2;
            return result2;
          }, "memoized");
          memoized.cache = new (memoize.Cache || MapCache)();
          return memoized;
        }
        __name(memoize, "memoize");
        memoize.Cache = MapCache;
        function negate(predicate) {
          if (typeof predicate != "function") {
            throw new TypeError2(FUNC_ERROR_TEXT);
          }
          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);
          };
        }
        __name(negate, "negate");
        function once(func) {
          return before(2, func);
        }
        __name(once, "once");
        var overArgs = castRest(function(func, transforms) {
          transforms = transforms.length == 1 && isArray(transforms[0]) ? arrayMap(transforms[0], baseUnary(getIteratee())) : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee()));
          var funcsLength = transforms.length;
          return baseRest(function(args) {
            var index = -1, length = nativeMin(args.length, funcsLength);
            while (++index < length) {
              args[index] = transforms[index].call(this, args[index]);
            }
            return apply(func, this, args);
          });
        });
        var partial = baseRest(function(func, partials) {
          var holders = replaceHolders(partials, getHolder(partial));
          return createWrap(func, WRAP_PARTIAL_FLAG, undefined2, partials, holders);
        });
        var partialRight = baseRest(function(func, partials) {
          var holders = replaceHolders(partials, getHolder(partialRight));
          return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined2, partials, holders);
        });
        var rearg = flatRest(function(func, indexes) {
          return createWrap(func, WRAP_REARG_FLAG, undefined2, undefined2, undefined2, indexes);
        });
        function rest(func, start) {
          if (typeof func != "function") {
            throw new TypeError2(FUNC_ERROR_TEXT);
          }
          start = start === undefined2 ? start : toInteger(start);
          return baseRest(func, start);
        }
        __name(rest, "rest");
        function spread(func, start) {
          if (typeof func != "function") {
            throw new TypeError2(FUNC_ERROR_TEXT);
          }
          start = start == null ? 0 : nativeMax(toInteger(start), 0);
          return baseRest(function(args) {
            var array = args[start], otherArgs = castSlice(args, 0, start);
            if (array) {
              arrayPush(otherArgs, array);
            }
            return apply(func, this, otherArgs);
          });
        }
        __name(spread, "spread");
        function throttle(func, wait, options29) {
          var leading = true, trailing = true;
          if (typeof func != "function") {
            throw new TypeError2(FUNC_ERROR_TEXT);
          }
          if (isObject2(options29)) {
            leading = "leading" in options29 ? !!options29.leading : leading;
            trailing = "trailing" in options29 ? !!options29.trailing : trailing;
          }
          return debounce(func, wait, {
            "leading": leading,
            "maxWait": wait,
            "trailing": trailing
          });
        }
        __name(throttle, "throttle");
        function unary(func) {
          return ary(func, 1);
        }
        __name(unary, "unary");
        function wrap4(value, wrapper) {
          return partial(castFunction(wrapper), value);
        }
        __name(wrap4, "wrap");
        function castArray() {
          if (!arguments.length) {
            return [];
          }
          var value = arguments[0];
          return isArray(value) ? value : [value];
        }
        __name(castArray, "castArray");
        function clone(value) {
          return baseClone(value, CLONE_SYMBOLS_FLAG);
        }
        __name(clone, "clone");
        function cloneWith(value, customizer) {
          customizer = typeof customizer == "function" ? customizer : undefined2;
          return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);
        }
        __name(cloneWith, "cloneWith");
        function cloneDeep(value) {
          return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
        }
        __name(cloneDeep, "cloneDeep");
        function cloneDeepWith(value, customizer) {
          customizer = typeof customizer == "function" ? customizer : undefined2;
          return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);
        }
        __name(cloneDeepWith, "cloneDeepWith");
        function conformsTo(object, source) {
          return source == null || baseConformsTo(object, source, keys(source));
        }
        __name(conformsTo, "conformsTo");
        function eq(value, other) {
          return value === other || value !== value && other !== other;
        }
        __name(eq, "eq");
        var gt = createRelationalOperation(baseGt);
        var gte = createRelationalOperation(function(value, other) {
          return value >= other;
        });
        var isArguments = baseIsArguments(function() {
          return arguments;
        }()) ? baseIsArguments : function(value) {
          return isObjectLike(value) && hasOwnProperty2.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
        };
        var isArray = Array2.isArray;
        var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;
        function isArrayLike(value) {
          return value != null && isLength(value.length) && !isFunction2(value);
        }
        __name(isArrayLike, "isArrayLike");
        function isArrayLikeObject(value) {
          return isObjectLike(value) && isArrayLike(value);
        }
        __name(isArrayLikeObject, "isArrayLikeObject");
        function isBoolean3(value) {
          return value === true || value === false || isObjectLike(value) && baseGetTag(value) == boolTag;
        }
        __name(isBoolean3, "isBoolean");
        var isBuffer = nativeIsBuffer || stubFalse;
        var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;
        function isElement2(value) {
          return isObjectLike(value) && value.nodeType === 1 && !isPlainObject2(value);
        }
        __name(isElement2, "isElement");
        function isEmpty(value) {
          if (value == null) {
            return true;
          }
          if (isArrayLike(value) && (isArray(value) || typeof value == "string" || typeof value.splice == "function" || isBuffer(value) || isTypedArray(value) || isArguments(value))) {
            return !value.length;
          }
          var tag = getTag(value);
          if (tag == mapTag || tag == setTag2) {
            return !value.size;
          }
          if (isPrototype(value)) {
            return !baseKeys(value).length;
          }
          for (var key in value) {
            if (hasOwnProperty2.call(value, key)) {
              return false;
            }
          }
          return true;
        }
        __name(isEmpty, "isEmpty");
        function isEqual(value, other) {
          return baseIsEqual(value, other);
        }
        __name(isEqual, "isEqual");
        function isEqualWith(value, other, customizer) {
          customizer = typeof customizer == "function" ? customizer : undefined2;
          var result2 = customizer ? customizer(value, other) : undefined2;
          return result2 === undefined2 ? baseIsEqual(value, other, undefined2, customizer) : !!result2;
        }
        __name(isEqualWith, "isEqualWith");
        function isError2(value) {
          if (!isObjectLike(value)) {
            return false;
          }
          var tag = baseGetTag(value);
          return tag == errorTag || tag == domExcTag || typeof value.message == "string" && typeof value.name == "string" && !isPlainObject2(value);
        }
        __name(isError2, "isError");
        function isFinite2(value) {
          return typeof value == "number" && nativeIsFinite(value);
        }
        __name(isFinite2, "isFinite");
        function isFunction2(value) {
          if (!isObject2(value)) {
            return false;
          }
          var tag = baseGetTag(value);
          return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
        }
        __name(isFunction2, "isFunction");
        function isInteger2(value) {
          return typeof value == "number" && value == toInteger(value);
        }
        __name(isInteger2, "isInteger");
        function isLength(value) {
          return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
        }
        __name(isLength, "isLength");
        function isObject2(value) {
          var type = typeof value;
          return value != null && (type == "object" || type == "function");
        }
        __name(isObject2, "isObject");
        function isObjectLike(value) {
          return value != null && typeof value == "object";
        }
        __name(isObjectLike, "isObjectLike");
        var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;
        function isMatch(object, source) {
          return object === source || baseIsMatch(object, source, getMatchData(source));
        }
        __name(isMatch, "isMatch");
        function isMatchWith(object, source, customizer) {
          customizer = typeof customizer == "function" ? customizer : undefined2;
          return baseIsMatch(object, source, getMatchData(source), customizer);
        }
        __name(isMatchWith, "isMatchWith");
        function isNaN3(value) {
          return isNumber(value) && value != +value;
        }
        __name(isNaN3, "isNaN");
        function isNative(value) {
          if (isMaskable(value)) {
            throw new Error2(CORE_ERROR_TEXT);
          }
          return baseIsNative(value);
        }
        __name(isNative, "isNative");
        function isNull(value) {
          return value === null;
        }
        __name(isNull, "isNull");
        function isNil(value) {
          return value == null;
        }
        __name(isNil, "isNil");
        function isNumber(value) {
          return typeof value == "number" || isObjectLike(value) && baseGetTag(value) == numberTag;
        }
        __name(isNumber, "isNumber");
        function isPlainObject2(value) {
          if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
            return false;
          }
          var proto = getPrototype(value);
          if (proto === null) {
            return true;
          }
          var Ctor = hasOwnProperty2.call(proto, "constructor") && proto.constructor;
          return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
        }
        __name(isPlainObject2, "isPlainObject");
        var isRegExp2 = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;
        function isSafeInteger(value) {
          return isInteger2(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;
        }
        __name(isSafeInteger, "isSafeInteger");
        var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
        function isString4(value) {
          return typeof value == "string" || !isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag;
        }
        __name(isString4, "isString");
        function isSymbol(value) {
          return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
        }
        __name(isSymbol, "isSymbol");
        var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
        function isUndefined(value) {
          return value === undefined2;
        }
        __name(isUndefined, "isUndefined");
        function isWeakMap(value) {
          return isObjectLike(value) && getTag(value) == weakMapTag;
        }
        __name(isWeakMap, "isWeakMap");
        function isWeakSet(value) {
          return isObjectLike(value) && baseGetTag(value) == weakSetTag;
        }
        __name(isWeakSet, "isWeakSet");
        var lt2 = createRelationalOperation(baseLt);
        var lte = createRelationalOperation(function(value, other) {
          return value <= other;
        });
        function toArray(value) {
          if (!value) {
            return [];
          }
          if (isArrayLike(value)) {
            return isString4(value) ? stringToArray(value) : copyArray(value);
          }
          if (symIterator && value[symIterator]) {
            return iteratorToArray(value[symIterator]());
          }
          var tag = getTag(value), func = tag == mapTag ? mapToArray : tag == setTag2 ? setToArray : values;
          return func(value);
        }
        __name(toArray, "toArray");
        function toFinite(value) {
          if (!value) {
            return value === 0 ? value : 0;
          }
          value = toNumber(value);
          if (value === INFINITY2 || value === -INFINITY2) {
            var sign = value < 0 ? -1 : 1;
            return sign * MAX_INTEGER;
          }
          return value === value ? value : 0;
        }
        __name(toFinite, "toFinite");
        function toInteger(value) {
          var result2 = toFinite(value), remainder = result2 % 1;
          return result2 === result2 ? remainder ? result2 - remainder : result2 : 0;
        }
        __name(toInteger, "toInteger");
        function toLength(value) {
          return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;
        }
        __name(toLength, "toLength");
        function toNumber(value) {
          if (typeof value == "number") {
            return value;
          }
          if (isSymbol(value)) {
            return NAN;
          }
          if (isObject2(value)) {
            var other = typeof value.valueOf == "function" ? value.valueOf() : value;
            value = isObject2(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;
        }
        __name(toNumber, "toNumber");
        function toPlainObject(value) {
          return copyObject(value, keysIn(value));
        }
        __name(toPlainObject, "toPlainObject");
        function toSafeInteger(value) {
          return value ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER) : value === 0 ? value : 0;
        }
        __name(toSafeInteger, "toSafeInteger");
        function toString2(value) {
          return value == null ? "" : baseToString(value);
        }
        __name(toString2, "toString");
        var assign = createAssigner(function(object, source) {
          if (isPrototype(source) || isArrayLike(source)) {
            copyObject(source, keys(source), object);
            return;
          }
          for (var key in source) {
            if (hasOwnProperty2.call(source, key)) {
              assignValue(object, key, source[key]);
            }
          }
        });
        var assignIn = createAssigner(function(object, source) {
          copyObject(source, keysIn(source), object);
        });
        var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {
          copyObject(source, keysIn(source), object, customizer);
        });
        var assignWith = createAssigner(function(object, source, srcIndex, customizer) {
          copyObject(source, keys(source), object, customizer);
        });
        var at = flatRest(baseAt);
        function create2(prototype, properties) {
          var result2 = baseCreate(prototype);
          return properties == null ? result2 : baseAssign(result2, properties);
        }
        __name(create2, "create");
        var defaults = baseRest(function(object, sources) {
          object = Object2(object);
          var index = -1;
          var length = sources.length;
          var guard = length > 2 ? sources[2] : undefined2;
          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 = object[key];
              if (value === undefined2 || eq(value, objectProto[key]) && !hasOwnProperty2.call(object, key)) {
                object[key] = source[key];
              }
            }
          }
          return object;
        });
        var defaultsDeep = baseRest(function(args) {
          args.push(undefined2, customDefaultsMerge);
          return apply(mergeWith, undefined2, args);
        });
        function findKey(object, predicate) {
          return baseFindKey(object, getIteratee(predicate, 3), baseForOwn);
        }
        __name(findKey, "findKey");
        function findLastKey(object, predicate) {
          return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);
        }
        __name(findLastKey, "findLastKey");
        function forIn(object, iteratee2) {
          return object == null ? object : baseFor(object, getIteratee(iteratee2, 3), keysIn);
        }
        __name(forIn, "forIn");
        function forInRight(object, iteratee2) {
          return object == null ? object : baseForRight(object, getIteratee(iteratee2, 3), keysIn);
        }
        __name(forInRight, "forInRight");
        function forOwn(object, iteratee2) {
          return object && baseForOwn(object, getIteratee(iteratee2, 3));
        }
        __name(forOwn, "forOwn");
        function forOwnRight(object, iteratee2) {
          return object && baseForOwnRight(object, getIteratee(iteratee2, 3));
        }
        __name(forOwnRight, "forOwnRight");
        function functions(object) {
          return object == null ? [] : baseFunctions(object, keys(object));
        }
        __name(functions, "functions");
        function functionsIn(object) {
          return object == null ? [] : baseFunctions(object, keysIn(object));
        }
        __name(functionsIn, "functionsIn");
        function get(object, path67, defaultValue) {
          var result2 = object == null ? undefined2 : baseGet(object, path67);
          return result2 === undefined2 ? defaultValue : result2;
        }
        __name(get, "get");
        function has(object, path67) {
          return object != null && hasPath(object, path67, baseHas);
        }
        __name(has, "has");
        function hasIn(object, path67) {
          return object != null && hasPath(object, path67, baseHasIn);
        }
        __name(hasIn, "hasIn");
        var invert = createInverter(function(result2, value, key) {
          if (value != null && typeof value.toString != "function") {
            value = nativeObjectToString.call(value);
          }
          result2[value] = key;
        }, constant(identity));
        var invertBy = createInverter(function(result2, value, key) {
          if (value != null && typeof value.toString != "function") {
            value = nativeObjectToString.call(value);
          }
          if (hasOwnProperty2.call(result2, value)) {
            result2[value].push(key);
          } else {
            result2[value] = [key];
          }
        }, getIteratee);
        var invoke = baseRest(baseInvoke);
        function keys(object) {
          return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
        }
        __name(keys, "keys");
        function keysIn(object) {
          return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
        }
        __name(keysIn, "keysIn");
        function mapKeys(object, iteratee2) {
          var result2 = {};
          iteratee2 = getIteratee(iteratee2, 3);
          baseForOwn(object, function(value, key, object2) {
            baseAssignValue(result2, iteratee2(value, key, object2), value);
          });
          return result2;
        }
        __name(mapKeys, "mapKeys");
        function mapValues(object, iteratee2) {
          var result2 = {};
          iteratee2 = getIteratee(iteratee2, 3);
          baseForOwn(object, function(value, key, object2) {
            baseAssignValue(result2, key, iteratee2(value, key, object2));
          });
          return result2;
        }
        __name(mapValues, "mapValues");
        var merge = createAssigner(function(object, source, srcIndex) {
          baseMerge(object, source, srcIndex);
        });
        var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {
          baseMerge(object, source, srcIndex, customizer);
        });
        var omit = flatRest(function(object, paths) {
          var result2 = {};
          if (object == null) {
            return result2;
          }
          var isDeep = false;
          paths = arrayMap(paths, function(path67) {
            path67 = castPath(path67, object);
            isDeep || (isDeep = path67.length > 1);
            return path67;
          });
          copyObject(object, getAllKeysIn(object), result2);
          if (isDeep) {
            result2 = baseClone(result2, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
          }
          var length = paths.length;
          while (length--) {
            baseUnset(result2, paths[length]);
          }
          return result2;
        });
        function omitBy(object, predicate) {
          return pickBy(object, negate(getIteratee(predicate)));
        }
        __name(omitBy, "omitBy");
        var pick = flatRest(function(object, paths) {
          return object == null ? {} : basePick(object, paths);
        });
        function pickBy(object, predicate) {
          if (object == null) {
            return {};
          }
          var props = arrayMap(getAllKeysIn(object), function(prop) {
            return [prop];
          });
          predicate = getIteratee(predicate);
          return basePickBy(object, props, function(value, path67) {
            return predicate(value, path67[0]);
          });
        }
        __name(pickBy, "pickBy");
        function result(object, path67, defaultValue) {
          path67 = castPath(path67, object);
          var index = -1, length = path67.length;
          if (!length) {
            length = 1;
            object = undefined2;
          }
          while (++index < length) {
            var value = object == null ? undefined2 : object[toKey(path67[index])];
            if (value === undefined2) {
              index = length;
              value = defaultValue;
            }
            object = isFunction2(value) ? value.call(object) : value;
          }
          return object;
        }
        __name(result, "result");
        function set(object, path67, value) {
          return object == null ? object : baseSet(object, path67, value);
        }
        __name(set, "set");
        function setWith(object, path67, value, customizer) {
          customizer = typeof customizer == "function" ? customizer : undefined2;
          return object == null ? object : baseSet(object, path67, value, customizer);
        }
        __name(setWith, "setWith");
        var toPairs = createToPairs(keys);
        var toPairsIn = createToPairs(keysIn);
        function transform(object, iteratee2, accumulator) {
          var isArr = isArray(object), isArrLike = isArr || isBuffer(object) || isTypedArray(object);
          iteratee2 = getIteratee(iteratee2, 4);
          if (accumulator == null) {
            var Ctor = object && object.constructor;
            if (isArrLike) {
              accumulator = isArr ? new Ctor() : [];
            } else if (isObject2(object)) {
              accumulator = isFunction2(Ctor) ? baseCreate(getPrototype(object)) : {};
            } else {
              accumulator = {};
            }
          }
          (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object2) {
            return iteratee2(accumulator, value, index, object2);
          });
          return accumulator;
        }
        __name(transform, "transform");
        function unset(object, path67) {
          return object == null ? true : baseUnset(object, path67);
        }
        __name(unset, "unset");
        function update(object, path67, updater) {
          return object == null ? object : baseUpdate(object, path67, castFunction(updater));
        }
        __name(update, "update");
        function updateWith(object, path67, updater, customizer) {
          customizer = typeof customizer == "function" ? customizer : undefined2;
          return object == null ? object : baseUpdate(object, path67, castFunction(updater), customizer);
        }
        __name(updateWith, "updateWith");
        function values(object) {
          return object == null ? [] : baseValues(object, keys(object));
        }
        __name(values, "values");
        function valuesIn(object) {
          return object == null ? [] : baseValues(object, keysIn(object));
        }
        __name(valuesIn, "valuesIn");
        function clamp(number, lower, upper) {
          if (upper === undefined2) {
            upper = lower;
            lower = undefined2;
          }
          if (upper !== undefined2) {
            upper = toNumber(upper);
            upper = upper === upper ? upper : 0;
          }
          if (lower !== undefined2) {
            lower = toNumber(lower);
            lower = lower === lower ? lower : 0;
          }
          return baseClamp(toNumber(number), lower, upper);
        }
        __name(clamp, "clamp");
        function inRange(number, start, end) {
          start = toFinite(start);
          if (end === undefined2) {
            end = start;
            start = 0;
          } else {
            end = toFinite(end);
          }
          number = toNumber(number);
          return baseInRange(number, start, end);
        }
        __name(inRange, "inRange");
        function random(lower, upper, floating) {
          if (floating && typeof floating != "boolean" && isIterateeCall(lower, upper, floating)) {
            upper = floating = undefined2;
          }
          if (floating === undefined2) {
            if (typeof upper == "boolean") {
              floating = upper;
              upper = undefined2;
            } else if (typeof lower == "boolean") {
              floating = lower;
              lower = undefined2;
            }
          }
          if (lower === undefined2 && upper === undefined2) {
            lower = 0;
            upper = 1;
          } else {
            lower = toFinite(lower);
            if (upper === undefined2) {
              upper = lower;
              lower = 0;
            } else {
              upper = toFinite(upper);
            }
          }
          if (lower > upper) {
            var temp = lower;
            lower = upper;
            upper = temp;
          }
          if (floating || lower % 1 || upper % 1) {
            var rand = nativeRandom();
            return nativeMin(lower + rand * (upper - lower + freeParseFloat("1e-" + ((rand + "").length - 1))), upper);
          }
          return baseRandom(lower, upper);
        }
        __name(random, "random");
        var camelCase2 = createCompounder(function(result2, word, index) {
          word = word.toLowerCase();
          return result2 + (index ? capitalize(word) : word);
        });
        function capitalize(string) {
          return upperFirst(toString2(string).toLowerCase());
        }
        __name(capitalize, "capitalize");
        function deburr(string) {
          string = toString2(string);
          return string && string.replace(reLatin, deburrLetter).replace(reComboMark, "");
        }
        __name(deburr, "deburr");
        function endsWith(string, target, position) {
          string = toString2(string);
          target = baseToString(target);
          var length = string.length;
          position = position === undefined2 ? length : baseClamp(toInteger(position), 0, length);
          var end = position;
          position -= target.length;
          return position >= 0 && string.slice(position, end) == target;
        }
        __name(endsWith, "endsWith");
        function escape2(string) {
          string = toString2(string);
          return string && reHasUnescapedHtml.test(string) ? string.replace(reUnescapedHtml, escapeHtmlChar) : string;
        }
        __name(escape2, "escape");
        function escapeRegExp(string) {
          string = toString2(string);
          return string && reHasRegExpChar.test(string) ? string.replace(reRegExpChar, "\\$&") : string;
        }
        __name(escapeRegExp, "escapeRegExp");
        var kebabCase = createCompounder(function(result2, word, index) {
          return result2 + (index ? "-" : "") + word.toLowerCase();
        });
        var lowerCase = createCompounder(function(result2, word, index) {
          return result2 + (index ? " " : "") + word.toLowerCase();
        });
        var lowerFirst = createCaseFirst("toLowerCase");
        function pad2(string, length, chars) {
          string = toString2(string);
          length = toInteger(length);
          var strLength = length ? stringSize(string) : 0;
          if (!length || strLength >= length) {
            return string;
          }
          var mid = (length - strLength) / 2;
          return createPadding(nativeFloor(mid), chars) + string + createPadding(nativeCeil(mid), chars);
        }
        __name(pad2, "pad");
        function padEnd(string, length, chars) {
          string = toString2(string);
          length = toInteger(length);
          var strLength = length ? stringSize(string) : 0;
          return length && strLength < length ? string + createPadding(length - strLength, chars) : string;
        }
        __name(padEnd, "padEnd");
        function padStart(string, length, chars) {
          string = toString2(string);
          length = toInteger(length);
          var strLength = length ? stringSize(string) : 0;
          return length && strLength < length ? createPadding(length - strLength, chars) + string : string;
        }
        __name(padStart, "padStart");
        function parseInt2(string, radix, guard) {
          if (guard || radix == null) {
            radix = 0;
          } else if (radix) {
            radix = +radix;
          }
          return nativeParseInt(toString2(string).replace(reTrimStart, ""), radix || 0);
        }
        __name(parseInt2, "parseInt");
        function repeat(string, n2, guard) {
          if (guard ? isIterateeCall(string, n2, guard) : n2 === undefined2) {
            n2 = 1;
          } else {
            n2 = toInteger(n2);
          }
          return baseRepeat(toString2(string), n2);
        }
        __name(repeat, "repeat");
        function replace() {
          var args = arguments, string = toString2(args[0]);
          return args.length < 3 ? string : string.replace(args[1], args[2]);
        }
        __name(replace, "replace");
        var snakeCase = createCompounder(function(result2, word, index) {
          return result2 + (index ? "_" : "") + word.toLowerCase();
        });
        function split(string, separator, limit) {
          if (limit && typeof limit != "number" && isIterateeCall(string, separator, limit)) {
            separator = limit = undefined2;
          }
          limit = limit === undefined2 ? MAX_ARRAY_LENGTH : limit >>> 0;
          if (!limit) {
            return [];
          }
          string = toString2(string);
          if (string && (typeof separator == "string" || separator != null && !isRegExp2(separator))) {
            separator = baseToString(separator);
            if (!separator && hasUnicode(string)) {
              return castSlice(stringToArray(string), 0, limit);
            }
          }
          return string.split(separator, limit);
        }
        __name(split, "split");
        var startCase = createCompounder(function(result2, word, index) {
          return result2 + (index ? " " : "") + upperFirst(word);
        });
        function startsWith(string, target, position) {
          string = toString2(string);
          position = position == null ? 0 : baseClamp(toInteger(position), 0, string.length);
          target = baseToString(target);
          return string.slice(position, position + target.length) == target;
        }
        __name(startsWith, "startsWith");
        function template(string, options29, guard) {
          var settings = lodash.templateSettings;
          if (guard && isIterateeCall(string, options29, guard)) {
            options29 = undefined2;
          }
          string = toString2(string);
          options29 = assignInWith({}, options29, settings, customDefaultsAssignIn);
          var imports = assignInWith({}, options29.imports, settings.imports, customDefaultsAssignIn), importsKeys = keys(imports), importsValues = baseValues(imports, importsKeys);
          var isEscaping, isEvaluating, index = 0, interpolate = options29.interpolate || reNoMatch, source = "__p += '";
          var reDelimiters = RegExp2(
            (options29.escape || reNoMatch).source + "|" + interpolate.source + "|" + (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + "|" + (options29.evaluate || reNoMatch).source + "|$",
            "g"
          );
          var sourceURL = "//# sourceURL=" + (hasOwnProperty2.call(options29, "sourceURL") ? (options29.sourceURL + "").replace(/\s/g, " ") : "lodash.templateSources[" + ++templateCounter + "]") + "\n";
          string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {
            interpolateValue || (interpolateValue = esTemplateValue);
            source += string.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 = hasOwnProperty2.call(options29, "variable") && options29.variable;
          if (!variable) {
            source = "with (obj) {\n" + source + "\n}\n";
          } else if (reForbiddenIdentifierChars.test(variable)) {
            throw new Error2(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 result2 = attempt(function() {
            return Function2(importsKeys, sourceURL + "return " + source).apply(undefined2, importsValues);
          });
          result2.source = source;
          if (isError2(result2)) {
            throw result2;
          }
          return result2;
        }
        __name(template, "template");
        function toLower(value) {
          return toString2(value).toLowerCase();
        }
        __name(toLower, "toLower");
        function toUpper(value) {
          return toString2(value).toUpperCase();
        }
        __name(toUpper, "toUpper");
        function trim(string, chars, guard) {
          string = toString2(string);
          if (string && (guard || chars === undefined2)) {
            return baseTrim(string);
          }
          if (!string || !(chars = baseToString(chars))) {
            return string;
          }
          var strSymbols = stringToArray(string), chrSymbols = stringToArray(chars), start = charsStartIndex(strSymbols, chrSymbols), end = charsEndIndex(strSymbols, chrSymbols) + 1;
          return castSlice(strSymbols, start, end).join("");
        }
        __name(trim, "trim");
        function trimEnd(string, chars, guard) {
          string = toString2(string);
          if (string && (guard || chars === undefined2)) {
            return string.slice(0, trimmedEndIndex(string) + 1);
          }
          if (!string || !(chars = baseToString(chars))) {
            return string;
          }
          var strSymbols = stringToArray(string), end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;
          return castSlice(strSymbols, 0, end).join("");
        }
        __name(trimEnd, "trimEnd");
        function trimStart(string, chars, guard) {
          string = toString2(string);
          if (string && (guard || chars === undefined2)) {
            return string.replace(reTrimStart, "");
          }
          if (!string || !(chars = baseToString(chars))) {
            return string;
          }
          var strSymbols = stringToArray(string), start = charsStartIndex(strSymbols, stringToArray(chars));
          return castSlice(strSymbols, start).join("");
        }
        __name(trimStart, "trimStart");
        function truncate4(string, options29) {
          var length = DEFAULT_TRUNC_LENGTH, omission = DEFAULT_TRUNC_OMISSION;
          if (isObject2(options29)) {
            var separator = "separator" in options29 ? options29.separator : separator;
            length = "length" in options29 ? toInteger(options29.length) : length;
            omission = "omission" in options29 ? baseToString(options29.omission) : omission;
          }
          string = toString2(string);
          var strLength = string.length;
          if (hasUnicode(string)) {
            var strSymbols = stringToArray(string);
            strLength = strSymbols.length;
          }
          if (length >= strLength) {
            return string;
          }
          var end = length - stringSize(omission);
          if (end < 1) {
            return omission;
          }
          var result2 = strSymbols ? castSlice(strSymbols, 0, end).join("") : string.slice(0, end);
          if (separator === undefined2) {
            return result2 + omission;
          }
          if (strSymbols) {
            end += result2.length - end;
          }
          if (isRegExp2(separator)) {
            if (string.slice(end).search(separator)) {
              var match, substring = result2;
              if (!separator.global) {
                separator = RegExp2(separator.source, toString2(reFlags.exec(separator)) + "g");
              }
              separator.lastIndex = 0;
              while (match = separator.exec(substring)) {
                var newEnd = match.index;
              }
              result2 = result2.slice(0, newEnd === undefined2 ? end : newEnd);
            }
          } else if (string.indexOf(baseToString(separator), end) != end) {
            var index = result2.lastIndexOf(separator);
            if (index > -1) {
              result2 = result2.slice(0, index);
            }
          }
          return result2 + omission;
        }
        __name(truncate4, "truncate");
        function unescape2(string) {
          string = toString2(string);
          return string && reHasEscapedHtml.test(string) ? string.replace(reEscapedHtml, unescapeHtmlChar) : string;
        }
        __name(unescape2, "unescape");
        var upperCase = createCompounder(function(result2, word, index) {
          return result2 + (index ? " " : "") + word.toUpperCase();
        });
        var upperFirst = createCaseFirst("toUpperCase");
        function words(string, pattern, guard) {
          string = toString2(string);
          pattern = guard ? undefined2 : pattern;
          if (pattern === undefined2) {
            return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);
          }
          return string.match(pattern) || [];
        }
        __name(words, "words");
        var attempt = baseRest(function(func, args) {
          try {
            return apply(func, undefined2, args);
          } catch (e3) {
            return isError2(e3) ? e3 : new Error2(e3);
          }
        });
        var bindAll = flatRest(function(object, methodNames) {
          arrayEach(methodNames, function(key) {
            key = toKey(key);
            baseAssignValue(object, key, bind(object[key], object));
          });
          return object;
        });
        function cond(pairs) {
          var length = pairs == null ? 0 : pairs.length, toIteratee = getIteratee();
          pairs = !length ? [] : arrayMap(pairs, function(pair) {
            if (typeof pair[1] != "function") {
              throw new TypeError2(FUNC_ERROR_TEXT);
            }
            return [toIteratee(pair[0]), pair[1]];
          });
          return baseRest(function(args) {
            var index = -1;
            while (++index < length) {
              var pair = pairs[index];
              if (apply(pair[0], this, args)) {
                return apply(pair[1], this, args);
              }
            }
          });
        }
        __name(cond, "cond");
        function conforms(source) {
          return baseConforms(baseClone(source, CLONE_DEEP_FLAG));
        }
        __name(conforms, "conforms");
        function constant(value) {
          return function() {
            return value;
          };
        }
        __name(constant, "constant");
        function defaultTo(value, defaultValue) {
          return value == null || value !== value ? defaultValue : value;
        }
        __name(defaultTo, "defaultTo");
        var flow = createFlow();
        var flowRight = createFlow(true);
        function identity(value) {
          return value;
        }
        __name(identity, "identity");
        function iteratee(func) {
          return baseIteratee(typeof func == "function" ? func : baseClone(func, CLONE_DEEP_FLAG));
        }
        __name(iteratee, "iteratee");
        function matches(source) {
          return baseMatches(baseClone(source, CLONE_DEEP_FLAG));
        }
        __name(matches, "matches");
        function matchesProperty(path67, srcValue) {
          return baseMatchesProperty(path67, baseClone(srcValue, CLONE_DEEP_FLAG));
        }
        __name(matchesProperty, "matchesProperty");
        var method = baseRest(function(path67, args) {
          return function(object) {
            return baseInvoke(object, path67, args);
          };
        });
        var methodOf = baseRest(function(object, args) {
          return function(path67) {
            return baseInvoke(object, path67, args);
          };
        });
        function mixin3(object, source, options29) {
          var props = keys(source), methodNames = baseFunctions(source, props);
          if (options29 == null && !(isObject2(source) && (methodNames.length || !props.length))) {
            options29 = source;
            source = object;
            object = this;
            methodNames = baseFunctions(source, keys(source));
          }
          var chain2 = !(isObject2(options29) && "chain" in options29) || !!options29.chain, isFunc = isFunction2(object);
          arrayEach(methodNames, function(methodName) {
            var func = source[methodName];
            object[methodName] = func;
            if (isFunc) {
              object.prototype[methodName] = function() {
                var chainAll = this.__chain__;
                if (chain2 || chainAll) {
                  var result2 = object(this.__wrapped__), actions = result2.__actions__ = copyArray(this.__actions__);
                  actions.push({ "func": func, "args": arguments, "thisArg": object });
                  result2.__chain__ = chainAll;
                  return result2;
                }
                return func.apply(object, arrayPush([this.value()], arguments));
              };
            }
          });
          return object;
        }
        __name(mixin3, "mixin");
        function noConflict() {
          if (root._ === this) {
            root._ = oldDash;
          }
          return this;
        }
        __name(noConflict, "noConflict");
        function noop() {
        }
        __name(noop, "noop");
        function nthArg(n2) {
          n2 = toInteger(n2);
          return baseRest(function(args) {
            return baseNth(args, n2);
          });
        }
        __name(nthArg, "nthArg");
        var over = createOver(arrayMap);
        var overEvery = createOver(arrayEvery);
        var overSome = createOver(arraySome);
        function property(path67) {
          return isKey(path67) ? baseProperty(toKey(path67)) : basePropertyDeep(path67);
        }
        __name(property, "property");
        function propertyOf(object) {
          return function(path67) {
            return object == null ? undefined2 : baseGet(object, path67);
          };
        }
        __name(propertyOf, "propertyOf");
        var range = createRange();
        var rangeRight = createRange(true);
        function stubArray() {
          return [];
        }
        __name(stubArray, "stubArray");
        function stubFalse() {
          return false;
        }
        __name(stubFalse, "stubFalse");
        function stubObject() {
          return {};
        }
        __name(stubObject, "stubObject");
        function stubString() {
          return "";
        }
        __name(stubString, "stubString");
        function stubTrue() {
          return true;
        }
        __name(stubTrue, "stubTrue");
        function times(n2, iteratee2) {
          n2 = toInteger(n2);
          if (n2 < 1 || n2 > MAX_SAFE_INTEGER) {
            return [];
          }
          var index = MAX_ARRAY_LENGTH, length = nativeMin(n2, MAX_ARRAY_LENGTH);
          iteratee2 = getIteratee(iteratee2);
          n2 -= MAX_ARRAY_LENGTH;
          var result2 = baseTimes(length, iteratee2);
          while (++index < n2) {
            iteratee2(index);
          }
          return result2;
        }
        __name(times, "times");
        function toPath3(value) {
          if (isArray(value)) {
            return arrayMap(value, toKey);
          }
          return isSymbol(value) ? [value] : copyArray(stringToPath(toString2(value)));
        }
        __name(toPath3, "toPath");
        function uniqueId(prefix) {
          var id = ++idCounter;
          return toString2(prefix) + id;
        }
        __name(uniqueId, "uniqueId");
        var add = createMathOperation(function(augend, addend) {
          return augend + addend;
        }, 0);
        var ceil = createRound("ceil");
        var divide = createMathOperation(function(dividend, divisor) {
          return dividend / divisor;
        }, 1);
        var floor = createRound("floor");
        function max(array) {
          return array && array.length ? baseExtremum(array, identity, baseGt) : undefined2;
        }
        __name(max, "max");
        function maxBy(array, iteratee2) {
          return array && array.length ? baseExtremum(array, getIteratee(iteratee2, 2), baseGt) : undefined2;
        }
        __name(maxBy, "maxBy");
        function mean(array) {
          return baseMean(array, identity);
        }
        __name(mean, "mean");
        function meanBy(array, iteratee2) {
          return baseMean(array, getIteratee(iteratee2, 2));
        }
        __name(meanBy, "meanBy");
        function min(array) {
          return array && array.length ? baseExtremum(array, identity, baseLt) : undefined2;
        }
        __name(min, "min");
        function minBy(array, iteratee2) {
          return array && array.length ? baseExtremum(array, getIteratee(iteratee2, 2), baseLt) : undefined2;
        }
        __name(minBy, "minBy");
        var multiply = createMathOperation(function(multiplier, multiplicand) {
          return multiplier * multiplicand;
        }, 1);
        var round = createRound("round");
        var subtract = createMathOperation(function(minuend, subtrahend) {
          return minuend - subtrahend;
        }, 0);
        function sum(array) {
          return array && array.length ? baseSum(array, identity) : 0;
        }
        __name(sum, "sum");
        function sumBy(array, iteratee2) {
          return array && array.length ? baseSum(array, getIteratee(iteratee2, 2)) : 0;
        }
        __name(sumBy, "sumBy");
        lodash.after = after;
        lodash.ary = ary;
        lodash.assign = assign;
        lodash.assignIn = assignIn;
        lodash.assignInWith = assignInWith;
        lodash.assignWith = assignWith;
        lodash.at = at;
        lodash.before = before;
        lodash.bind = bind;
        lodash.bindAll = bindAll;
        lodash.bindKey = bindKey;
        lodash.castArray = castArray;
        lodash.chain = chain;
        lodash.chunk = chunk;
        lodash.compact = compact;
        lodash.concat = concat;
        lodash.cond = cond;
        lodash.conforms = conforms;
        lodash.constant = constant;
        lodash.countBy = countBy;
        lodash.create = create2;
        lodash.curry = curry;
        lodash.curryRight = curryRight;
        lodash.debounce = debounce;
        lodash.defaults = defaults;
        lodash.defaultsDeep = defaultsDeep;
        lodash.defer = defer;
        lodash.delay = delay;
        lodash.difference = difference;
        lodash.differenceBy = differenceBy;
        lodash.differenceWith = differenceWith;
        lodash.drop = drop;
        lodash.dropRight = dropRight;
        lodash.dropRightWhile = dropRightWhile;
        lodash.dropWhile = dropWhile;
        lodash.fill = fill2;
        lodash.filter = filter;
        lodash.flatMap = flatMap;
        lodash.flatMapDeep = flatMapDeep;
        lodash.flatMapDepth = flatMapDepth;
        lodash.flatten = flatten;
        lodash.flattenDeep = flattenDeep;
        lodash.flattenDepth = flattenDepth;
        lodash.flip = flip;
        lodash.flow = flow;
        lodash.flowRight = flowRight;
        lodash.fromPairs = fromPairs;
        lodash.functions = functions;
        lodash.functionsIn = functionsIn;
        lodash.groupBy = groupBy;
        lodash.initial = initial;
        lodash.intersection = intersection;
        lodash.intersectionBy = intersectionBy;
        lodash.intersectionWith = intersectionWith;
        lodash.invert = invert;
        lodash.invertBy = invertBy;
        lodash.invokeMap = invokeMap;
        lodash.iteratee = iteratee;
        lodash.keyBy = keyBy;
        lodash.keys = keys;
        lodash.keysIn = keysIn;
        lodash.map = map;
        lodash.mapKeys = mapKeys;
        lodash.mapValues = mapValues;
        lodash.matches = matches;
        lodash.matchesProperty = matchesProperty;
        lodash.memoize = memoize;
        lodash.merge = merge;
        lodash.mergeWith = mergeWith;
        lodash.method = method;
        lodash.methodOf = methodOf;
        lodash.mixin = mixin3;
        lodash.negate = negate;
        lodash.nthArg = nthArg;
        lodash.omit = omit;
        lodash.omitBy = omitBy;
        lodash.once = once;
        lodash.orderBy = orderBy;
        lodash.over = over;
        lodash.overArgs = overArgs;
        lodash.overEvery = overEvery;
        lodash.overSome = overSome;
        lodash.partial = partial;
        lodash.partialRight = partialRight;
        lodash.partition = partition;
        lodash.pick = pick;
        lodash.pickBy = pickBy;
        lodash.property = property;
        lodash.propertyOf = propertyOf;
        lodash.pull = pull;
        lodash.pullAll = pullAll;
        lodash.pullAllBy = pullAllBy;
        lodash.pullAllWith = pullAllWith;
        lodash.pullAt = pullAt;
        lodash.range = range;
        lodash.rangeRight = rangeRight;
        lodash.rearg = rearg;
        lodash.reject = reject;
        lodash.remove = remove;
        lodash.rest = rest;
        lodash.reverse = reverse;
        lodash.sampleSize = sampleSize;
        lodash.set = set;
        lodash.setWith = setWith;
        lodash.shuffle = shuffle;
        lodash.slice = slice;
        lodash.sortBy = sortBy;
        lodash.sortedUniq = sortedUniq;
        lodash.sortedUniqBy = sortedUniqBy;
        lodash.split = split;
        lodash.spread = spread;
        lodash.tail = tail;
        lodash.take = take;
        lodash.takeRight = takeRight;
        lodash.takeRightWhile = takeRightWhile;
        lodash.takeWhile = takeWhile;
        lodash.tap = tap;
        lodash.throttle = throttle;
        lodash.thru = thru;
        lodash.toArray = toArray;
        lodash.toPairs = toPairs;
        lodash.toPairsIn = toPairsIn;
        lodash.toPath = toPath3;
        lodash.toPlainObject = toPlainObject;
        lodash.transform = transform;
        lodash.unary = unary;
        lodash.union = union;
        lodash.unionBy = unionBy;
        lodash.unionWith = unionWith;
        lodash.uniq = uniq;
        lodash.uniqBy = uniqBy;
        lodash.uniqWith = uniqWith;
        lodash.unset = unset;
        lodash.unzip = unzip;
        lodash.unzipWith = unzipWith;
        lodash.update = update;
        lodash.updateWith = updateWith;
        lodash.values = values;
        lodash.valuesIn = valuesIn;
        lodash.without = without;
        lodash.words = words;
        lodash.wrap = wrap4;
        lodash.xor = xor;
        lodash.xorBy = xorBy;
        lodash.xorWith = xorWith;
        lodash.zip = zip;
        lodash.zipObject = zipObject;
        lodash.zipObjectDeep = zipObjectDeep;
        lodash.zipWith = zipWith;
        lodash.entries = toPairs;
        lodash.entriesIn = toPairsIn;
        lodash.extend = assignIn;
        lodash.extendWith = assignInWith;
        mixin3(lodash, lodash);
        lodash.add = add;
        lodash.attempt = attempt;
        lodash.camelCase = camelCase2;
        lodash.capitalize = capitalize;
        lodash.ceil = ceil;
        lodash.clamp = clamp;
        lodash.clone = clone;
        lodash.cloneDeep = cloneDeep;
        lodash.cloneDeepWith = cloneDeepWith;
        lodash.cloneWith = cloneWith;
        lodash.conformsTo = conformsTo;
        lodash.deburr = deburr;
        lodash.defaultTo = defaultTo;
        lodash.divide = divide;
        lodash.endsWith = endsWith;
        lodash.eq = eq;
        lodash.escape = escape2;
        lodash.escapeRegExp = escapeRegExp;
        lodash.every = every;
        lodash.find = find;
        lodash.findIndex = findIndex2;
        lodash.findKey = findKey;
        lodash.findLast = findLast;
        lodash.findLastIndex = findLastIndex;
        lodash.findLastKey = findLastKey;
        lodash.floor = floor;
        lodash.forEach = forEach;
        lodash.forEachRight = forEachRight;
        lodash.forIn = forIn;
        lodash.forInRight = forInRight;
        lodash.forOwn = forOwn;
        lodash.forOwnRight = forOwnRight;
        lodash.get = get;
        lodash.gt = gt;
        lodash.gte = gte;
        lodash.has = has;
        lodash.hasIn = hasIn;
        lodash.head = head;
        lodash.identity = identity;
        lodash.includes = includes;
        lodash.indexOf = indexOf;
        lodash.inRange = inRange;
        lodash.invoke = invoke;
        lodash.isArguments = isArguments;
        lodash.isArray = isArray;
        lodash.isArrayBuffer = isArrayBuffer;
        lodash.isArrayLike = isArrayLike;
        lodash.isArrayLikeObject = isArrayLikeObject;
        lodash.isBoolean = isBoolean3;
        lodash.isBuffer = isBuffer;
        lodash.isDate = isDate;
        lodash.isElement = isElement2;
        lodash.isEmpty = isEmpty;
        lodash.isEqual = isEqual;
        lodash.isEqualWith = isEqualWith;
        lodash.isError = isError2;
        lodash.isFinite = isFinite2;
        lodash.isFunction = isFunction2;
        lodash.isInteger = isInteger2;
        lodash.isLength = isLength;
        lodash.isMap = isMap;
        lodash.isMatch = isMatch;
        lodash.isMatchWith = isMatchWith;
        lodash.isNaN = isNaN3;
        lodash.isNative = isNative;
        lodash.isNil = isNil;
        lodash.isNull = isNull;
        lodash.isNumber = isNumber;
        lodash.isObject = isObject2;
        lodash.isObjectLike = isObjectLike;
        lodash.isPlainObject = isPlainObject2;
        lodash.isRegExp = isRegExp2;
        lodash.isSafeInteger = isSafeInteger;
        lodash.isSet = isSet;
        lodash.isString = isString4;
        lodash.isSymbol = isSymbol;
        lodash.isTypedArray = isTypedArray;
        lodash.isUndefined = isUndefined;
        lodash.isWeakMap = isWeakMap;
        lodash.isWeakSet = isWeakSet;
        lodash.join = join15;
        lodash.kebabCase = kebabCase;
        lodash.last = last;
        lodash.lastIndexOf = lastIndexOf;
        lodash.lowerCase = lowerCase;
        lodash.lowerFirst = lowerFirst;
        lodash.lt = lt2;
        lodash.lte = lte;
        lodash.max = max;
        lodash.maxBy = maxBy;
        lodash.mean = mean;
        lodash.meanBy = meanBy;
        lodash.min = min;
        lodash.minBy = minBy;
        lodash.stubArray = stubArray;
        lodash.stubFalse = stubFalse;
        lodash.stubObject = stubObject;
        lodash.stubString = stubString;
        lodash.stubTrue = stubTrue;
        lodash.multiply = multiply;
        lodash.nth = nth;
        lodash.noConflict = noConflict;
        lodash.noop = noop;
        lodash.now = now;
        lodash.pad = pad2;
        lodash.padEnd = padEnd;
        lodash.padStart = padStart;
        lodash.parseInt = parseInt2;
        lodash.random = random;
        lodash.reduce = reduce;
        lodash.reduceRight = reduceRight;
        lodash.repeat = repeat;
        lodash.replace = replace;
        lodash.result = result;
        lodash.round = round;
        lodash.runInContext = runInContext2;
        lodash.sample = sample;
        lodash.size = size;
        lodash.snakeCase = snakeCase;
        lodash.some = some;
        lodash.sortedIndex = sortedIndex;
        lodash.sortedIndexBy = sortedIndexBy;
        lodash.sortedIndexOf = sortedIndexOf;
        lodash.sortedLastIndex = sortedLastIndex;
        lodash.sortedLastIndexBy = sortedLastIndexBy;
        lodash.sortedLastIndexOf = sortedLastIndexOf;
        lodash.startCase = startCase;
        lodash.startsWith = startsWith;
        lodash.subtract = subtract;
        lodash.sum = sum;
        lodash.sumBy = sumBy;
        lodash.template = template;
        lodash.times = times;
        lodash.toFinite = toFinite;
        lodash.toInteger = toInteger;
        lodash.toLength = toLength;
        lodash.toLower = toLower;
        lodash.toNumber = toNumber;
        lodash.toSafeInteger = toSafeInteger;
        lodash.toString = toString2;
        lodash.toUpper = toUpper;
        lodash.trim = trim;
        lodash.trimEnd = trimEnd;
        lodash.trimStart = trimStart;
        lodash.truncate = truncate4;
        lodash.unescape = unescape2;
        lodash.uniqueId = uniqueId;
        lodash.upperCase = upperCase;
        lodash.upperFirst = upperFirst;
        lodash.each = forEach;
        lodash.eachRight = forEachRight;
        lodash.first = head;
        mixin3(lodash, function() {
          var source = {};
          baseForOwn(lodash, function(func, methodName) {
            if (!hasOwnProperty2.call(lodash.prototype, methodName)) {
              source[methodName] = func;
            }
          });
          return source;
        }(), { "chain": false });
        lodash.VERSION = VERSION;
        arrayEach(["bind", "bindKey", "curry", "curryRight", "partial", "partialRight"], function(methodName) {
          lodash[methodName].placeholder = lodash;
        });
        arrayEach(["drop", "take"], function(methodName, index) {
          LazyWrapper.prototype[methodName] = function(n2) {
            n2 = n2 === undefined2 ? 1 : nativeMax(toInteger(n2), 0);
            var result2 = this.__filtered__ && !index ? new LazyWrapper(this) : this.clone();
            if (result2.__filtered__) {
              result2.__takeCount__ = nativeMin(n2, result2.__takeCount__);
            } else {
              result2.__views__.push({
                "size": nativeMin(n2, MAX_ARRAY_LENGTH),
                "type": methodName + (result2.__dir__ < 0 ? "Right" : "")
              });
            }
            return result2;
          };
          LazyWrapper.prototype[methodName + "Right"] = function(n2) {
            return this.reverse()[methodName](n2).reverse();
          };
        });
        arrayEach(["filter", "map", "takeWhile"], function(methodName, index) {
          var type = index + 1, isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;
          LazyWrapper.prototype[methodName] = function(iteratee2) {
            var result2 = this.clone();
            result2.__iteratees__.push({
              "iteratee": getIteratee(iteratee2, 3),
              "type": type
            });
            result2.__filtered__ = result2.__filtered__ || isFilter;
            return result2;
          };
        });
        arrayEach(["head", "last"], function(methodName, index) {
          var takeName2 = "take" + (index ? "Right" : "");
          LazyWrapper.prototype[methodName] = function() {
            return this[takeName2](1).value()[0];
          };
        });
        arrayEach(["initial", "tail"], function(methodName, index) {
          var dropName = "drop" + (index ? "" : "Right");
          LazyWrapper.prototype[methodName] = function() {
            return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);
          };
        });
        LazyWrapper.prototype.compact = function() {
          return this.filter(identity);
        };
        LazyWrapper.prototype.find = function(predicate) {
          return this.filter(predicate).head();
        };
        LazyWrapper.prototype.findLast = function(predicate) {
          return this.reverse().find(predicate);
        };
        LazyWrapper.prototype.invokeMap = baseRest(function(path67, args) {
          if (typeof path67 == "function") {
            return new LazyWrapper(this);
          }
          return this.map(function(value) {
            return baseInvoke(value, path67, args);
          });
        });
        LazyWrapper.prototype.reject = function(predicate) {
          return this.filter(negate(getIteratee(predicate)));
        };
        LazyWrapper.prototype.slice = function(start, end) {
          start = toInteger(start);
          var result2 = this;
          if (result2.__filtered__ && (start > 0 || end < 0)) {
            return new LazyWrapper(result2);
          }
          if (start < 0) {
            result2 = result2.takeRight(-start);
          } else if (start) {
            result2 = result2.drop(start);
          }
          if (end !== undefined2) {
            end = toInteger(end);
            result2 = end < 0 ? result2.dropRight(-end) : result2.take(end - start);
          }
          return result2;
        };
        LazyWrapper.prototype.takeRightWhile = function(predicate) {
          return this.reverse().takeWhile(predicate).reverse();
        };
        LazyWrapper.prototype.toArray = function() {
          return this.take(MAX_ARRAY_LENGTH);
        };
        baseForOwn(LazyWrapper.prototype, function(func, methodName) {
          var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName), isTaker = /^(?:head|last)$/.test(methodName), lodashFunc = lodash[isTaker ? "take" + (methodName == "last" ? "Right" : "") : methodName], retUnwrapped = isTaker || /^find/.test(methodName);
          if (!lodashFunc) {
            return;
          }
          lodash.prototype[methodName] = function() {
            var value = this.__wrapped__, args = isTaker ? [1] : arguments, isLazy = value instanceof LazyWrapper, iteratee2 = args[0], useLazy = isLazy || isArray(value);
            var interceptor = /* @__PURE__ */ __name(function(value2) {
              var result3 = lodashFunc.apply(lodash, arrayPush([value2], args));
              return isTaker && chainAll ? result3[0] : result3;
            }, "interceptor");
            if (useLazy && checkIteratee && typeof iteratee2 == "function" && iteratee2.length != 1) {
              isLazy = useLazy = false;
            }
            var chainAll = this.__chain__, isHybrid = !!this.__actions__.length, isUnwrapped = retUnwrapped && !chainAll, onlyLazy = isLazy && !isHybrid;
            if (!retUnwrapped && useLazy) {
              value = onlyLazy ? value : new LazyWrapper(this);
              var result2 = func.apply(value, args);
              result2.__actions__.push({ "func": thru, "args": [interceptor], "thisArg": undefined2 });
              return new LodashWrapper(result2, chainAll);
            }
            if (isUnwrapped && onlyLazy) {
              return func.apply(this, args);
            }
            result2 = this.thru(interceptor);
            return isUnwrapped ? isTaker ? result2.value()[0] : result2.value() : result2;
          };
        });
        arrayEach(["pop", "push", "shift", "sort", "splice", "unshift"], function(methodName) {
          var func = arrayProto[methodName], chainName = /^(?:push|sort|unshift)$/.test(methodName) ? "tap" : "thru", retUnwrapped = /^(?:pop|shift)$/.test(methodName);
          lodash.prototype[methodName] = function() {
            var args = arguments;
            if (retUnwrapped && !this.__chain__) {
              var value = this.value();
              return func.apply(isArray(value) ? value : [], args);
            }
            return this[chainName](function(value2) {
              return func.apply(isArray(value2) ? value2 : [], args);
            });
          };
        });
        baseForOwn(LazyWrapper.prototype, function(func, methodName) {
          var lodashFunc = lodash[methodName];
          if (lodashFunc) {
            var key = lodashFunc.name + "";
            if (!hasOwnProperty2.call(realNames, key)) {
              realNames[key] = [];
            }
            realNames[key].push({ "name": methodName, "func": lodashFunc });
          }
        });
        realNames[createHybrid(undefined2, WRAP_BIND_KEY_FLAG).name] = [{
          "name": "wrapper",
          "func": undefined2
        }];
        LazyWrapper.prototype.clone = lazyClone;
        LazyWrapper.prototype.reverse = lazyReverse;
        LazyWrapper.prototype.value = lazyValue;
        lodash.prototype.at = wrapperAt;
        lodash.prototype.chain = wrapperChain;
        lodash.prototype.commit = wrapperCommit;
        lodash.prototype.next = wrapperNext;
        lodash.prototype.plant = wrapperPlant;
        lodash.prototype.reverse = wrapperReverse;
        lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;
        lodash.prototype.first = lodash.prototype.head;
        if (symIterator) {
          lodash.prototype[symIterator] = wrapperToIterator;
        }
        return lodash;
      }, "runInContext");
      var _3 = runInContext();
      if (typeof define == "function" && typeof define.amd == "object" && define.amd) {
        root._ = _3;
        define(function() {
          return _3;
        });
      } else if (freeModule) {
        (freeModule.exports = _3)._ = _3;
        freeExports._ = _3;
      } else {
        root._ = _3;
      }
    }).call(exports2);
  }
});

// ../../node_modules/.pnpm/ansi-escapes@4.3.2/node_modules/ansi-escapes/index.js
var require_ansi_escapes = __commonJS({
  "../../node_modules/.pnpm/ansi-escapes@4.3.2/node_modules/ansi-escapes/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var ansiEscapes2 = module3.exports;
    module3.exports.default = ansiEscapes2;
    var ESC2 = "\x1B[";
    var OSC2 = "\x1B]";
    var BEL2 = "\x07";
    var SEP2 = ";";
    var isTerminalApp2 = process.env.TERM_PROGRAM === "Apple_Terminal";
    ansiEscapes2.cursorTo = (x2, y2) => {
      if (typeof x2 !== "number") {
        throw new TypeError("The `x` argument is required");
      }
      if (typeof y2 !== "number") {
        return ESC2 + (x2 + 1) + "G";
      }
      return ESC2 + (y2 + 1) + ";" + (x2 + 1) + "H";
    };
    ansiEscapes2.cursorMove = (x2, y2) => {
      if (typeof x2 !== "number") {
        throw new TypeError("The `x` argument is required");
      }
      let ret = "";
      if (x2 < 0) {
        ret += ESC2 + -x2 + "D";
      } else if (x2 > 0) {
        ret += ESC2 + x2 + "C";
      }
      if (y2 < 0) {
        ret += ESC2 + -y2 + "A";
      } else if (y2 > 0) {
        ret += ESC2 + y2 + "B";
      }
      return ret;
    };
    ansiEscapes2.cursorUp = (count = 1) => ESC2 + count + "A";
    ansiEscapes2.cursorDown = (count = 1) => ESC2 + count + "B";
    ansiEscapes2.cursorForward = (count = 1) => ESC2 + count + "C";
    ansiEscapes2.cursorBackward = (count = 1) => ESC2 + count + "D";
    ansiEscapes2.cursorLeft = ESC2 + "G";
    ansiEscapes2.cursorSavePosition = isTerminalApp2 ? "\x1B7" : ESC2 + "s";
    ansiEscapes2.cursorRestorePosition = isTerminalApp2 ? "\x1B8" : ESC2 + "u";
    ansiEscapes2.cursorGetPosition = ESC2 + "6n";
    ansiEscapes2.cursorNextLine = ESC2 + "E";
    ansiEscapes2.cursorPrevLine = ESC2 + "F";
    ansiEscapes2.cursorHide = ESC2 + "?25l";
    ansiEscapes2.cursorShow = ESC2 + "?25h";
    ansiEscapes2.eraseLines = (count) => {
      let clear = "";
      for (let i = 0; i < count; i++) {
        clear += ansiEscapes2.eraseLine + (i < count - 1 ? ansiEscapes2.cursorUp() : "");
      }
      if (count) {
        clear += ansiEscapes2.cursorLeft;
      }
      return clear;
    };
    ansiEscapes2.eraseEndLine = ESC2 + "K";
    ansiEscapes2.eraseStartLine = ESC2 + "1K";
    ansiEscapes2.eraseLine = ESC2 + "2K";
    ansiEscapes2.eraseDown = ESC2 + "J";
    ansiEscapes2.eraseUp = ESC2 + "1J";
    ansiEscapes2.eraseScreen = ESC2 + "2J";
    ansiEscapes2.scrollUp = ESC2 + "S";
    ansiEscapes2.scrollDown = ESC2 + "T";
    ansiEscapes2.clearScreen = "\x1Bc";
    ansiEscapes2.clearTerminal = process.platform === "win32" ? `${ansiEscapes2.eraseScreen}${ESC2}0f` : (
      // 1. Erases the screen (Only done in case `2` is not supported)
      // 2. Erases the whole screen including scrollback buffer
      // 3. Moves cursor to the top-left position
      // More info: https://www.real-world-systems.com/docs/ANSIcode.html
      `${ansiEscapes2.eraseScreen}${ESC2}3J${ESC2}H`
    );
    ansiEscapes2.beep = BEL2;
    ansiEscapes2.link = (text, url4) => {
      return [
        OSC2,
        "8",
        SEP2,
        SEP2,
        url4,
        BEL2,
        text,
        OSC2,
        "8",
        SEP2,
        SEP2,
        BEL2
      ].join("");
    };
    ansiEscapes2.image = (buffer, options29 = {}) => {
      let ret = `${OSC2}1337;File=inline=1`;
      if (options29.width) {
        ret += `;width=${options29.width}`;
      }
      if (options29.height) {
        ret += `;height=${options29.height}`;
      }
      if (options29.preserveAspectRatio === false) {
        ret += ";preserveAspectRatio=0";
      }
      return ret + ":" + buffer.toString("base64") + BEL2;
    };
    ansiEscapes2.iTerm = {
      setCwd: (cwd2 = process.cwd()) => `${OSC2}50;CurrentDir=${cwd2}${BEL2}`,
      annotation: (message, options29 = {}) => {
        let ret = `${OSC2}1337;`;
        const hasX = typeof options29.x !== "undefined";
        const hasY = typeof options29.y !== "undefined";
        if ((hasX || hasY) && !(hasX && hasY && typeof options29.length !== "undefined")) {
          throw new Error("`x`, `y` and `length` must be defined when `x` or `y` is defined");
        }
        message = message.replace(/\|/g, "");
        ret += options29.isHidden ? "AddHiddenAnnotation=" : "AddAnnotation=";
        if (options29.length > 0) {
          ret += (hasX ? [message, options29.length, options29.x, options29.y] : [options29.length, message]).join("|");
        } else {
          ret += message;
        }
        return ret + BEL2;
      }
    };
  }
});

// ../../node_modules/.pnpm/mimic-fn@2.1.0/node_modules/mimic-fn/index.js
var require_mimic_fn = __commonJS({
  "../../node_modules/.pnpm/mimic-fn@2.1.0/node_modules/mimic-fn/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var mimicFn = /* @__PURE__ */ __name((to, from) => {
      for (const prop of Reflect.ownKeys(from)) {
        Object.defineProperty(to, prop, Object.getOwnPropertyDescriptor(from, prop));
      }
      return to;
    }, "mimicFn");
    module3.exports = mimicFn;
    module3.exports.default = mimicFn;
  }
});

// ../../node_modules/.pnpm/onetime@5.1.2/node_modules/onetime/index.js
var require_onetime = __commonJS({
  "../../node_modules/.pnpm/onetime@5.1.2/node_modules/onetime/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var mimicFn = require_mimic_fn();
    var calledFunctions2 = /* @__PURE__ */ new WeakMap();
    var onetime3 = /* @__PURE__ */ __name((function_, options29 = {}) => {
      if (typeof function_ !== "function") {
        throw new TypeError("Expected a function");
      }
      let returnValue;
      let callCount = 0;
      const functionName = function_.displayName || function_.name || "<anonymous>";
      const onetime4 = /* @__PURE__ */ __name(function(...arguments_) {
        calledFunctions2.set(onetime4, ++callCount);
        if (callCount === 1) {
          returnValue = function_.apply(this, arguments_);
          function_ = null;
        } else if (options29.throw === true) {
          throw new Error(`Function \`${functionName}\` can only be called once`);
        }
        return returnValue;
      }, "onetime");
      mimicFn(onetime4, function_);
      calledFunctions2.set(onetime4, callCount);
      return onetime4;
    }, "onetime");
    module3.exports = onetime3;
    module3.exports.default = onetime3;
    module3.exports.callCount = (function_) => {
      if (!calledFunctions2.has(function_)) {
        throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
      }
      return calledFunctions2.get(function_);
    };
  }
});

// ../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js
var require_signals = __commonJS({
  "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js"(exports2, module3) {
    init_import_meta_url();
    module3.exports = [
      "SIGABRT",
      "SIGALRM",
      "SIGHUP",
      "SIGINT",
      "SIGTERM"
    ];
    if (process.platform !== "win32") {
      module3.exports.push(
        "SIGVTALRM",
        "SIGXCPU",
        "SIGXFSZ",
        "SIGUSR2",
        "SIGTRAP",
        "SIGSYS",
        "SIGQUIT",
        "SIGIOT"
        // should detect profiler and enable/disable accordingly.
        // see #21
        // 'SIGPROF'
      );
    }
    if (process.platform === "linux") {
      module3.exports.push(
        "SIGIO",
        "SIGPOLL",
        "SIGPWR",
        "SIGSTKFLT",
        "SIGUNUSED"
      );
    }
  }
});

// ../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js
var require_signal_exit = __commonJS({
  "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js"(exports2, module3) {
    init_import_meta_url();
    var process11 = global.process;
    var processOk = /* @__PURE__ */ __name(function(process12) {
      return process12 && typeof process12 === "object" && typeof process12.removeListener === "function" && typeof process12.emit === "function" && typeof process12.reallyExit === "function" && typeof process12.listeners === "function" && typeof process12.kill === "function" && typeof process12.pid === "number" && typeof process12.on === "function";
    }, "processOk");
    if (!processOk(process11)) {
      module3.exports = function() {
        return function() {
        };
      };
    } else {
      assert27 = require("assert");
      signals = require_signals();
      isWin = /^win/i.test(process11.platform);
      EE = require("events");
      if (typeof EE !== "function") {
        EE = EE.EventEmitter;
      }
      if (process11.__signal_exit_emitter__) {
        emitter = process11.__signal_exit_emitter__;
      } else {
        emitter = process11.__signal_exit_emitter__ = new EE();
        emitter.count = 0;
        emitter.emitted = {};
      }
      if (!emitter.infinite) {
        emitter.setMaxListeners(Infinity);
        emitter.infinite = true;
      }
      module3.exports = function(cb, opts) {
        if (!processOk(global.process)) {
          return function() {
          };
        }
        assert27.equal(typeof cb, "function", "a callback must be provided for exit handler");
        if (loaded === false) {
          load();
        }
        var ev = "exit";
        if (opts && opts.alwaysLast) {
          ev = "afterexit";
        }
        var remove = /* @__PURE__ */ __name(function() {
          emitter.removeListener(ev, cb);
          if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
            unload();
          }
        }, "remove");
        emitter.on(ev, cb);
        return remove;
      };
      unload = /* @__PURE__ */ __name(function unload2() {
        if (!loaded || !processOk(global.process)) {
          return;
        }
        loaded = false;
        signals.forEach(function(sig) {
          try {
            process11.removeListener(sig, sigListeners[sig]);
          } catch (er) {
          }
        });
        process11.emit = originalProcessEmit;
        process11.reallyExit = originalProcessReallyExit;
        emitter.count -= 1;
      }, "unload");
      module3.exports.unload = unload;
      emit = /* @__PURE__ */ __name(function emit2(event, code, signal) {
        if (emitter.emitted[event]) {
          return;
        }
        emitter.emitted[event] = true;
        emitter.emit(event, code, signal);
      }, "emit");
      sigListeners = {};
      signals.forEach(function(sig) {
        sigListeners[sig] = /* @__PURE__ */ __name(function listener() {
          if (!processOk(global.process)) {
            return;
          }
          var listeners = process11.listeners(sig);
          if (listeners.length === emitter.count) {
            unload();
            emit("exit", null, sig);
            emit("afterexit", null, sig);
            if (isWin && sig === "SIGHUP") {
              sig = "SIGINT";
            }
            process11.kill(process11.pid, sig);
          }
        }, "listener");
      });
      module3.exports.signals = function() {
        return signals;
      };
      loaded = false;
      load = /* @__PURE__ */ __name(function load2() {
        if (loaded || !processOk(global.process)) {
          return;
        }
        loaded = true;
        emitter.count += 1;
        signals = signals.filter(function(sig) {
          try {
            process11.on(sig, sigListeners[sig]);
            return true;
          } catch (er) {
            return false;
          }
        });
        process11.emit = processEmit;
        process11.reallyExit = processReallyExit;
      }, "load");
      module3.exports.load = load;
      originalProcessReallyExit = process11.reallyExit;
      processReallyExit = /* @__PURE__ */ __name(function processReallyExit2(code) {
        if (!processOk(global.process)) {
          return;
        }
        process11.exitCode = code || /* istanbul ignore next */
        0;
        emit("exit", process11.exitCode, null);
        emit("afterexit", process11.exitCode, null);
        originalProcessReallyExit.call(process11, process11.exitCode);
      }, "processReallyExit");
      originalProcessEmit = process11.emit;
      processEmit = /* @__PURE__ */ __name(function processEmit2(ev, arg) {
        if (ev === "exit" && processOk(global.process)) {
          if (arg !== void 0) {
            process11.exitCode = arg;
          }
          var ret = originalProcessEmit.apply(this, arguments);
          emit("exit", process11.exitCode, null);
          emit("afterexit", process11.exitCode, null);
          return ret;
        } else {
          return originalProcessEmit.apply(this, arguments);
        }
      }, "processEmit");
    }
    var assert27;
    var signals;
    var isWin;
    var EE;
    var emitter;
    var unload;
    var emit;
    var sigListeners;
    var loaded;
    var load;
    var originalProcessReallyExit;
    var processReallyExit;
    var originalProcessEmit;
    var processEmit;
  }
});

// ../../node_modules/.pnpm/restore-cursor@3.1.0/node_modules/restore-cursor/index.js
var require_restore_cursor = __commonJS({
  "../../node_modules/.pnpm/restore-cursor@3.1.0/node_modules/restore-cursor/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var onetime3 = require_onetime();
    var signalExit2 = require_signal_exit();
    module3.exports = onetime3(() => {
      signalExit2(() => {
        process.stderr.write("\x1B[?25h");
      }, { alwaysLast: true });
    });
  }
});

// ../../node_modules/.pnpm/cli-cursor@3.1.0/node_modules/cli-cursor/index.js
var require_cli_cursor = __commonJS({
  "../../node_modules/.pnpm/cli-cursor@3.1.0/node_modules/cli-cursor/index.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var restoreCursor2 = require_restore_cursor();
    var isHidden2 = false;
    exports2.show = (writableStream = process.stderr) => {
      if (!writableStream.isTTY) {
        return;
      }
      isHidden2 = false;
      writableStream.write("\x1B[?25h");
    };
    exports2.hide = (writableStream = process.stderr) => {
      if (!writableStream.isTTY) {
        return;
      }
      restoreCursor2();
      isHidden2 = true;
      writableStream.write("\x1B[?25l");
    };
    exports2.toggle = (force, writableStream) => {
      if (force !== void 0) {
        isHidden2 = force;
      }
      if (isHidden2) {
        exports2.show(writableStream);
      } else {
        exports2.hide(writableStream);
      }
    };
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/log-update.js
var require_log_update = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/log-update.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var ansi_escapes_1 = __importDefault(require_ansi_escapes());
    var cli_cursor_1 = __importDefault(require_cli_cursor());
    var create2 = /* @__PURE__ */ __name((stream2, { showCursor = false } = {}) => {
      let previousLineCount = 0;
      let previousOutput = "";
      let hasHiddenCursor = false;
      const render7 = /* @__PURE__ */ __name((str) => {
        if (!showCursor && !hasHiddenCursor) {
          cli_cursor_1.default.hide();
          hasHiddenCursor = true;
        }
        const output = str + "\n";
        if (output === previousOutput) {
          return;
        }
        previousOutput = output;
        stream2.write(ansi_escapes_1.default.eraseLines(previousLineCount) + output);
        previousLineCount = output.split("\n").length;
      }, "render");
      render7.clear = () => {
        stream2.write(ansi_escapes_1.default.eraseLines(previousLineCount));
        previousOutput = "";
        previousLineCount = 0;
      };
      render7.done = () => {
        previousOutput = "";
        previousLineCount = 0;
        if (!showCursor) {
          cli_cursor_1.default.show();
          hasHiddenCursor = false;
        }
      };
      return render7;
    }, "create");
    exports2.default = { create: create2 };
  }
});

// ../../node_modules/.pnpm/ci-info@2.0.0/node_modules/ci-info/vendors.json
var require_vendors = __commonJS({
  "../../node_modules/.pnpm/ci-info@2.0.0/node_modules/ci-info/vendors.json"(exports2, module3) {
    module3.exports = [
      {
        name: "AppVeyor",
        constant: "APPVEYOR",
        env: "APPVEYOR",
        pr: "APPVEYOR_PULL_REQUEST_NUMBER"
      },
      {
        name: "Azure Pipelines",
        constant: "AZURE_PIPELINES",
        env: "SYSTEM_TEAMFOUNDATIONCOLLECTIONURI",
        pr: "SYSTEM_PULLREQUEST_PULLREQUESTID"
      },
      {
        name: "Bamboo",
        constant: "BAMBOO",
        env: "bamboo_planKey"
      },
      {
        name: "Bitbucket Pipelines",
        constant: "BITBUCKET",
        env: "BITBUCKET_COMMIT",
        pr: "BITBUCKET_PR_ID"
      },
      {
        name: "Bitrise",
        constant: "BITRISE",
        env: "BITRISE_IO",
        pr: "BITRISE_PULL_REQUEST"
      },
      {
        name: "Buddy",
        constant: "BUDDY",
        env: "BUDDY_WORKSPACE_ID",
        pr: "BUDDY_EXECUTION_PULL_REQUEST_ID"
      },
      {
        name: "Buildkite",
        constant: "BUILDKITE",
        env: "BUILDKITE",
        pr: { env: "BUILDKITE_PULL_REQUEST", ne: "false" }
      },
      {
        name: "CircleCI",
        constant: "CIRCLE",
        env: "CIRCLECI",
        pr: "CIRCLE_PULL_REQUEST"
      },
      {
        name: "Cirrus CI",
        constant: "CIRRUS",
        env: "CIRRUS_CI",
        pr: "CIRRUS_PR"
      },
      {
        name: "AWS CodeBuild",
        constant: "CODEBUILD",
        env: "CODEBUILD_BUILD_ARN"
      },
      {
        name: "Codeship",
        constant: "CODESHIP",
        env: { CI_NAME: "codeship" }
      },
      {
        name: "Drone",
        constant: "DRONE",
        env: "DRONE",
        pr: { DRONE_BUILD_EVENT: "pull_request" }
      },
      {
        name: "dsari",
        constant: "DSARI",
        env: "DSARI"
      },
      {
        name: "GitLab CI",
        constant: "GITLAB",
        env: "GITLAB_CI"
      },
      {
        name: "GoCD",
        constant: "GOCD",
        env: "GO_PIPELINE_LABEL"
      },
      {
        name: "Hudson",
        constant: "HUDSON",
        env: "HUDSON_URL"
      },
      {
        name: "Jenkins",
        constant: "JENKINS",
        env: ["JENKINS_URL", "BUILD_ID"],
        pr: { any: ["ghprbPullId", "CHANGE_ID"] }
      },
      {
        name: "Magnum CI",
        constant: "MAGNUM",
        env: "MAGNUM"
      },
      {
        name: "Netlify CI",
        constant: "NETLIFY",
        env: "NETLIFY_BUILD_BASE",
        pr: { env: "PULL_REQUEST", ne: "false" }
      },
      {
        name: "Sail CI",
        constant: "SAIL",
        env: "SAILCI",
        pr: "SAIL_PULL_REQUEST_NUMBER"
      },
      {
        name: "Semaphore",
        constant: "SEMAPHORE",
        env: "SEMAPHORE",
        pr: "PULL_REQUEST_NUMBER"
      },
      {
        name: "Shippable",
        constant: "SHIPPABLE",
        env: "SHIPPABLE",
        pr: { IS_PULL_REQUEST: "true" }
      },
      {
        name: "Solano CI",
        constant: "SOLANO",
        env: "TDDIUM",
        pr: "TDDIUM_PR_ID"
      },
      {
        name: "Strider CD",
        constant: "STRIDER",
        env: "STRIDER"
      },
      {
        name: "TaskCluster",
        constant: "TASKCLUSTER",
        env: ["TASK_ID", "RUN_ID"]
      },
      {
        name: "TeamCity",
        constant: "TEAMCITY",
        env: "TEAMCITY_VERSION"
      },
      {
        name: "Travis CI",
        constant: "TRAVIS",
        env: "TRAVIS",
        pr: { env: "TRAVIS_PULL_REQUEST", ne: "false" }
      }
    ];
  }
});

// ../../node_modules/.pnpm/ci-info@2.0.0/node_modules/ci-info/index.js
var require_ci_info = __commonJS({
  "../../node_modules/.pnpm/ci-info@2.0.0/node_modules/ci-info/index.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var vendors = require_vendors();
    var env5 = process.env;
    Object.defineProperty(exports2, "_vendors", {
      value: vendors.map(function(v2) {
        return v2.constant;
      })
    });
    exports2.name = null;
    exports2.isPR = null;
    vendors.forEach(function(vendor) {
      var envs = Array.isArray(vendor.env) ? vendor.env : [vendor.env];
      var isCI2 = envs.every(function(obj) {
        return checkEnv(obj);
      });
      exports2[vendor.constant] = isCI2;
      if (isCI2) {
        exports2.name = vendor.name;
        switch (typeof vendor.pr) {
          case "string":
            exports2.isPR = !!env5[vendor.pr];
            break;
          case "object":
            if ("env" in vendor.pr) {
              exports2.isPR = vendor.pr.env in env5 && env5[vendor.pr.env] !== vendor.pr.ne;
            } else if ("any" in vendor.pr) {
              exports2.isPR = vendor.pr.any.some(function(key) {
                return !!env5[key];
              });
            } else {
              exports2.isPR = checkEnv(vendor.pr);
            }
            break;
          default:
            exports2.isPR = null;
        }
      }
    });
    exports2.isCI = !!(env5.CI || // Travis CI, CircleCI, Cirrus CI, Gitlab CI, Appveyor, CodeShip, dsari
    env5.CONTINUOUS_INTEGRATION || // Travis CI, Cirrus CI
    env5.BUILD_NUMBER || // Jenkins, TeamCity
    env5.RUN_ID || // TaskCluster, dsari
    exports2.name || false);
    function checkEnv(obj) {
      if (typeof obj === "string")
        return !!env5[obj];
      return Object.keys(obj).every(function(k2) {
        return env5[k2] === obj[k2];
      });
    }
    __name(checkEnv, "checkEnv");
  }
});

// ../../node_modules/.pnpm/is-ci@2.0.0/node_modules/is-ci/index.js
var require_is_ci = __commonJS({
  "../../node_modules/.pnpm/is-ci@2.0.0/node_modules/is-ci/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = require_ci_info().isCI;
  }
});

// ../../node_modules/.pnpm/auto-bind@4.0.0/node_modules/auto-bind/index.js
var require_auto_bind = __commonJS({
  "../../node_modules/.pnpm/auto-bind@4.0.0/node_modules/auto-bind/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var getAllProperties = /* @__PURE__ */ __name((object) => {
      const properties = /* @__PURE__ */ new Set();
      do {
        for (const key of Reflect.ownKeys(object)) {
          properties.add([object, key]);
        }
      } while ((object = Reflect.getPrototypeOf(object)) && object !== Object.prototype);
      return properties;
    }, "getAllProperties");
    module3.exports = (self2, { include, exclude } = {}) => {
      const filter = /* @__PURE__ */ __name((key) => {
        const match = /* @__PURE__ */ __name((pattern) => typeof pattern === "string" ? key === pattern : pattern.test(key), "match");
        if (include) {
          return include.some(match);
        }
        if (exclude) {
          return !exclude.some(match);
        }
        return true;
      }, "filter");
      for (const [object, key] of getAllProperties(self2.constructor.prototype)) {
        if (key === "constructor" || !filter(key)) {
          continue;
        }
        const descriptor2 = Reflect.getOwnPropertyDescriptor(object, key);
        if (descriptor2 && typeof descriptor2.value === "function") {
          self2[key] = self2[key].bind(self2);
        }
      }
      return self2;
    };
  }
});

// ../../node_modules/.pnpm/scheduler@0.20.2/node_modules/scheduler/cjs/scheduler.production.min.js
var require_scheduler_production_min = __commonJS({
  "../../node_modules/.pnpm/scheduler@0.20.2/node_modules/scheduler/cjs/scheduler.production.min.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var f;
    var g2;
    var h2;
    var k2;
    if ("object" === typeof performance && "function" === typeof performance.now) {
      l2 = performance;
      exports2.unstable_now = function() {
        return l2.now();
      };
    } else {
      p2 = Date, q2 = p2.now();
      exports2.unstable_now = function() {
        return p2.now() - q2;
      };
    }
    var l2;
    var p2;
    var q2;
    if ("undefined" === typeof window || "function" !== typeof MessageChannel) {
      t3 = null, u = null, w2 = /* @__PURE__ */ __name(function() {
        if (null !== t3)
          try {
            var a = exports2.unstable_now();
            t3(true, a);
            t3 = null;
          } catch (b2) {
            throw setTimeout(w2, 0), b2;
          }
      }, "w");
      f = /* @__PURE__ */ __name(function(a) {
        null !== t3 ? setTimeout(f, 0, a) : (t3 = a, setTimeout(w2, 0));
      }, "f");
      g2 = /* @__PURE__ */ __name(function(a, b2) {
        u = setTimeout(a, b2);
      }, "g");
      h2 = /* @__PURE__ */ __name(function() {
        clearTimeout(u);
      }, "h");
      exports2.unstable_shouldYield = function() {
        return false;
      };
      k2 = exports2.unstable_forceFrameRate = function() {
      };
    } else {
      x2 = window.setTimeout, y2 = window.clearTimeout;
      if ("undefined" !== typeof console) {
        z2 = window.cancelAnimationFrame;
        "function" !== typeof window.requestAnimationFrame && console.error("This browser doesn't support requestAnimationFrame. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills");
        "function" !== typeof z2 && console.error("This browser doesn't support cancelAnimationFrame. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills");
      }
      A2 = false, B2 = null, C2 = -1, D = 5, E2 = 0;
      exports2.unstable_shouldYield = function() {
        return exports2.unstable_now() >= E2;
      };
      k2 = /* @__PURE__ */ __name(function() {
      }, "k");
      exports2.unstable_forceFrameRate = function(a) {
        0 > a || 125 < a ? console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported") : D = 0 < a ? Math.floor(1e3 / a) : 5;
      };
      F = new MessageChannel(), G2 = F.port2;
      F.port1.onmessage = function() {
        if (null !== B2) {
          var a = exports2.unstable_now();
          E2 = a + D;
          try {
            B2(true, a) ? G2.postMessage(null) : (A2 = false, B2 = null);
          } catch (b2) {
            throw G2.postMessage(null), b2;
          }
        } else
          A2 = false;
      };
      f = /* @__PURE__ */ __name(function(a) {
        B2 = a;
        A2 || (A2 = true, G2.postMessage(null));
      }, "f");
      g2 = /* @__PURE__ */ __name(function(a, b2) {
        C2 = x2(function() {
          a(exports2.unstable_now());
        }, b2);
      }, "g");
      h2 = /* @__PURE__ */ __name(function() {
        y2(C2);
        C2 = -1;
      }, "h");
    }
    var t3;
    var u;
    var w2;
    var x2;
    var y2;
    var z2;
    var A2;
    var B2;
    var C2;
    var D;
    var E2;
    var F;
    var G2;
    function H2(a, b2) {
      var c2 = a.length;
      a.push(b2);
      a:
        for (; ; ) {
          var d2 = c2 - 1 >>> 1, e3 = a[d2];
          if (void 0 !== e3 && 0 < I2(e3, b2))
            a[d2] = b2, a[c2] = e3, c2 = d2;
          else
            break a;
        }
    }
    __name(H2, "H");
    function J2(a) {
      a = a[0];
      return void 0 === a ? null : a;
    }
    __name(J2, "J");
    function K2(a) {
      var b2 = a[0];
      if (void 0 !== b2) {
        var c2 = a.pop();
        if (c2 !== b2) {
          a[0] = c2;
          a:
            for (var d2 = 0, e3 = a.length; d2 < e3; ) {
              var m2 = 2 * (d2 + 1) - 1, n2 = a[m2], v2 = m2 + 1, r3 = a[v2];
              if (void 0 !== n2 && 0 > I2(n2, c2))
                void 0 !== r3 && 0 > I2(r3, n2) ? (a[d2] = r3, a[v2] = c2, d2 = v2) : (a[d2] = n2, a[m2] = c2, d2 = m2);
              else if (void 0 !== r3 && 0 > I2(r3, c2))
                a[d2] = r3, a[v2] = c2, d2 = v2;
              else
                break a;
            }
        }
        return b2;
      }
      return null;
    }
    __name(K2, "K");
    function I2(a, b2) {
      var c2 = a.sortIndex - b2.sortIndex;
      return 0 !== c2 ? c2 : a.id - b2.id;
    }
    __name(I2, "I");
    var L2 = [];
    var M2 = [];
    var N2 = 1;
    var O2 = null;
    var P2 = 3;
    var Q3 = false;
    var R2 = false;
    var S2 = false;
    function T2(a) {
      for (var b2 = J2(M2); null !== b2; ) {
        if (null === b2.callback)
          K2(M2);
        else if (b2.startTime <= a)
          K2(M2), b2.sortIndex = b2.expirationTime, H2(L2, b2);
        else
          break;
        b2 = J2(M2);
      }
    }
    __name(T2, "T");
    function U2(a) {
      S2 = false;
      T2(a);
      if (!R2)
        if (null !== J2(L2))
          R2 = true, f(V2);
        else {
          var b2 = J2(M2);
          null !== b2 && g2(U2, b2.startTime - a);
        }
    }
    __name(U2, "U");
    function V2(a, b2) {
      R2 = false;
      S2 && (S2 = false, h2());
      Q3 = true;
      var c2 = P2;
      try {
        T2(b2);
        for (O2 = J2(L2); null !== O2 && (!(O2.expirationTime > b2) || a && !exports2.unstable_shouldYield()); ) {
          var d2 = O2.callback;
          if ("function" === typeof d2) {
            O2.callback = null;
            P2 = O2.priorityLevel;
            var e3 = d2(O2.expirationTime <= b2);
            b2 = exports2.unstable_now();
            "function" === typeof e3 ? O2.callback = e3 : O2 === J2(L2) && K2(L2);
            T2(b2);
          } else
            K2(L2);
          O2 = J2(L2);
        }
        if (null !== O2)
          var m2 = true;
        else {
          var n2 = J2(M2);
          null !== n2 && g2(U2, n2.startTime - b2);
          m2 = false;
        }
        return m2;
      } finally {
        O2 = null, P2 = c2, Q3 = false;
      }
    }
    __name(V2, "V");
    var W2 = k2;
    exports2.unstable_IdlePriority = 5;
    exports2.unstable_ImmediatePriority = 1;
    exports2.unstable_LowPriority = 4;
    exports2.unstable_NormalPriority = 3;
    exports2.unstable_Profiling = null;
    exports2.unstable_UserBlockingPriority = 2;
    exports2.unstable_cancelCallback = function(a) {
      a.callback = null;
    };
    exports2.unstable_continueExecution = function() {
      R2 || Q3 || (R2 = true, f(V2));
    };
    exports2.unstable_getCurrentPriorityLevel = function() {
      return P2;
    };
    exports2.unstable_getFirstCallbackNode = function() {
      return J2(L2);
    };
    exports2.unstable_next = function(a) {
      switch (P2) {
        case 1:
        case 2:
        case 3:
          var b2 = 3;
          break;
        default:
          b2 = P2;
      }
      var c2 = P2;
      P2 = b2;
      try {
        return a();
      } finally {
        P2 = c2;
      }
    };
    exports2.unstable_pauseExecution = function() {
    };
    exports2.unstable_requestPaint = W2;
    exports2.unstable_runWithPriority = function(a, b2) {
      switch (a) {
        case 1:
        case 2:
        case 3:
        case 4:
        case 5:
          break;
        default:
          a = 3;
      }
      var c2 = P2;
      P2 = a;
      try {
        return b2();
      } finally {
        P2 = c2;
      }
    };
    exports2.unstable_scheduleCallback = function(a, b2, c2) {
      var d2 = exports2.unstable_now();
      "object" === typeof c2 && null !== c2 ? (c2 = c2.delay, c2 = "number" === typeof c2 && 0 < c2 ? d2 + c2 : d2) : c2 = d2;
      switch (a) {
        case 1:
          var e3 = -1;
          break;
        case 2:
          e3 = 250;
          break;
        case 5:
          e3 = 1073741823;
          break;
        case 4:
          e3 = 1e4;
          break;
        default:
          e3 = 5e3;
      }
      e3 = c2 + e3;
      a = { id: N2++, callback: b2, priorityLevel: a, startTime: c2, expirationTime: e3, sortIndex: -1 };
      c2 > d2 ? (a.sortIndex = c2, H2(M2, a), null === J2(L2) && a === J2(M2) && (S2 ? h2() : S2 = true, g2(U2, c2 - d2))) : (a.sortIndex = e3, H2(L2, a), R2 || Q3 || (R2 = true, f(V2)));
      return a;
    };
    exports2.unstable_wrapCallback = function(a) {
      var b2 = P2;
      return function() {
        var c2 = P2;
        P2 = b2;
        try {
          return a.apply(this, arguments);
        } finally {
          P2 = c2;
        }
      };
    };
  }
});

// ../../node_modules/.pnpm/scheduler@0.20.2/node_modules/scheduler/index.js
var require_scheduler = __commonJS({
  "../../node_modules/.pnpm/scheduler@0.20.2/node_modules/scheduler/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    if (true) {
      module3.exports = require_scheduler_production_min();
    } else {
      module3.exports = null;
    }
  }
});

// ../../node_modules/.pnpm/react-reconciler@0.26.2_react@17.0.2/node_modules/react-reconciler/cjs/react-reconciler.production.min.js
var require_react_reconciler_production_min = __commonJS({
  "../../node_modules/.pnpm/react-reconciler@0.26.2_react@17.0.2/node_modules/react-reconciler/cjs/react-reconciler.production.min.js"(exports2, module3) {
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function $$$reconciler($$$hostConfig) {
      var exports3 = {};
      "use strict";
      var aa = require_object_assign(), ba = require_react(), m2 = require_scheduler();
      function q2(a) {
        for (var b2 = "https://reactjs.org/docs/error-decoder.html?invariant=" + a, c2 = 1; c2 < arguments.length; c2++)
          b2 += "&args[]=" + encodeURIComponent(arguments[c2]);
        return "Minified React error #" + a + "; visit " + b2 + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
      }
      __name(q2, "q");
      var ca = ba.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, da2 = 60103, ea = 60106, fa = 60107, ha = 60108, ia = 60114, ja = 60109, ka = 60110, la = 60112, ma = 60113, na = 60120, oa = 60115, pa2 = 60116, qa = 60121, ra = 60129, sa = 60130, ta = 60131;
      if ("function" === typeof Symbol && Symbol.for) {
        var r3 = Symbol.for;
        da2 = r3("react.element");
        ea = r3("react.portal");
        fa = r3("react.fragment");
        ha = r3("react.strict_mode");
        ia = r3("react.profiler");
        ja = r3("react.provider");
        ka = r3("react.context");
        la = r3("react.forward_ref");
        ma = r3("react.suspense");
        na = r3("react.suspense_list");
        oa = r3("react.memo");
        pa2 = r3("react.lazy");
        qa = r3("react.block");
        r3("react.scope");
        ra = r3("react.debug_trace_mode");
        sa = r3("react.offscreen");
        ta = r3("react.legacy_hidden");
      }
      var ua = "function" === typeof Symbol && Symbol.iterator;
      function va(a) {
        if (null === a || "object" !== typeof a)
          return null;
        a = ua && a[ua] || a["@@iterator"];
        return "function" === typeof a ? a : null;
      }
      __name(va, "va");
      function wa(a) {
        if (null == a)
          return null;
        if ("function" === typeof a)
          return a.displayName || a.name || null;
        if ("string" === typeof a)
          return a;
        switch (a) {
          case fa:
            return "Fragment";
          case ea:
            return "Portal";
          case ia:
            return "Profiler";
          case ha:
            return "StrictMode";
          case ma:
            return "Suspense";
          case na:
            return "SuspenseList";
        }
        if ("object" === typeof a)
          switch (a.$$typeof) {
            case ka:
              return (a.displayName || "Context") + ".Consumer";
            case ja:
              return (a._context.displayName || "Context") + ".Provider";
            case la:
              var b2 = a.render;
              b2 = b2.displayName || b2.name || "";
              return a.displayName || ("" !== b2 ? "ForwardRef(" + b2 + ")" : "ForwardRef");
            case oa:
              return wa(a.type);
            case qa:
              return wa(a._render);
            case pa2:
              b2 = a._payload;
              a = a._init;
              try {
                return wa(a(b2));
              } catch (c2) {
              }
          }
        return null;
      }
      __name(wa, "wa");
      function xa(a) {
        var b2 = a, c2 = a;
        if (a.alternate)
          for (; b2.return; )
            b2 = b2.return;
        else {
          a = b2;
          do
            b2 = a, 0 !== (b2.flags & 1026) && (c2 = b2.return), a = b2.return;
          while (a);
        }
        return 3 === b2.tag ? c2 : null;
      }
      __name(xa, "xa");
      function ya(a) {
        if (xa(a) !== a)
          throw Error(q2(188));
      }
      __name(ya, "ya");
      function za(a) {
        var b2 = a.alternate;
        if (!b2) {
          b2 = xa(a);
          if (null === b2)
            throw Error(q2(188));
          return b2 !== a ? null : a;
        }
        for (var c2 = a, d2 = b2; ; ) {
          var e3 = c2.return;
          if (null === e3)
            break;
          var f = e3.alternate;
          if (null === f) {
            d2 = e3.return;
            if (null !== d2) {
              c2 = d2;
              continue;
            }
            break;
          }
          if (e3.child === f.child) {
            for (f = e3.child; f; ) {
              if (f === c2)
                return ya(e3), a;
              if (f === d2)
                return ya(e3), b2;
              f = f.sibling;
            }
            throw Error(q2(188));
          }
          if (c2.return !== d2.return)
            c2 = e3, d2 = f;
          else {
            for (var g2 = false, h2 = e3.child; h2; ) {
              if (h2 === c2) {
                g2 = true;
                c2 = e3;
                d2 = f;
                break;
              }
              if (h2 === d2) {
                g2 = true;
                d2 = e3;
                c2 = f;
                break;
              }
              h2 = h2.sibling;
            }
            if (!g2) {
              for (h2 = f.child; h2; ) {
                if (h2 === c2) {
                  g2 = true;
                  c2 = f;
                  d2 = e3;
                  break;
                }
                if (h2 === d2) {
                  g2 = true;
                  d2 = f;
                  c2 = e3;
                  break;
                }
                h2 = h2.sibling;
              }
              if (!g2)
                throw Error(q2(189));
            }
          }
          if (c2.alternate !== d2)
            throw Error(q2(190));
        }
        if (3 !== c2.tag)
          throw Error(q2(188));
        return c2.stateNode.current === c2 ? a : b2;
      }
      __name(za, "za");
      function Aa(a) {
        a = za(a);
        if (!a)
          return null;
        for (var b2 = a; ; ) {
          if (5 === b2.tag || 6 === b2.tag)
            return b2;
          if (b2.child)
            b2.child.return = b2, b2 = b2.child;
          else {
            if (b2 === a)
              break;
            for (; !b2.sibling; ) {
              if (!b2.return || b2.return === a)
                return null;
              b2 = b2.return;
            }
            b2.sibling.return = b2.return;
            b2 = b2.sibling;
          }
        }
        return null;
      }
      __name(Aa, "Aa");
      function Ba(a) {
        a = za(a);
        if (!a)
          return null;
        for (var b2 = a; ; ) {
          if (5 === b2.tag || 6 === b2.tag)
            return b2;
          if (b2.child && 4 !== b2.tag)
            b2.child.return = b2, b2 = b2.child;
          else {
            if (b2 === a)
              break;
            for (; !b2.sibling; ) {
              if (!b2.return || b2.return === a)
                return null;
              b2 = b2.return;
            }
            b2.sibling.return = b2.return;
            b2 = b2.sibling;
          }
        }
        return null;
      }
      __name(Ba, "Ba");
      function Ca(a, b2) {
        for (var c2 = a.alternate; null !== b2; ) {
          if (b2 === a || b2 === c2)
            return true;
          b2 = b2.return;
        }
        return false;
      }
      __name(Ca, "Ca");
      var Da = $$$hostConfig.getPublicInstance, Ea = $$$hostConfig.getRootHostContext, Fa = $$$hostConfig.getChildHostContext, Ga = $$$hostConfig.prepareForCommit, Ha = $$$hostConfig.resetAfterCommit, Ia = $$$hostConfig.createInstance, Ja = $$$hostConfig.appendInitialChild, Ka = $$$hostConfig.finalizeInitialChildren, La = $$$hostConfig.prepareUpdate, Ma = $$$hostConfig.shouldSetTextContent, Na = $$$hostConfig.createTextInstance, Pa = $$$hostConfig.scheduleTimeout, Qa = $$$hostConfig.cancelTimeout, Ra = $$$hostConfig.noTimeout, Sa = $$$hostConfig.isPrimaryRenderer, Ta = $$$hostConfig.supportsMutation, Ua = $$$hostConfig.supportsPersistence, Va = $$$hostConfig.supportsHydration, Wa = $$$hostConfig.getInstanceFromNode, Xa = $$$hostConfig.makeOpaqueHydratingObject, Ya = $$$hostConfig.makeClientId, Za = $$$hostConfig.beforeActiveInstanceBlur, $a = $$$hostConfig.afterActiveInstanceBlur, ab = $$$hostConfig.preparePortalMount, bb = $$$hostConfig.supportsTestSelectors, cb = $$$hostConfig.findFiberRoot, db = $$$hostConfig.getBoundingRect, eb = $$$hostConfig.getTextContent, fb = $$$hostConfig.isHiddenSubtree, gb = $$$hostConfig.matchAccessibilityRole, hb = $$$hostConfig.setFocusIfFocusable, ib = $$$hostConfig.setupIntersectionObserver, jb = $$$hostConfig.appendChild, kb = $$$hostConfig.appendChildToContainer, lb = $$$hostConfig.commitTextUpdate, mb = $$$hostConfig.commitMount, nb = $$$hostConfig.commitUpdate, ob = $$$hostConfig.insertBefore, pb = $$$hostConfig.insertInContainerBefore, qb = $$$hostConfig.removeChild, rb = $$$hostConfig.removeChildFromContainer, sb = $$$hostConfig.resetTextContent, tb = $$$hostConfig.hideInstance, ub = $$$hostConfig.hideTextInstance, vb = $$$hostConfig.unhideInstance, wb = $$$hostConfig.unhideTextInstance, xb = $$$hostConfig.clearContainer, yb = $$$hostConfig.cloneInstance, zb = $$$hostConfig.createContainerChildSet, Ab = $$$hostConfig.appendChildToContainerChildSet, Bb = $$$hostConfig.finalizeContainerChildren, Cb = $$$hostConfig.replaceContainerChildren, Db = $$$hostConfig.cloneHiddenInstance, Eb = $$$hostConfig.cloneHiddenTextInstance, Fb = $$$hostConfig.canHydrateInstance, Gb = $$$hostConfig.canHydrateTextInstance, Hb = $$$hostConfig.isSuspenseInstancePending, Ib = $$$hostConfig.isSuspenseInstanceFallback, Jb = $$$hostConfig.getNextHydratableSibling, Kb = $$$hostConfig.getFirstHydratableChild, Lb = $$$hostConfig.hydrateInstance, Mb = $$$hostConfig.hydrateTextInstance, Nb = $$$hostConfig.getNextHydratableInstanceAfterSuspenseInstance, Ob = $$$hostConfig.commitHydratedContainer, Pb = $$$hostConfig.commitHydratedSuspenseInstance, Qb;
      function Rb(a) {
        if (void 0 === Qb)
          try {
            throw Error();
          } catch (c2) {
            var b2 = c2.stack.trim().match(/\n( *(at )?)/);
            Qb = b2 && b2[1] || "";
          }
        return "\n" + Qb + a;
      }
      __name(Rb, "Rb");
      var Sb = false;
      function Tb(a, b2) {
        if (!a || Sb)
          return "";
        Sb = true;
        var c2 = Error.prepareStackTrace;
        Error.prepareStackTrace = void 0;
        try {
          if (b2)
            if (b2 = /* @__PURE__ */ __name(function() {
              throw Error();
            }, "b"), Object.defineProperty(b2.prototype, "props", { set: function() {
              throw Error();
            } }), "object" === typeof Reflect && Reflect.construct) {
              try {
                Reflect.construct(b2, []);
              } catch (k2) {
                var d2 = k2;
              }
              Reflect.construct(a, [], b2);
            } else {
              try {
                b2.call();
              } catch (k2) {
                d2 = k2;
              }
              a.call(b2.prototype);
            }
          else {
            try {
              throw Error();
            } catch (k2) {
              d2 = k2;
            }
            a();
          }
        } catch (k2) {
          if (k2 && d2 && "string" === typeof k2.stack) {
            for (var e3 = k2.stack.split("\n"), f = d2.stack.split("\n"), g2 = e3.length - 1, h2 = f.length - 1; 1 <= g2 && 0 <= h2 && e3[g2] !== f[h2]; )
              h2--;
            for (; 1 <= g2 && 0 <= h2; g2--, h2--)
              if (e3[g2] !== f[h2]) {
                if (1 !== g2 || 1 !== h2) {
                  do
                    if (g2--, h2--, 0 > h2 || e3[g2] !== f[h2])
                      return "\n" + e3[g2].replace(" at new ", " at ");
                  while (1 <= g2 && 0 <= h2);
                }
                break;
              }
          }
        } finally {
          Sb = false, Error.prepareStackTrace = c2;
        }
        return (a = a ? a.displayName || a.name : "") ? Rb(a) : "";
      }
      __name(Tb, "Tb");
      var Ub = [], Vb = -1;
      function Wb(a) {
        return { current: a };
      }
      __name(Wb, "Wb");
      function z2(a) {
        0 > Vb || (a.current = Ub[Vb], Ub[Vb] = null, Vb--);
      }
      __name(z2, "z");
      function A2(a, b2) {
        Vb++;
        Ub[Vb] = a.current;
        a.current = b2;
      }
      __name(A2, "A");
      var Xb = {}, B2 = Wb(Xb), D = Wb(false), Yb = Xb;
      function Zb(a, b2) {
        var c2 = a.type.contextTypes;
        if (!c2)
          return Xb;
        var d2 = a.stateNode;
        if (d2 && d2.__reactInternalMemoizedUnmaskedChildContext === b2)
          return d2.__reactInternalMemoizedMaskedChildContext;
        var e3 = {}, f;
        for (f in c2)
          e3[f] = b2[f];
        d2 && (a = a.stateNode, a.__reactInternalMemoizedUnmaskedChildContext = b2, a.__reactInternalMemoizedMaskedChildContext = e3);
        return e3;
      }
      __name(Zb, "Zb");
      function E2(a) {
        a = a.childContextTypes;
        return null !== a && void 0 !== a;
      }
      __name(E2, "E");
      function $b() {
        z2(D);
        z2(B2);
      }
      __name($b, "$b");
      function ac(a, b2, c2) {
        if (B2.current !== Xb)
          throw Error(q2(168));
        A2(B2, b2);
        A2(D, c2);
      }
      __name(ac, "ac");
      function bc(a, b2, c2) {
        var d2 = a.stateNode;
        a = b2.childContextTypes;
        if ("function" !== typeof d2.getChildContext)
          return c2;
        d2 = d2.getChildContext();
        for (var e3 in d2)
          if (!(e3 in a))
            throw Error(q2(108, wa(b2) || "Unknown", e3));
        return aa({}, c2, d2);
      }
      __name(bc, "bc");
      function cc(a) {
        a = (a = a.stateNode) && a.__reactInternalMemoizedMergedChildContext || Xb;
        Yb = B2.current;
        A2(B2, a);
        A2(D, D.current);
        return true;
      }
      __name(cc, "cc");
      function dc(a, b2, c2) {
        var d2 = a.stateNode;
        if (!d2)
          throw Error(q2(169));
        c2 ? (a = bc(a, b2, Yb), d2.__reactInternalMemoizedMergedChildContext = a, z2(D), z2(B2), A2(B2, a)) : z2(D);
        A2(D, c2);
      }
      __name(dc, "dc");
      var ec = null, fc = null, gc = m2.unstable_now;
      gc();
      var hc = 0, F = 8;
      function ic(a) {
        if (0 !== (1 & a))
          return F = 15, 1;
        if (0 !== (2 & a))
          return F = 14, 2;
        if (0 !== (4 & a))
          return F = 13, 4;
        var b2 = 24 & a;
        if (0 !== b2)
          return F = 12, b2;
        if (0 !== (a & 32))
          return F = 11, 32;
        b2 = 192 & a;
        if (0 !== b2)
          return F = 10, b2;
        if (0 !== (a & 256))
          return F = 9, 256;
        b2 = 3584 & a;
        if (0 !== b2)
          return F = 8, b2;
        if (0 !== (a & 4096))
          return F = 7, 4096;
        b2 = 4186112 & a;
        if (0 !== b2)
          return F = 6, b2;
        b2 = 62914560 & a;
        if (0 !== b2)
          return F = 5, b2;
        if (a & 67108864)
          return F = 4, 67108864;
        if (0 !== (a & 134217728))
          return F = 3, 134217728;
        b2 = 805306368 & a;
        if (0 !== b2)
          return F = 2, b2;
        if (0 !== (1073741824 & a))
          return F = 1, 1073741824;
        F = 8;
        return a;
      }
      __name(ic, "ic");
      function jc(a) {
        switch (a) {
          case 99:
            return 15;
          case 98:
            return 10;
          case 97:
          case 96:
            return 8;
          case 95:
            return 2;
          default:
            return 0;
        }
      }
      __name(jc, "jc");
      function kc(a) {
        switch (a) {
          case 15:
          case 14:
            return 99;
          case 13:
          case 12:
          case 11:
          case 10:
            return 98;
          case 9:
          case 8:
          case 7:
          case 6:
          case 4:
          case 5:
            return 97;
          case 3:
          case 2:
          case 1:
            return 95;
          case 0:
            return 90;
          default:
            throw Error(q2(358, a));
        }
      }
      __name(kc, "kc");
      function lc(a, b2) {
        var c2 = a.pendingLanes;
        if (0 === c2)
          return F = 0;
        var d2 = 0, e3 = 0, f = a.expiredLanes, g2 = a.suspendedLanes, h2 = a.pingedLanes;
        if (0 !== f)
          d2 = f, e3 = F = 15;
        else if (f = c2 & 134217727, 0 !== f) {
          var k2 = f & ~g2;
          0 !== k2 ? (d2 = ic(k2), e3 = F) : (h2 &= f, 0 !== h2 && (d2 = ic(h2), e3 = F));
        } else
          f = c2 & ~g2, 0 !== f ? (d2 = ic(f), e3 = F) : 0 !== h2 && (d2 = ic(h2), e3 = F);
        if (0 === d2)
          return 0;
        d2 = 31 - mc(d2);
        d2 = c2 & ((0 > d2 ? 0 : 1 << d2) << 1) - 1;
        if (0 !== b2 && b2 !== d2 && 0 === (b2 & g2)) {
          ic(b2);
          if (e3 <= F)
            return b2;
          F = e3;
        }
        b2 = a.entangledLanes;
        if (0 !== b2)
          for (a = a.entanglements, b2 &= d2; 0 < b2; )
            c2 = 31 - mc(b2), e3 = 1 << c2, d2 |= a[c2], b2 &= ~e3;
        return d2;
      }
      __name(lc, "lc");
      function nc(a) {
        a = a.pendingLanes & -1073741825;
        return 0 !== a ? a : a & 1073741824 ? 1073741824 : 0;
      }
      __name(nc, "nc");
      function oc(a, b2) {
        switch (a) {
          case 15:
            return 1;
          case 14:
            return 2;
          case 12:
            return a = pc(24 & ~b2), 0 === a ? oc(10, b2) : a;
          case 10:
            return a = pc(192 & ~b2), 0 === a ? oc(8, b2) : a;
          case 8:
            return a = pc(3584 & ~b2), 0 === a && (a = pc(4186112 & ~b2), 0 === a && (a = 512)), a;
          case 2:
            return b2 = pc(805306368 & ~b2), 0 === b2 && (b2 = 268435456), b2;
        }
        throw Error(q2(358, a));
      }
      __name(oc, "oc");
      function pc(a) {
        return a & -a;
      }
      __name(pc, "pc");
      function qc(a) {
        for (var b2 = [], c2 = 0; 31 > c2; c2++)
          b2.push(a);
        return b2;
      }
      __name(qc, "qc");
      function rc(a, b2, c2) {
        a.pendingLanes |= b2;
        var d2 = b2 - 1;
        a.suspendedLanes &= d2;
        a.pingedLanes &= d2;
        a = a.eventTimes;
        b2 = 31 - mc(b2);
        a[b2] = c2;
      }
      __name(rc, "rc");
      var mc = Math.clz32 ? Math.clz32 : sc, tc = Math.log, uc = Math.LN2;
      function sc(a) {
        return 0 === a ? 32 : 31 - (tc(a) / uc | 0) | 0;
      }
      __name(sc, "sc");
      var vc = m2.unstable_runWithPriority, wc = m2.unstable_scheduleCallback, xc = m2.unstable_cancelCallback, yc = m2.unstable_shouldYield, zc = m2.unstable_requestPaint, Ac = m2.unstable_now, Bc = m2.unstable_getCurrentPriorityLevel, Cc = m2.unstable_ImmediatePriority, Dc = m2.unstable_UserBlockingPriority, Ec = m2.unstable_NormalPriority, Fc = m2.unstable_LowPriority, Gc = m2.unstable_IdlePriority, Hc = {}, Ic = void 0 !== zc ? zc : function() {
      }, Jc = null, Kc = null, Lc = false, Mc = Ac(), G2 = 1e4 > Mc ? Ac : function() {
        return Ac() - Mc;
      };
      function Nc() {
        switch (Bc()) {
          case Cc:
            return 99;
          case Dc:
            return 98;
          case Ec:
            return 97;
          case Fc:
            return 96;
          case Gc:
            return 95;
          default:
            throw Error(q2(332));
        }
      }
      __name(Nc, "Nc");
      function Oc(a) {
        switch (a) {
          case 99:
            return Cc;
          case 98:
            return Dc;
          case 97:
            return Ec;
          case 96:
            return Fc;
          case 95:
            return Gc;
          default:
            throw Error(q2(332));
        }
      }
      __name(Oc, "Oc");
      function Pc(a, b2) {
        a = Oc(a);
        return vc(a, b2);
      }
      __name(Pc, "Pc");
      function Qc(a, b2, c2) {
        a = Oc(a);
        return wc(a, b2, c2);
      }
      __name(Qc, "Qc");
      function H2() {
        if (null !== Kc) {
          var a = Kc;
          Kc = null;
          xc(a);
        }
        Rc();
      }
      __name(H2, "H");
      function Rc() {
        if (!Lc && null !== Jc) {
          Lc = true;
          var a = 0;
          try {
            var b2 = Jc;
            Pc(99, function() {
              for (; a < b2.length; a++) {
                var c2 = b2[a];
                do
                  c2 = c2(true);
                while (null !== c2);
              }
            });
            Jc = null;
          } catch (c2) {
            throw null !== Jc && (Jc = Jc.slice(a + 1)), wc(Cc, H2), c2;
          } finally {
            Lc = false;
          }
        }
      }
      __name(Rc, "Rc");
      var Sc = ca.ReactCurrentBatchConfig;
      function Tc(a, b2) {
        return a === b2 && (0 !== a || 1 / a === 1 / b2) || a !== a && b2 !== b2;
      }
      __name(Tc, "Tc");
      var I2 = "function" === typeof Object.is ? Object.is : Tc, Uc = Object.prototype.hasOwnProperty;
      function Vc(a, b2) {
        if (I2(a, b2))
          return true;
        if ("object" !== typeof a || null === a || "object" !== typeof b2 || null === b2)
          return false;
        var c2 = Object.keys(a), d2 = Object.keys(b2);
        if (c2.length !== d2.length)
          return false;
        for (d2 = 0; d2 < c2.length; d2++)
          if (!Uc.call(b2, c2[d2]) || !I2(a[c2[d2]], b2[c2[d2]]))
            return false;
        return true;
      }
      __name(Vc, "Vc");
      function Wc(a) {
        switch (a.tag) {
          case 5:
            return Rb(a.type);
          case 16:
            return Rb("Lazy");
          case 13:
            return Rb("Suspense");
          case 19:
            return Rb("SuspenseList");
          case 0:
          case 2:
          case 15:
            return a = Tb(a.type, false), a;
          case 11:
            return a = Tb(a.type.render, false), a;
          case 22:
            return a = Tb(a.type._render, false), a;
          case 1:
            return a = Tb(a.type, true), a;
          default:
            return "";
        }
      }
      __name(Wc, "Wc");
      function Xc(a, b2) {
        if (a && a.defaultProps) {
          b2 = aa({}, b2);
          a = a.defaultProps;
          for (var c2 in a)
            void 0 === b2[c2] && (b2[c2] = a[c2]);
          return b2;
        }
        return b2;
      }
      __name(Xc, "Xc");
      var Yc = Wb(null), Zc = null, $c = null, ad = null;
      function bd() {
        ad = $c = Zc = null;
      }
      __name(bd, "bd");
      function cd(a, b2) {
        a = a.type._context;
        Sa ? (A2(Yc, a._currentValue), a._currentValue = b2) : (A2(Yc, a._currentValue2), a._currentValue2 = b2);
      }
      __name(cd, "cd");
      function dd(a) {
        var b2 = Yc.current;
        z2(Yc);
        a = a.type._context;
        Sa ? a._currentValue = b2 : a._currentValue2 = b2;
      }
      __name(dd, "dd");
      function ed(a, b2) {
        for (; null !== a; ) {
          var c2 = a.alternate;
          if ((a.childLanes & b2) === b2)
            if (null === c2 || (c2.childLanes & b2) === b2)
              break;
            else
              c2.childLanes |= b2;
          else
            a.childLanes |= b2, null !== c2 && (c2.childLanes |= b2);
          a = a.return;
        }
      }
      __name(ed, "ed");
      function fd(a, b2) {
        Zc = a;
        ad = $c = null;
        a = a.dependencies;
        null !== a && null !== a.firstContext && (0 !== (a.lanes & b2) && (gd2 = true), a.firstContext = null);
      }
      __name(fd, "fd");
      function J2(a, b2) {
        if (ad !== a && false !== b2 && 0 !== b2) {
          if ("number" !== typeof b2 || 1073741823 === b2)
            ad = a, b2 = 1073741823;
          b2 = { context: a, observedBits: b2, next: null };
          if (null === $c) {
            if (null === Zc)
              throw Error(q2(308));
            $c = b2;
            Zc.dependencies = { lanes: 0, firstContext: b2, responders: null };
          } else
            $c = $c.next = b2;
        }
        return Sa ? a._currentValue : a._currentValue2;
      }
      __name(J2, "J");
      var hd = false;
      function id(a) {
        a.updateQueue = { baseState: a.memoizedState, firstBaseUpdate: null, lastBaseUpdate: null, shared: { pending: null }, effects: null };
      }
      __name(id, "id");
      function jd(a, b2) {
        a = a.updateQueue;
        b2.updateQueue === a && (b2.updateQueue = { baseState: a.baseState, firstBaseUpdate: a.firstBaseUpdate, lastBaseUpdate: a.lastBaseUpdate, shared: a.shared, effects: a.effects });
      }
      __name(jd, "jd");
      function kd(a, b2) {
        return { eventTime: a, lane: b2, tag: 0, payload: null, callback: null, next: null };
      }
      __name(kd, "kd");
      function md(a, b2) {
        a = a.updateQueue;
        if (null !== a) {
          a = a.shared;
          var c2 = a.pending;
          null === c2 ? b2.next = b2 : (b2.next = c2.next, c2.next = b2);
          a.pending = b2;
        }
      }
      __name(md, "md");
      function nd(a, b2) {
        var c2 = a.updateQueue, d2 = a.alternate;
        if (null !== d2 && (d2 = d2.updateQueue, c2 === d2)) {
          var e3 = null, f = null;
          c2 = c2.firstBaseUpdate;
          if (null !== c2) {
            do {
              var g2 = { eventTime: c2.eventTime, lane: c2.lane, tag: c2.tag, payload: c2.payload, callback: c2.callback, next: null };
              null === f ? e3 = f = g2 : f = f.next = g2;
              c2 = c2.next;
            } while (null !== c2);
            null === f ? e3 = f = b2 : f = f.next = b2;
          } else
            e3 = f = b2;
          c2 = { baseState: d2.baseState, firstBaseUpdate: e3, lastBaseUpdate: f, shared: d2.shared, effects: d2.effects };
          a.updateQueue = c2;
          return;
        }
        a = c2.lastBaseUpdate;
        null === a ? c2.firstBaseUpdate = b2 : a.next = b2;
        c2.lastBaseUpdate = b2;
      }
      __name(nd, "nd");
      function od(a, b2, c2, d2) {
        var e3 = a.updateQueue;
        hd = false;
        var f = e3.firstBaseUpdate, g2 = e3.lastBaseUpdate, h2 = e3.shared.pending;
        if (null !== h2) {
          e3.shared.pending = null;
          var k2 = h2, l2 = k2.next;
          k2.next = null;
          null === g2 ? f = l2 : g2.next = l2;
          g2 = k2;
          var n2 = a.alternate;
          if (null !== n2) {
            n2 = n2.updateQueue;
            var t3 = n2.lastBaseUpdate;
            t3 !== g2 && (null === t3 ? n2.firstBaseUpdate = l2 : t3.next = l2, n2.lastBaseUpdate = k2);
          }
        }
        if (null !== f) {
          t3 = e3.baseState;
          g2 = 0;
          n2 = l2 = k2 = null;
          do {
            h2 = f.lane;
            var p2 = f.eventTime;
            if ((d2 & h2) === h2) {
              null !== n2 && (n2 = n2.next = {
                eventTime: p2,
                lane: 0,
                tag: f.tag,
                payload: f.payload,
                callback: f.callback,
                next: null
              });
              a: {
                var y2 = a, x2 = f;
                h2 = b2;
                p2 = c2;
                switch (x2.tag) {
                  case 1:
                    y2 = x2.payload;
                    if ("function" === typeof y2) {
                      t3 = y2.call(p2, t3, h2);
                      break a;
                    }
                    t3 = y2;
                    break a;
                  case 3:
                    y2.flags = y2.flags & -4097 | 64;
                  case 0:
                    y2 = x2.payload;
                    h2 = "function" === typeof y2 ? y2.call(p2, t3, h2) : y2;
                    if (null === h2 || void 0 === h2)
                      break a;
                    t3 = aa({}, t3, h2);
                    break a;
                  case 2:
                    hd = true;
                }
              }
              null !== f.callback && (a.flags |= 32, h2 = e3.effects, null === h2 ? e3.effects = [f] : h2.push(f));
            } else
              p2 = { eventTime: p2, lane: h2, tag: f.tag, payload: f.payload, callback: f.callback, next: null }, null === n2 ? (l2 = n2 = p2, k2 = t3) : n2 = n2.next = p2, g2 |= h2;
            f = f.next;
            if (null === f)
              if (h2 = e3.shared.pending, null === h2)
                break;
              else
                f = h2.next, h2.next = null, e3.lastBaseUpdate = h2, e3.shared.pending = null;
          } while (1);
          null === n2 && (k2 = t3);
          e3.baseState = k2;
          e3.firstBaseUpdate = l2;
          e3.lastBaseUpdate = n2;
          pd |= g2;
          a.lanes = g2;
          a.memoizedState = t3;
        }
      }
      __name(od, "od");
      function qd(a, b2, c2) {
        a = b2.effects;
        b2.effects = null;
        if (null !== a)
          for (b2 = 0; b2 < a.length; b2++) {
            var d2 = a[b2], e3 = d2.callback;
            if (null !== e3) {
              d2.callback = null;
              d2 = c2;
              if ("function" !== typeof e3)
                throw Error(q2(191, e3));
              e3.call(d2);
            }
          }
      }
      __name(qd, "qd");
      var rd = new ba.Component().refs;
      function sd(a, b2, c2, d2) {
        b2 = a.memoizedState;
        c2 = c2(d2, b2);
        c2 = null === c2 || void 0 === c2 ? b2 : aa({}, b2, c2);
        a.memoizedState = c2;
        0 === a.lanes && (a.updateQueue.baseState = c2);
      }
      __name(sd, "sd");
      var vd = { isMounted: function(a) {
        return (a = a._reactInternals) ? xa(a) === a : false;
      }, enqueueSetState: function(a, b2, c2) {
        a = a._reactInternals;
        var d2 = K2(), e3 = td(a), f = kd(d2, e3);
        f.payload = b2;
        void 0 !== c2 && null !== c2 && (f.callback = c2);
        md(a, f);
        ud(a, e3, d2);
      }, enqueueReplaceState: function(a, b2, c2) {
        a = a._reactInternals;
        var d2 = K2(), e3 = td(a), f = kd(d2, e3);
        f.tag = 1;
        f.payload = b2;
        void 0 !== c2 && null !== c2 && (f.callback = c2);
        md(a, f);
        ud(a, e3, d2);
      }, enqueueForceUpdate: function(a, b2) {
        a = a._reactInternals;
        var c2 = K2(), d2 = td(a), e3 = kd(c2, d2);
        e3.tag = 2;
        void 0 !== b2 && null !== b2 && (e3.callback = b2);
        md(a, e3);
        ud(a, d2, c2);
      } };
      function wd(a, b2, c2, d2, e3, f, g2) {
        a = a.stateNode;
        return "function" === typeof a.shouldComponentUpdate ? a.shouldComponentUpdate(d2, f, g2) : b2.prototype && b2.prototype.isPureReactComponent ? !Vc(c2, d2) || !Vc(e3, f) : true;
      }
      __name(wd, "wd");
      function xd(a, b2, c2) {
        var d2 = false, e3 = Xb;
        var f = b2.contextType;
        "object" === typeof f && null !== f ? f = J2(f) : (e3 = E2(b2) ? Yb : B2.current, d2 = b2.contextTypes, f = (d2 = null !== d2 && void 0 !== d2) ? Zb(a, e3) : Xb);
        b2 = new b2(c2, f);
        a.memoizedState = null !== b2.state && void 0 !== b2.state ? b2.state : null;
        b2.updater = vd;
        a.stateNode = b2;
        b2._reactInternals = a;
        d2 && (a = a.stateNode, a.__reactInternalMemoizedUnmaskedChildContext = e3, a.__reactInternalMemoizedMaskedChildContext = f);
        return b2;
      }
      __name(xd, "xd");
      function yd(a, b2, c2, d2) {
        a = b2.state;
        "function" === typeof b2.componentWillReceiveProps && b2.componentWillReceiveProps(c2, d2);
        "function" === typeof b2.UNSAFE_componentWillReceiveProps && b2.UNSAFE_componentWillReceiveProps(c2, d2);
        b2.state !== a && vd.enqueueReplaceState(b2, b2.state, null);
      }
      __name(yd, "yd");
      function zd(a, b2, c2, d2) {
        var e3 = a.stateNode;
        e3.props = c2;
        e3.state = a.memoizedState;
        e3.refs = rd;
        id(a);
        var f = b2.contextType;
        "object" === typeof f && null !== f ? e3.context = J2(f) : (f = E2(b2) ? Yb : B2.current, e3.context = Zb(a, f));
        od(a, c2, e3, d2);
        e3.state = a.memoizedState;
        f = b2.getDerivedStateFromProps;
        "function" === typeof f && (sd(a, b2, f, c2), e3.state = a.memoizedState);
        "function" === typeof b2.getDerivedStateFromProps || "function" === typeof e3.getSnapshotBeforeUpdate || "function" !== typeof e3.UNSAFE_componentWillMount && "function" !== typeof e3.componentWillMount || (b2 = e3.state, "function" === typeof e3.componentWillMount && e3.componentWillMount(), "function" === typeof e3.UNSAFE_componentWillMount && e3.UNSAFE_componentWillMount(), b2 !== e3.state && vd.enqueueReplaceState(e3, e3.state, null), od(a, c2, e3, d2), e3.state = a.memoizedState);
        "function" === typeof e3.componentDidMount && (a.flags |= 4);
      }
      __name(zd, "zd");
      var Ad = Array.isArray;
      function Bd(a, b2, c2) {
        a = c2.ref;
        if (null !== a && "function" !== typeof a && "object" !== typeof a) {
          if (c2._owner) {
            c2 = c2._owner;
            if (c2) {
              if (1 !== c2.tag)
                throw Error(q2(309));
              var d2 = c2.stateNode;
            }
            if (!d2)
              throw Error(q2(147, a));
            var e3 = "" + a;
            if (null !== b2 && null !== b2.ref && "function" === typeof b2.ref && b2.ref._stringRef === e3)
              return b2.ref;
            b2 = /* @__PURE__ */ __name(function(a2) {
              var b3 = d2.refs;
              b3 === rd && (b3 = d2.refs = {});
              null === a2 ? delete b3[e3] : b3[e3] = a2;
            }, "b");
            b2._stringRef = e3;
            return b2;
          }
          if ("string" !== typeof a)
            throw Error(q2(284));
          if (!c2._owner)
            throw Error(q2(290, a));
        }
        return a;
      }
      __name(Bd, "Bd");
      function Cd(a, b2) {
        if ("textarea" !== a.type)
          throw Error(q2(31, "[object Object]" === Object.prototype.toString.call(b2) ? "object with keys {" + Object.keys(b2).join(", ") + "}" : b2));
      }
      __name(Cd, "Cd");
      function Dd(a) {
        function b2(b3, c3) {
          if (a) {
            var d3 = b3.lastEffect;
            null !== d3 ? (d3.nextEffect = c3, b3.lastEffect = c3) : b3.firstEffect = b3.lastEffect = c3;
            c3.nextEffect = null;
            c3.flags = 8;
          }
        }
        __name(b2, "b");
        function c2(c3, d3) {
          if (!a)
            return null;
          for (; null !== d3; )
            b2(c3, d3), d3 = d3.sibling;
          return null;
        }
        __name(c2, "c");
        function d2(a2, b3) {
          for (a2 = /* @__PURE__ */ new Map(); null !== b3; )
            null !== b3.key ? a2.set(b3.key, b3) : a2.set(b3.index, b3), b3 = b3.sibling;
          return a2;
        }
        __name(d2, "d");
        function e3(a2, b3) {
          a2 = Ed(a2, b3);
          a2.index = 0;
          a2.sibling = null;
          return a2;
        }
        __name(e3, "e");
        function f(b3, c3, d3) {
          b3.index = d3;
          if (!a)
            return c3;
          d3 = b3.alternate;
          if (null !== d3)
            return d3 = d3.index, d3 < c3 ? (b3.flags = 2, c3) : d3;
          b3.flags = 2;
          return c3;
        }
        __name(f, "f");
        function g2(b3) {
          a && null === b3.alternate && (b3.flags = 2);
          return b3;
        }
        __name(g2, "g");
        function h2(a2, b3, c3, d3) {
          if (null === b3 || 6 !== b3.tag)
            return b3 = Fd(c3, a2.mode, d3), b3.return = a2, b3;
          b3 = e3(b3, c3);
          b3.return = a2;
          return b3;
        }
        __name(h2, "h");
        function k2(a2, b3, c3, d3) {
          if (null !== b3 && b3.elementType === c3.type)
            return d3 = e3(b3, c3.props), d3.ref = Bd(a2, b3, c3), d3.return = a2, d3;
          d3 = Gd(c3.type, c3.key, c3.props, null, a2.mode, d3);
          d3.ref = Bd(a2, b3, c3);
          d3.return = a2;
          return d3;
        }
        __name(k2, "k");
        function l2(a2, b3, c3, d3) {
          if (null === b3 || 4 !== b3.tag || b3.stateNode.containerInfo !== c3.containerInfo || b3.stateNode.implementation !== c3.implementation)
            return b3 = Hd(c3, a2.mode, d3), b3.return = a2, b3;
          b3 = e3(b3, c3.children || []);
          b3.return = a2;
          return b3;
        }
        __name(l2, "l");
        function n2(a2, b3, c3, d3, f2) {
          if (null === b3 || 7 !== b3.tag)
            return b3 = Id(c3, a2.mode, d3, f2), b3.return = a2, b3;
          b3 = e3(b3, c3);
          b3.return = a2;
          return b3;
        }
        __name(n2, "n");
        function t3(a2, b3, c3) {
          if ("string" === typeof b3 || "number" === typeof b3)
            return b3 = Fd("" + b3, a2.mode, c3), b3.return = a2, b3;
          if ("object" === typeof b3 && null !== b3) {
            switch (b3.$$typeof) {
              case da2:
                return c3 = Gd(b3.type, b3.key, b3.props, null, a2.mode, c3), c3.ref = Bd(a2, null, b3), c3.return = a2, c3;
              case ea:
                return b3 = Hd(b3, a2.mode, c3), b3.return = a2, b3;
            }
            if (Ad(b3) || va(b3))
              return b3 = Id(
                b3,
                a2.mode,
                c3,
                null
              ), b3.return = a2, b3;
            Cd(a2, b3);
          }
          return null;
        }
        __name(t3, "t");
        function p2(a2, b3, c3, d3) {
          var e4 = null !== b3 ? b3.key : null;
          if ("string" === typeof c3 || "number" === typeof c3)
            return null !== e4 ? null : h2(a2, b3, "" + c3, d3);
          if ("object" === typeof c3 && null !== c3) {
            switch (c3.$$typeof) {
              case da2:
                return c3.key === e4 ? c3.type === fa ? n2(a2, b3, c3.props.children, d3, e4) : k2(a2, b3, c3, d3) : null;
              case ea:
                return c3.key === e4 ? l2(a2, b3, c3, d3) : null;
            }
            if (Ad(c3) || va(c3))
              return null !== e4 ? null : n2(a2, b3, c3, d3, null);
            Cd(a2, c3);
          }
          return null;
        }
        __name(p2, "p");
        function y2(a2, b3, c3, d3, e4) {
          if ("string" === typeof d3 || "number" === typeof d3)
            return a2 = a2.get(c3) || null, h2(b3, a2, "" + d3, e4);
          if ("object" === typeof d3 && null !== d3) {
            switch (d3.$$typeof) {
              case da2:
                return a2 = a2.get(null === d3.key ? c3 : d3.key) || null, d3.type === fa ? n2(b3, a2, d3.props.children, e4, d3.key) : k2(b3, a2, d3, e4);
              case ea:
                return a2 = a2.get(null === d3.key ? c3 : d3.key) || null, l2(b3, a2, d3, e4);
            }
            if (Ad(d3) || va(d3))
              return a2 = a2.get(c3) || null, n2(b3, a2, d3, e4, null);
            Cd(b3, d3);
          }
          return null;
        }
        __name(y2, "y");
        function x2(e4, g3, h3, k3) {
          for (var l3 = null, v2 = null, u = g3, C2 = g3 = 0, n3 = null; null !== u && C2 < h3.length; C2++) {
            u.index > C2 ? (n3 = u, u = null) : n3 = u.sibling;
            var w2 = p2(e4, u, h3[C2], k3);
            if (null === w2) {
              null === u && (u = n3);
              break;
            }
            a && u && null === w2.alternate && b2(e4, u);
            g3 = f(w2, g3, C2);
            null === v2 ? l3 = w2 : v2.sibling = w2;
            v2 = w2;
            u = n3;
          }
          if (C2 === h3.length)
            return c2(e4, u), l3;
          if (null === u) {
            for (; C2 < h3.length; C2++)
              u = t3(e4, h3[C2], k3), null !== u && (g3 = f(u, g3, C2), null === v2 ? l3 = u : v2.sibling = u, v2 = u);
            return l3;
          }
          for (u = d2(e4, u); C2 < h3.length; C2++)
            n3 = y2(u, e4, C2, h3[C2], k3), null !== n3 && (a && null !== n3.alternate && u.delete(null === n3.key ? C2 : n3.key), g3 = f(n3, g3, C2), null === v2 ? l3 = n3 : v2.sibling = n3, v2 = n3);
          a && u.forEach(function(a2) {
            return b2(e4, a2);
          });
          return l3;
        }
        __name(x2, "x");
        function Y2(e4, g3, h3, k3) {
          var l3 = va(h3);
          if ("function" !== typeof l3)
            throw Error(q2(150));
          h3 = l3.call(h3);
          if (null == h3)
            throw Error(q2(151));
          for (var u = l3 = null, v2 = g3, n3 = g3 = 0, C2 = null, w2 = h3.next(); null !== v2 && !w2.done; n3++, w2 = h3.next()) {
            v2.index > n3 ? (C2 = v2, v2 = null) : C2 = v2.sibling;
            var x3 = p2(e4, v2, w2.value, k3);
            if (null === x3) {
              null === v2 && (v2 = C2);
              break;
            }
            a && v2 && null === x3.alternate && b2(e4, v2);
            g3 = f(x3, g3, n3);
            null === u ? l3 = x3 : u.sibling = x3;
            u = x3;
            v2 = C2;
          }
          if (w2.done)
            return c2(e4, v2), l3;
          if (null === v2) {
            for (; !w2.done; n3++, w2 = h3.next())
              w2 = t3(e4, w2.value, k3), null !== w2 && (g3 = f(w2, g3, n3), null === u ? l3 = w2 : u.sibling = w2, u = w2);
            return l3;
          }
          for (v2 = d2(e4, v2); !w2.done; n3++, w2 = h3.next())
            w2 = y2(v2, e4, n3, w2.value, k3), null !== w2 && (a && null !== w2.alternate && v2.delete(null === w2.key ? n3 : w2.key), g3 = f(w2, g3, n3), null === u ? l3 = w2 : u.sibling = w2, u = w2);
          a && v2.forEach(function(a2) {
            return b2(e4, a2);
          });
          return l3;
        }
        __name(Y2, "Y");
        return function(a2, d3, f2, h3) {
          var k3 = "object" === typeof f2 && null !== f2 && f2.type === fa && null === f2.key;
          k3 && (f2 = f2.props.children);
          var l3 = "object" === typeof f2 && null !== f2;
          if (l3)
            switch (f2.$$typeof) {
              case da2:
                a: {
                  l3 = f2.key;
                  for (k3 = d3; null !== k3; ) {
                    if (k3.key === l3) {
                      switch (k3.tag) {
                        case 7:
                          if (f2.type === fa) {
                            c2(a2, k3.sibling);
                            d3 = e3(k3, f2.props.children);
                            d3.return = a2;
                            a2 = d3;
                            break a;
                          }
                          break;
                        default:
                          if (k3.elementType === f2.type) {
                            c2(a2, k3.sibling);
                            d3 = e3(k3, f2.props);
                            d3.ref = Bd(a2, k3, f2);
                            d3.return = a2;
                            a2 = d3;
                            break a;
                          }
                      }
                      c2(a2, k3);
                      break;
                    } else
                      b2(a2, k3);
                    k3 = k3.sibling;
                  }
                  f2.type === fa ? (d3 = Id(f2.props.children, a2.mode, h3, f2.key), d3.return = a2, a2 = d3) : (h3 = Gd(f2.type, f2.key, f2.props, null, a2.mode, h3), h3.ref = Bd(a2, d3, f2), h3.return = a2, a2 = h3);
                }
                return g2(a2);
              case ea:
                a: {
                  for (k3 = f2.key; null !== d3; ) {
                    if (d3.key === k3)
                      if (4 === d3.tag && d3.stateNode.containerInfo === f2.containerInfo && d3.stateNode.implementation === f2.implementation) {
                        c2(a2, d3.sibling);
                        d3 = e3(d3, f2.children || []);
                        d3.return = a2;
                        a2 = d3;
                        break a;
                      } else {
                        c2(a2, d3);
                        break;
                      }
                    else
                      b2(a2, d3);
                    d3 = d3.sibling;
                  }
                  d3 = Hd(f2, a2.mode, h3);
                  d3.return = a2;
                  a2 = d3;
                }
                return g2(a2);
            }
          if ("string" === typeof f2 || "number" === typeof f2)
            return f2 = "" + f2, null !== d3 && 6 === d3.tag ? (c2(a2, d3.sibling), d3 = e3(d3, f2), d3.return = a2, a2 = d3) : (c2(a2, d3), d3 = Fd(f2, a2.mode, h3), d3.return = a2, a2 = d3), g2(a2);
          if (Ad(f2))
            return x2(a2, d3, f2, h3);
          if (va(f2))
            return Y2(a2, d3, f2, h3);
          l3 && Cd(a2, f2);
          if ("undefined" === typeof f2 && !k3)
            switch (a2.tag) {
              case 1:
              case 22:
              case 0:
              case 11:
              case 15:
                throw Error(q2(152, wa(a2.type) || "Component"));
            }
          return c2(a2, d3);
        };
      }
      __name(Dd, "Dd");
      var Jd = Dd(true), Kd = Dd(false), Ld = {}, L2 = Wb(Ld), Md = Wb(Ld), Nd = Wb(Ld);
      function Od(a) {
        if (a === Ld)
          throw Error(q2(174));
        return a;
      }
      __name(Od, "Od");
      function Pd(a, b2) {
        A2(Nd, b2);
        A2(Md, a);
        A2(L2, Ld);
        a = Ea(b2);
        z2(L2);
        A2(L2, a);
      }
      __name(Pd, "Pd");
      function Qd() {
        z2(L2);
        z2(Md);
        z2(Nd);
      }
      __name(Qd, "Qd");
      function Rd(a) {
        var b2 = Od(Nd.current), c2 = Od(L2.current);
        b2 = Fa(c2, a.type, b2);
        c2 !== b2 && (A2(Md, a), A2(L2, b2));
      }
      __name(Rd, "Rd");
      function Sd(a) {
        Md.current === a && (z2(L2), z2(Md));
      }
      __name(Sd, "Sd");
      var M2 = Wb(0);
      function Td(a) {
        for (var b2 = a; null !== b2; ) {
          if (13 === b2.tag) {
            var c2 = b2.memoizedState;
            if (null !== c2 && (c2 = c2.dehydrated, null === c2 || Hb(c2) || Ib(c2)))
              return b2;
          } else if (19 === b2.tag && void 0 !== b2.memoizedProps.revealOrder) {
            if (0 !== (b2.flags & 64))
              return b2;
          } else if (null !== b2.child) {
            b2.child.return = b2;
            b2 = b2.child;
            continue;
          }
          if (b2 === a)
            break;
          for (; null === b2.sibling; ) {
            if (null === b2.return || b2.return === a)
              return null;
            b2 = b2.return;
          }
          b2.sibling.return = b2.return;
          b2 = b2.sibling;
        }
        return null;
      }
      __name(Td, "Td");
      var Ud = null, Vd = null, Wd = false;
      function Xd(a, b2) {
        var c2 = Yd(5, null, null, 0);
        c2.elementType = "DELETED";
        c2.type = "DELETED";
        c2.stateNode = b2;
        c2.return = a;
        c2.flags = 8;
        null !== a.lastEffect ? (a.lastEffect.nextEffect = c2, a.lastEffect = c2) : a.firstEffect = a.lastEffect = c2;
      }
      __name(Xd, "Xd");
      function Zd(a, b2) {
        switch (a.tag) {
          case 5:
            return b2 = Fb(b2, a.type, a.pendingProps), null !== b2 ? (a.stateNode = b2, true) : false;
          case 6:
            return b2 = Gb(b2, a.pendingProps), null !== b2 ? (a.stateNode = b2, true) : false;
          case 13:
            return false;
          default:
            return false;
        }
      }
      __name(Zd, "Zd");
      function $d(a) {
        if (Wd) {
          var b2 = Vd;
          if (b2) {
            var c2 = b2;
            if (!Zd(a, b2)) {
              b2 = Jb(c2);
              if (!b2 || !Zd(a, b2)) {
                a.flags = a.flags & -1025 | 2;
                Wd = false;
                Ud = a;
                return;
              }
              Xd(Ud, c2);
            }
            Ud = a;
            Vd = Kb(b2);
          } else
            a.flags = a.flags & -1025 | 2, Wd = false, Ud = a;
        }
      }
      __name($d, "$d");
      function ae(a) {
        for (a = a.return; null !== a && 5 !== a.tag && 3 !== a.tag && 13 !== a.tag; )
          a = a.return;
        Ud = a;
      }
      __name(ae, "ae");
      function be2(a) {
        if (!Va || a !== Ud)
          return false;
        if (!Wd)
          return ae(a), Wd = true, false;
        var b2 = a.type;
        if (5 !== a.tag || "head" !== b2 && "body" !== b2 && !Ma(b2, a.memoizedProps))
          for (b2 = Vd; b2; )
            Xd(a, b2), b2 = Jb(b2);
        ae(a);
        if (13 === a.tag) {
          if (!Va)
            throw Error(q2(316));
          a = a.memoizedState;
          a = null !== a ? a.dehydrated : null;
          if (!a)
            throw Error(q2(317));
          Vd = Nb(a);
        } else
          Vd = Ud ? Jb(a.stateNode) : null;
        return true;
      }
      __name(be2, "be");
      function ce() {
        Va && (Vd = Ud = null, Wd = false);
      }
      __name(ce, "ce");
      var de = [];
      function ee() {
        for (var a = 0; a < de.length; a++) {
          var b2 = de[a];
          Sa ? b2._workInProgressVersionPrimary = null : b2._workInProgressVersionSecondary = null;
        }
        de.length = 0;
      }
      __name(ee, "ee");
      var fe = ca.ReactCurrentDispatcher, ge = ca.ReactCurrentBatchConfig, he2 = 0, N2 = null, O2 = null, P2 = null, ie = false, je = false;
      function Q3() {
        throw Error(q2(321));
      }
      __name(Q3, "Q");
      function ke(a, b2) {
        if (null === b2)
          return false;
        for (var c2 = 0; c2 < b2.length && c2 < a.length; c2++)
          if (!I2(a[c2], b2[c2]))
            return false;
        return true;
      }
      __name(ke, "ke");
      function le(a, b2, c2, d2, e3, f) {
        he2 = f;
        N2 = b2;
        b2.memoizedState = null;
        b2.updateQueue = null;
        b2.lanes = 0;
        fe.current = null === a || null === a.memoizedState ? me : ne;
        a = c2(d2, e3);
        if (je) {
          f = 0;
          do {
            je = false;
            if (!(25 > f))
              throw Error(q2(301));
            f += 1;
            P2 = O2 = null;
            b2.updateQueue = null;
            fe.current = oe;
            a = c2(d2, e3);
          } while (je);
        }
        fe.current = pe;
        b2 = null !== O2 && null !== O2.next;
        he2 = 0;
        P2 = O2 = N2 = null;
        ie = false;
        if (b2)
          throw Error(q2(300));
        return a;
      }
      __name(le, "le");
      function qe() {
        var a = { memoizedState: null, baseState: null, baseQueue: null, queue: null, next: null };
        null === P2 ? N2.memoizedState = P2 = a : P2 = P2.next = a;
        return P2;
      }
      __name(qe, "qe");
      function re() {
        if (null === O2) {
          var a = N2.alternate;
          a = null !== a ? a.memoizedState : null;
        } else
          a = O2.next;
        var b2 = null === P2 ? N2.memoizedState : P2.next;
        if (null !== b2)
          P2 = b2, O2 = a;
        else {
          if (null === a)
            throw Error(q2(310));
          O2 = a;
          a = { memoizedState: O2.memoizedState, baseState: O2.baseState, baseQueue: O2.baseQueue, queue: O2.queue, next: null };
          null === P2 ? N2.memoizedState = P2 = a : P2 = P2.next = a;
        }
        return P2;
      }
      __name(re, "re");
      function se2(a, b2) {
        return "function" === typeof b2 ? b2(a) : b2;
      }
      __name(se2, "se");
      function te(a) {
        var b2 = re(), c2 = b2.queue;
        if (null === c2)
          throw Error(q2(311));
        c2.lastRenderedReducer = a;
        var d2 = O2, e3 = d2.baseQueue, f = c2.pending;
        if (null !== f) {
          if (null !== e3) {
            var g2 = e3.next;
            e3.next = f.next;
            f.next = g2;
          }
          d2.baseQueue = e3 = f;
          c2.pending = null;
        }
        if (null !== e3) {
          e3 = e3.next;
          d2 = d2.baseState;
          var h2 = g2 = f = null, k2 = e3;
          do {
            var l2 = k2.lane;
            if ((he2 & l2) === l2)
              null !== h2 && (h2 = h2.next = { lane: 0, action: k2.action, eagerReducer: k2.eagerReducer, eagerState: k2.eagerState, next: null }), d2 = k2.eagerReducer === a ? k2.eagerState : a(d2, k2.action);
            else {
              var n2 = {
                lane: l2,
                action: k2.action,
                eagerReducer: k2.eagerReducer,
                eagerState: k2.eagerState,
                next: null
              };
              null === h2 ? (g2 = h2 = n2, f = d2) : h2 = h2.next = n2;
              N2.lanes |= l2;
              pd |= l2;
            }
            k2 = k2.next;
          } while (null !== k2 && k2 !== e3);
          null === h2 ? f = d2 : h2.next = g2;
          I2(d2, b2.memoizedState) || (gd2 = true);
          b2.memoizedState = d2;
          b2.baseState = f;
          b2.baseQueue = h2;
          c2.lastRenderedState = d2;
        }
        return [b2.memoizedState, c2.dispatch];
      }
      __name(te, "te");
      function ue(a) {
        var b2 = re(), c2 = b2.queue;
        if (null === c2)
          throw Error(q2(311));
        c2.lastRenderedReducer = a;
        var d2 = c2.dispatch, e3 = c2.pending, f = b2.memoizedState;
        if (null !== e3) {
          c2.pending = null;
          var g2 = e3 = e3.next;
          do
            f = a(f, g2.action), g2 = g2.next;
          while (g2 !== e3);
          I2(f, b2.memoizedState) || (gd2 = true);
          b2.memoizedState = f;
          null === b2.baseQueue && (b2.baseState = f);
          c2.lastRenderedState = f;
        }
        return [f, d2];
      }
      __name(ue, "ue");
      function ve(a, b2, c2) {
        var d2 = b2._getVersion;
        d2 = d2(b2._source);
        var e3 = Sa ? b2._workInProgressVersionPrimary : b2._workInProgressVersionSecondary;
        if (null !== e3)
          a = e3 === d2;
        else if (a = a.mutableReadLanes, a = (he2 & a) === a)
          Sa ? b2._workInProgressVersionPrimary = d2 : b2._workInProgressVersionSecondary = d2, de.push(b2);
        if (a)
          return c2(b2._source);
        de.push(b2);
        throw Error(q2(350));
      }
      __name(ve, "ve");
      function we(a, b2, c2, d2) {
        var e3 = R2;
        if (null === e3)
          throw Error(q2(349));
        var f = b2._getVersion, g2 = f(b2._source), h2 = fe.current, k2 = h2.useState(function() {
          return ve(e3, b2, c2);
        }), l2 = k2[1], n2 = k2[0];
        k2 = P2;
        var t3 = a.memoizedState, p2 = t3.refs, y2 = p2.getSnapshot, x2 = t3.source;
        t3 = t3.subscribe;
        var Y2 = N2;
        a.memoizedState = { refs: p2, source: b2, subscribe: d2 };
        h2.useEffect(function() {
          p2.getSnapshot = c2;
          p2.setSnapshot = l2;
          var a2 = f(b2._source);
          if (!I2(g2, a2)) {
            a2 = c2(b2._source);
            I2(n2, a2) || (l2(a2), a2 = td(Y2), e3.mutableReadLanes |= a2 & e3.pendingLanes);
            a2 = e3.mutableReadLanes;
            e3.entangledLanes |= a2;
            for (var d3 = e3.entanglements, h3 = a2; 0 < h3; ) {
              var k3 = 31 - mc(h3), t4 = 1 << k3;
              d3[k3] |= a2;
              h3 &= ~t4;
            }
          }
        }, [c2, b2, d2]);
        h2.useEffect(function() {
          return d2(b2._source, function() {
            var a2 = p2.getSnapshot, c3 = p2.setSnapshot;
            try {
              c3(a2(b2._source));
              var d3 = td(Y2);
              e3.mutableReadLanes |= d3 & e3.pendingLanes;
            } catch (Oa) {
              c3(function() {
                throw Oa;
              });
            }
          });
        }, [b2, d2]);
        I2(y2, c2) && I2(x2, b2) && I2(t3, d2) || (a = { pending: null, dispatch: null, lastRenderedReducer: se2, lastRenderedState: n2 }, a.dispatch = l2 = xe.bind(null, N2, a), k2.queue = a, k2.baseQueue = null, n2 = ve(e3, b2, c2), k2.memoizedState = k2.baseState = n2);
        return n2;
      }
      __name(we, "we");
      function ye(a, b2, c2) {
        var d2 = re();
        return we(d2, a, b2, c2);
      }
      __name(ye, "ye");
      function ze(a) {
        var b2 = qe();
        "function" === typeof a && (a = a());
        b2.memoizedState = b2.baseState = a;
        a = b2.queue = { pending: null, dispatch: null, lastRenderedReducer: se2, lastRenderedState: a };
        a = a.dispatch = xe.bind(null, N2, a);
        return [b2.memoizedState, a];
      }
      __name(ze, "ze");
      function Ae(a, b2, c2, d2) {
        a = { tag: a, create: b2, destroy: c2, deps: d2, next: null };
        b2 = N2.updateQueue;
        null === b2 ? (b2 = { lastEffect: null }, N2.updateQueue = b2, b2.lastEffect = a.next = a) : (c2 = b2.lastEffect, null === c2 ? b2.lastEffect = a.next = a : (d2 = c2.next, c2.next = a, a.next = d2, b2.lastEffect = a));
        return a;
      }
      __name(Ae, "Ae");
      function Be(a) {
        var b2 = qe();
        a = { current: a };
        return b2.memoizedState = a;
      }
      __name(Be, "Be");
      function Ce() {
        return re().memoizedState;
      }
      __name(Ce, "Ce");
      function De(a, b2, c2, d2) {
        var e3 = qe();
        N2.flags |= a;
        e3.memoizedState = Ae(1 | b2, c2, void 0, void 0 === d2 ? null : d2);
      }
      __name(De, "De");
      function Ee(a, b2, c2, d2) {
        var e3 = re();
        d2 = void 0 === d2 ? null : d2;
        var f = void 0;
        if (null !== O2) {
          var g2 = O2.memoizedState;
          f = g2.destroy;
          if (null !== d2 && ke(d2, g2.deps)) {
            Ae(b2, c2, f, d2);
            return;
          }
        }
        N2.flags |= a;
        e3.memoizedState = Ae(1 | b2, c2, f, d2);
      }
      __name(Ee, "Ee");
      function Fe(a, b2) {
        return De(516, 4, a, b2);
      }
      __name(Fe, "Fe");
      function Ge(a, b2) {
        return Ee(516, 4, a, b2);
      }
      __name(Ge, "Ge");
      function He(a, b2) {
        return Ee(4, 2, a, b2);
      }
      __name(He, "He");
      function Ie(a, b2) {
        if ("function" === typeof b2)
          return a = a(), b2(a), function() {
            b2(null);
          };
        if (null !== b2 && void 0 !== b2)
          return a = a(), b2.current = a, function() {
            b2.current = null;
          };
      }
      __name(Ie, "Ie");
      function Je(a, b2, c2) {
        c2 = null !== c2 && void 0 !== c2 ? c2.concat([a]) : null;
        return Ee(4, 2, Ie.bind(null, b2, a), c2);
      }
      __name(Je, "Je");
      function Ke() {
      }
      __name(Ke, "Ke");
      function Le(a, b2) {
        var c2 = re();
        b2 = void 0 === b2 ? null : b2;
        var d2 = c2.memoizedState;
        if (null !== d2 && null !== b2 && ke(b2, d2[1]))
          return d2[0];
        c2.memoizedState = [a, b2];
        return a;
      }
      __name(Le, "Le");
      function Me(a, b2) {
        var c2 = re();
        b2 = void 0 === b2 ? null : b2;
        var d2 = c2.memoizedState;
        if (null !== d2 && null !== b2 && ke(b2, d2[1]))
          return d2[0];
        a = a();
        c2.memoizedState = [a, b2];
        return a;
      }
      __name(Me, "Me");
      function Ne(a, b2) {
        var c2 = Nc();
        Pc(98 > c2 ? 98 : c2, function() {
          a(true);
        });
        Pc(97 < c2 ? 97 : c2, function() {
          var c3 = ge.transition;
          ge.transition = 1;
          try {
            a(false), b2();
          } finally {
            ge.transition = c3;
          }
        });
      }
      __name(Ne, "Ne");
      function xe(a, b2, c2) {
        var d2 = K2(), e3 = td(a), f = { lane: e3, action: c2, eagerReducer: null, eagerState: null, next: null }, g2 = b2.pending;
        null === g2 ? f.next = f : (f.next = g2.next, g2.next = f);
        b2.pending = f;
        g2 = a.alternate;
        if (a === N2 || null !== g2 && g2 === N2)
          je = ie = true;
        else {
          if (0 === a.lanes && (null === g2 || 0 === g2.lanes) && (g2 = b2.lastRenderedReducer, null !== g2))
            try {
              var h2 = b2.lastRenderedState, k2 = g2(h2, c2);
              f.eagerReducer = g2;
              f.eagerState = k2;
              if (I2(k2, h2))
                return;
            } catch (l2) {
            } finally {
            }
          ud(a, e3, d2);
        }
      }
      __name(xe, "xe");
      var pe = { readContext: J2, useCallback: Q3, useContext: Q3, useEffect: Q3, useImperativeHandle: Q3, useLayoutEffect: Q3, useMemo: Q3, useReducer: Q3, useRef: Q3, useState: Q3, useDebugValue: Q3, useDeferredValue: Q3, useTransition: Q3, useMutableSource: Q3, useOpaqueIdentifier: Q3, unstable_isNewReconciler: false }, me = { readContext: J2, useCallback: function(a, b2) {
        qe().memoizedState = [a, void 0 === b2 ? null : b2];
        return a;
      }, useContext: J2, useEffect: Fe, useImperativeHandle: function(a, b2, c2) {
        c2 = null !== c2 && void 0 !== c2 ? c2.concat([a]) : null;
        return De(4, 2, Ie.bind(null, b2, a), c2);
      }, useLayoutEffect: function(a, b2) {
        return De(4, 2, a, b2);
      }, useMemo: function(a, b2) {
        var c2 = qe();
        b2 = void 0 === b2 ? null : b2;
        a = a();
        c2.memoizedState = [a, b2];
        return a;
      }, useReducer: function(a, b2, c2) {
        var d2 = qe();
        b2 = void 0 !== c2 ? c2(b2) : b2;
        d2.memoizedState = d2.baseState = b2;
        a = d2.queue = { pending: null, dispatch: null, lastRenderedReducer: a, lastRenderedState: b2 };
        a = a.dispatch = xe.bind(null, N2, a);
        return [d2.memoizedState, a];
      }, useRef: Be, useState: ze, useDebugValue: Ke, useDeferredValue: function(a) {
        var b2 = ze(a), c2 = b2[0], d2 = b2[1];
        Fe(function() {
          var b3 = ge.transition;
          ge.transition = 1;
          try {
            d2(a);
          } finally {
            ge.transition = b3;
          }
        }, [a]);
        return c2;
      }, useTransition: function() {
        var a = ze(false), b2 = a[0];
        a = Ne.bind(null, a[1]);
        Be(a);
        return [a, b2];
      }, useMutableSource: function(a, b2, c2) {
        var d2 = qe();
        d2.memoizedState = { refs: { getSnapshot: b2, setSnapshot: null }, source: a, subscribe: c2 };
        return we(d2, a, b2, c2);
      }, useOpaqueIdentifier: function() {
        if (Wd) {
          var a = false, b2 = Xa(function() {
            a || (a = true, c2(Ya()));
            throw Error(q2(355));
          }), c2 = ze(b2)[1];
          0 === (N2.mode & 2) && (N2.flags |= 516, Ae(5, function() {
            c2(Ya());
          }, void 0, null));
          return b2;
        }
        b2 = Ya();
        ze(b2);
        return b2;
      }, unstable_isNewReconciler: false }, ne = {
        readContext: J2,
        useCallback: Le,
        useContext: J2,
        useEffect: Ge,
        useImperativeHandle: Je,
        useLayoutEffect: He,
        useMemo: Me,
        useReducer: te,
        useRef: Ce,
        useState: function() {
          return te(se2);
        },
        useDebugValue: Ke,
        useDeferredValue: function(a) {
          var b2 = te(se2), c2 = b2[0], d2 = b2[1];
          Ge(function() {
            var b3 = ge.transition;
            ge.transition = 1;
            try {
              d2(a);
            } finally {
              ge.transition = b3;
            }
          }, [a]);
          return c2;
        },
        useTransition: function() {
          var a = te(se2)[0];
          return [Ce().current, a];
        },
        useMutableSource: ye,
        useOpaqueIdentifier: function() {
          return te(se2)[0];
        },
        unstable_isNewReconciler: false
      }, oe = {
        readContext: J2,
        useCallback: Le,
        useContext: J2,
        useEffect: Ge,
        useImperativeHandle: Je,
        useLayoutEffect: He,
        useMemo: Me,
        useReducer: ue,
        useRef: Ce,
        useState: function() {
          return ue(se2);
        },
        useDebugValue: Ke,
        useDeferredValue: function(a) {
          var b2 = ue(se2), c2 = b2[0], d2 = b2[1];
          Ge(function() {
            var b3 = ge.transition;
            ge.transition = 1;
            try {
              d2(a);
            } finally {
              ge.transition = b3;
            }
          }, [a]);
          return c2;
        },
        useTransition: function() {
          var a = ue(se2)[0];
          return [Ce().current, a];
        },
        useMutableSource: ye,
        useOpaqueIdentifier: function() {
          return ue(se2)[0];
        },
        unstable_isNewReconciler: false
      }, Oe = ca.ReactCurrentOwner, gd2 = false;
      function S2(a, b2, c2, d2) {
        b2.child = null === a ? Kd(b2, null, c2, d2) : Jd(b2, a.child, c2, d2);
      }
      __name(S2, "S");
      function Pe(a, b2, c2, d2, e3) {
        c2 = c2.render;
        var f = b2.ref;
        fd(b2, e3);
        d2 = le(a, b2, c2, d2, f, e3);
        if (null !== a && !gd2)
          return b2.updateQueue = a.updateQueue, b2.flags &= -517, a.lanes &= ~e3, Re(a, b2, e3);
        b2.flags |= 1;
        S2(a, b2, d2, e3);
        return b2.child;
      }
      __name(Pe, "Pe");
      function Se(a, b2, c2, d2, e3, f) {
        if (null === a) {
          var g2 = c2.type;
          if ("function" === typeof g2 && !Te(g2) && void 0 === g2.defaultProps && null === c2.compare && void 0 === c2.defaultProps)
            return b2.tag = 15, b2.type = g2, Ue(a, b2, g2, d2, e3, f);
          a = Gd(c2.type, null, d2, b2, b2.mode, f);
          a.ref = b2.ref;
          a.return = b2;
          return b2.child = a;
        }
        g2 = a.child;
        if (0 === (e3 & f) && (e3 = g2.memoizedProps, c2 = c2.compare, c2 = null !== c2 ? c2 : Vc, c2(e3, d2) && a.ref === b2.ref))
          return Re(a, b2, f);
        b2.flags |= 1;
        a = Ed(g2, d2);
        a.ref = b2.ref;
        a.return = b2;
        return b2.child = a;
      }
      __name(Se, "Se");
      function Ue(a, b2, c2, d2, e3, f) {
        if (null !== a && Vc(a.memoizedProps, d2) && a.ref === b2.ref)
          if (gd2 = false, 0 !== (f & e3))
            0 !== (a.flags & 16384) && (gd2 = true);
          else
            return b2.lanes = a.lanes, Re(a, b2, f);
        return Ve(a, b2, c2, d2, f);
      }
      __name(Ue, "Ue");
      function We(a, b2, c2) {
        var d2 = b2.pendingProps, e3 = d2.children, f = null !== a ? a.memoizedState : null;
        if ("hidden" === d2.mode || "unstable-defer-without-hiding" === d2.mode)
          if (0 === (b2.mode & 4))
            b2.memoizedState = { baseLanes: 0 }, Xe(b2, c2);
          else if (0 !== (c2 & 1073741824))
            b2.memoizedState = { baseLanes: 0 }, Xe(b2, null !== f ? f.baseLanes : c2);
          else
            return a = null !== f ? f.baseLanes | c2 : c2, b2.lanes = b2.childLanes = 1073741824, b2.memoizedState = { baseLanes: a }, Xe(b2, a), null;
        else
          null !== f ? (d2 = f.baseLanes | c2, b2.memoizedState = null) : d2 = c2, Xe(b2, d2);
        S2(a, b2, e3, c2);
        return b2.child;
      }
      __name(We, "We");
      function Ye(a, b2) {
        var c2 = b2.ref;
        if (null === a && null !== c2 || null !== a && a.ref !== c2)
          b2.flags |= 128;
      }
      __name(Ye, "Ye");
      function Ve(a, b2, c2, d2, e3) {
        var f = E2(c2) ? Yb : B2.current;
        f = Zb(b2, f);
        fd(b2, e3);
        c2 = le(a, b2, c2, d2, f, e3);
        if (null !== a && !gd2)
          return b2.updateQueue = a.updateQueue, b2.flags &= -517, a.lanes &= ~e3, Re(a, b2, e3);
        b2.flags |= 1;
        S2(a, b2, c2, e3);
        return b2.child;
      }
      __name(Ve, "Ve");
      function Ze(a, b2, c2, d2, e3) {
        if (E2(c2)) {
          var f = true;
          cc(b2);
        } else
          f = false;
        fd(b2, e3);
        if (null === b2.stateNode)
          null !== a && (a.alternate = null, b2.alternate = null, b2.flags |= 2), xd(b2, c2, d2), zd(b2, c2, d2, e3), d2 = true;
        else if (null === a) {
          var g2 = b2.stateNode, h2 = b2.memoizedProps;
          g2.props = h2;
          var k2 = g2.context, l2 = c2.contextType;
          "object" === typeof l2 && null !== l2 ? l2 = J2(l2) : (l2 = E2(c2) ? Yb : B2.current, l2 = Zb(b2, l2));
          var n2 = c2.getDerivedStateFromProps, t3 = "function" === typeof n2 || "function" === typeof g2.getSnapshotBeforeUpdate;
          t3 || "function" !== typeof g2.UNSAFE_componentWillReceiveProps && "function" !== typeof g2.componentWillReceiveProps || (h2 !== d2 || k2 !== l2) && yd(b2, g2, d2, l2);
          hd = false;
          var p2 = b2.memoizedState;
          g2.state = p2;
          od(b2, d2, g2, e3);
          k2 = b2.memoizedState;
          h2 !== d2 || p2 !== k2 || D.current || hd ? ("function" === typeof n2 && (sd(b2, c2, n2, d2), k2 = b2.memoizedState), (h2 = hd || wd(b2, c2, h2, d2, p2, k2, l2)) ? (t3 || "function" !== typeof g2.UNSAFE_componentWillMount && "function" !== typeof g2.componentWillMount || ("function" === typeof g2.componentWillMount && g2.componentWillMount(), "function" === typeof g2.UNSAFE_componentWillMount && g2.UNSAFE_componentWillMount()), "function" === typeof g2.componentDidMount && (b2.flags |= 4)) : ("function" === typeof g2.componentDidMount && (b2.flags |= 4), b2.memoizedProps = d2, b2.memoizedState = k2), g2.props = d2, g2.state = k2, g2.context = l2, d2 = h2) : ("function" === typeof g2.componentDidMount && (b2.flags |= 4), d2 = false);
        } else {
          g2 = b2.stateNode;
          jd(a, b2);
          h2 = b2.memoizedProps;
          l2 = b2.type === b2.elementType ? h2 : Xc(b2.type, h2);
          g2.props = l2;
          t3 = b2.pendingProps;
          p2 = g2.context;
          k2 = c2.contextType;
          "object" === typeof k2 && null !== k2 ? k2 = J2(k2) : (k2 = E2(c2) ? Yb : B2.current, k2 = Zb(b2, k2));
          var y2 = c2.getDerivedStateFromProps;
          (n2 = "function" === typeof y2 || "function" === typeof g2.getSnapshotBeforeUpdate) || "function" !== typeof g2.UNSAFE_componentWillReceiveProps && "function" !== typeof g2.componentWillReceiveProps || (h2 !== t3 || p2 !== k2) && yd(b2, g2, d2, k2);
          hd = false;
          p2 = b2.memoizedState;
          g2.state = p2;
          od(b2, d2, g2, e3);
          var x2 = b2.memoizedState;
          h2 !== t3 || p2 !== x2 || D.current || hd ? ("function" === typeof y2 && (sd(b2, c2, y2, d2), x2 = b2.memoizedState), (l2 = hd || wd(b2, c2, l2, d2, p2, x2, k2)) ? (n2 || "function" !== typeof g2.UNSAFE_componentWillUpdate && "function" !== typeof g2.componentWillUpdate || ("function" === typeof g2.componentWillUpdate && g2.componentWillUpdate(d2, x2, k2), "function" === typeof g2.UNSAFE_componentWillUpdate && g2.UNSAFE_componentWillUpdate(d2, x2, k2)), "function" === typeof g2.componentDidUpdate && (b2.flags |= 4), "function" === typeof g2.getSnapshotBeforeUpdate && (b2.flags |= 256)) : ("function" !== typeof g2.componentDidUpdate || h2 === a.memoizedProps && p2 === a.memoizedState || (b2.flags |= 4), "function" !== typeof g2.getSnapshotBeforeUpdate || h2 === a.memoizedProps && p2 === a.memoizedState || (b2.flags |= 256), b2.memoizedProps = d2, b2.memoizedState = x2), g2.props = d2, g2.state = x2, g2.context = k2, d2 = l2) : ("function" !== typeof g2.componentDidUpdate || h2 === a.memoizedProps && p2 === a.memoizedState || (b2.flags |= 4), "function" !== typeof g2.getSnapshotBeforeUpdate || h2 === a.memoizedProps && p2 === a.memoizedState || (b2.flags |= 256), d2 = false);
        }
        return $e(a, b2, c2, d2, f, e3);
      }
      __name(Ze, "Ze");
      function $e(a, b2, c2, d2, e3, f) {
        Ye(a, b2);
        var g2 = 0 !== (b2.flags & 64);
        if (!d2 && !g2)
          return e3 && dc(b2, c2, false), Re(a, b2, f);
        d2 = b2.stateNode;
        Oe.current = b2;
        var h2 = g2 && "function" !== typeof c2.getDerivedStateFromError ? null : d2.render();
        b2.flags |= 1;
        null !== a && g2 ? (b2.child = Jd(b2, a.child, null, f), b2.child = Jd(b2, null, h2, f)) : S2(a, b2, h2, f);
        b2.memoizedState = d2.state;
        e3 && dc(b2, c2, true);
        return b2.child;
      }
      __name($e, "$e");
      function af2(a) {
        var b2 = a.stateNode;
        b2.pendingContext ? ac(a, b2.pendingContext, b2.pendingContext !== b2.context) : b2.context && ac(a, b2.context, false);
        Pd(a, b2.containerInfo);
      }
      __name(af2, "af");
      var bf = { dehydrated: null, retryLane: 0 };
      function cf(a, b2, c2) {
        var d2 = b2.pendingProps, e3 = M2.current, f = false, g2;
        (g2 = 0 !== (b2.flags & 64)) || (g2 = null !== a && null === a.memoizedState ? false : 0 !== (e3 & 2));
        g2 ? (f = true, b2.flags &= -65) : null !== a && null === a.memoizedState || void 0 === d2.fallback || true === d2.unstable_avoidThisFallback || (e3 |= 1);
        A2(M2, e3 & 1);
        if (null === a) {
          void 0 !== d2.fallback && $d(b2);
          a = d2.children;
          e3 = d2.fallback;
          if (f)
            return a = df(b2, a, e3, c2), b2.child.memoizedState = { baseLanes: c2 }, b2.memoizedState = bf, a;
          if ("number" === typeof d2.unstable_expectedLoadTime)
            return a = df(b2, a, e3, c2), b2.child.memoizedState = { baseLanes: c2 }, b2.memoizedState = bf, b2.lanes = 33554432, a;
          c2 = ef({ mode: "visible", children: a }, b2.mode, c2, null);
          c2.return = b2;
          return b2.child = c2;
        }
        if (null !== a.memoizedState) {
          if (f)
            return d2 = ff2(a, b2, d2.children, d2.fallback, c2), f = b2.child, e3 = a.child.memoizedState, f.memoizedState = null === e3 ? { baseLanes: c2 } : { baseLanes: e3.baseLanes | c2 }, f.childLanes = a.childLanes & ~c2, b2.memoizedState = bf, d2;
          c2 = gf(a, b2, d2.children, c2);
          b2.memoizedState = null;
          return c2;
        }
        if (f)
          return d2 = ff2(a, b2, d2.children, d2.fallback, c2), f = b2.child, e3 = a.child.memoizedState, f.memoizedState = null === e3 ? { baseLanes: c2 } : { baseLanes: e3.baseLanes | c2 }, f.childLanes = a.childLanes & ~c2, b2.memoizedState = bf, d2;
        c2 = gf(a, b2, d2.children, c2);
        b2.memoizedState = null;
        return c2;
      }
      __name(cf, "cf");
      function df(a, b2, c2, d2) {
        var e3 = a.mode, f = a.child;
        b2 = { mode: "hidden", children: b2 };
        0 === (e3 & 2) && null !== f ? (f.childLanes = 0, f.pendingProps = b2) : f = ef(b2, e3, 0, null);
        c2 = Id(c2, e3, d2, null);
        f.return = a;
        c2.return = a;
        f.sibling = c2;
        a.child = f;
        return c2;
      }
      __name(df, "df");
      function gf(a, b2, c2, d2) {
        var e3 = a.child;
        a = e3.sibling;
        c2 = Ed(e3, { mode: "visible", children: c2 });
        0 === (b2.mode & 2) && (c2.lanes = d2);
        c2.return = b2;
        c2.sibling = null;
        null !== a && (a.nextEffect = null, a.flags = 8, b2.firstEffect = b2.lastEffect = a);
        return b2.child = c2;
      }
      __name(gf, "gf");
      function ff2(a, b2, c2, d2, e3) {
        var f = b2.mode, g2 = a.child;
        a = g2.sibling;
        var h2 = { mode: "hidden", children: c2 };
        0 === (f & 2) && b2.child !== g2 ? (c2 = b2.child, c2.childLanes = 0, c2.pendingProps = h2, g2 = c2.lastEffect, null !== g2 ? (b2.firstEffect = c2.firstEffect, b2.lastEffect = g2, g2.nextEffect = null) : b2.firstEffect = b2.lastEffect = null) : c2 = Ed(g2, h2);
        null !== a ? d2 = Ed(a, d2) : (d2 = Id(d2, f, e3, null), d2.flags |= 2);
        d2.return = b2;
        c2.return = b2;
        c2.sibling = d2;
        b2.child = c2;
        return d2;
      }
      __name(ff2, "ff");
      function hf(a, b2) {
        a.lanes |= b2;
        var c2 = a.alternate;
        null !== c2 && (c2.lanes |= b2);
        ed(a.return, b2);
      }
      __name(hf, "hf");
      function jf(a, b2, c2, d2, e3, f) {
        var g2 = a.memoizedState;
        null === g2 ? a.memoizedState = { isBackwards: b2, rendering: null, renderingStartTime: 0, last: d2, tail: c2, tailMode: e3, lastEffect: f } : (g2.isBackwards = b2, g2.rendering = null, g2.renderingStartTime = 0, g2.last = d2, g2.tail = c2, g2.tailMode = e3, g2.lastEffect = f);
      }
      __name(jf, "jf");
      function kf(a, b2, c2) {
        var d2 = b2.pendingProps, e3 = d2.revealOrder, f = d2.tail;
        S2(a, b2, d2.children, c2);
        d2 = M2.current;
        if (0 !== (d2 & 2))
          d2 = d2 & 1 | 2, b2.flags |= 64;
        else {
          if (null !== a && 0 !== (a.flags & 64))
            a:
              for (a = b2.child; null !== a; ) {
                if (13 === a.tag)
                  null !== a.memoizedState && hf(a, c2);
                else if (19 === a.tag)
                  hf(a, c2);
                else if (null !== a.child) {
                  a.child.return = a;
                  a = a.child;
                  continue;
                }
                if (a === b2)
                  break a;
                for (; null === a.sibling; ) {
                  if (null === a.return || a.return === b2)
                    break a;
                  a = a.return;
                }
                a.sibling.return = a.return;
                a = a.sibling;
              }
          d2 &= 1;
        }
        A2(M2, d2);
        if (0 === (b2.mode & 2))
          b2.memoizedState = null;
        else
          switch (e3) {
            case "forwards":
              c2 = b2.child;
              for (e3 = null; null !== c2; )
                a = c2.alternate, null !== a && null === Td(a) && (e3 = c2), c2 = c2.sibling;
              c2 = e3;
              null === c2 ? (e3 = b2.child, b2.child = null) : (e3 = c2.sibling, c2.sibling = null);
              jf(b2, false, e3, c2, f, b2.lastEffect);
              break;
            case "backwards":
              c2 = null;
              e3 = b2.child;
              for (b2.child = null; null !== e3; ) {
                a = e3.alternate;
                if (null !== a && null === Td(a)) {
                  b2.child = e3;
                  break;
                }
                a = e3.sibling;
                e3.sibling = c2;
                c2 = e3;
                e3 = a;
              }
              jf(b2, true, c2, null, f, b2.lastEffect);
              break;
            case "together":
              jf(b2, false, null, null, void 0, b2.lastEffect);
              break;
            default:
              b2.memoizedState = null;
          }
        return b2.child;
      }
      __name(kf, "kf");
      function Re(a, b2, c2) {
        null !== a && (b2.dependencies = a.dependencies);
        pd |= b2.lanes;
        if (0 !== (c2 & b2.childLanes)) {
          if (null !== a && b2.child !== a.child)
            throw Error(q2(153));
          if (null !== b2.child) {
            a = b2.child;
            c2 = Ed(a, a.pendingProps);
            b2.child = c2;
            for (c2.return = b2; null !== a.sibling; )
              a = a.sibling, c2 = c2.sibling = Ed(a, a.pendingProps), c2.return = b2;
            c2.sibling = null;
          }
          return b2.child;
        }
        return null;
      }
      __name(Re, "Re");
      function lf(a) {
        a.flags |= 4;
      }
      __name(lf, "lf");
      var mf, nf, of, pf;
      if (Ta)
        mf = /* @__PURE__ */ __name(function(a, b2) {
          for (var c2 = b2.child; null !== c2; ) {
            if (5 === c2.tag || 6 === c2.tag)
              Ja(a, c2.stateNode);
            else if (4 !== c2.tag && null !== c2.child) {
              c2.child.return = c2;
              c2 = c2.child;
              continue;
            }
            if (c2 === b2)
              break;
            for (; null === c2.sibling; ) {
              if (null === c2.return || c2.return === b2)
                return;
              c2 = c2.return;
            }
            c2.sibling.return = c2.return;
            c2 = c2.sibling;
          }
        }, "mf"), nf = /* @__PURE__ */ __name(function() {
        }, "nf"), of = /* @__PURE__ */ __name(function(a, b2, c2, d2, e3) {
          a = a.memoizedProps;
          if (a !== d2) {
            var f = b2.stateNode, g2 = Od(L2.current);
            c2 = La(f, c2, a, d2, e3, g2);
            (b2.updateQueue = c2) && lf(b2);
          }
        }, "of"), pf = /* @__PURE__ */ __name(function(a, b2, c2, d2) {
          c2 !== d2 && lf(b2);
        }, "pf");
      else if (Ua) {
        mf = /* @__PURE__ */ __name(function(a, b2, c2, d2) {
          for (var e3 = b2.child; null !== e3; ) {
            if (5 === e3.tag) {
              var f = e3.stateNode;
              c2 && d2 && (f = Db(f, e3.type, e3.memoizedProps, e3));
              Ja(a, f);
            } else if (6 === e3.tag)
              f = e3.stateNode, c2 && d2 && (f = Eb(f, e3.memoizedProps, e3)), Ja(a, f);
            else if (4 !== e3.tag) {
              if (13 === e3.tag && 0 !== (e3.flags & 4) && (f = null !== e3.memoizedState)) {
                var g2 = e3.child;
                if (null !== g2 && (null !== g2.child && (g2.child.return = g2, mf(a, g2, true, f)), f = g2.sibling, null !== f)) {
                  f.return = e3;
                  e3 = f;
                  continue;
                }
              }
              if (null !== e3.child) {
                e3.child.return = e3;
                e3 = e3.child;
                continue;
              }
            }
            if (e3 === b2)
              break;
            for (; null === e3.sibling; ) {
              if (null === e3.return || e3.return === b2)
                return;
              e3 = e3.return;
            }
            e3.sibling.return = e3.return;
            e3 = e3.sibling;
          }
        }, "mf");
        var qf = /* @__PURE__ */ __name(function(a, b2, c2, d2) {
          for (var e3 = b2.child; null !== e3; ) {
            if (5 === e3.tag) {
              var f = e3.stateNode;
              c2 && d2 && (f = Db(f, e3.type, e3.memoizedProps, e3));
              Ab(a, f);
            } else if (6 === e3.tag)
              f = e3.stateNode, c2 && d2 && (f = Eb(f, e3.memoizedProps, e3)), Ab(a, f);
            else if (4 !== e3.tag) {
              if (13 === e3.tag && 0 !== (e3.flags & 4) && (f = null !== e3.memoizedState)) {
                var g2 = e3.child;
                if (null !== g2 && (null !== g2.child && (g2.child.return = g2, qf(a, g2, true, f)), f = g2.sibling, null !== f)) {
                  f.return = e3;
                  e3 = f;
                  continue;
                }
              }
              if (null !== e3.child) {
                e3.child.return = e3;
                e3 = e3.child;
                continue;
              }
            }
            if (e3 === b2)
              break;
            for (; null === e3.sibling; ) {
              if (null === e3.return || e3.return === b2)
                return;
              e3 = e3.return;
            }
            e3.sibling.return = e3.return;
            e3 = e3.sibling;
          }
        }, "qf");
        nf = /* @__PURE__ */ __name(function(a) {
          var b2 = a.stateNode;
          if (null !== a.firstEffect) {
            var c2 = b2.containerInfo, d2 = zb(c2);
            qf(d2, a, false, false);
            b2.pendingChildren = d2;
            lf(a);
            Bb(c2, d2);
          }
        }, "nf");
        of = /* @__PURE__ */ __name(function(a, b2, c2, d2, e3) {
          var f = a.stateNode, g2 = a.memoizedProps;
          if ((a = null === b2.firstEffect) && g2 === d2)
            b2.stateNode = f;
          else {
            var h2 = b2.stateNode, k2 = Od(L2.current), l2 = null;
            g2 !== d2 && (l2 = La(h2, c2, g2, d2, e3, k2));
            a && null === l2 ? b2.stateNode = f : (f = yb(
              f,
              l2,
              c2,
              g2,
              d2,
              b2,
              a,
              h2
            ), Ka(f, c2, d2, e3, k2) && lf(b2), b2.stateNode = f, a ? lf(b2) : mf(f, b2, false, false));
          }
        }, "of");
        pf = /* @__PURE__ */ __name(function(a, b2, c2, d2) {
          c2 !== d2 ? (a = Od(Nd.current), c2 = Od(L2.current), b2.stateNode = Na(d2, a, c2, b2), lf(b2)) : b2.stateNode = a.stateNode;
        }, "pf");
      } else
        nf = /* @__PURE__ */ __name(function() {
        }, "nf"), of = /* @__PURE__ */ __name(function() {
        }, "of"), pf = /* @__PURE__ */ __name(function() {
        }, "pf");
      function rf(a, b2) {
        if (!Wd)
          switch (a.tailMode) {
            case "hidden":
              b2 = a.tail;
              for (var c2 = null; null !== b2; )
                null !== b2.alternate && (c2 = b2), b2 = b2.sibling;
              null === c2 ? a.tail = null : c2.sibling = null;
              break;
            case "collapsed":
              c2 = a.tail;
              for (var d2 = null; null !== c2; )
                null !== c2.alternate && (d2 = c2), c2 = c2.sibling;
              null === d2 ? b2 || null === a.tail ? a.tail = null : a.tail.sibling = null : d2.sibling = null;
          }
      }
      __name(rf, "rf");
      function sf(a, b2, c2) {
        var d2 = b2.pendingProps;
        switch (b2.tag) {
          case 2:
          case 16:
          case 15:
          case 0:
          case 11:
          case 7:
          case 8:
          case 12:
          case 9:
          case 14:
            return null;
          case 1:
            return E2(b2.type) && $b(), null;
          case 3:
            Qd();
            z2(D);
            z2(B2);
            ee();
            d2 = b2.stateNode;
            d2.pendingContext && (d2.context = d2.pendingContext, d2.pendingContext = null);
            if (null === a || null === a.child)
              be2(b2) ? lf(b2) : d2.hydrate || (b2.flags |= 256);
            nf(b2);
            return null;
          case 5:
            Sd(b2);
            var e3 = Od(Nd.current);
            c2 = b2.type;
            if (null !== a && null != b2.stateNode)
              of(a, b2, c2, d2, e3), a.ref !== b2.ref && (b2.flags |= 128);
            else {
              if (!d2) {
                if (null === b2.stateNode)
                  throw Error(q2(166));
                return null;
              }
              a = Od(L2.current);
              if (be2(b2)) {
                if (!Va)
                  throw Error(q2(175));
                a = Lb(b2.stateNode, b2.type, b2.memoizedProps, e3, a, b2);
                b2.updateQueue = a;
                null !== a && lf(b2);
              } else {
                var f = Ia(c2, d2, e3, a, b2);
                mf(f, b2, false, false);
                b2.stateNode = f;
                Ka(f, c2, d2, e3, a) && lf(b2);
              }
              null !== b2.ref && (b2.flags |= 128);
            }
            return null;
          case 6:
            if (a && null != b2.stateNode)
              pf(a, b2, a.memoizedProps, d2);
            else {
              if ("string" !== typeof d2 && null === b2.stateNode)
                throw Error(q2(166));
              a = Od(Nd.current);
              e3 = Od(L2.current);
              if (be2(b2)) {
                if (!Va)
                  throw Error(q2(176));
                Mb(
                  b2.stateNode,
                  b2.memoizedProps,
                  b2
                ) && lf(b2);
              } else
                b2.stateNode = Na(d2, a, e3, b2);
            }
            return null;
          case 13:
            z2(M2);
            d2 = b2.memoizedState;
            if (0 !== (b2.flags & 64))
              return b2.lanes = c2, b2;
            d2 = null !== d2;
            e3 = false;
            null === a ? void 0 !== b2.memoizedProps.fallback && be2(b2) : e3 = null !== a.memoizedState;
            if (d2 && !e3 && 0 !== (b2.mode & 2))
              if (null === a && true !== b2.memoizedProps.unstable_avoidThisFallback || 0 !== (M2.current & 1))
                0 === T2 && (T2 = 3);
              else {
                if (0 === T2 || 3 === T2)
                  T2 = 4;
                null === R2 || 0 === (pd & 134217727) && 0 === (tf & 134217727) || uf(R2, U2);
              }
            Ua && d2 && (b2.flags |= 4);
            Ta && (d2 || e3) && (b2.flags |= 4);
            return null;
          case 4:
            return Qd(), nf(b2), null === a && ab(b2.stateNode.containerInfo), null;
          case 10:
            return dd(b2), null;
          case 17:
            return E2(b2.type) && $b(), null;
          case 19:
            z2(M2);
            d2 = b2.memoizedState;
            if (null === d2)
              return null;
            e3 = 0 !== (b2.flags & 64);
            f = d2.rendering;
            if (null === f)
              if (e3)
                rf(d2, false);
              else {
                if (0 !== T2 || null !== a && 0 !== (a.flags & 64))
                  for (a = b2.child; null !== a; ) {
                    f = Td(a);
                    if (null !== f) {
                      b2.flags |= 64;
                      rf(d2, false);
                      a = f.updateQueue;
                      null !== a && (b2.updateQueue = a, b2.flags |= 4);
                      null === d2.lastEffect && (b2.firstEffect = null);
                      b2.lastEffect = d2.lastEffect;
                      a = c2;
                      for (d2 = b2.child; null !== d2; )
                        e3 = d2, c2 = a, e3.flags &= 2, e3.nextEffect = null, e3.firstEffect = null, e3.lastEffect = null, f = e3.alternate, null === f ? (e3.childLanes = 0, e3.lanes = c2, e3.child = null, e3.memoizedProps = null, e3.memoizedState = null, e3.updateQueue = null, e3.dependencies = null, e3.stateNode = null) : (e3.childLanes = f.childLanes, e3.lanes = f.lanes, e3.child = f.child, e3.memoizedProps = f.memoizedProps, e3.memoizedState = f.memoizedState, e3.updateQueue = f.updateQueue, e3.type = f.type, c2 = f.dependencies, e3.dependencies = null === c2 ? null : { lanes: c2.lanes, firstContext: c2.firstContext }), d2 = d2.sibling;
                      A2(M2, M2.current & 1 | 2);
                      return b2.child;
                    }
                    a = a.sibling;
                  }
                null !== d2.tail && G2() > vf && (b2.flags |= 64, e3 = true, rf(d2, false), b2.lanes = 33554432);
              }
            else {
              if (!e3)
                if (a = Td(f), null !== a) {
                  if (b2.flags |= 64, e3 = true, a = a.updateQueue, null !== a && (b2.updateQueue = a, b2.flags |= 4), rf(d2, true), null === d2.tail && "hidden" === d2.tailMode && !f.alternate && !Wd)
                    return b2 = b2.lastEffect = d2.lastEffect, null !== b2 && (b2.nextEffect = null), null;
                } else
                  2 * G2() - d2.renderingStartTime > vf && 1073741824 !== c2 && (b2.flags |= 64, e3 = true, rf(d2, false), b2.lanes = 33554432);
              d2.isBackwards ? (f.sibling = b2.child, b2.child = f) : (a = d2.last, null !== a ? a.sibling = f : b2.child = f, d2.last = f);
            }
            return null !== d2.tail ? (a = d2.tail, d2.rendering = a, d2.tail = a.sibling, d2.lastEffect = b2.lastEffect, d2.renderingStartTime = G2(), a.sibling = null, b2 = M2.current, A2(M2, e3 ? b2 & 1 | 2 : b2 & 1), a) : null;
          case 23:
          case 24:
            return wf(), null !== a && null !== a.memoizedState !== (null !== b2.memoizedState) && "unstable-defer-without-hiding" !== d2.mode && (b2.flags |= 4), null;
        }
        throw Error(q2(156, b2.tag));
      }
      __name(sf, "sf");
      function xf(a) {
        switch (a.tag) {
          case 1:
            E2(a.type) && $b();
            var b2 = a.flags;
            return b2 & 4096 ? (a.flags = b2 & -4097 | 64, a) : null;
          case 3:
            Qd();
            z2(D);
            z2(B2);
            ee();
            b2 = a.flags;
            if (0 !== (b2 & 64))
              throw Error(q2(285));
            a.flags = b2 & -4097 | 64;
            return a;
          case 5:
            return Sd(a), null;
          case 13:
            return z2(M2), b2 = a.flags, b2 & 4096 ? (a.flags = b2 & -4097 | 64, a) : null;
          case 19:
            return z2(M2), null;
          case 4:
            return Qd(), null;
          case 10:
            return dd(a), null;
          case 23:
          case 24:
            return wf(), null;
          default:
            return null;
        }
      }
      __name(xf, "xf");
      function yf(a, b2) {
        try {
          var c2 = "", d2 = b2;
          do
            c2 += Wc(d2), d2 = d2.return;
          while (d2);
          var e3 = c2;
        } catch (f) {
          e3 = "\nError generating stack: " + f.message + "\n" + f.stack;
        }
        return { value: a, source: b2, stack: e3 };
      }
      __name(yf, "yf");
      function zf(a, b2) {
        try {
          console.error(b2.value);
        } catch (c2) {
          setTimeout(function() {
            throw c2;
          });
        }
      }
      __name(zf, "zf");
      var Af = "function" === typeof WeakMap ? WeakMap : Map;
      function Bf(a, b2, c2) {
        c2 = kd(-1, c2);
        c2.tag = 3;
        c2.payload = { element: null };
        var d2 = b2.value;
        c2.callback = function() {
          Cf || (Cf = true, Df = d2);
          zf(a, b2);
        };
        return c2;
      }
      __name(Bf, "Bf");
      function Ef(a, b2, c2) {
        c2 = kd(-1, c2);
        c2.tag = 3;
        var d2 = a.type.getDerivedStateFromError;
        if ("function" === typeof d2) {
          var e3 = b2.value;
          c2.payload = function() {
            zf(a, b2);
            return d2(e3);
          };
        }
        var f = a.stateNode;
        null !== f && "function" === typeof f.componentDidCatch && (c2.callback = function() {
          "function" !== typeof d2 && (null === Ff ? Ff = /* @__PURE__ */ new Set([this]) : Ff.add(this), zf(a, b2));
          var c3 = b2.stack;
          this.componentDidCatch(b2.value, { componentStack: null !== c3 ? c3 : "" });
        });
        return c2;
      }
      __name(Ef, "Ef");
      var Gf = "function" === typeof WeakSet ? WeakSet : Set;
      function Hf(a) {
        var b2 = a.ref;
        if (null !== b2)
          if ("function" === typeof b2)
            try {
              b2(null);
            } catch (c2) {
              If(a, c2);
            }
          else
            b2.current = null;
      }
      __name(Hf, "Hf");
      function Jf(a, b2) {
        switch (b2.tag) {
          case 0:
          case 11:
          case 15:
          case 22:
            return;
          case 1:
            if (b2.flags & 256 && null !== a) {
              var c2 = a.memoizedProps, d2 = a.memoizedState;
              a = b2.stateNode;
              b2 = a.getSnapshotBeforeUpdate(b2.elementType === b2.type ? c2 : Xc(b2.type, c2), d2);
              a.__reactInternalSnapshotBeforeUpdate = b2;
            }
            return;
          case 3:
            Ta && b2.flags & 256 && xb(b2.stateNode.containerInfo);
            return;
          case 5:
          case 6:
          case 4:
          case 17:
            return;
        }
        throw Error(q2(163));
      }
      __name(Jf, "Jf");
      function Kf(a, b2) {
        b2 = b2.updateQueue;
        b2 = null !== b2 ? b2.lastEffect : null;
        if (null !== b2) {
          var c2 = b2 = b2.next;
          do {
            if ((c2.tag & a) === a) {
              var d2 = c2.destroy;
              c2.destroy = void 0;
              void 0 !== d2 && d2();
            }
            c2 = c2.next;
          } while (c2 !== b2);
        }
      }
      __name(Kf, "Kf");
      function Lf(a, b2, c2) {
        switch (c2.tag) {
          case 0:
          case 11:
          case 15:
          case 22:
            b2 = c2.updateQueue;
            b2 = null !== b2 ? b2.lastEffect : null;
            if (null !== b2) {
              a = b2 = b2.next;
              do {
                if (3 === (a.tag & 3)) {
                  var d2 = a.create;
                  a.destroy = d2();
                }
                a = a.next;
              } while (a !== b2);
            }
            b2 = c2.updateQueue;
            b2 = null !== b2 ? b2.lastEffect : null;
            if (null !== b2) {
              a = b2 = b2.next;
              do {
                var e3 = a;
                d2 = e3.next;
                e3 = e3.tag;
                0 !== (e3 & 4) && 0 !== (e3 & 1) && (Mf(c2, a), Nf(c2, a));
                a = d2;
              } while (a !== b2);
            }
            return;
          case 1:
            a = c2.stateNode;
            c2.flags & 4 && (null === b2 ? a.componentDidMount() : (d2 = c2.elementType === c2.type ? b2.memoizedProps : Xc(c2.type, b2.memoizedProps), a.componentDidUpdate(
              d2,
              b2.memoizedState,
              a.__reactInternalSnapshotBeforeUpdate
            )));
            b2 = c2.updateQueue;
            null !== b2 && qd(c2, b2, a);
            return;
          case 3:
            b2 = c2.updateQueue;
            if (null !== b2) {
              a = null;
              if (null !== c2.child)
                switch (c2.child.tag) {
                  case 5:
                    a = Da(c2.child.stateNode);
                    break;
                  case 1:
                    a = c2.child.stateNode;
                }
              qd(c2, b2, a);
            }
            return;
          case 5:
            a = c2.stateNode;
            null === b2 && c2.flags & 4 && mb(a, c2.type, c2.memoizedProps, c2);
            return;
          case 6:
            return;
          case 4:
            return;
          case 12:
            return;
          case 13:
            Va && null === c2.memoizedState && (c2 = c2.alternate, null !== c2 && (c2 = c2.memoizedState, null !== c2 && (c2 = c2.dehydrated, null !== c2 && Pb(c2))));
            return;
          case 19:
          case 17:
          case 20:
          case 21:
          case 23:
          case 24:
            return;
        }
        throw Error(q2(163));
      }
      __name(Lf, "Lf");
      function Of(a, b2) {
        if (Ta)
          for (var c2 = a; ; ) {
            if (5 === c2.tag) {
              var d2 = c2.stateNode;
              b2 ? tb(d2) : vb(c2.stateNode, c2.memoizedProps);
            } else if (6 === c2.tag)
              d2 = c2.stateNode, b2 ? ub(d2) : wb(d2, c2.memoizedProps);
            else if ((23 !== c2.tag && 24 !== c2.tag || null === c2.memoizedState || c2 === a) && null !== c2.child) {
              c2.child.return = c2;
              c2 = c2.child;
              continue;
            }
            if (c2 === a)
              break;
            for (; null === c2.sibling; ) {
              if (null === c2.return || c2.return === a)
                return;
              c2 = c2.return;
            }
            c2.sibling.return = c2.return;
            c2 = c2.sibling;
          }
      }
      __name(Of, "Of");
      function Pf(a, b2) {
        if (fc && "function" === typeof fc.onCommitFiberUnmount)
          try {
            fc.onCommitFiberUnmount(ec, b2);
          } catch (f) {
          }
        switch (b2.tag) {
          case 0:
          case 11:
          case 14:
          case 15:
          case 22:
            a = b2.updateQueue;
            if (null !== a && (a = a.lastEffect, null !== a)) {
              var c2 = a = a.next;
              do {
                var d2 = c2, e3 = d2.destroy;
                d2 = d2.tag;
                if (void 0 !== e3)
                  if (0 !== (d2 & 4))
                    Mf(b2, c2);
                  else {
                    d2 = b2;
                    try {
                      e3();
                    } catch (f) {
                      If(d2, f);
                    }
                  }
                c2 = c2.next;
              } while (c2 !== a);
            }
            break;
          case 1:
            Hf(b2);
            a = b2.stateNode;
            if ("function" === typeof a.componentWillUnmount)
              try {
                a.props = b2.memoizedProps, a.state = b2.memoizedState, a.componentWillUnmount();
              } catch (f) {
                If(
                  b2,
                  f
                );
              }
            break;
          case 5:
            Hf(b2);
            break;
          case 4:
            Ta ? Qf(a, b2) : Ua && Ua && (b2 = b2.stateNode.containerInfo, a = zb(b2), Cb(b2, a));
        }
      }
      __name(Pf, "Pf");
      function Rf(a, b2) {
        for (var c2 = b2; ; )
          if (Pf(a, c2), null === c2.child || Ta && 4 === c2.tag) {
            if (c2 === b2)
              break;
            for (; null === c2.sibling; ) {
              if (null === c2.return || c2.return === b2)
                return;
              c2 = c2.return;
            }
            c2.sibling.return = c2.return;
            c2 = c2.sibling;
          } else
            c2.child.return = c2, c2 = c2.child;
      }
      __name(Rf, "Rf");
      function Sf(a) {
        a.alternate = null;
        a.child = null;
        a.dependencies = null;
        a.firstEffect = null;
        a.lastEffect = null;
        a.memoizedProps = null;
        a.memoizedState = null;
        a.pendingProps = null;
        a.return = null;
        a.updateQueue = null;
      }
      __name(Sf, "Sf");
      function Tf(a) {
        return 5 === a.tag || 3 === a.tag || 4 === a.tag;
      }
      __name(Tf, "Tf");
      function Uf(a) {
        if (Ta) {
          a: {
            for (var b2 = a.return; null !== b2; ) {
              if (Tf(b2))
                break a;
              b2 = b2.return;
            }
            throw Error(q2(160));
          }
          var c2 = b2;
          b2 = c2.stateNode;
          switch (c2.tag) {
            case 5:
              var d2 = false;
              break;
            case 3:
              b2 = b2.containerInfo;
              d2 = true;
              break;
            case 4:
              b2 = b2.containerInfo;
              d2 = true;
              break;
            default:
              throw Error(q2(161));
          }
          c2.flags & 16 && (sb(b2), c2.flags &= -17);
          a:
            b:
              for (c2 = a; ; ) {
                for (; null === c2.sibling; ) {
                  if (null === c2.return || Tf(c2.return)) {
                    c2 = null;
                    break a;
                  }
                  c2 = c2.return;
                }
                c2.sibling.return = c2.return;
                for (c2 = c2.sibling; 5 !== c2.tag && 6 !== c2.tag && 18 !== c2.tag; ) {
                  if (c2.flags & 2)
                    continue b;
                  if (null === c2.child || 4 === c2.tag)
                    continue b;
                  else
                    c2.child.return = c2, c2 = c2.child;
                }
                if (!(c2.flags & 2)) {
                  c2 = c2.stateNode;
                  break a;
                }
              }
          d2 ? Vf(a, c2, b2) : Wf(a, c2, b2);
        }
      }
      __name(Uf, "Uf");
      function Vf(a, b2, c2) {
        var d2 = a.tag, e3 = 5 === d2 || 6 === d2;
        if (e3)
          a = e3 ? a.stateNode : a.stateNode.instance, b2 ? pb(c2, a, b2) : kb(c2, a);
        else if (4 !== d2 && (a = a.child, null !== a))
          for (Vf(a, b2, c2), a = a.sibling; null !== a; )
            Vf(a, b2, c2), a = a.sibling;
      }
      __name(Vf, "Vf");
      function Wf(a, b2, c2) {
        var d2 = a.tag, e3 = 5 === d2 || 6 === d2;
        if (e3)
          a = e3 ? a.stateNode : a.stateNode.instance, b2 ? ob(c2, a, b2) : jb(c2, a);
        else if (4 !== d2 && (a = a.child, null !== a))
          for (Wf(a, b2, c2), a = a.sibling; null !== a; )
            Wf(a, b2, c2), a = a.sibling;
      }
      __name(Wf, "Wf");
      function Qf(a, b2) {
        for (var c2 = b2, d2 = false, e3, f; ; ) {
          if (!d2) {
            d2 = c2.return;
            a:
              for (; ; ) {
                if (null === d2)
                  throw Error(q2(160));
                e3 = d2.stateNode;
                switch (d2.tag) {
                  case 5:
                    f = false;
                    break a;
                  case 3:
                    e3 = e3.containerInfo;
                    f = true;
                    break a;
                  case 4:
                    e3 = e3.containerInfo;
                    f = true;
                    break a;
                }
                d2 = d2.return;
              }
            d2 = true;
          }
          if (5 === c2.tag || 6 === c2.tag)
            Rf(a, c2), f ? rb(e3, c2.stateNode) : qb(e3, c2.stateNode);
          else if (4 === c2.tag) {
            if (null !== c2.child) {
              e3 = c2.stateNode.containerInfo;
              f = true;
              c2.child.return = c2;
              c2 = c2.child;
              continue;
            }
          } else if (Pf(a, c2), null !== c2.child) {
            c2.child.return = c2;
            c2 = c2.child;
            continue;
          }
          if (c2 === b2)
            break;
          for (; null === c2.sibling; ) {
            if (null === c2.return || c2.return === b2)
              return;
            c2 = c2.return;
            4 === c2.tag && (d2 = false);
          }
          c2.sibling.return = c2.return;
          c2 = c2.sibling;
        }
      }
      __name(Qf, "Qf");
      function Xf(a, b2) {
        if (Ta) {
          switch (b2.tag) {
            case 0:
            case 11:
            case 14:
            case 15:
            case 22:
              Kf(3, b2);
              return;
            case 1:
              return;
            case 5:
              var c2 = b2.stateNode;
              if (null != c2) {
                var d2 = b2.memoizedProps;
                a = null !== a ? a.memoizedProps : d2;
                var e3 = b2.type, f = b2.updateQueue;
                b2.updateQueue = null;
                null !== f && nb(c2, f, e3, a, d2, b2);
              }
              return;
            case 6:
              if (null === b2.stateNode)
                throw Error(q2(162));
              c2 = b2.memoizedProps;
              lb(b2.stateNode, null !== a ? a.memoizedProps : c2, c2);
              return;
            case 3:
              Va && (b2 = b2.stateNode, b2.hydrate && (b2.hydrate = false, Ob(b2.containerInfo)));
              return;
            case 12:
              return;
            case 13:
              Yf(b2);
              Zf(b2);
              return;
            case 19:
              Zf(b2);
              return;
            case 17:
              return;
            case 23:
            case 24:
              Of(b2, null !== b2.memoizedState);
              return;
          }
          throw Error(q2(163));
        }
        switch (b2.tag) {
          case 0:
          case 11:
          case 14:
          case 15:
          case 22:
            Kf(3, b2);
            return;
          case 12:
            return;
          case 13:
            Yf(b2);
            Zf(b2);
            return;
          case 19:
            Zf(b2);
            return;
          case 3:
            Va && (c2 = b2.stateNode, c2.hydrate && (c2.hydrate = false, Ob(c2.containerInfo)));
            break;
          case 23:
          case 24:
            return;
        }
        a:
          if (Ua) {
            switch (b2.tag) {
              case 1:
              case 5:
              case 6:
              case 20:
                break a;
              case 3:
              case 4:
                b2 = b2.stateNode;
                Cb(b2.containerInfo, b2.pendingChildren);
                break a;
            }
            throw Error(q2(163));
          }
      }
      __name(Xf, "Xf");
      function Yf(a) {
        null !== a.memoizedState && ($f = G2(), Ta && Of(a.child, true));
      }
      __name(Yf, "Yf");
      function Zf(a) {
        var b2 = a.updateQueue;
        if (null !== b2) {
          a.updateQueue = null;
          var c2 = a.stateNode;
          null === c2 && (c2 = a.stateNode = new Gf());
          b2.forEach(function(b3) {
            var d2 = ag.bind(null, a, b3);
            c2.has(b3) || (c2.add(b3), b3.then(d2, d2));
          });
        }
      }
      __name(Zf, "Zf");
      function bg(a, b2) {
        return null !== a && (a = a.memoizedState, null === a || null !== a.dehydrated) ? (b2 = b2.memoizedState, null !== b2 && null === b2.dehydrated) : false;
      }
      __name(bg, "bg");
      var cg = 0, dg = 1, eg = 2, fg = 3, gg = 4;
      if ("function" === typeof Symbol && Symbol.for) {
        var hg = Symbol.for;
        cg = hg("selector.component");
        dg = hg("selector.has_pseudo_class");
        eg = hg("selector.role");
        fg = hg("selector.test_id");
        gg = hg("selector.text");
      }
      function ig(a) {
        var b2 = Wa(a);
        if (null != b2) {
          if ("string" !== typeof b2.memoizedProps["data-testname"])
            throw Error(q2(364));
          return b2;
        }
        a = cb(a);
        if (null === a)
          throw Error(q2(362));
        return a.stateNode.current;
      }
      __name(ig, "ig");
      function jg(a, b2) {
        switch (b2.$$typeof) {
          case cg:
            if (a.type === b2.value)
              return true;
            break;
          case dg:
            a: {
              b2 = b2.value;
              a = [a, 0];
              for (var c2 = 0; c2 < a.length; ) {
                var d2 = a[c2++], e3 = a[c2++], f = b2[e3];
                if (5 !== d2.tag || !fb(d2)) {
                  for (; null != f && jg(d2, f); )
                    e3++, f = b2[e3];
                  if (e3 === b2.length) {
                    b2 = true;
                    break a;
                  } else
                    for (d2 = d2.child; null !== d2; )
                      a.push(d2, e3), d2 = d2.sibling;
                }
              }
              b2 = false;
            }
            return b2;
          case eg:
            if (5 === a.tag && gb(a.stateNode, b2.value))
              return true;
            break;
          case gg:
            if (5 === a.tag || 6 === a.tag) {
              if (a = eb(a), null !== a && 0 <= a.indexOf(b2.value))
                return true;
            }
            break;
          case fg:
            if (5 === a.tag && (a = a.memoizedProps["data-testname"], "string" === typeof a && a.toLowerCase() === b2.value.toLowerCase()))
              return true;
            break;
          default:
            throw Error(q2(365, b2));
        }
        return false;
      }
      __name(jg, "jg");
      function kg(a) {
        switch (a.$$typeof) {
          case cg:
            return "<" + (wa(a.value) || "Unknown") + ">";
          case dg:
            return ":has(" + (kg(a) || "") + ")";
          case eg:
            return '[role="' + a.value + '"]';
          case gg:
            return '"' + a.value + '"';
          case fg:
            return '[data-testname="' + a.value + '"]';
          default:
            throw Error(q2(365, a));
        }
      }
      __name(kg, "kg");
      function lg(a, b2) {
        var c2 = [];
        a = [a, 0];
        for (var d2 = 0; d2 < a.length; ) {
          var e3 = a[d2++], f = a[d2++], g2 = b2[f];
          if (5 !== e3.tag || !fb(e3)) {
            for (; null != g2 && jg(e3, g2); )
              f++, g2 = b2[f];
            if (f === b2.length)
              c2.push(e3);
            else
              for (e3 = e3.child; null !== e3; )
                a.push(e3, f), e3 = e3.sibling;
          }
        }
        return c2;
      }
      __name(lg, "lg");
      function mg(a, b2) {
        if (!bb)
          throw Error(q2(363));
        a = ig(a);
        a = lg(a, b2);
        b2 = [];
        a = Array.from(a);
        for (var c2 = 0; c2 < a.length; ) {
          var d2 = a[c2++];
          if (5 === d2.tag)
            fb(d2) || b2.push(d2.stateNode);
          else
            for (d2 = d2.child; null !== d2; )
              a.push(d2), d2 = d2.sibling;
        }
        return b2;
      }
      __name(mg, "mg");
      var ng = null;
      function og(a) {
        if (null === ng)
          try {
            var b2 = ("require" + Math.random()).slice(0, 7);
            ng = (module3 && module3[b2]).call(module3, "timers").setImmediate;
          } catch (c2) {
            ng = /* @__PURE__ */ __name(function(a2) {
              var b3 = new MessageChannel();
              b3.port1.onmessage = a2;
              b3.port2.postMessage(void 0);
            }, "ng");
          }
        return ng(a);
      }
      __name(og, "og");
      var pg = Math.ceil, qg = ca.ReactCurrentDispatcher, rg = ca.ReactCurrentOwner, sg = ca.IsSomeRendererActing, V2 = 0, R2 = null, W2 = null, U2 = 0, tg = 0, ug = Wb(0), T2 = 0, vg = null, wg = 0, pd = 0, tf = 0, xg = 0, yg = null, $f = 0, vf = Infinity;
      function zg() {
        vf = G2() + 500;
      }
      __name(zg, "zg");
      var X2 = null, Cf = false, Df = null, Ff = null, Ag = false, Bg = null, Cg = 90, Dg = [], Eg = [], Fg = null, Gg = 0, Hg = null, Ig = -1, Jg = 0, Kg = 0, Lg = null, Mg = false;
      function K2() {
        return 0 !== (V2 & 48) ? G2() : -1 !== Ig ? Ig : Ig = G2();
      }
      __name(K2, "K");
      function td(a) {
        a = a.mode;
        if (0 === (a & 2))
          return 1;
        if (0 === (a & 4))
          return 99 === Nc() ? 1 : 2;
        0 === Jg && (Jg = wg);
        if (0 !== Sc.transition) {
          0 !== Kg && (Kg = null !== yg ? yg.pendingLanes : 0);
          a = Jg;
          var b2 = 4186112 & ~Kg;
          b2 &= -b2;
          0 === b2 && (a = 4186112 & ~a, b2 = a & -a, 0 === b2 && (b2 = 8192));
          return b2;
        }
        a = Nc();
        0 !== (V2 & 4) && 98 === a ? a = oc(12, Jg) : (a = jc(a), a = oc(a, Jg));
        return a;
      }
      __name(td, "td");
      function ud(a, b2, c2) {
        if (50 < Gg)
          throw Gg = 0, Hg = null, Error(q2(185));
        a = Ng(a, b2);
        if (null === a)
          return null;
        rc(a, b2, c2);
        a === R2 && (tf |= b2, 4 === T2 && uf(a, U2));
        var d2 = Nc();
        1 === b2 ? 0 !== (V2 & 8) && 0 === (V2 & 48) ? Og(a) : (Z2(a, c2), 0 === V2 && (zg(), H2())) : (0 === (V2 & 4) || 98 !== d2 && 99 !== d2 || (null === Fg ? Fg = /* @__PURE__ */ new Set([a]) : Fg.add(a)), Z2(a, c2));
        yg = a;
      }
      __name(ud, "ud");
      function Ng(a, b2) {
        a.lanes |= b2;
        var c2 = a.alternate;
        null !== c2 && (c2.lanes |= b2);
        c2 = a;
        for (a = a.return; null !== a; )
          a.childLanes |= b2, c2 = a.alternate, null !== c2 && (c2.childLanes |= b2), c2 = a, a = a.return;
        return 3 === c2.tag ? c2.stateNode : null;
      }
      __name(Ng, "Ng");
      function Z2(a, b2) {
        for (var c2 = a.callbackNode, d2 = a.suspendedLanes, e3 = a.pingedLanes, f = a.expirationTimes, g2 = a.pendingLanes; 0 < g2; ) {
          var h2 = 31 - mc(g2), k2 = 1 << h2, l2 = f[h2];
          if (-1 === l2) {
            if (0 === (k2 & d2) || 0 !== (k2 & e3)) {
              l2 = b2;
              ic(k2);
              var n2 = F;
              f[h2] = 10 <= n2 ? l2 + 250 : 6 <= n2 ? l2 + 5e3 : -1;
            }
          } else
            l2 <= b2 && (a.expiredLanes |= k2);
          g2 &= ~k2;
        }
        d2 = lc(a, a === R2 ? U2 : 0);
        b2 = F;
        if (0 === d2)
          null !== c2 && (c2 !== Hc && xc(c2), a.callbackNode = null, a.callbackPriority = 0);
        else {
          if (null !== c2) {
            if (a.callbackPriority === b2)
              return;
            c2 !== Hc && xc(c2);
          }
          15 === b2 ? (c2 = Og.bind(null, a), null === Jc ? (Jc = [c2], Kc = wc(Cc, Rc)) : Jc.push(c2), c2 = Hc) : 14 === b2 ? c2 = Qc(99, Og.bind(null, a)) : (c2 = kc(b2), c2 = Qc(c2, Pg.bind(null, a)));
          a.callbackPriority = b2;
          a.callbackNode = c2;
        }
      }
      __name(Z2, "Z");
      function Pg(a) {
        Ig = -1;
        Kg = Jg = 0;
        if (0 !== (V2 & 48))
          throw Error(q2(327));
        var b2 = a.callbackNode;
        if (Qg() && a.callbackNode !== b2)
          return null;
        var c2 = lc(a, a === R2 ? U2 : 0);
        if (0 === c2)
          return null;
        var d2 = c2;
        var e3 = V2;
        V2 |= 16;
        var f = Rg();
        if (R2 !== a || U2 !== d2)
          zg(), Sg(a, d2);
        do
          try {
            Tg();
            break;
          } catch (h2) {
            Ug(a, h2);
          }
        while (1);
        bd();
        qg.current = f;
        V2 = e3;
        null !== W2 ? d2 = 0 : (R2 = null, U2 = 0, d2 = T2);
        if (0 !== (wg & tf))
          Sg(a, 0);
        else if (0 !== d2) {
          2 === d2 && (V2 |= 64, a.hydrate && (a.hydrate = false, xb(a.containerInfo)), c2 = nc(a), 0 !== c2 && (d2 = Vg(a, c2)));
          if (1 === d2)
            throw b2 = vg, Sg(a, 0), uf(a, c2), Z2(a, G2()), b2;
          a.finishedWork = a.current.alternate;
          a.finishedLanes = c2;
          switch (d2) {
            case 0:
            case 1:
              throw Error(q2(345));
            case 2:
              Zg(a);
              break;
            case 3:
              uf(a, c2);
              if ((c2 & 62914560) === c2 && (d2 = $f + 500 - G2(), 10 < d2)) {
                if (0 !== lc(a, 0))
                  break;
                e3 = a.suspendedLanes;
                if ((e3 & c2) !== c2) {
                  K2();
                  a.pingedLanes |= a.suspendedLanes & e3;
                  break;
                }
                a.timeoutHandle = Pa(Zg.bind(null, a), d2);
                break;
              }
              Zg(a);
              break;
            case 4:
              uf(a, c2);
              if ((c2 & 4186112) === c2)
                break;
              d2 = a.eventTimes;
              for (e3 = -1; 0 < c2; ) {
                var g2 = 31 - mc(c2);
                f = 1 << g2;
                g2 = d2[g2];
                g2 > e3 && (e3 = g2);
                c2 &= ~f;
              }
              c2 = e3;
              c2 = G2() - c2;
              c2 = (120 > c2 ? 120 : 480 > c2 ? 480 : 1080 > c2 ? 1080 : 1920 > c2 ? 1920 : 3e3 > c2 ? 3e3 : 4320 > c2 ? 4320 : 1960 * pg(c2 / 1960)) - c2;
              if (10 < c2) {
                a.timeoutHandle = Pa(Zg.bind(null, a), c2);
                break;
              }
              Zg(a);
              break;
            case 5:
              Zg(a);
              break;
            default:
              throw Error(q2(329));
          }
        }
        Z2(a, G2());
        return a.callbackNode === b2 ? Pg.bind(null, a) : null;
      }
      __name(Pg, "Pg");
      function uf(a, b2) {
        b2 &= ~xg;
        b2 &= ~tf;
        a.suspendedLanes |= b2;
        a.pingedLanes &= ~b2;
        for (a = a.expirationTimes; 0 < b2; ) {
          var c2 = 31 - mc(b2), d2 = 1 << c2;
          a[c2] = -1;
          b2 &= ~d2;
        }
      }
      __name(uf, "uf");
      function Og(a) {
        if (0 !== (V2 & 48))
          throw Error(q2(327));
        Qg();
        if (a === R2 && 0 !== (a.expiredLanes & U2)) {
          var b2 = U2;
          var c2 = Vg(a, b2);
          0 !== (wg & tf) && (b2 = lc(a, b2), c2 = Vg(a, b2));
        } else
          b2 = lc(a, 0), c2 = Vg(a, b2);
        0 !== a.tag && 2 === c2 && (V2 |= 64, a.hydrate && (a.hydrate = false, xb(a.containerInfo)), b2 = nc(a), 0 !== b2 && (c2 = Vg(a, b2)));
        if (1 === c2)
          throw c2 = vg, Sg(a, 0), uf(a, b2), Z2(a, G2()), c2;
        a.finishedWork = a.current.alternate;
        a.finishedLanes = b2;
        Zg(a);
        Z2(a, G2());
        return null;
      }
      __name(Og, "Og");
      function $g() {
        if (null !== Fg) {
          var a = Fg;
          Fg = null;
          a.forEach(function(a2) {
            a2.expiredLanes |= 24 & a2.pendingLanes;
            Z2(a2, G2());
          });
        }
        H2();
      }
      __name($g, "$g");
      function ah(a, b2) {
        var c2 = V2;
        V2 |= 1;
        try {
          return a(b2);
        } finally {
          V2 = c2, 0 === V2 && (zg(), H2());
        }
      }
      __name(ah, "ah");
      function bh(a, b2) {
        var c2 = V2;
        if (0 !== (c2 & 48))
          return a(b2);
        V2 |= 1;
        try {
          if (a)
            return Pc(99, a.bind(null, b2));
        } finally {
          V2 = c2, H2();
        }
      }
      __name(bh, "bh");
      function Xe(a, b2) {
        A2(ug, tg);
        tg |= b2;
        wg |= b2;
      }
      __name(Xe, "Xe");
      function wf() {
        tg = ug.current;
        z2(ug);
      }
      __name(wf, "wf");
      function Sg(a, b2) {
        a.finishedWork = null;
        a.finishedLanes = 0;
        var c2 = a.timeoutHandle;
        c2 !== Ra && (a.timeoutHandle = Ra, Qa(c2));
        if (null !== W2)
          for (c2 = W2.return; null !== c2; ) {
            var d2 = c2;
            switch (d2.tag) {
              case 1:
                d2 = d2.type.childContextTypes;
                null !== d2 && void 0 !== d2 && $b();
                break;
              case 3:
                Qd();
                z2(D);
                z2(B2);
                ee();
                break;
              case 5:
                Sd(d2);
                break;
              case 4:
                Qd();
                break;
              case 13:
                z2(M2);
                break;
              case 19:
                z2(M2);
                break;
              case 10:
                dd(d2);
                break;
              case 23:
              case 24:
                wf();
            }
            c2 = c2.return;
          }
        R2 = a;
        W2 = Ed(a.current, null);
        U2 = tg = wg = b2;
        T2 = 0;
        vg = null;
        xg = tf = pd = 0;
      }
      __name(Sg, "Sg");
      function Ug(a, b2) {
        do {
          var c2 = W2;
          try {
            bd();
            fe.current = pe;
            if (ie) {
              for (var d2 = N2.memoizedState; null !== d2; ) {
                var e3 = d2.queue;
                null !== e3 && (e3.pending = null);
                d2 = d2.next;
              }
              ie = false;
            }
            he2 = 0;
            P2 = O2 = N2 = null;
            je = false;
            rg.current = null;
            if (null === c2 || null === c2.return) {
              T2 = 1;
              vg = b2;
              W2 = null;
              break;
            }
            a: {
              var f = a, g2 = c2.return, h2 = c2, k2 = b2;
              b2 = U2;
              h2.flags |= 2048;
              h2.firstEffect = h2.lastEffect = null;
              if (null !== k2 && "object" === typeof k2 && "function" === typeof k2.then) {
                var l2 = k2;
                if (0 === (h2.mode & 2)) {
                  var n2 = h2.alternate;
                  n2 ? (h2.updateQueue = n2.updateQueue, h2.memoizedState = n2.memoizedState, h2.lanes = n2.lanes) : (h2.updateQueue = null, h2.memoizedState = null);
                }
                var t3 = 0 !== (M2.current & 1), p2 = g2;
                do {
                  var y2;
                  if (y2 = 13 === p2.tag) {
                    var x2 = p2.memoizedState;
                    if (null !== x2)
                      y2 = null !== x2.dehydrated ? true : false;
                    else {
                      var Y2 = p2.memoizedProps;
                      y2 = void 0 === Y2.fallback ? false : true !== Y2.unstable_avoidThisFallback ? true : t3 ? false : true;
                    }
                  }
                  if (y2) {
                    var u = p2.updateQueue;
                    if (null === u) {
                      var v2 = /* @__PURE__ */ new Set();
                      v2.add(l2);
                      p2.updateQueue = v2;
                    } else
                      u.add(l2);
                    if (0 === (p2.mode & 2)) {
                      p2.flags |= 64;
                      h2.flags |= 16384;
                      h2.flags &= -2981;
                      if (1 === h2.tag)
                        if (null === h2.alternate)
                          h2.tag = 17;
                        else {
                          var C2 = kd(-1, 1);
                          C2.tag = 2;
                          md(h2, C2);
                        }
                      h2.lanes |= 1;
                      break a;
                    }
                    k2 = void 0;
                    h2 = b2;
                    var Oa = f.pingCache;
                    null === Oa ? (Oa = f.pingCache = new Af(), k2 = /* @__PURE__ */ new Set(), Oa.set(l2, k2)) : (k2 = Oa.get(l2), void 0 === k2 && (k2 = /* @__PURE__ */ new Set(), Oa.set(l2, k2)));
                    if (!k2.has(h2)) {
                      k2.add(h2);
                      var Qe = ch.bind(null, f, l2, h2);
                      l2.then(Qe, Qe);
                    }
                    p2.flags |= 4096;
                    p2.lanes = b2;
                    break a;
                  }
                  p2 = p2.return;
                } while (null !== p2);
                k2 = Error((wa(h2.type) || "A React component") + " suspended while rendering, but no fallback UI was specified.\n\nAdd a <Suspense fallback=...> component higher in the tree to provide a loading indicator or placeholder to display.");
              }
              5 !== T2 && (T2 = 2);
              k2 = yf(k2, h2);
              p2 = g2;
              do {
                switch (p2.tag) {
                  case 3:
                    f = k2;
                    p2.flags |= 4096;
                    b2 &= -b2;
                    p2.lanes |= b2;
                    var Wg = Bf(p2, f, b2);
                    nd(p2, Wg);
                    break a;
                  case 1:
                    f = k2;
                    var Xg = p2.type, ld = p2.stateNode;
                    if (0 === (p2.flags & 64) && ("function" === typeof Xg.getDerivedStateFromError || null !== ld && "function" === typeof ld.componentDidCatch && (null === Ff || !Ff.has(ld)))) {
                      p2.flags |= 4096;
                      b2 &= -b2;
                      p2.lanes |= b2;
                      var Yg = Ef(p2, f, b2);
                      nd(p2, Yg);
                      break a;
                    }
                }
                p2 = p2.return;
              } while (null !== p2);
            }
            dh(c2);
          } catch (w2) {
            b2 = w2;
            W2 === c2 && null !== c2 && (W2 = c2 = c2.return);
            continue;
          }
          break;
        } while (1);
      }
      __name(Ug, "Ug");
      function Rg() {
        var a = qg.current;
        qg.current = pe;
        return null === a ? pe : a;
      }
      __name(Rg, "Rg");
      function Vg(a, b2) {
        var c2 = V2;
        V2 |= 16;
        var d2 = Rg();
        R2 === a && U2 === b2 || Sg(a, b2);
        do
          try {
            eh();
            break;
          } catch (e3) {
            Ug(a, e3);
          }
        while (1);
        bd();
        V2 = c2;
        qg.current = d2;
        if (null !== W2)
          throw Error(q2(261));
        R2 = null;
        U2 = 0;
        return T2;
      }
      __name(Vg, "Vg");
      function eh() {
        for (; null !== W2; )
          fh(W2);
      }
      __name(eh, "eh");
      function Tg() {
        for (; null !== W2 && !yc(); )
          fh(W2);
      }
      __name(Tg, "Tg");
      function fh(a) {
        var b2 = gh(a.alternate, a, tg);
        a.memoizedProps = a.pendingProps;
        null === b2 ? dh(a) : W2 = b2;
        rg.current = null;
      }
      __name(fh, "fh");
      function dh(a) {
        var b2 = a;
        do {
          var c2 = b2.alternate;
          a = b2.return;
          if (0 === (b2.flags & 2048)) {
            c2 = sf(c2, b2, tg);
            if (null !== c2) {
              W2 = c2;
              return;
            }
            c2 = b2;
            if (24 !== c2.tag && 23 !== c2.tag || null === c2.memoizedState || 0 !== (tg & 1073741824) || 0 === (c2.mode & 4)) {
              for (var d2 = 0, e3 = c2.child; null !== e3; )
                d2 |= e3.lanes | e3.childLanes, e3 = e3.sibling;
              c2.childLanes = d2;
            }
            null !== a && 0 === (a.flags & 2048) && (null === a.firstEffect && (a.firstEffect = b2.firstEffect), null !== b2.lastEffect && (null !== a.lastEffect && (a.lastEffect.nextEffect = b2.firstEffect), a.lastEffect = b2.lastEffect), 1 < b2.flags && (null !== a.lastEffect ? a.lastEffect.nextEffect = b2 : a.firstEffect = b2, a.lastEffect = b2));
          } else {
            c2 = xf(b2);
            if (null !== c2) {
              c2.flags &= 2047;
              W2 = c2;
              return;
            }
            null !== a && (a.firstEffect = a.lastEffect = null, a.flags |= 2048);
          }
          b2 = b2.sibling;
          if (null !== b2) {
            W2 = b2;
            return;
          }
          W2 = b2 = a;
        } while (null !== b2);
        0 === T2 && (T2 = 5);
      }
      __name(dh, "dh");
      function Zg(a) {
        var b2 = Nc();
        Pc(99, hh.bind(null, a, b2));
        return null;
      }
      __name(Zg, "Zg");
      function hh(a, b2) {
        do
          Qg();
        while (null !== Bg);
        if (0 !== (V2 & 48))
          throw Error(q2(327));
        var c2 = a.finishedWork;
        if (null === c2)
          return null;
        a.finishedWork = null;
        a.finishedLanes = 0;
        if (c2 === a.current)
          throw Error(q2(177));
        a.callbackNode = null;
        var d2 = c2.lanes | c2.childLanes, e3 = d2, f = a.pendingLanes & ~e3;
        a.pendingLanes = e3;
        a.suspendedLanes = 0;
        a.pingedLanes = 0;
        a.expiredLanes &= e3;
        a.mutableReadLanes &= e3;
        a.entangledLanes &= e3;
        e3 = a.entanglements;
        for (var g2 = a.eventTimes, h2 = a.expirationTimes; 0 < f; ) {
          var k2 = 31 - mc(f), l2 = 1 << k2;
          e3[k2] = 0;
          g2[k2] = -1;
          h2[k2] = -1;
          f &= ~l2;
        }
        null !== Fg && 0 === (d2 & 24) && Fg.has(a) && Fg.delete(a);
        a === R2 && (W2 = R2 = null, U2 = 0);
        1 < c2.flags ? null !== c2.lastEffect ? (c2.lastEffect.nextEffect = c2, d2 = c2.firstEffect) : d2 = c2 : d2 = c2.firstEffect;
        if (null !== d2) {
          e3 = V2;
          V2 |= 32;
          rg.current = null;
          Lg = Ga(a.containerInfo);
          Mg = false;
          X2 = d2;
          do
            try {
              ih();
            } catch (v2) {
              if (null === X2)
                throw Error(q2(330));
              If(X2, v2);
              X2 = X2.nextEffect;
            }
          while (null !== X2);
          Lg = null;
          X2 = d2;
          do
            try {
              for (g2 = a; null !== X2; ) {
                var n2 = X2.flags;
                n2 & 16 && Ta && sb(X2.stateNode);
                if (n2 & 128) {
                  var t3 = X2.alternate;
                  if (null !== t3) {
                    var p2 = t3.ref;
                    null !== p2 && ("function" === typeof p2 ? p2(null) : p2.current = null);
                  }
                }
                switch (n2 & 1038) {
                  case 2:
                    Uf(X2);
                    X2.flags &= -3;
                    break;
                  case 6:
                    Uf(X2);
                    X2.flags &= -3;
                    Xf(X2.alternate, X2);
                    break;
                  case 1024:
                    X2.flags &= -1025;
                    break;
                  case 1028:
                    X2.flags &= -1025;
                    Xf(X2.alternate, X2);
                    break;
                  case 4:
                    Xf(X2.alternate, X2);
                    break;
                  case 8:
                    h2 = g2;
                    f = X2;
                    Ta ? Qf(h2, f) : Rf(h2, f);
                    var y2 = f.alternate;
                    Sf(f);
                    null !== y2 && Sf(y2);
                }
                X2 = X2.nextEffect;
              }
            } catch (v2) {
              if (null === X2)
                throw Error(q2(330));
              If(X2, v2);
              X2 = X2.nextEffect;
            }
          while (null !== X2);
          Mg && $a();
          Ha(a.containerInfo);
          a.current = c2;
          X2 = d2;
          do
            try {
              for (n2 = a; null !== X2; ) {
                var x2 = X2.flags;
                x2 & 36 && Lf(n2, X2.alternate, X2);
                if (x2 & 128) {
                  t3 = void 0;
                  var Y2 = X2.ref;
                  if (null !== Y2) {
                    var u = X2.stateNode;
                    switch (X2.tag) {
                      case 5:
                        t3 = Da(u);
                        break;
                      default:
                        t3 = u;
                    }
                    "function" === typeof Y2 ? Y2(t3) : Y2.current = t3;
                  }
                }
                X2 = X2.nextEffect;
              }
            } catch (v2) {
              if (null === X2)
                throw Error(q2(330));
              If(X2, v2);
              X2 = X2.nextEffect;
            }
          while (null !== X2);
          X2 = null;
          Ic();
          V2 = e3;
        } else
          a.current = c2;
        if (Ag)
          Ag = false, Bg = a, Cg = b2;
        else
          for (X2 = d2; null !== X2; )
            b2 = X2.nextEffect, X2.nextEffect = null, X2.flags & 8 && (x2 = X2, x2.sibling = null, x2.stateNode = null), X2 = b2;
        d2 = a.pendingLanes;
        0 === d2 && (Ff = null);
        1 === d2 ? a === Hg ? Gg++ : (Gg = 0, Hg = a) : Gg = 0;
        c2 = c2.stateNode;
        if (fc && "function" === typeof fc.onCommitFiberRoot)
          try {
            fc.onCommitFiberRoot(
              ec,
              c2,
              void 0,
              64 === (c2.current.flags & 64)
            );
          } catch (v2) {
          }
        Z2(a, G2());
        if (Cf)
          throw Cf = false, a = Df, Df = null, a;
        if (0 !== (V2 & 8))
          return null;
        H2();
        return null;
      }
      __name(hh, "hh");
      function ih() {
        for (; null !== X2; ) {
          var a = X2.alternate;
          Mg || null === Lg || (0 !== (X2.flags & 8) ? Ca(X2, Lg) && (Mg = true, Za()) : 13 === X2.tag && bg(a, X2) && Ca(X2, Lg) && (Mg = true, Za()));
          var b2 = X2.flags;
          0 !== (b2 & 256) && Jf(a, X2);
          0 === (b2 & 512) || Ag || (Ag = true, Qc(97, function() {
            Qg();
            return null;
          }));
          X2 = X2.nextEffect;
        }
      }
      __name(ih, "ih");
      function Qg() {
        if (90 !== Cg) {
          var a = 97 < Cg ? 97 : Cg;
          Cg = 90;
          return Pc(a, jh);
        }
        return false;
      }
      __name(Qg, "Qg");
      function Nf(a, b2) {
        Dg.push(b2, a);
        Ag || (Ag = true, Qc(97, function() {
          Qg();
          return null;
        }));
      }
      __name(Nf, "Nf");
      function Mf(a, b2) {
        Eg.push(b2, a);
        Ag || (Ag = true, Qc(97, function() {
          Qg();
          return null;
        }));
      }
      __name(Mf, "Mf");
      function jh() {
        if (null === Bg)
          return false;
        var a = Bg;
        Bg = null;
        if (0 !== (V2 & 48))
          throw Error(q2(331));
        var b2 = V2;
        V2 |= 32;
        var c2 = Eg;
        Eg = [];
        for (var d2 = 0; d2 < c2.length; d2 += 2) {
          var e3 = c2[d2], f = c2[d2 + 1], g2 = e3.destroy;
          e3.destroy = void 0;
          if ("function" === typeof g2)
            try {
              g2();
            } catch (k2) {
              if (null === f)
                throw Error(q2(330));
              If(f, k2);
            }
        }
        c2 = Dg;
        Dg = [];
        for (d2 = 0; d2 < c2.length; d2 += 2) {
          e3 = c2[d2];
          f = c2[d2 + 1];
          try {
            var h2 = e3.create;
            e3.destroy = h2();
          } catch (k2) {
            if (null === f)
              throw Error(q2(330));
            If(f, k2);
          }
        }
        for (h2 = a.current.firstEffect; null !== h2; )
          a = h2.nextEffect, h2.nextEffect = null, h2.flags & 8 && (h2.sibling = null, h2.stateNode = null), h2 = a;
        V2 = b2;
        H2();
        return true;
      }
      __name(jh, "jh");
      function kh(a, b2, c2) {
        b2 = yf(c2, b2);
        b2 = Bf(a, b2, 1);
        md(a, b2);
        b2 = K2();
        a = Ng(a, 1);
        null !== a && (rc(a, 1, b2), Z2(a, b2));
      }
      __name(kh, "kh");
      function If(a, b2) {
        if (3 === a.tag)
          kh(a, a, b2);
        else
          for (var c2 = a.return; null !== c2; ) {
            if (3 === c2.tag) {
              kh(c2, a, b2);
              break;
            } else if (1 === c2.tag) {
              var d2 = c2.stateNode;
              if ("function" === typeof c2.type.getDerivedStateFromError || "function" === typeof d2.componentDidCatch && (null === Ff || !Ff.has(d2))) {
                a = yf(b2, a);
                var e3 = Ef(c2, a, 1);
                md(c2, e3);
                e3 = K2();
                c2 = Ng(c2, 1);
                if (null !== c2)
                  rc(c2, 1, e3), Z2(c2, e3);
                else if ("function" === typeof d2.componentDidCatch && (null === Ff || !Ff.has(d2)))
                  try {
                    d2.componentDidCatch(b2, a);
                  } catch (f) {
                  }
                break;
              }
            }
            c2 = c2.return;
          }
      }
      __name(If, "If");
      function ch(a, b2, c2) {
        var d2 = a.pingCache;
        null !== d2 && d2.delete(b2);
        b2 = K2();
        a.pingedLanes |= a.suspendedLanes & c2;
        R2 === a && (U2 & c2) === c2 && (4 === T2 || 3 === T2 && (U2 & 62914560) === U2 && 500 > G2() - $f ? Sg(a, 0) : xg |= c2);
        Z2(a, b2);
      }
      __name(ch, "ch");
      function ag(a, b2) {
        var c2 = a.stateNode;
        null !== c2 && c2.delete(b2);
        b2 = 0;
        0 === b2 && (b2 = a.mode, 0 === (b2 & 2) ? b2 = 1 : 0 === (b2 & 4) ? b2 = 99 === Nc() ? 1 : 2 : (0 === Jg && (Jg = wg), b2 = pc(62914560 & ~Jg), 0 === b2 && (b2 = 4194304)));
        c2 = K2();
        a = Ng(a, b2);
        null !== a && (rc(a, b2, c2), Z2(a, c2));
      }
      __name(ag, "ag");
      var gh;
      gh = /* @__PURE__ */ __name(function(a, b2, c2) {
        var d2 = b2.lanes;
        if (null !== a)
          if (a.memoizedProps !== b2.pendingProps || D.current)
            gd2 = true;
          else if (0 !== (c2 & d2))
            gd2 = 0 !== (a.flags & 16384) ? true : false;
          else {
            gd2 = false;
            switch (b2.tag) {
              case 3:
                af2(b2);
                ce();
                break;
              case 5:
                Rd(b2);
                break;
              case 1:
                E2(b2.type) && cc(b2);
                break;
              case 4:
                Pd(b2, b2.stateNode.containerInfo);
                break;
              case 10:
                cd(b2, b2.memoizedProps.value);
                break;
              case 13:
                if (null !== b2.memoizedState) {
                  if (0 !== (c2 & b2.child.childLanes))
                    return cf(a, b2, c2);
                  A2(M2, M2.current & 1);
                  b2 = Re(a, b2, c2);
                  return null !== b2 ? b2.sibling : null;
                }
                A2(M2, M2.current & 1);
                break;
              case 19:
                d2 = 0 !== (c2 & b2.childLanes);
                if (0 !== (a.flags & 64)) {
                  if (d2)
                    return kf(a, b2, c2);
                  b2.flags |= 64;
                }
                var e3 = b2.memoizedState;
                null !== e3 && (e3.rendering = null, e3.tail = null, e3.lastEffect = null);
                A2(M2, M2.current);
                if (d2)
                  break;
                else
                  return null;
              case 23:
              case 24:
                return b2.lanes = 0, We(a, b2, c2);
            }
            return Re(a, b2, c2);
          }
        else
          gd2 = false;
        b2.lanes = 0;
        switch (b2.tag) {
          case 2:
            d2 = b2.type;
            null !== a && (a.alternate = null, b2.alternate = null, b2.flags |= 2);
            a = b2.pendingProps;
            e3 = Zb(b2, B2.current);
            fd(b2, c2);
            e3 = le(null, b2, d2, a, e3, c2);
            b2.flags |= 1;
            if ("object" === typeof e3 && null !== e3 && "function" === typeof e3.render && void 0 === e3.$$typeof) {
              b2.tag = 1;
              b2.memoizedState = null;
              b2.updateQueue = null;
              if (E2(d2)) {
                var f = true;
                cc(b2);
              } else
                f = false;
              b2.memoizedState = null !== e3.state && void 0 !== e3.state ? e3.state : null;
              id(b2);
              var g2 = d2.getDerivedStateFromProps;
              "function" === typeof g2 && sd(b2, d2, g2, a);
              e3.updater = vd;
              b2.stateNode = e3;
              e3._reactInternals = b2;
              zd(b2, d2, a, c2);
              b2 = $e(null, b2, d2, true, f, c2);
            } else
              b2.tag = 0, S2(null, b2, e3, c2), b2 = b2.child;
            return b2;
          case 16:
            e3 = b2.elementType;
            a: {
              null !== a && (a.alternate = null, b2.alternate = null, b2.flags |= 2);
              a = b2.pendingProps;
              f = e3._init;
              e3 = f(e3._payload);
              b2.type = e3;
              f = b2.tag = lh(e3);
              a = Xc(e3, a);
              switch (f) {
                case 0:
                  b2 = Ve(null, b2, e3, a, c2);
                  break a;
                case 1:
                  b2 = Ze(null, b2, e3, a, c2);
                  break a;
                case 11:
                  b2 = Pe(null, b2, e3, a, c2);
                  break a;
                case 14:
                  b2 = Se(null, b2, e3, Xc(e3.type, a), d2, c2);
                  break a;
              }
              throw Error(q2(306, e3, ""));
            }
            return b2;
          case 0:
            return d2 = b2.type, e3 = b2.pendingProps, e3 = b2.elementType === d2 ? e3 : Xc(d2, e3), Ve(a, b2, d2, e3, c2);
          case 1:
            return d2 = b2.type, e3 = b2.pendingProps, e3 = b2.elementType === d2 ? e3 : Xc(d2, e3), Ze(a, b2, d2, e3, c2);
          case 3:
            af2(b2);
            d2 = b2.updateQueue;
            if (null === a || null === d2)
              throw Error(q2(282));
            d2 = b2.pendingProps;
            e3 = b2.memoizedState;
            e3 = null !== e3 ? e3.element : null;
            jd(a, b2);
            od(b2, d2, null, c2);
            d2 = b2.memoizedState.element;
            if (d2 === e3)
              ce(), b2 = Re(a, b2, c2);
            else {
              e3 = b2.stateNode;
              if (f = e3.hydrate)
                Va ? (Vd = Kb(b2.stateNode.containerInfo), Ud = b2, f = Wd = true) : f = false;
              if (f) {
                if (Va && (a = e3.mutableSourceEagerHydrationData, null != a))
                  for (e3 = 0; e3 < a.length; e3 += 2)
                    f = a[e3], g2 = a[e3 + 1], Sa ? f._workInProgressVersionPrimary = g2 : f._workInProgressVersionSecondary = g2, de.push(f);
                c2 = Kd(b2, null, d2, c2);
                for (b2.child = c2; c2; )
                  c2.flags = c2.flags & -3 | 1024, c2 = c2.sibling;
              } else
                S2(a, b2, d2, c2), ce();
              b2 = b2.child;
            }
            return b2;
          case 5:
            return Rd(b2), null === a && $d(b2), d2 = b2.type, e3 = b2.pendingProps, f = null !== a ? a.memoizedProps : null, g2 = e3.children, Ma(d2, e3) ? g2 = null : null !== f && Ma(d2, f) && (b2.flags |= 16), Ye(a, b2), S2(a, b2, g2, c2), b2.child;
          case 6:
            return null === a && $d(b2), null;
          case 13:
            return cf(a, b2, c2);
          case 4:
            return Pd(b2, b2.stateNode.containerInfo), d2 = b2.pendingProps, null === a ? b2.child = Jd(b2, null, d2, c2) : S2(a, b2, d2, c2), b2.child;
          case 11:
            return d2 = b2.type, e3 = b2.pendingProps, e3 = b2.elementType === d2 ? e3 : Xc(d2, e3), Pe(a, b2, d2, e3, c2);
          case 7:
            return S2(a, b2, b2.pendingProps, c2), b2.child;
          case 8:
            return S2(
              a,
              b2,
              b2.pendingProps.children,
              c2
            ), b2.child;
          case 12:
            return S2(a, b2, b2.pendingProps.children, c2), b2.child;
          case 10:
            a: {
              d2 = b2.type._context;
              e3 = b2.pendingProps;
              g2 = b2.memoizedProps;
              f = e3.value;
              cd(b2, f);
              if (null !== g2) {
                var h2 = g2.value;
                f = I2(h2, f) ? 0 : ("function" === typeof d2._calculateChangedBits ? d2._calculateChangedBits(h2, f) : 1073741823) | 0;
                if (0 === f) {
                  if (g2.children === e3.children && !D.current) {
                    b2 = Re(a, b2, c2);
                    break a;
                  }
                } else
                  for (h2 = b2.child, null !== h2 && (h2.return = b2); null !== h2; ) {
                    var k2 = h2.dependencies;
                    if (null !== k2) {
                      g2 = h2.child;
                      for (var l2 = k2.firstContext; null !== l2; ) {
                        if (l2.context === d2 && 0 !== (l2.observedBits & f)) {
                          1 === h2.tag && (l2 = kd(-1, c2 & -c2), l2.tag = 2, md(h2, l2));
                          h2.lanes |= c2;
                          l2 = h2.alternate;
                          null !== l2 && (l2.lanes |= c2);
                          ed(h2.return, c2);
                          k2.lanes |= c2;
                          break;
                        }
                        l2 = l2.next;
                      }
                    } else
                      g2 = 10 === h2.tag ? h2.type === b2.type ? null : h2.child : h2.child;
                    if (null !== g2)
                      g2.return = h2;
                    else
                      for (g2 = h2; null !== g2; ) {
                        if (g2 === b2) {
                          g2 = null;
                          break;
                        }
                        h2 = g2.sibling;
                        if (null !== h2) {
                          h2.return = g2.return;
                          g2 = h2;
                          break;
                        }
                        g2 = g2.return;
                      }
                    h2 = g2;
                  }
              }
              S2(a, b2, e3.children, c2);
              b2 = b2.child;
            }
            return b2;
          case 9:
            return e3 = b2.type, f = b2.pendingProps, d2 = f.children, fd(b2, c2), e3 = J2(e3, f.unstable_observedBits), d2 = d2(e3), b2.flags |= 1, S2(
              a,
              b2,
              d2,
              c2
            ), b2.child;
          case 14:
            return e3 = b2.type, f = Xc(e3, b2.pendingProps), f = Xc(e3.type, f), Se(a, b2, e3, f, d2, c2);
          case 15:
            return Ue(a, b2, b2.type, b2.pendingProps, d2, c2);
          case 17:
            return d2 = b2.type, e3 = b2.pendingProps, e3 = b2.elementType === d2 ? e3 : Xc(d2, e3), null !== a && (a.alternate = null, b2.alternate = null, b2.flags |= 2), b2.tag = 1, E2(d2) ? (a = true, cc(b2)) : a = false, fd(b2, c2), xd(b2, d2, e3), zd(b2, d2, e3, c2), $e(null, b2, d2, true, a, c2);
          case 19:
            return kf(a, b2, c2);
          case 23:
            return We(a, b2, c2);
          case 24:
            return We(a, b2, c2);
        }
        throw Error(q2(156, b2.tag));
      }, "gh");
      var mh = { current: false }, nh = m2.unstable_flushAllWithoutAsserting, oh = "function" === typeof nh;
      function ph() {
        if (void 0 !== nh)
          return nh();
        for (var a = false; Qg(); )
          a = true;
        return a;
      }
      __name(ph, "ph");
      function qh(a) {
        try {
          ph(), og(function() {
            ph() ? qh(a) : a();
          });
        } catch (b2) {
          a(b2);
        }
      }
      __name(qh, "qh");
      var rh = 0, sh = false;
      function th(a, b2, c2, d2) {
        this.tag = a;
        this.key = c2;
        this.sibling = this.child = this.return = this.stateNode = this.type = this.elementType = null;
        this.index = 0;
        this.ref = null;
        this.pendingProps = b2;
        this.dependencies = this.memoizedState = this.updateQueue = this.memoizedProps = null;
        this.mode = d2;
        this.flags = 0;
        this.lastEffect = this.firstEffect = this.nextEffect = null;
        this.childLanes = this.lanes = 0;
        this.alternate = null;
      }
      __name(th, "th");
      function Yd(a, b2, c2, d2) {
        return new th(a, b2, c2, d2);
      }
      __name(Yd, "Yd");
      function Te(a) {
        a = a.prototype;
        return !(!a || !a.isReactComponent);
      }
      __name(Te, "Te");
      function lh(a) {
        if ("function" === typeof a)
          return Te(a) ? 1 : 0;
        if (void 0 !== a && null !== a) {
          a = a.$$typeof;
          if (a === la)
            return 11;
          if (a === oa)
            return 14;
        }
        return 2;
      }
      __name(lh, "lh");
      function Ed(a, b2) {
        var c2 = a.alternate;
        null === c2 ? (c2 = Yd(a.tag, b2, a.key, a.mode), c2.elementType = a.elementType, c2.type = a.type, c2.stateNode = a.stateNode, c2.alternate = a, a.alternate = c2) : (c2.pendingProps = b2, c2.type = a.type, c2.flags = 0, c2.nextEffect = null, c2.firstEffect = null, c2.lastEffect = null);
        c2.childLanes = a.childLanes;
        c2.lanes = a.lanes;
        c2.child = a.child;
        c2.memoizedProps = a.memoizedProps;
        c2.memoizedState = a.memoizedState;
        c2.updateQueue = a.updateQueue;
        b2 = a.dependencies;
        c2.dependencies = null === b2 ? null : { lanes: b2.lanes, firstContext: b2.firstContext };
        c2.sibling = a.sibling;
        c2.index = a.index;
        c2.ref = a.ref;
        return c2;
      }
      __name(Ed, "Ed");
      function Gd(a, b2, c2, d2, e3, f) {
        var g2 = 2;
        d2 = a;
        if ("function" === typeof a)
          Te(a) && (g2 = 1);
        else if ("string" === typeof a)
          g2 = 5;
        else
          a:
            switch (a) {
              case fa:
                return Id(c2.children, e3, f, b2);
              case ra:
                g2 = 8;
                e3 |= 16;
                break;
              case ha:
                g2 = 8;
                e3 |= 1;
                break;
              case ia:
                return a = Yd(12, c2, b2, e3 | 8), a.elementType = ia, a.type = ia, a.lanes = f, a;
              case ma:
                return a = Yd(13, c2, b2, e3), a.type = ma, a.elementType = ma, a.lanes = f, a;
              case na:
                return a = Yd(19, c2, b2, e3), a.elementType = na, a.lanes = f, a;
              case sa:
                return ef(c2, e3, f, b2);
              case ta:
                return a = Yd(24, c2, b2, e3), a.elementType = ta, a.lanes = f, a;
              default:
                if ("object" === typeof a && null !== a)
                  switch (a.$$typeof) {
                    case ja:
                      g2 = 10;
                      break a;
                    case ka:
                      g2 = 9;
                      break a;
                    case la:
                      g2 = 11;
                      break a;
                    case oa:
                      g2 = 14;
                      break a;
                    case pa2:
                      g2 = 16;
                      d2 = null;
                      break a;
                    case qa:
                      g2 = 22;
                      break a;
                  }
                throw Error(q2(130, null == a ? a : typeof a, ""));
            }
        b2 = Yd(g2, c2, b2, e3);
        b2.elementType = a;
        b2.type = d2;
        b2.lanes = f;
        return b2;
      }
      __name(Gd, "Gd");
      function Id(a, b2, c2, d2) {
        a = Yd(7, a, d2, b2);
        a.lanes = c2;
        return a;
      }
      __name(Id, "Id");
      function ef(a, b2, c2, d2) {
        a = Yd(23, a, d2, b2);
        a.elementType = sa;
        a.lanes = c2;
        return a;
      }
      __name(ef, "ef");
      function Fd(a, b2, c2) {
        a = Yd(6, a, null, b2);
        a.lanes = c2;
        return a;
      }
      __name(Fd, "Fd");
      function Hd(a, b2, c2) {
        b2 = Yd(4, null !== a.children ? a.children : [], a.key, b2);
        b2.lanes = c2;
        b2.stateNode = { containerInfo: a.containerInfo, pendingChildren: null, implementation: a.implementation };
        return b2;
      }
      __name(Hd, "Hd");
      function uh(a, b2, c2) {
        this.tag = b2;
        this.containerInfo = a;
        this.finishedWork = this.pingCache = this.current = this.pendingChildren = null;
        this.timeoutHandle = Ra;
        this.pendingContext = this.context = null;
        this.hydrate = c2;
        this.callbackNode = null;
        this.callbackPriority = 0;
        this.eventTimes = qc(0);
        this.expirationTimes = qc(-1);
        this.entangledLanes = this.finishedLanes = this.mutableReadLanes = this.expiredLanes = this.pingedLanes = this.suspendedLanes = this.pendingLanes = 0;
        this.entanglements = qc(0);
        Va && (this.mutableSourceEagerHydrationData = null);
      }
      __name(uh, "uh");
      function vh(a) {
        var b2 = a._reactInternals;
        if (void 0 === b2) {
          if ("function" === typeof a.render)
            throw Error(q2(188));
          throw Error(q2(268, Object.keys(a)));
        }
        a = Aa(b2);
        return null === a ? null : a.stateNode;
      }
      __name(vh, "vh");
      function wh(a, b2) {
        a = a.memoizedState;
        if (null !== a && null !== a.dehydrated) {
          var c2 = a.retryLane;
          a.retryLane = 0 !== c2 && c2 < b2 ? c2 : b2;
        }
      }
      __name(wh, "wh");
      function xh(a, b2) {
        wh(a, b2);
        (a = a.alternate) && wh(a, b2);
      }
      __name(xh, "xh");
      function yh(a) {
        a = Aa(a);
        return null === a ? null : a.stateNode;
      }
      __name(yh, "yh");
      function zh() {
        return null;
      }
      __name(zh, "zh");
      exports3.IsThisRendererActing = mh;
      exports3.act = function(a) {
        function b2() {
          rh--;
          sg.current = c2;
          mh.current = d2;
        }
        __name(b2, "b");
        false === sh && (sh = true, console.error("act(...) is not supported in production builds of React, and might not behave as expected."));
        rh++;
        var c2 = sg.current, d2 = mh.current;
        sg.current = true;
        mh.current = true;
        try {
          var e3 = ah(a);
        } catch (f) {
          throw b2(), f;
        }
        if (null !== e3 && "object" === typeof e3 && "function" === typeof e3.then)
          return { then: function(a2, d3) {
            e3.then(function() {
              1 < rh || true === oh && true === c2 ? (b2(), a2()) : qh(function(c3) {
                b2();
                c3 ? d3(c3) : a2();
              });
            }, function(a3) {
              b2();
              d3(a3);
            });
          } };
        try {
          1 !== rh || false !== oh && false !== c2 || ph(), b2();
        } catch (f) {
          throw b2(), f;
        }
        return { then: function(a2) {
          a2();
        } };
      };
      exports3.attemptContinuousHydration = function(a) {
        if (13 === a.tag) {
          var b2 = K2();
          ud(a, 67108864, b2);
          xh(a, 67108864);
        }
      };
      exports3.attemptHydrationAtCurrentPriority = function(a) {
        if (13 === a.tag) {
          var b2 = K2(), c2 = td(a);
          ud(a, c2, b2);
          xh(a, c2);
        }
      };
      exports3.attemptSynchronousHydration = function(a) {
        switch (a.tag) {
          case 3:
            var b2 = a.stateNode;
            if (b2.hydrate) {
              var c2 = ic(b2.pendingLanes);
              b2.expiredLanes |= c2 & b2.pendingLanes;
              Z2(b2, G2());
              0 === (V2 & 48) && (zg(), H2());
            }
            break;
          case 13:
            var d2 = K2();
            bh(function() {
              return ud(a, 1, d2);
            });
            xh(a, 4);
        }
      };
      exports3.attemptUserBlockingHydration = function(a) {
        if (13 === a.tag) {
          var b2 = K2();
          ud(a, 4, b2);
          xh(a, 4);
        }
      };
      exports3.batchedEventUpdates = function(a, b2) {
        var c2 = V2;
        V2 |= 2;
        try {
          return a(b2);
        } finally {
          V2 = c2, 0 === V2 && (zg(), H2());
        }
      };
      exports3.batchedUpdates = ah;
      exports3.createComponentSelector = function(a) {
        return { $$typeof: cg, value: a };
      };
      exports3.createContainer = function(a, b2, c2) {
        a = new uh(a, b2, c2);
        b2 = Yd(3, null, null, 2 === b2 ? 7 : 1 === b2 ? 3 : 0);
        a.current = b2;
        b2.stateNode = a;
        id(b2);
        return a;
      };
      exports3.createHasPsuedoClassSelector = function(a) {
        return { $$typeof: dg, value: a };
      };
      exports3.createPortal = function(a, b2, c2) {
        var d2 = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
        return { $$typeof: ea, key: null == d2 ? null : "" + d2, children: a, containerInfo: b2, implementation: c2 };
      };
      exports3.createRoleSelector = function(a) {
        return { $$typeof: eg, value: a };
      };
      exports3.createTestNameSelector = function(a) {
        return { $$typeof: fg, value: a };
      };
      exports3.createTextSelector = function(a) {
        return { $$typeof: gg, value: a };
      };
      exports3.deferredUpdates = function(a) {
        return Pc(97, a);
      };
      exports3.discreteUpdates = function(a, b2, c2, d2, e3) {
        var f = V2;
        V2 |= 4;
        try {
          return Pc(98, a.bind(null, b2, c2, d2, e3));
        } finally {
          V2 = f, 0 === V2 && (zg(), H2());
        }
      };
      exports3.findAllNodes = mg;
      exports3.findBoundingRects = function(a, b2) {
        if (!bb)
          throw Error(q2(363));
        b2 = mg(a, b2);
        a = [];
        for (var c2 = 0; c2 < b2.length; c2++)
          a.push(db(b2[c2]));
        for (b2 = a.length - 1; 0 < b2; b2--) {
          c2 = a[b2];
          for (var d2 = c2.x, e3 = d2 + c2.width, f = c2.y, g2 = f + c2.height, h2 = b2 - 1; 0 <= h2; h2--)
            if (b2 !== h2) {
              var k2 = a[h2], l2 = k2.x, n2 = l2 + k2.width, t3 = k2.y, p2 = t3 + k2.height;
              if (d2 >= l2 && f >= t3 && e3 <= n2 && g2 <= p2) {
                a.splice(b2, 1);
                break;
              } else if (!(d2 !== l2 || c2.width !== k2.width || p2 < f || t3 > g2)) {
                t3 > f && (k2.height += t3 - f, k2.y = f);
                p2 < g2 && (k2.height = g2 - t3);
                a.splice(b2, 1);
                break;
              } else if (!(f !== t3 || c2.height !== k2.height || n2 < d2 || l2 > e3)) {
                l2 > d2 && (k2.width += l2 - d2, k2.x = d2);
                n2 < e3 && (k2.width = e3 - l2);
                a.splice(b2, 1);
                break;
              }
            }
        }
        return a;
      };
      exports3.findHostInstance = vh;
      exports3.findHostInstanceWithNoPortals = function(a) {
        a = Ba(a);
        return null === a ? null : 20 === a.tag ? a.stateNode.instance : a.stateNode;
      };
      exports3.findHostInstanceWithWarning = function(a) {
        return vh(a);
      };
      exports3.flushControlled = function(a) {
        var b2 = V2;
        V2 |= 1;
        try {
          Pc(99, a);
        } finally {
          V2 = b2, 0 === V2 && (zg(), H2());
        }
      };
      exports3.flushDiscreteUpdates = function() {
        0 === (V2 & 49) && ($g(), Qg());
      };
      exports3.flushPassiveEffects = Qg;
      exports3.flushSync = bh;
      exports3.focusWithin = function(a, b2) {
        if (!bb)
          throw Error(q2(363));
        a = ig(a);
        b2 = lg(a, b2);
        b2 = Array.from(b2);
        for (a = 0; a < b2.length; ) {
          var c2 = b2[a++];
          if (!fb(c2)) {
            if (5 === c2.tag && hb(c2.stateNode))
              return true;
            for (c2 = c2.child; null !== c2; )
              b2.push(c2), c2 = c2.sibling;
          }
        }
        return false;
      };
      exports3.getCurrentUpdateLanePriority = function() {
        return hc;
      };
      exports3.getFindAllNodesFailureDescription = function(a, b2) {
        if (!bb)
          throw Error(q2(363));
        var c2 = 0, d2 = [];
        a = [ig(a), 0];
        for (var e3 = 0; e3 < a.length; ) {
          var f = a[e3++], g2 = a[e3++], h2 = b2[g2];
          if (5 !== f.tag || !fb(f)) {
            if (jg(f, h2) && (d2.push(kg(h2)), g2++, g2 > c2 && (c2 = g2)), g2 < b2.length)
              for (f = f.child; null !== f; )
                a.push(f, g2), f = f.sibling;
          }
        }
        if (c2 < b2.length) {
          for (a = []; c2 < b2.length; c2++)
            a.push(kg(b2[c2]));
          return "findAllNodes was able to match part of the selector:\n  " + (d2.join(" > ") + "\n\nNo matching component was found for:\n  ") + a.join(" > ");
        }
        return null;
      };
      exports3.getPublicRootInstance = function(a) {
        a = a.current;
        if (!a.child)
          return null;
        switch (a.child.tag) {
          case 5:
            return Da(a.child.stateNode);
          default:
            return a.child.stateNode;
        }
      };
      exports3.injectIntoDevTools = function(a) {
        a = {
          bundleType: a.bundleType,
          version: a.version,
          rendererPackageName: a.rendererPackageName,
          rendererConfig: a.rendererConfig,
          overrideHookState: null,
          overrideHookStateDeletePath: null,
          overrideHookStateRenamePath: null,
          overrideProps: null,
          overridePropsDeletePath: null,
          overridePropsRenamePath: null,
          setSuspenseHandler: null,
          scheduleUpdate: null,
          currentDispatcherRef: ca.ReactCurrentDispatcher,
          findHostInstanceByFiber: yh,
          findFiberByHostInstance: a.findFiberByHostInstance || zh,
          findHostInstancesForRefresh: null,
          scheduleRefresh: null,
          scheduleRoot: null,
          setRefreshHandler: null,
          getCurrentFiber: null
        };
        if ("undefined" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__)
          a = false;
        else {
          var b2 = __REACT_DEVTOOLS_GLOBAL_HOOK__;
          if (!b2.isDisabled && b2.supportsFiber)
            try {
              ec = b2.inject(a), fc = b2;
            } catch (c2) {
            }
          a = true;
        }
        return a;
      };
      exports3.observeVisibleRects = function(a, b2, c2, d2) {
        if (!bb)
          throw Error(q2(363));
        a = mg(a, b2);
        var e3 = ib(a, c2, d2).disconnect;
        return { disconnect: function() {
          e3();
        } };
      };
      exports3.registerMutableSourceForHydration = function(a, b2) {
        var c2 = b2._getVersion;
        c2 = c2(b2._source);
        null == a.mutableSourceEagerHydrationData ? a.mutableSourceEagerHydrationData = [b2, c2] : a.mutableSourceEagerHydrationData.push(b2, c2);
      };
      exports3.runWithPriority = function(a, b2) {
        var c2 = hc;
        try {
          return hc = a, b2();
        } finally {
          hc = c2;
        }
      };
      exports3.shouldSuspend = function() {
        return false;
      };
      exports3.unbatchedUpdates = function(a, b2) {
        var c2 = V2;
        V2 &= -2;
        V2 |= 8;
        try {
          return a(b2);
        } finally {
          V2 = c2, 0 === V2 && (zg(), H2());
        }
      };
      exports3.updateContainer = function(a, b2, c2, d2) {
        var e3 = b2.current, f = K2(), g2 = td(e3);
        a:
          if (c2) {
            c2 = c2._reactInternals;
            b: {
              if (xa(c2) !== c2 || 1 !== c2.tag)
                throw Error(q2(170));
              var h2 = c2;
              do {
                switch (h2.tag) {
                  case 3:
                    h2 = h2.stateNode.context;
                    break b;
                  case 1:
                    if (E2(h2.type)) {
                      h2 = h2.stateNode.__reactInternalMemoizedMergedChildContext;
                      break b;
                    }
                }
                h2 = h2.return;
              } while (null !== h2);
              throw Error(q2(171));
            }
            if (1 === c2.tag) {
              var k2 = c2.type;
              if (E2(k2)) {
                c2 = bc(c2, k2, h2);
                break a;
              }
            }
            c2 = h2;
          } else
            c2 = Xb;
        null === b2.context ? b2.context = c2 : b2.pendingContext = c2;
        b2 = kd(f, g2);
        b2.payload = { element: a };
        d2 = void 0 === d2 ? null : d2;
        null !== d2 && (b2.callback = d2);
        md(e3, b2);
        ud(e3, g2, f);
        return g2;
      };
      return exports3;
    }, "$$$reconciler");
  }
});

// ../../node_modules/.pnpm/react-reconciler@0.26.2_react@17.0.2/node_modules/react-reconciler/index.js
var require_react_reconciler = __commonJS({
  "../../node_modules/.pnpm/react-reconciler@0.26.2_react@17.0.2/node_modules/react-reconciler/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    if (true) {
      module3.exports = require_react_reconciler_production_min();
    } else {
      module3.exports = null;
    }
  }
});

// ../../node_modules/.pnpm/file+vendor+yoga-layout-2.0.0-beta.1.tgz/node_modules/yoga-layout/dist/build/wasm-sync.js
var require_wasm_sync = __commonJS({
  "../../node_modules/.pnpm/file+vendor+yoga-layout-2.0.0-beta.1.tgz/node_modules/yoga-layout/dist/build/wasm-sync.js"(exports2, module3) {
    init_import_meta_url();
    var loadYoga = (() => {
      var _scriptDir = typeof document !== "undefined" && document.currentScript ? document.currentScript.src : void 0;
      if (typeof __filename !== "undefined")
        _scriptDir = _scriptDir || __filename;
      return function(loadYoga2) {
        loadYoga2 = loadYoga2 || {};
        var l2;
        l2 || (l2 = typeof loadYoga2 !== "undefined" ? loadYoga2 : {});
        var aa, ba;
        l2.ready = new Promise(function(a, b2) {
          aa = a;
          ba = b2;
        });
        var ca = Object.assign({}, l2), da2 = "object" == typeof window, ea = "function" == typeof importScripts, q2 = "", fa, ha;
        if ("object" == typeof process && "object" == typeof process.versions && "string" == typeof process.versions.node) {
          var fs26 = require("fs"), ia = require("path");
          q2 = ea ? ia.dirname(q2) + "/" : __dirname + "/";
          fa = /* @__PURE__ */ __name((a, b2) => {
            a = a.startsWith("file://") ? new URL(a) : ia.normalize(a);
            return fs26.readFileSync(a, b2 ? void 0 : "utf8");
          }, "fa");
          ha = /* @__PURE__ */ __name((a) => {
            a = fa(a, true);
            a.buffer || (a = new Uint8Array(a));
            return a;
          }, "ha");
          1 < process.argv.length && process.argv[1].replace(/\\/g, "/");
          process.argv.slice(2);
          process.on("uncaughtException", function(a) {
            throw a;
          });
          process.on(
            "unhandledRejection",
            function(a) {
              throw a;
            }
          );
          l2.inspect = function() {
            return "[Emscripten Module object]";
          };
        } else if (da2 || ea)
          ea ? q2 = self.location.href : "undefined" != typeof document && document.currentScript && (q2 = document.currentScript.src), _scriptDir && (q2 = _scriptDir), 0 !== q2.indexOf("blob:") ? q2 = q2.substr(0, q2.replace(/[?#].*/, "").lastIndexOf("/") + 1) : q2 = "", fa = /* @__PURE__ */ __name((a) => {
            var b2 = new XMLHttpRequest();
            b2.open("GET", a, false);
            b2.send(null);
            return b2.responseText;
          }, "fa"), ea && (ha = /* @__PURE__ */ __name((a) => {
            var b2 = new XMLHttpRequest();
            b2.open("GET", a, false);
            b2.responseType = "arraybuffer";
            b2.send(null);
            return new Uint8Array(b2.response);
          }, "ha"));
        var ja = l2.print || console.log.bind(console), v2 = l2.printErr || console.warn.bind(console);
        Object.assign(l2, ca);
        ca = null;
        var ka;
        l2.wasmBinary && (ka = l2.wasmBinary);
        var noExitRuntime = l2.noExitRuntime || true;
        "object" != typeof WebAssembly && la("no native wasm support detected");
        var ma, na = false;
        function oa(a, b2, c2) {
          c2 = b2 + c2;
          for (var d2 = ""; !(b2 >= c2); ) {
            var e3 = a[b2++];
            if (!e3)
              break;
            if (e3 & 128) {
              var f = a[b2++] & 63;
              if (192 == (e3 & 224))
                d2 += String.fromCharCode((e3 & 31) << 6 | f);
              else {
                var g2 = a[b2++] & 63;
                e3 = 224 == (e3 & 240) ? (e3 & 15) << 12 | f << 6 | g2 : (e3 & 7) << 18 | f << 12 | g2 << 6 | a[b2++] & 63;
                65536 > e3 ? d2 += String.fromCharCode(e3) : (e3 -= 65536, d2 += String.fromCharCode(55296 | e3 >> 10, 56320 | e3 & 1023));
              }
            } else
              d2 += String.fromCharCode(e3);
          }
          return d2;
        }
        __name(oa, "oa");
        var pa2, qa, w2, x2, ra, z2, A2, sa, ta;
        function ua() {
          var a = ma.buffer;
          pa2 = a;
          l2.HEAP8 = qa = new Int8Array(a);
          l2.HEAP16 = x2 = new Int16Array(a);
          l2.HEAP32 = z2 = new Int32Array(a);
          l2.HEAPU8 = w2 = new Uint8Array(a);
          l2.HEAPU16 = ra = new Uint16Array(a);
          l2.HEAPU32 = A2 = new Uint32Array(a);
          l2.HEAPF32 = sa = new Float32Array(a);
          l2.HEAPF64 = ta = new Float64Array(a);
        }
        __name(ua, "ua");
        var va, wa = [], xa = [], ya = [];
        function za() {
          var a = l2.preRun.shift();
          wa.unshift(a);
        }
        __name(za, "za");
        var B2 = 0, Aa = null, D = null;
        function la(a) {
          if (l2.onAbort)
            l2.onAbort(a);
          a = "Aborted(" + a + ")";
          v2(a);
          na = true;
          a = new WebAssembly.RuntimeError(a + ". Build with -sASSERTIONS for more info.");
          ba(a);
          throw a;
        }
        __name(la, "la");
        var E2;
        E2 = "wasm-sync.wasm";
        if (!E2.startsWith("data:application/octet-stream;base64,")) {
          var Ba = E2;
          E2 = l2.locateFile ? l2.locateFile(Ba, q2) : q2 + Ba;
        }
        function Ca(a) {
          var b2 = E2;
          try {
            a: {
              try {
                if (b2 == E2 && ka) {
                  var c2 = new Uint8Array(ka);
                  break a;
                }
                if (ha) {
                  c2 = ha(b2);
                  break a;
                }
                throw "sync fetching of the wasm failed: you can preload it to Module['wasmBinary'] manually, or emcc.py will do that for you when generating HTML (but not JS)";
              } catch (f) {
                la(f);
              }
              c2 = void 0;
            }
            var d2 = new WebAssembly.Module(c2);
            var e3 = new WebAssembly.Instance(d2, a);
          } catch (f) {
            throw a = f.toString(), v2("failed to compile wasm module: " + a), (a.includes("imported Memory") || a.includes("memory import")) && v2("Memory size incompatibility issues may be due to changing INITIAL_MEMORY at runtime to something too large. Use ALLOW_MEMORY_GROWTH to allow any size memory (and also make sure not to set INITIAL_MEMORY at runtime to something smaller than it was at compile time)."), f;
          }
          return [e3, d2];
        }
        __name(Ca, "Ca");
        function Da(a) {
          for (; 0 < a.length; )
            a.shift()(l2);
        }
        __name(Da, "Da");
        function Ea(a) {
          if (void 0 === a)
            return "_unknown";
          a = a.replace(/[^a-zA-Z0-9_]/g, "$");
          var b2 = a.charCodeAt(0);
          return 48 <= b2 && 57 >= b2 ? "_" + a : a;
        }
        __name(Ea, "Ea");
        function Fa(a, b2) {
          a = Ea(a);
          return function() {
            return b2.apply(this, arguments);
          };
        }
        __name(Fa, "Fa");
        var F = [{}, { value: void 0 }, { value: null }, { value: true }, { value: false }], Ga = [];
        function Ha(a) {
          var b2 = Error, c2 = Fa(a, function(d2) {
            this.name = a;
            this.message = d2;
            d2 = Error(d2).stack;
            void 0 !== d2 && (this.stack = this.toString() + "\n" + d2.replace(/^Error(:[^\n]*)?\n/, ""));
          });
          c2.prototype = Object.create(b2.prototype);
          c2.prototype.constructor = c2;
          c2.prototype.toString = function() {
            return void 0 === this.message ? this.name : this.name + ": " + this.message;
          };
          return c2;
        }
        __name(Ha, "Ha");
        var H2 = void 0;
        function I2(a) {
          throw new H2(a);
        }
        __name(I2, "I");
        var J2 = /* @__PURE__ */ __name((a) => {
          a || I2("Cannot use deleted val. handle = " + a);
          return F[a].value;
        }, "J"), Ia = /* @__PURE__ */ __name((a) => {
          switch (a) {
            case void 0:
              return 1;
            case null:
              return 2;
            case true:
              return 3;
            case false:
              return 4;
            default:
              var b2 = Ga.length ? Ga.pop() : F.length;
              F[b2] = { ga: 1, value: a };
              return b2;
          }
        }, "Ia"), Ja = void 0, Ka = void 0;
        function K2(a) {
          for (var b2 = ""; w2[a]; )
            b2 += Ka[w2[a++]];
          return b2;
        }
        __name(K2, "K");
        var L2 = [];
        function La() {
          for (; L2.length; ) {
            var a = L2.pop();
            a.L.Z = false;
            a["delete"]();
          }
        }
        __name(La, "La");
        var M2 = void 0, N2 = {};
        function Ma(a, b2) {
          for (void 0 === b2 && I2("ptr should not be undefined"); a.P; )
            b2 = a.aa(b2), a = a.P;
          return b2;
        }
        __name(Ma, "Ma");
        var O2 = {};
        function Na(a) {
          a = Oa(a);
          var b2 = K2(a);
          P2(a);
          return b2;
        }
        __name(Na, "Na");
        function Pa(a, b2) {
          var c2 = O2[a];
          void 0 === c2 && I2(b2 + " has unknown type " + Na(a));
          return c2;
        }
        __name(Pa, "Pa");
        function Qa() {
        }
        __name(Qa, "Qa");
        var Ra = false;
        function Sa(a) {
          --a.count.value;
          0 === a.count.value && (a.S ? a.T.V(a.S) : a.O.M.V(a.N));
        }
        __name(Sa, "Sa");
        function Ta(a, b2, c2) {
          if (b2 === c2)
            return a;
          if (void 0 === c2.P)
            return null;
          a = Ta(a, b2, c2.P);
          return null === a ? null : c2.na(a);
        }
        __name(Ta, "Ta");
        var Ua = {};
        function Va(a, b2) {
          b2 = Ma(a, b2);
          return N2[b2];
        }
        __name(Va, "Va");
        var Wa = void 0;
        function Xa(a) {
          throw new Wa(a);
        }
        __name(Xa, "Xa");
        function Ya(a, b2) {
          b2.O && b2.N || Xa("makeClassHandle requires ptr and ptrType");
          !!b2.T !== !!b2.S && Xa("Both smartPtrType and smartPtr must be specified");
          b2.count = { value: 1 };
          return Q3(Object.create(a, { L: { value: b2 } }));
        }
        __name(Ya, "Ya");
        function Q3(a) {
          if ("undefined" === typeof FinalizationRegistry)
            return Q3 = /* @__PURE__ */ __name((b2) => b2, "Q"), a;
          Ra = new FinalizationRegistry((b2) => {
            Sa(b2.L);
          });
          Q3 = /* @__PURE__ */ __name((b2) => {
            var c2 = b2.L;
            c2.S && Ra.register(b2, { L: c2 }, b2);
            return b2;
          }, "Q");
          Qa = /* @__PURE__ */ __name((b2) => {
            Ra.unregister(b2);
          }, "Qa");
          return Q3(a);
        }
        __name(Q3, "Q");
        var Za = {};
        function $a(a) {
          for (; a.length; ) {
            var b2 = a.pop();
            a.pop()(b2);
          }
        }
        __name($a, "$a");
        function R2(a) {
          return this.fromWireType(z2[a >> 2]);
        }
        __name(R2, "R");
        var S2 = {}, ab = {};
        function T2(a, b2, c2) {
          function d2(h2) {
            h2 = c2(h2);
            h2.length !== a.length && Xa("Mismatched type converter count");
            for (var m2 = 0; m2 < a.length; ++m2)
              U2(a[m2], h2[m2]);
          }
          __name(d2, "d");
          a.forEach(function(h2) {
            ab[h2] = b2;
          });
          var e3 = Array(b2.length), f = [], g2 = 0;
          b2.forEach((h2, m2) => {
            O2.hasOwnProperty(h2) ? e3[m2] = O2[h2] : (f.push(h2), S2.hasOwnProperty(h2) || (S2[h2] = []), S2[h2].push(() => {
              e3[m2] = O2[h2];
              ++g2;
              g2 === f.length && d2(e3);
            }));
          });
          0 === f.length && d2(e3);
        }
        __name(T2, "T");
        function bb(a) {
          switch (a) {
            case 1:
              return 0;
            case 2:
              return 1;
            case 4:
              return 2;
            case 8:
              return 3;
            default:
              throw new TypeError("Unknown type size: " + a);
          }
        }
        __name(bb, "bb");
        function U2(a, b2, c2 = {}) {
          if (!("argPackAdvance" in b2))
            throw new TypeError("registerType registeredInstance requires argPackAdvance");
          var d2 = b2.name;
          a || I2('type "' + d2 + '" must have a positive integer typeid pointer');
          if (O2.hasOwnProperty(a)) {
            if (c2.ua)
              return;
            I2("Cannot register type '" + d2 + "' twice");
          }
          O2[a] = b2;
          delete ab[a];
          S2.hasOwnProperty(a) && (b2 = S2[a], delete S2[a], b2.forEach((e3) => e3()));
        }
        __name(U2, "U");
        function cb(a) {
          I2(a.L.O.M.name + " instance already deleted");
        }
        __name(cb, "cb");
        function V2() {
        }
        __name(V2, "V");
        function db(a, b2, c2) {
          if (void 0 === a[b2].R) {
            var d2 = a[b2];
            a[b2] = function() {
              a[b2].R.hasOwnProperty(arguments.length) || I2("Function '" + c2 + "' called with an invalid number of arguments (" + arguments.length + ") - expects one of (" + a[b2].R + ")!");
              return a[b2].R[arguments.length].apply(this, arguments);
            };
            a[b2].R = [];
            a[b2].R[d2.Y] = d2;
          }
        }
        __name(db, "db");
        function eb(a, b2) {
          l2.hasOwnProperty(a) ? (I2("Cannot register public name '" + a + "' twice"), db(l2, a, a), l2.hasOwnProperty(void 0) && I2("Cannot register multiple overloads of a function with the same number of arguments (undefined)!"), l2[a].R[void 0] = b2) : l2[a] = b2;
        }
        __name(eb, "eb");
        function fb(a, b2, c2, d2, e3, f, g2, h2) {
          this.name = a;
          this.constructor = b2;
          this.W = c2;
          this.V = d2;
          this.P = e3;
          this.pa = f;
          this.aa = g2;
          this.na = h2;
          this.ja = [];
        }
        __name(fb, "fb");
        function gb(a, b2, c2) {
          for (; b2 !== c2; )
            b2.aa || I2("Expected null or instance of " + c2.name + ", got an instance of " + b2.name), a = b2.aa(a), b2 = b2.P;
          return a;
        }
        __name(gb, "gb");
        function hb(a, b2) {
          if (null === b2)
            return this.ea && I2("null is not a valid " + this.name), 0;
          b2.L || I2('Cannot pass "' + ib(b2) + '" as a ' + this.name);
          b2.L.N || I2("Cannot pass deleted object as a pointer of type " + this.name);
          return gb(b2.L.N, b2.L.O.M, this.M);
        }
        __name(hb, "hb");
        function jb(a, b2) {
          if (null === b2) {
            this.ea && I2("null is not a valid " + this.name);
            if (this.da) {
              var c2 = this.fa();
              null !== a && a.push(this.V, c2);
              return c2;
            }
            return 0;
          }
          b2.L || I2('Cannot pass "' + ib(b2) + '" as a ' + this.name);
          b2.L.N || I2("Cannot pass deleted object as a pointer of type " + this.name);
          !this.ba && b2.L.O.ba && I2("Cannot convert argument of type " + (b2.L.T ? b2.L.T.name : b2.L.O.name) + " to parameter type " + this.name);
          c2 = gb(b2.L.N, b2.L.O.M, this.M);
          if (this.da)
            switch (void 0 === b2.L.S && I2("Passing raw pointer to smart pointer is illegal"), this.Ba) {
              case 0:
                b2.L.T === this ? c2 = b2.L.S : I2("Cannot convert argument of type " + (b2.L.T ? b2.L.T.name : b2.L.O.name) + " to parameter type " + this.name);
                break;
              case 1:
                c2 = b2.L.S;
                break;
              case 2:
                if (b2.L.T === this)
                  c2 = b2.L.S;
                else {
                  var d2 = b2.clone();
                  c2 = this.xa(c2, Ia(function() {
                    d2["delete"]();
                  }));
                  null !== a && a.push(this.V, c2);
                }
                break;
              default:
                I2("Unsupporting sharing policy");
            }
          return c2;
        }
        __name(jb, "jb");
        function kb(a, b2) {
          if (null === b2)
            return this.ea && I2("null is not a valid " + this.name), 0;
          b2.L || I2('Cannot pass "' + ib(b2) + '" as a ' + this.name);
          b2.L.N || I2("Cannot pass deleted object as a pointer of type " + this.name);
          b2.L.O.ba && I2("Cannot convert argument of type " + b2.L.O.name + " to parameter type " + this.name);
          return gb(b2.L.N, b2.L.O.M, this.M);
        }
        __name(kb, "kb");
        function W2(a, b2, c2, d2) {
          this.name = a;
          this.M = b2;
          this.ea = c2;
          this.ba = d2;
          this.da = false;
          this.V = this.xa = this.fa = this.ka = this.Ba = this.wa = void 0;
          void 0 !== b2.P ? this.toWireType = jb : (this.toWireType = d2 ? hb : kb, this.U = null);
        }
        __name(W2, "W");
        function nb(a, b2) {
          l2.hasOwnProperty(a) || Xa("Replacing nonexistant public symbol");
          l2[a] = b2;
          l2[a].Y = void 0;
        }
        __name(nb, "nb");
        function ob(a, b2) {
          var c2 = [];
          return function() {
            c2.length = 0;
            Object.assign(c2, arguments);
            if (a.includes("j")) {
              var d2 = l2["dynCall_" + a];
              d2 = c2 && c2.length ? d2.apply(null, [b2].concat(c2)) : d2.call(null, b2);
            } else
              d2 = va.get(b2).apply(null, c2);
            return d2;
          };
        }
        __name(ob, "ob");
        function X2(a, b2) {
          a = K2(a);
          var c2 = a.includes("j") ? ob(a, b2) : va.get(b2);
          "function" != typeof c2 && I2("unknown function pointer with signature " + a + ": " + b2);
          return c2;
        }
        __name(X2, "X");
        var pb = void 0;
        function qb(a, b2) {
          function c2(f) {
            e3[f] || O2[f] || (ab[f] ? ab[f].forEach(c2) : (d2.push(f), e3[f] = true));
          }
          __name(c2, "c");
          var d2 = [], e3 = {};
          b2.forEach(c2);
          throw new pb(a + ": " + d2.map(Na).join([", "]));
        }
        __name(qb, "qb");
        function rb(a, b2, c2, d2, e3) {
          var f = b2.length;
          2 > f && I2("argTypes array size mismatch! Must at least get return value and 'this' types!");
          var g2 = null !== b2[1] && null !== c2, h2 = false;
          for (c2 = 1; c2 < b2.length; ++c2)
            if (null !== b2[c2] && void 0 === b2[c2].U) {
              h2 = true;
              break;
            }
          var m2 = "void" !== b2[0].name, k2 = f - 2, n2 = Array(k2), p2 = [], r3 = [];
          return function() {
            arguments.length !== k2 && I2("function " + a + " called with " + arguments.length + " arguments, expected " + k2 + " args!");
            r3.length = 0;
            p2.length = g2 ? 2 : 1;
            p2[0] = e3;
            if (g2) {
              var u = b2[1].toWireType(r3, this);
              p2[1] = u;
            }
            for (var t3 = 0; t3 < k2; ++t3)
              n2[t3] = b2[t3 + 2].toWireType(r3, arguments[t3]), p2.push(n2[t3]);
            t3 = d2.apply(null, p2);
            if (h2)
              $a(r3);
            else
              for (var y2 = g2 ? 1 : 2; y2 < b2.length; y2++) {
                var C2 = 1 === y2 ? u : n2[y2 - 2];
                null !== b2[y2].U && b2[y2].U(C2);
              }
            u = m2 ? b2[0].fromWireType(t3) : void 0;
            return u;
          };
        }
        __name(rb, "rb");
        function sb(a, b2) {
          for (var c2 = [], d2 = 0; d2 < a; d2++)
            c2.push(A2[b2 + 4 * d2 >> 2]);
          return c2;
        }
        __name(sb, "sb");
        function tb(a) {
          4 < a && 0 === --F[a].ga && (F[a] = void 0, Ga.push(a));
        }
        __name(tb, "tb");
        function ib(a) {
          if (null === a)
            return "null";
          var b2 = typeof a;
          return "object" === b2 || "array" === b2 || "function" === b2 ? a.toString() : "" + a;
        }
        __name(ib, "ib");
        function ub(a, b2) {
          switch (b2) {
            case 2:
              return function(c2) {
                return this.fromWireType(sa[c2 >> 2]);
              };
            case 3:
              return function(c2) {
                return this.fromWireType(ta[c2 >> 3]);
              };
            default:
              throw new TypeError("Unknown float type: " + a);
          }
        }
        __name(ub, "ub");
        function vb(a, b2, c2) {
          switch (b2) {
            case 0:
              return c2 ? function(d2) {
                return qa[d2];
              } : function(d2) {
                return w2[d2];
              };
            case 1:
              return c2 ? function(d2) {
                return x2[d2 >> 1];
              } : function(d2) {
                return ra[d2 >> 1];
              };
            case 2:
              return c2 ? function(d2) {
                return z2[d2 >> 2];
              } : function(d2) {
                return A2[d2 >> 2];
              };
            default:
              throw new TypeError("Unknown integer type: " + a);
          }
        }
        __name(vb, "vb");
        function wb(a, b2) {
          for (var c2 = "", d2 = 0; !(d2 >= b2 / 2); ++d2) {
            var e3 = x2[a + 2 * d2 >> 1];
            if (0 == e3)
              break;
            c2 += String.fromCharCode(e3);
          }
          return c2;
        }
        __name(wb, "wb");
        function xb(a, b2, c2) {
          void 0 === c2 && (c2 = 2147483647);
          if (2 > c2)
            return 0;
          c2 -= 2;
          var d2 = b2;
          c2 = c2 < 2 * a.length ? c2 / 2 : a.length;
          for (var e3 = 0; e3 < c2; ++e3)
            x2[b2 >> 1] = a.charCodeAt(e3), b2 += 2;
          x2[b2 >> 1] = 0;
          return b2 - d2;
        }
        __name(xb, "xb");
        function yb(a) {
          return 2 * a.length;
        }
        __name(yb, "yb");
        function zb(a, b2) {
          for (var c2 = 0, d2 = ""; !(c2 >= b2 / 4); ) {
            var e3 = z2[a + 4 * c2 >> 2];
            if (0 == e3)
              break;
            ++c2;
            65536 <= e3 ? (e3 -= 65536, d2 += String.fromCharCode(55296 | e3 >> 10, 56320 | e3 & 1023)) : d2 += String.fromCharCode(e3);
          }
          return d2;
        }
        __name(zb, "zb");
        function Ab(a, b2, c2) {
          void 0 === c2 && (c2 = 2147483647);
          if (4 > c2)
            return 0;
          var d2 = b2;
          c2 = d2 + c2 - 4;
          for (var e3 = 0; e3 < a.length; ++e3) {
            var f = a.charCodeAt(e3);
            if (55296 <= f && 57343 >= f) {
              var g2 = a.charCodeAt(++e3);
              f = 65536 + ((f & 1023) << 10) | g2 & 1023;
            }
            z2[b2 >> 2] = f;
            b2 += 4;
            if (b2 + 4 > c2)
              break;
          }
          z2[b2 >> 2] = 0;
          return b2 - d2;
        }
        __name(Ab, "Ab");
        function Bb(a) {
          for (var b2 = 0, c2 = 0; c2 < a.length; ++c2) {
            var d2 = a.charCodeAt(c2);
            55296 <= d2 && 57343 >= d2 && ++c2;
            b2 += 4;
          }
          return b2;
        }
        __name(Bb, "Bb");
        var Cb = {};
        function Db(a) {
          var b2 = Cb[a];
          return void 0 === b2 ? K2(a) : b2;
        }
        __name(Db, "Db");
        var Eb = [];
        function Fb(a) {
          var b2 = Eb.length;
          Eb.push(a);
          return b2;
        }
        __name(Fb, "Fb");
        function Gb(a, b2) {
          for (var c2 = Array(a), d2 = 0; d2 < a; ++d2)
            c2[d2] = Pa(A2[b2 + 4 * d2 >> 2], "parameter " + d2);
          return c2;
        }
        __name(Gb, "Gb");
        var Hb = [], Ib = [null, [], []];
        H2 = l2.BindingError = Ha("BindingError");
        l2.count_emval_handles = function() {
          for (var a = 0, b2 = 5; b2 < F.length; ++b2)
            void 0 !== F[b2] && ++a;
          return a;
        };
        l2.get_first_emval = function() {
          for (var a = 5; a < F.length; ++a)
            if (void 0 !== F[a])
              return F[a];
          return null;
        };
        Ja = l2.PureVirtualError = Ha("PureVirtualError");
        for (var Jb = Array(256), Kb = 0; 256 > Kb; ++Kb)
          Jb[Kb] = String.fromCharCode(Kb);
        Ka = Jb;
        l2.getInheritedInstanceCount = function() {
          return Object.keys(N2).length;
        };
        l2.getLiveInheritedInstances = function() {
          var a = [], b2;
          for (b2 in N2)
            N2.hasOwnProperty(b2) && a.push(N2[b2]);
          return a;
        };
        l2.flushPendingDeletes = La;
        l2.setDelayFunction = function(a) {
          M2 = a;
          L2.length && M2 && M2(La);
        };
        Wa = l2.InternalError = Ha("InternalError");
        V2.prototype.isAliasOf = function(a) {
          if (!(this instanceof V2 && a instanceof V2))
            return false;
          var b2 = this.L.O.M, c2 = this.L.N, d2 = a.L.O.M;
          for (a = a.L.N; b2.P; )
            c2 = b2.aa(c2), b2 = b2.P;
          for (; d2.P; )
            a = d2.aa(a), d2 = d2.P;
          return b2 === d2 && c2 === a;
        };
        V2.prototype.clone = function() {
          this.L.N || cb(this);
          if (this.L.$)
            return this.L.count.value += 1, this;
          var a = Q3, b2 = Object, c2 = b2.create, d2 = Object.getPrototypeOf(this), e3 = this.L;
          a = a(c2.call(b2, d2, { L: { value: { count: e3.count, Z: e3.Z, $: e3.$, N: e3.N, O: e3.O, S: e3.S, T: e3.T } } }));
          a.L.count.value += 1;
          a.L.Z = false;
          return a;
        };
        V2.prototype["delete"] = function() {
          this.L.N || cb(this);
          this.L.Z && !this.L.$ && I2("Object already scheduled for deletion");
          Qa(this);
          Sa(this.L);
          this.L.$ || (this.L.S = void 0, this.L.N = void 0);
        };
        V2.prototype.isDeleted = function() {
          return !this.L.N;
        };
        V2.prototype.deleteLater = function() {
          this.L.N || cb(this);
          this.L.Z && !this.L.$ && I2("Object already scheduled for deletion");
          L2.push(this);
          1 === L2.length && M2 && M2(La);
          this.L.Z = true;
          return this;
        };
        W2.prototype.qa = function(a) {
          this.ka && (a = this.ka(a));
          return a;
        };
        W2.prototype.ha = function(a) {
          this.V && this.V(a);
        };
        W2.prototype.argPackAdvance = 8;
        W2.prototype.readValueFromPointer = R2;
        W2.prototype.deleteObject = function(a) {
          if (null !== a)
            a["delete"]();
        };
        W2.prototype.fromWireType = function(a) {
          function b2() {
            return this.da ? Ya(this.M.W, { O: this.wa, N: c2, T: this, S: a }) : Ya(this.M.W, { O: this, N: a });
          }
          __name(b2, "b");
          var c2 = this.qa(a);
          if (!c2)
            return this.ha(a), null;
          var d2 = Va(this.M, c2);
          if (void 0 !== d2) {
            if (0 === d2.L.count.value)
              return d2.L.N = c2, d2.L.S = a, d2.clone();
            d2 = d2.clone();
            this.ha(a);
            return d2;
          }
          d2 = this.M.pa(c2);
          d2 = Ua[d2];
          if (!d2)
            return b2.call(this);
          d2 = this.ba ? d2.la : d2.pointerType;
          var e3 = Ta(c2, this.M, d2.M);
          return null === e3 ? b2.call(this) : this.da ? Ya(d2.M.W, { O: d2, N: e3, T: this, S: a }) : Ya(d2.M.W, { O: d2, N: e3 });
        };
        pb = l2.UnboundTypeError = Ha("UnboundTypeError");
        var Mb = { p: function(a, b2, c2) {
          a = K2(a);
          b2 = Pa(b2, "wrapper");
          c2 = J2(c2);
          var d2 = [].slice, e3 = b2.M, f = e3.W, g2 = e3.P.W, h2 = e3.P.constructor;
          a = Fa(a, function() {
            e3.P.ja.forEach(function(k2) {
              if (this[k2] === g2[k2])
                throw new Ja("Pure virtual function " + k2 + " must be implemented in JavaScript");
            }.bind(this));
            Object.defineProperty(this, "__parent", { value: f });
            this.__construct.apply(this, d2.call(arguments));
          });
          f.__construct = function() {
            this === f && I2("Pass correct 'this' to __construct");
            var k2 = h2.implement.apply(void 0, [this].concat(d2.call(arguments)));
            Qa(k2);
            var n2 = k2.L;
            k2.notifyOnDestruction();
            n2.$ = true;
            Object.defineProperties(this, { L: { value: n2 } });
            Q3(this);
            k2 = n2.N;
            k2 = Ma(e3, k2);
            N2.hasOwnProperty(k2) ? I2("Tried to register registered instance: " + k2) : N2[k2] = this;
          };
          f.__destruct = function() {
            this === f && I2("Pass correct 'this' to __destruct");
            Qa(this);
            var k2 = this.L.N;
            k2 = Ma(e3, k2);
            N2.hasOwnProperty(k2) ? delete N2[k2] : I2("Tried to unregister unregistered instance: " + k2);
          };
          a.prototype = Object.create(f);
          for (var m2 in c2)
            a.prototype[m2] = c2[m2];
          return Ia(a);
        }, j: function(a) {
          var b2 = Za[a];
          delete Za[a];
          var c2 = b2.fa, d2 = b2.V, e3 = b2.ia, f = e3.map((g2) => g2.ta).concat(e3.map((g2) => g2.za));
          T2([a], f, (g2) => {
            var h2 = {};
            e3.forEach((m2, k2) => {
              var n2 = g2[k2], p2 = m2.ra, r3 = m2.sa, u = g2[k2 + e3.length], t3 = m2.ya, y2 = m2.Aa;
              h2[m2.oa] = { read: (C2) => n2.fromWireType(p2(r3, C2)), write: (C2, Z2) => {
                var G2 = [];
                t3(y2, C2, u.toWireType(G2, Z2));
                $a(G2);
              } };
            });
            return [{ name: b2.name, fromWireType: function(m2) {
              var k2 = {}, n2;
              for (n2 in h2)
                k2[n2] = h2[n2].read(m2);
              d2(m2);
              return k2;
            }, toWireType: function(m2, k2) {
              for (var n2 in h2)
                if (!(n2 in k2))
                  throw new TypeError('Missing field:  "' + n2 + '"');
              var p2 = c2();
              for (n2 in h2)
                h2[n2].write(p2, k2[n2]);
              null !== m2 && m2.push(d2, p2);
              return p2;
            }, argPackAdvance: 8, readValueFromPointer: R2, U: d2 }];
          });
        }, v: function() {
        }, B: function(a, b2, c2, d2, e3) {
          var f = bb(c2);
          b2 = K2(b2);
          U2(a, { name: b2, fromWireType: function(g2) {
            return !!g2;
          }, toWireType: function(g2, h2) {
            return h2 ? d2 : e3;
          }, argPackAdvance: 8, readValueFromPointer: function(g2) {
            if (1 === c2)
              var h2 = qa;
            else if (2 === c2)
              h2 = x2;
            else if (4 === c2)
              h2 = z2;
            else
              throw new TypeError("Unknown boolean type size: " + b2);
            return this.fromWireType(h2[g2 >> f]);
          }, U: null });
        }, f: function(a, b2, c2, d2, e3, f, g2, h2, m2, k2, n2, p2, r3) {
          n2 = K2(n2);
          f = X2(e3, f);
          h2 && (h2 = X2(g2, h2));
          k2 && (k2 = X2(
            m2,
            k2
          ));
          r3 = X2(p2, r3);
          var u = Ea(n2);
          eb(u, function() {
            qb("Cannot construct " + n2 + " due to unbound types", [d2]);
          });
          T2([a, b2, c2], d2 ? [d2] : [], function(t3) {
            t3 = t3[0];
            if (d2) {
              var y2 = t3.M;
              var C2 = y2.W;
            } else
              C2 = V2.prototype;
            t3 = Fa(u, function() {
              if (Object.getPrototypeOf(this) !== Z2)
                throw new H2("Use 'new' to construct " + n2);
              if (void 0 === G2.X)
                throw new H2(n2 + " has no accessible constructor");
              var lb = G2.X[arguments.length];
              if (void 0 === lb)
                throw new H2("Tried to invoke ctor of " + n2 + " with invalid number of parameters (" + arguments.length + ") - expected (" + Object.keys(G2.X).toString() + ") parameters instead!");
              return lb.apply(this, arguments);
            });
            var Z2 = Object.create(C2, { constructor: { value: t3 } });
            t3.prototype = Z2;
            var G2 = new fb(n2, t3, Z2, r3, y2, f, h2, k2);
            y2 = new W2(n2, G2, true, false);
            C2 = new W2(n2 + "*", G2, false, false);
            var mb = new W2(n2 + " const*", G2, false, true);
            Ua[a] = { pointerType: C2, la: mb };
            nb(u, t3);
            return [y2, C2, mb];
          });
        }, c: function(a, b2, c2, d2, e3, f, g2) {
          var h2 = sb(c2, d2);
          b2 = K2(b2);
          f = X2(e3, f);
          T2([], [a], function(m2) {
            function k2() {
              qb("Cannot call " + n2 + " due to unbound types", h2);
            }
            __name(k2, "k");
            m2 = m2[0];
            var n2 = m2.name + "." + b2;
            b2.startsWith("@@") && (b2 = Symbol[b2.substring(2)]);
            var p2 = m2.M.constructor;
            void 0 === p2[b2] ? (k2.Y = c2 - 1, p2[b2] = k2) : (db(p2, b2, n2), p2[b2].R[c2 - 1] = k2);
            T2([], h2, function(r3) {
              r3 = [r3[0], null].concat(r3.slice(1));
              r3 = rb(n2, r3, null, f, g2);
              void 0 === p2[b2].R ? (r3.Y = c2 - 1, p2[b2] = r3) : p2[b2].R[c2 - 1] = r3;
              return [];
            });
            return [];
          });
        }, o: function(a, b2, c2, d2, e3, f) {
          0 < b2 || la();
          var g2 = sb(b2, c2);
          e3 = X2(d2, e3);
          T2([], [a], function(h2) {
            h2 = h2[0];
            var m2 = "constructor " + h2.name;
            void 0 === h2.M.X && (h2.M.X = []);
            if (void 0 !== h2.M.X[b2 - 1])
              throw new H2("Cannot register multiple constructors with identical number of parameters (" + (b2 - 1) + ") for class '" + h2.name + "'! Overload resolution is currently only performed using the parameter count, not actual type info!");
            h2.M.X[b2 - 1] = () => {
              qb("Cannot construct " + h2.name + " due to unbound types", g2);
            };
            T2([], g2, function(k2) {
              k2.splice(1, 0, null);
              h2.M.X[b2 - 1] = rb(m2, k2, null, e3, f);
              return [];
            });
            return [];
          });
        }, a: function(a, b2, c2, d2, e3, f, g2, h2) {
          var m2 = sb(c2, d2);
          b2 = K2(b2);
          f = X2(e3, f);
          T2([], [a], function(k2) {
            function n2() {
              qb("Cannot call " + p2 + " due to unbound types", m2);
            }
            __name(n2, "n");
            k2 = k2[0];
            var p2 = k2.name + "." + b2;
            b2.startsWith("@@") && (b2 = Symbol[b2.substring(2)]);
            h2 && k2.M.ja.push(b2);
            var r3 = k2.M.W, u = r3[b2];
            void 0 === u || void 0 === u.R && u.className !== k2.name && u.Y === c2 - 2 ? (n2.Y = c2 - 2, n2.className = k2.name, r3[b2] = n2) : (db(r3, b2, p2), r3[b2].R[c2 - 2] = n2);
            T2([], m2, function(t3) {
              t3 = rb(p2, t3, k2, f, g2);
              void 0 === r3[b2].R ? (t3.Y = c2 - 2, r3[b2] = t3) : r3[b2].R[c2 - 2] = t3;
              return [];
            });
            return [];
          });
        }, A: function(a, b2) {
          b2 = K2(b2);
          U2(a, { name: b2, fromWireType: function(c2) {
            var d2 = J2(c2);
            tb(c2);
            return d2;
          }, toWireType: function(c2, d2) {
            return Ia(d2);
          }, argPackAdvance: 8, readValueFromPointer: R2, U: null });
        }, m: function(a, b2, c2) {
          c2 = bb(c2);
          b2 = K2(b2);
          U2(a, { name: b2, fromWireType: function(d2) {
            return d2;
          }, toWireType: function(d2, e3) {
            return e3;
          }, argPackAdvance: 8, readValueFromPointer: ub(b2, c2), U: null });
        }, d: function(a, b2, c2, d2, e3) {
          b2 = K2(b2);
          -1 === e3 && (e3 = 4294967295);
          e3 = bb(c2);
          var f = /* @__PURE__ */ __name((h2) => h2, "f");
          if (0 === d2) {
            var g2 = 32 - 8 * c2;
            f = /* @__PURE__ */ __name((h2) => h2 << g2 >>> g2, "f");
          }
          c2 = b2.includes("unsigned") ? function(h2, m2) {
            return m2 >>> 0;
          } : function(h2, m2) {
            return m2;
          };
          U2(a, { name: b2, fromWireType: f, toWireType: c2, argPackAdvance: 8, readValueFromPointer: vb(b2, e3, 0 !== d2), U: null });
        }, b: function(a, b2, c2) {
          function d2(f) {
            f >>= 2;
            var g2 = A2;
            return new e3(pa2, g2[f + 1], g2[f]);
          }
          __name(d2, "d");
          var e3 = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array][b2];
          c2 = K2(c2);
          U2(
            a,
            { name: c2, fromWireType: d2, argPackAdvance: 8, readValueFromPointer: d2 },
            { ua: true }
          );
        }, n: function(a, b2) {
          b2 = K2(b2);
          var c2 = "std::string" === b2;
          U2(a, { name: b2, fromWireType: function(d2) {
            var e3 = A2[d2 >> 2], f = d2 + 4;
            if (c2)
              for (var g2 = f, h2 = 0; h2 <= e3; ++h2) {
                var m2 = f + h2;
                if (h2 == e3 || 0 == w2[m2]) {
                  g2 = g2 ? oa(w2, g2, m2 - g2) : "";
                  if (void 0 === k2)
                    var k2 = g2;
                  else
                    k2 += String.fromCharCode(0), k2 += g2;
                  g2 = m2 + 1;
                }
              }
            else {
              k2 = Array(e3);
              for (h2 = 0; h2 < e3; ++h2)
                k2[h2] = String.fromCharCode(w2[f + h2]);
              k2 = k2.join("");
            }
            P2(d2);
            return k2;
          }, toWireType: function(d2, e3) {
            e3 instanceof ArrayBuffer && (e3 = new Uint8Array(e3));
            var f, g2 = "string" == typeof e3;
            g2 || e3 instanceof Uint8Array || e3 instanceof Uint8ClampedArray || e3 instanceof Int8Array || I2("Cannot pass non-string to std::string");
            if (c2 && g2) {
              var h2 = 0;
              for (f = 0; f < e3.length; ++f) {
                var m2 = e3.charCodeAt(f);
                127 >= m2 ? h2++ : 2047 >= m2 ? h2 += 2 : 55296 <= m2 && 57343 >= m2 ? (h2 += 4, ++f) : h2 += 3;
              }
              f = h2;
            } else
              f = e3.length;
            h2 = Lb(4 + f + 1);
            m2 = h2 + 4;
            A2[h2 >> 2] = f;
            if (c2 && g2) {
              if (g2 = m2, m2 = f + 1, f = w2, 0 < m2) {
                m2 = g2 + m2 - 1;
                for (var k2 = 0; k2 < e3.length; ++k2) {
                  var n2 = e3.charCodeAt(k2);
                  if (55296 <= n2 && 57343 >= n2) {
                    var p2 = e3.charCodeAt(++k2);
                    n2 = 65536 + ((n2 & 1023) << 10) | p2 & 1023;
                  }
                  if (127 >= n2) {
                    if (g2 >= m2)
                      break;
                    f[g2++] = n2;
                  } else {
                    if (2047 >= n2) {
                      if (g2 + 1 >= m2)
                        break;
                      f[g2++] = 192 | n2 >> 6;
                    } else {
                      if (65535 >= n2) {
                        if (g2 + 2 >= m2)
                          break;
                        f[g2++] = 224 | n2 >> 12;
                      } else {
                        if (g2 + 3 >= m2)
                          break;
                        f[g2++] = 240 | n2 >> 18;
                        f[g2++] = 128 | n2 >> 12 & 63;
                      }
                      f[g2++] = 128 | n2 >> 6 & 63;
                    }
                    f[g2++] = 128 | n2 & 63;
                  }
                }
                f[g2] = 0;
              }
            } else if (g2)
              for (g2 = 0; g2 < f; ++g2)
                k2 = e3.charCodeAt(g2), 255 < k2 && (P2(m2), I2("String has UTF-16 code units that do not fit in 8 bits")), w2[m2 + g2] = k2;
            else
              for (g2 = 0; g2 < f; ++g2)
                w2[m2 + g2] = e3[g2];
            null !== d2 && d2.push(P2, h2);
            return h2;
          }, argPackAdvance: 8, readValueFromPointer: R2, U: function(d2) {
            P2(d2);
          } });
        }, i: function(a, b2, c2) {
          c2 = K2(c2);
          if (2 === b2) {
            var d2 = wb;
            var e3 = xb;
            var f = yb;
            var g2 = /* @__PURE__ */ __name(() => ra, "g");
            var h2 = 1;
          } else
            4 === b2 && (d2 = zb, e3 = Ab, f = Bb, g2 = /* @__PURE__ */ __name(() => A2, "g"), h2 = 2);
          U2(a, { name: c2, fromWireType: function(m2) {
            for (var k2 = A2[m2 >> 2], n2 = g2(), p2, r3 = m2 + 4, u = 0; u <= k2; ++u) {
              var t3 = m2 + 4 + u * b2;
              if (u == k2 || 0 == n2[t3 >> h2])
                r3 = d2(r3, t3 - r3), void 0 === p2 ? p2 = r3 : (p2 += String.fromCharCode(0), p2 += r3), r3 = t3 + b2;
            }
            P2(m2);
            return p2;
          }, toWireType: function(m2, k2) {
            "string" != typeof k2 && I2("Cannot pass non-string to C++ string type " + c2);
            var n2 = f(k2), p2 = Lb(4 + n2 + b2);
            A2[p2 >> 2] = n2 >> h2;
            e3(k2, p2 + 4, n2 + b2);
            null !== m2 && m2.push(P2, p2);
            return p2;
          }, argPackAdvance: 8, readValueFromPointer: R2, U: function(m2) {
            P2(m2);
          } });
        }, k: function(a, b2, c2, d2, e3, f) {
          Za[a] = {
            name: K2(b2),
            fa: X2(c2, d2),
            V: X2(e3, f),
            ia: []
          };
        }, h: function(a, b2, c2, d2, e3, f, g2, h2, m2, k2) {
          Za[a].ia.push({ oa: K2(b2), ta: c2, ra: X2(d2, e3), sa: f, za: g2, ya: X2(h2, m2), Aa: k2 });
        }, C: function(a, b2) {
          b2 = K2(b2);
          U2(a, { va: true, name: b2, argPackAdvance: 0, fromWireType: function() {
          }, toWireType: function() {
          } });
        }, s: function(a, b2, c2, d2, e3) {
          a = Eb[a];
          b2 = J2(b2);
          c2 = Db(c2);
          var f = [];
          A2[d2 >> 2] = Ia(f);
          return a(b2, c2, f, e3);
        }, t: function(a, b2, c2, d2) {
          a = Eb[a];
          b2 = J2(b2);
          c2 = Db(c2);
          a(b2, c2, null, d2);
        }, g: tb, l: function(a, b2) {
          var c2 = Gb(a, b2), d2 = c2[0];
          b2 = d2.name + "_$" + c2.slice(1).map(function(g2) {
            return g2.name;
          }).join("_") + "$";
          var e3 = Hb[b2];
          if (void 0 !== e3)
            return e3;
          var f = Array(a - 1);
          e3 = Fb((g2, h2, m2, k2) => {
            for (var n2 = 0, p2 = 0; p2 < a - 1; ++p2)
              f[p2] = c2[p2 + 1].readValueFromPointer(k2 + n2), n2 += c2[p2 + 1].argPackAdvance;
            g2 = g2[h2].apply(g2, f);
            for (p2 = 0; p2 < a - 1; ++p2)
              c2[p2 + 1].ma && c2[p2 + 1].ma(f[p2]);
            if (!d2.va)
              return d2.toWireType(m2, g2);
          });
          return Hb[b2] = e3;
        }, q: function(a) {
          4 < a && (F[a].ga += 1);
        }, r: function(a) {
          var b2 = J2(a);
          $a(b2);
          tb(a);
        }, e: function() {
          la("");
        }, x: function(a, b2, c2) {
          w2.copyWithin(a, b2, b2 + c2);
        }, w: function(a) {
          var b2 = w2.length;
          a >>>= 0;
          if (2147483648 < a)
            return false;
          for (var c2 = 1; 4 >= c2; c2 *= 2) {
            var d2 = b2 * (1 + 0.2 / c2);
            d2 = Math.min(d2, a + 100663296);
            var e3 = Math;
            d2 = Math.max(a, d2);
            e3 = e3.min.call(e3, 2147483648, d2 + (65536 - d2 % 65536) % 65536);
            a: {
              try {
                ma.grow(e3 - pa2.byteLength + 65535 >>> 16);
                ua();
                var f = 1;
                break a;
              } catch (g2) {
              }
              f = void 0;
            }
            if (f)
              return true;
          }
          return false;
        }, z: function() {
          return 52;
        }, u: function() {
          return 70;
        }, y: function(a, b2, c2, d2) {
          for (var e3 = 0, f = 0; f < c2; f++) {
            var g2 = A2[b2 >> 2], h2 = A2[b2 + 4 >> 2];
            b2 += 8;
            for (var m2 = 0; m2 < h2; m2++) {
              var k2 = w2[g2 + m2], n2 = Ib[a];
              0 === k2 || 10 === k2 ? ((1 === a ? ja : v2)(oa(n2, 0)), n2.length = 0) : n2.push(k2);
            }
            e3 += h2;
          }
          A2[d2 >> 2] = e3;
          return 0;
        } }, Y2 = function() {
          function a(c2) {
            l2.asm = c2.exports;
            ma = l2.asm.D;
            ua();
            va = l2.asm.I;
            xa.unshift(l2.asm.E);
            B2--;
            l2.monitorRunDependencies && l2.monitorRunDependencies(B2);
            0 == B2 && (null !== Aa && (clearInterval(Aa), Aa = null), D && (c2 = D, D = null, c2()));
          }
          __name(a, "a");
          var b2 = { a: Mb };
          B2++;
          l2.monitorRunDependencies && l2.monitorRunDependencies(B2);
          if (l2.instantiateWasm)
            try {
              return l2.instantiateWasm(b2, a);
            } catch (c2) {
              v2("Module.instantiateWasm callback failed with error: " + c2), ba(c2);
            }
          b2 = Ca(b2);
          a(b2[0]);
          return l2.asm;
        }();
        l2.___wasm_call_ctors = Y2.E;
        var Oa = l2.___getTypeName = Y2.F;
        l2.__embind_initialize_bindings = Y2.G;
        var Lb = l2._malloc = Y2.H, P2 = l2._free = Y2.J;
        l2.dynCall_jiji = Y2.K;
        var Nb;
        D = /* @__PURE__ */ __name(function Ob() {
          Nb || Pb();
          Nb || (D = Ob);
        }, "Ob");
        function Pb() {
          function a() {
            if (!Nb && (Nb = true, l2.calledRun = true, !na)) {
              Da(xa);
              aa(l2);
              if (l2.onRuntimeInitialized)
                l2.onRuntimeInitialized();
              if (l2.postRun)
                for ("function" == typeof l2.postRun && (l2.postRun = [l2.postRun]); l2.postRun.length; ) {
                  var b2 = l2.postRun.shift();
                  ya.unshift(b2);
                }
              Da(ya);
            }
          }
          __name(a, "a");
          if (!(0 < B2)) {
            if (l2.preRun)
              for ("function" == typeof l2.preRun && (l2.preRun = [l2.preRun]); l2.preRun.length; )
                za();
            Da(wa);
            0 < B2 || (l2.setStatus ? (l2.setStatus("Running..."), setTimeout(function() {
              setTimeout(function() {
                l2.setStatus("");
              }, 1);
              a();
            }, 1)) : a());
          }
        }
        __name(Pb, "Pb");
        if (l2.preInit)
          for ("function" == typeof l2.preInit && (l2.preInit = [l2.preInit]); 0 < l2.preInit.length; )
            l2.preInit.pop()();
        Pb();
        return loadYoga2;
      };
    })();
    if (typeof exports2 === "object" && typeof module3 === "object")
      module3.exports = loadYoga;
    else if (typeof define === "function" && define["amd"])
      define([], function() {
        return loadYoga;
      });
    else if (typeof exports2 === "object")
      exports2["loadYoga"] = loadYoga;
  }
});

// ../../node_modules/.pnpm/file+vendor+yoga-layout-2.0.0-beta.1.tgz/node_modules/yoga-layout/dist/generated/YGEnums.js
var require_YGEnums = __commonJS({
  "../../node_modules/.pnpm/file+vendor+yoga-layout-2.0.0-beta.1.tgz/node_modules/yoga-layout/dist/generated/YGEnums.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = {
      ALIGN_AUTO: 0,
      ALIGN_FLEX_START: 1,
      ALIGN_CENTER: 2,
      ALIGN_FLEX_END: 3,
      ALIGN_STRETCH: 4,
      ALIGN_BASELINE: 5,
      ALIGN_SPACE_BETWEEN: 6,
      ALIGN_SPACE_AROUND: 7,
      DIMENSION_WIDTH: 0,
      DIMENSION_HEIGHT: 1,
      DIRECTION_INHERIT: 0,
      DIRECTION_LTR: 1,
      DIRECTION_RTL: 2,
      DISPLAY_FLEX: 0,
      DISPLAY_NONE: 1,
      EDGE_LEFT: 0,
      EDGE_TOP: 1,
      EDGE_RIGHT: 2,
      EDGE_BOTTOM: 3,
      EDGE_START: 4,
      EDGE_END: 5,
      EDGE_HORIZONTAL: 6,
      EDGE_VERTICAL: 7,
      EDGE_ALL: 8,
      EXPERIMENTAL_FEATURE_WEB_FLEX_BASIS: 0,
      FLEX_DIRECTION_COLUMN: 0,
      FLEX_DIRECTION_COLUMN_REVERSE: 1,
      FLEX_DIRECTION_ROW: 2,
      FLEX_DIRECTION_ROW_REVERSE: 3,
      GUTTER_COLUMN: 0,
      GUTTER_ROW: 1,
      GUTTER_ALL: 2,
      JUSTIFY_FLEX_START: 0,
      JUSTIFY_CENTER: 1,
      JUSTIFY_FLEX_END: 2,
      JUSTIFY_SPACE_BETWEEN: 3,
      JUSTIFY_SPACE_AROUND: 4,
      JUSTIFY_SPACE_EVENLY: 5,
      LOG_LEVEL_ERROR: 0,
      LOG_LEVEL_WARN: 1,
      LOG_LEVEL_INFO: 2,
      LOG_LEVEL_DEBUG: 3,
      LOG_LEVEL_VERBOSE: 4,
      LOG_LEVEL_FATAL: 5,
      MEASURE_MODE_UNDEFINED: 0,
      MEASURE_MODE_EXACTLY: 1,
      MEASURE_MODE_AT_MOST: 2,
      NODE_TYPE_DEFAULT: 0,
      NODE_TYPE_TEXT: 1,
      OVERFLOW_VISIBLE: 0,
      OVERFLOW_HIDDEN: 1,
      OVERFLOW_SCROLL: 2,
      POSITION_TYPE_STATIC: 0,
      POSITION_TYPE_RELATIVE: 1,
      POSITION_TYPE_ABSOLUTE: 2,
      PRINT_OPTIONS_LAYOUT: 1,
      PRINT_OPTIONS_STYLE: 2,
      PRINT_OPTIONS_CHILDREN: 4,
      UNIT_UNDEFINED: 0,
      UNIT_POINT: 1,
      UNIT_PERCENT: 2,
      UNIT_AUTO: 3,
      WRAP_NO_WRAP: 0,
      WRAP_WRAP: 1,
      WRAP_WRAP_REVERSE: 2
    };
  }
});

// ../../node_modules/.pnpm/file+vendor+yoga-layout-2.0.0-beta.1.tgz/node_modules/yoga-layout/dist/wrapAsm.js
var require_wrapAsm = __commonJS({
  "../../node_modules/.pnpm/file+vendor+yoga-layout-2.0.0-beta.1.tgz/node_modules/yoga-layout/dist/wrapAsm.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var CONSTANTS = require_YGEnums();
    module3.exports = (lib) => {
      function patch(prototype, name, fn2) {
        const original = prototype[name];
        prototype[name] = function() {
          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
            args[_key] = arguments[_key];
          }
          return fn2.call(this, original, ...args);
        };
      }
      __name(patch, "patch");
      for (const fnName of ["setPosition", "setMargin", "setFlexBasis", "setWidth", "setHeight", "setMinWidth", "setMinHeight", "setMaxWidth", "setMaxHeight", "setPadding"]) {
        const methods = {
          [CONSTANTS.UNIT_POINT]: lib.Node.prototype[fnName],
          [CONSTANTS.UNIT_PERCENT]: lib.Node.prototype[`${fnName}Percent`],
          [CONSTANTS.UNIT_AUTO]: lib.Node.prototype[`${fnName}Auto`]
        };
        patch(lib.Node.prototype, fnName, function(original) {
          for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
            args[_key2 - 1] = arguments[_key2];
          }
          const value = args.pop();
          let unit, asNumber;
          if (value === "auto") {
            unit = CONSTANTS.UNIT_AUTO;
            asNumber = void 0;
          } else if (typeof value === "object") {
            unit = value.unit;
            asNumber = value.valueOf();
          } else {
            unit = typeof value === "string" && value.endsWith("%") ? CONSTANTS.UNIT_PERCENT : CONSTANTS.UNIT_POINT;
            asNumber = parseFloat(value);
            if (!Number.isNaN(value) && Number.isNaN(asNumber)) {
              throw new Error(`Invalid value ${value} for ${fnName}`);
            }
          }
          if (!methods[unit])
            throw new Error(`Failed to execute "${fnName}": Unsupported unit '${value}'`);
          if (asNumber !== void 0) {
            return methods[unit].call(this, ...args, asNumber);
          } else {
            return methods[unit].call(this, ...args);
          }
        });
      }
      function wrapMeasureFunction(measureFunction) {
        return lib.MeasureCallback.implement({
          measure: measureFunction
        });
      }
      __name(wrapMeasureFunction, "wrapMeasureFunction");
      patch(lib.Node.prototype, "setMeasureFunc", function(original, measureFunc) {
        original.call(this, wrapMeasureFunction(measureFunc));
      });
      function wrapDirtiedFunc(dirtiedFunction) {
        return lib.DirtiedCallback.implement({
          dirtied: dirtiedFunction
        });
      }
      __name(wrapDirtiedFunc, "wrapDirtiedFunc");
      patch(lib.Node.prototype, "setDirtiedFunc", function(original, dirtiedFunc) {
        original.call(this, wrapDirtiedFunc(dirtiedFunc));
      });
      patch(lib.Config.prototype, "free", function() {
        lib.Config.destroy(this);
      });
      patch(lib.Node, "create", (_3, config) => {
        return config ? lib.Node.createWithConfig(config) : lib.Node.createDefault();
      });
      patch(lib.Node.prototype, "free", function() {
        lib.Node.destroy(this);
      });
      patch(lib.Node.prototype, "freeRecursive", function() {
        for (let t3 = 0, T2 = this.getChildCount(); t3 < T2; ++t3) {
          this.getChild(0).freeRecursive();
        }
        this.free();
      });
      patch(lib.Node.prototype, "setMeasureFunc", function(original, measureFunc) {
        if (measureFunc) {
          return original.call(this, function() {
            return measureFunc(...arguments);
          });
        } else {
          return this.unsetMeasureFunc();
        }
      });
      patch(lib.Node.prototype, "calculateLayout", function(original) {
        let width = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : NaN;
        let height = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : NaN;
        let direction = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : CONSTANTS.DIRECTION_LTR;
        return original.call(this, width, height, direction);
      });
      return {
        Config: lib.Config,
        Node: lib.Node,
        ...CONSTANTS
      };
    };
  }
});

// ../../node_modules/.pnpm/file+vendor+yoga-layout-2.0.0-beta.1.tgz/node_modules/yoga-layout/dist/entrypoint/_entrySync.js
var require_entrySync = __commonJS({
  "../../node_modules/.pnpm/file+vendor+yoga-layout-2.0.0-beta.1.tgz/node_modules/yoga-layout/dist/entrypoint/_entrySync.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var wrapAsm = require_wrapAsm();
    module3.exports = (asm) => wrapAsm(asm());
  }
});

// ../../node_modules/.pnpm/file+vendor+yoga-layout-2.0.0-beta.1.tgz/node_modules/yoga-layout/dist/entrypoint/wasm-sync.js
var require_wasm_sync2 = __commonJS({
  "../../node_modules/.pnpm/file+vendor+yoga-layout-2.0.0-beta.1.tgz/node_modules/yoga-layout/dist/entrypoint/wasm-sync.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var asm = require_wasm_sync();
    module3.exports = require_entrySync()(asm);
  }
});

// ../../node_modules/.pnpm/ansi-regex@5.0.1/node_modules/ansi-regex/index.js
var require_ansi_regex = __commonJS({
  "../../node_modules/.pnpm/ansi-regex@5.0.1/node_modules/ansi-regex/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = ({ onlyFirst = false } = {}) => {
      const pattern = [
        "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
        "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))"
      ].join("|");
      return new RegExp(pattern, onlyFirst ? void 0 : "g");
    };
  }
});

// ../../node_modules/.pnpm/strip-ansi@6.0.1/node_modules/strip-ansi/index.js
var require_strip_ansi = __commonJS({
  "../../node_modules/.pnpm/strip-ansi@6.0.1/node_modules/strip-ansi/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var ansiRegex2 = require_ansi_regex();
    module3.exports = (string) => typeof string === "string" ? string.replace(ansiRegex2(), "") : string;
  }
});

// ../../node_modules/.pnpm/is-fullwidth-code-point@3.0.0/node_modules/is-fullwidth-code-point/index.js
var require_is_fullwidth_code_point = __commonJS({
  "../../node_modules/.pnpm/is-fullwidth-code-point@3.0.0/node_modules/is-fullwidth-code-point/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var isFullwidthCodePoint2 = /* @__PURE__ */ __name((codePoint) => {
      if (Number.isNaN(codePoint)) {
        return false;
      }
      if (codePoint >= 4352 && (codePoint <= 4447 || // Hangul Jamo
      codePoint === 9001 || // LEFT-POINTING ANGLE BRACKET
      codePoint === 9002 || // RIGHT-POINTING ANGLE BRACKET
      // CJK Radicals Supplement .. Enclosed CJK Letters and Months
      11904 <= codePoint && codePoint <= 12871 && codePoint !== 12351 || // Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A
      12880 <= codePoint && codePoint <= 19903 || // CJK Unified Ideographs .. Yi Radicals
      19968 <= codePoint && codePoint <= 42182 || // Hangul Jamo Extended-A
      43360 <= codePoint && codePoint <= 43388 || // Hangul Syllables
      44032 <= codePoint && codePoint <= 55203 || // CJK Compatibility Ideographs
      63744 <= codePoint && codePoint <= 64255 || // Vertical Forms
      65040 <= codePoint && codePoint <= 65049 || // CJK Compatibility Forms .. Small Form Variants
      65072 <= codePoint && codePoint <= 65131 || // Halfwidth and Fullwidth Forms
      65281 <= codePoint && codePoint <= 65376 || 65504 <= codePoint && codePoint <= 65510 || // Kana Supplement
      110592 <= codePoint && codePoint <= 110593 || // Enclosed Ideographic Supplement
      127488 <= codePoint && codePoint <= 127569 || // CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane
      131072 <= codePoint && codePoint <= 262141)) {
        return true;
      }
      return false;
    }, "isFullwidthCodePoint");
    module3.exports = isFullwidthCodePoint2;
    module3.exports.default = isFullwidthCodePoint2;
  }
});

// ../../node_modules/.pnpm/emoji-regex@8.0.0/node_modules/emoji-regex/index.js
var require_emoji_regex = __commonJS({
  "../../node_modules/.pnpm/emoji-regex@8.0.0/node_modules/emoji-regex/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = function() {
      return /\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62(?:\uDB40\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDB40\uDC73\uDB40\uDC63\uDB40\uDC74|\uDB40\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F|\uD83D\uDC68(?:\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFE])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83D\uDC68|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D[\uDC66\uDC67])|[\u2695\u2696\u2708]\uFE0F|\uD83D[\uDC66\uDC67]|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|(?:\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708])\uFE0F|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C[\uDFFB-\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)\uD83C\uDFFB|\uD83E\uDDD1(?:\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])|\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1)|(?:\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB-\uDFFE])|(?:\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)(?:\uD83C[\uDFFB\uDFFC])|\uD83D\uDC69(?:\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFC-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|(?:\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)(?:\uD83C[\uDFFB-\uDFFD])|\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D\uDC41\uFE0F\u200D\uD83D\uDDE8|\uD83D\uDC69(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|(?:(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)\uFE0F|\uD83D\uDC6F|\uD83E[\uDD3C\uDDDE\uDDDF])\u200D[\u2640\u2642]|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD6-\uDDDD])(?:(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|\u200D[\u2640\u2642])|\uD83C\uDFF4\u200D\u2620)\uFE0F|\uD83D\uDC69\u200D\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|\uD83C\uDFF3\uFE0F\u200D\uD83C\uDF08|\uD83D\uDC15\u200D\uD83E\uDDBA|\uD83D\uDC69\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC67|\uD83C\uDDFD\uD83C\uDDF0|\uD83C\uDDF4\uD83C\uDDF2|\uD83C\uDDF6\uD83C\uDDE6|[#\*0-9]\uFE0F\u20E3|\uD83C\uDDE7(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF])|\uD83C\uDDF9(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF])|\uD83C\uDDEA(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA])|\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])|\uD83C\uDDF7(?:\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC])|\uD83D\uDC69(?:\uD83C[\uDFFB-\uDFFF])|\uD83C\uDDF2(?:\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF])|\uD83C\uDDE6(?:\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF])|\uD83C\uDDF0(?:\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF])|\uD83C\uDDED(?:\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA])|\uD83C\uDDE9(?:\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF])|\uD83C\uDDFE(?:\uD83C[\uDDEA\uDDF9])|\uD83C\uDDEC(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE])|\uD83C\uDDF8(?:\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF])|\uD83C\uDDEB(?:\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7])|\uD83C\uDDF5(?:\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE])|\uD83C\uDDFB(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA])|\uD83C\uDDF3(?:\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF])|\uD83C\uDDE8(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF])|\uD83C\uDDF1(?:\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE])|\uD83C\uDDFF(?:\uD83C[\uDDE6\uDDF2\uDDFC])|\uD83C\uDDFC(?:\uD83C[\uDDEB\uDDF8])|\uD83C\uDDFA(?:\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF])|\uD83C\uDDEE(?:\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9])|\uD83C\uDDEF(?:\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5])|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u261D\u270A-\u270D]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC70\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDCAA\uDD74\uDD7A\uDD90\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0F\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD36\uDDB5\uDDB6\uDDBB\uDDD2-\uDDD5])(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u270A\u270B\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF93\uDFA0-\uDFCA\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF4\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC3E\uDC40\uDC42-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDD7A\uDD95\uDD96\uDDA4\uDDFB-\uDE4F\uDE80-\uDEC5\uDECC\uDED0-\uDED2\uDED5\uDEEB\uDEEC\uDEF4-\uDEFA\uDFE0-\uDFEB]|\uD83E[\uDD0D-\uDD3A\uDD3C-\uDD45\uDD47-\uDD71\uDD73-\uDD76\uDD7A-\uDDA2\uDDA5-\uDDAA\uDDAE-\uDDCA\uDDCD-\uDDFF\uDE70-\uDE73\uDE78-\uDE7A\uDE80-\uDE82\uDE90-\uDE95])|(?:[#\*0-9\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23E9-\u23F3\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB-\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u261D\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692-\u2697\u2699\u269B\u269C\u26A0\u26A1\u26AA\u26AB\u26B0\u26B1\u26BD\u26BE\u26C4\u26C5\u26C8\u26CE\u26CF\u26D1\u26D3\u26D4\u26E9\u26EA\u26F0-\u26F5\u26F7-\u26FA\u26FD\u2702\u2705\u2708-\u270D\u270F\u2712\u2714\u2716\u271D\u2721\u2728\u2733\u2734\u2744\u2747\u274C\u274E\u2753-\u2755\u2757\u2763\u2764\u2795-\u2797\u27A1\u27B0\u27BF\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B50\u2B55\u3030\u303D\u3297\u3299]|\uD83C[\uDC04\uDCCF\uDD70\uDD71\uDD7E\uDD7F\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE02\uDE1A\uDE2F\uDE32-\uDE3A\uDE50\uDE51\uDF00-\uDF21\uDF24-\uDF93\uDF96\uDF97\uDF99-\uDF9B\uDF9E-\uDFF0\uDFF3-\uDFF5\uDFF7-\uDFFF]|\uD83D[\uDC00-\uDCFD\uDCFF-\uDD3D\uDD49-\uDD4E\uDD50-\uDD67\uDD6F\uDD70\uDD73-\uDD7A\uDD87\uDD8A-\uDD8D\uDD90\uDD95\uDD96\uDDA4\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA-\uDE4F\uDE80-\uDEC5\uDECB-\uDED2\uDED5\uDEE0-\uDEE5\uDEE9\uDEEB\uDEEC\uDEF0\uDEF3-\uDEFA\uDFE0-\uDFEB]|\uD83E[\uDD0D-\uDD3A\uDD3C-\uDD45\uDD47-\uDD71\uDD73-\uDD76\uDD7A-\uDDA2\uDDA5-\uDDAA\uDDAE-\uDDCA\uDDCD-\uDDFF\uDE70-\uDE73\uDE78-\uDE7A\uDE80-\uDE82\uDE90-\uDE95])\uFE0F|(?:[\u261D\u26F9\u270A-\u270D]|\uD83C[\uDF85\uDFC2-\uDFC4\uDFC7\uDFCA-\uDFCC]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66-\uDC78\uDC7C\uDC81-\uDC83\uDC85-\uDC87\uDC8F\uDC91\uDCAA\uDD74\uDD75\uDD7A\uDD90\uDD95\uDD96\uDE45-\uDE47\uDE4B-\uDE4F\uDEA3\uDEB4-\uDEB6\uDEC0\uDECC]|\uD83E[\uDD0F\uDD18-\uDD1F\uDD26\uDD30-\uDD39\uDD3C-\uDD3E\uDDB5\uDDB6\uDDB8\uDDB9\uDDBB\uDDCD-\uDDCF\uDDD1-\uDDDD])/g;
    };
  }
});

// ../../node_modules/.pnpm/string-width@4.2.3/node_modules/string-width/index.js
var require_string_width = __commonJS({
  "../../node_modules/.pnpm/string-width@4.2.3/node_modules/string-width/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var stripAnsi4 = require_strip_ansi();
    var isFullwidthCodePoint2 = require_is_fullwidth_code_point();
    var emojiRegex2 = require_emoji_regex();
    var stringWidth2 = /* @__PURE__ */ __name((string) => {
      if (typeof string !== "string" || string.length === 0) {
        return 0;
      }
      string = stripAnsi4(string);
      if (string.length === 0) {
        return 0;
      }
      string = string.replace(emojiRegex2(), "  ");
      let width = 0;
      for (let i = 0; i < string.length; i++) {
        const code = string.codePointAt(i);
        if (code <= 31 || code >= 127 && code <= 159) {
          continue;
        }
        if (code >= 768 && code <= 879) {
          continue;
        }
        if (code > 65535) {
          i++;
        }
        width += isFullwidthCodePoint2(code) ? 2 : 1;
      }
      return width;
    }, "stringWidth");
    module3.exports = stringWidth2;
    module3.exports.default = stringWidth2;
  }
});

// ../../node_modules/.pnpm/widest-line@3.1.0/node_modules/widest-line/index.js
var require_widest_line = __commonJS({
  "../../node_modules/.pnpm/widest-line@3.1.0/node_modules/widest-line/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var stringWidth2 = require_string_width();
    var widestLine = /* @__PURE__ */ __name((input) => {
      let max = 0;
      for (const line of input.split("\n")) {
        max = Math.max(max, stringWidth2(line));
      }
      return max;
    }, "widestLine");
    module3.exports = widestLine;
    module3.exports.default = widestLine;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/measure-text.js
var require_measure_text = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/measure-text.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var widest_line_1 = __importDefault(require_widest_line());
    var cache2 = {};
    exports2.default = (text) => {
      if (text.length === 0) {
        return {
          width: 0,
          height: 0
        };
      }
      if (cache2[text]) {
        return cache2[text];
      }
      const width = widest_line_1.default(text);
      const height = text.split("\n").length;
      cache2[text] = { width, height };
      return { width, height };
    };
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/styles.js
var require_styles = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/styles.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var yoga_layout_prebuilt_1 = __importDefault(require_wasm_sync2());
    var applyPositionStyles = /* @__PURE__ */ __name((node2, style) => {
      if ("position" in style) {
        node2.setPositionType(style.position === "absolute" ? yoga_layout_prebuilt_1.default.POSITION_TYPE_ABSOLUTE : yoga_layout_prebuilt_1.default.POSITION_TYPE_RELATIVE);
      }
    }, "applyPositionStyles");
    var applyMarginStyles = /* @__PURE__ */ __name((node2, style) => {
      if ("marginLeft" in style) {
        node2.setMargin(yoga_layout_prebuilt_1.default.EDGE_START, style.marginLeft || 0);
      }
      if ("marginRight" in style) {
        node2.setMargin(yoga_layout_prebuilt_1.default.EDGE_END, style.marginRight || 0);
      }
      if ("marginTop" in style) {
        node2.setMargin(yoga_layout_prebuilt_1.default.EDGE_TOP, style.marginTop || 0);
      }
      if ("marginBottom" in style) {
        node2.setMargin(yoga_layout_prebuilt_1.default.EDGE_BOTTOM, style.marginBottom || 0);
      }
    }, "applyMarginStyles");
    var applyPaddingStyles = /* @__PURE__ */ __name((node2, style) => {
      if ("paddingLeft" in style) {
        node2.setPadding(yoga_layout_prebuilt_1.default.EDGE_LEFT, style.paddingLeft || 0);
      }
      if ("paddingRight" in style) {
        node2.setPadding(yoga_layout_prebuilt_1.default.EDGE_RIGHT, style.paddingRight || 0);
      }
      if ("paddingTop" in style) {
        node2.setPadding(yoga_layout_prebuilt_1.default.EDGE_TOP, style.paddingTop || 0);
      }
      if ("paddingBottom" in style) {
        node2.setPadding(yoga_layout_prebuilt_1.default.EDGE_BOTTOM, style.paddingBottom || 0);
      }
    }, "applyPaddingStyles");
    var applyFlexStyles = /* @__PURE__ */ __name((node2, style) => {
      var _a2;
      if ("flexGrow" in style) {
        node2.setFlexGrow((_a2 = style.flexGrow) !== null && _a2 !== void 0 ? _a2 : 0);
      }
      if ("flexShrink" in style) {
        node2.setFlexShrink(typeof style.flexShrink === "number" ? style.flexShrink : 1);
      }
      if ("flexDirection" in style) {
        if (style.flexDirection === "row") {
          node2.setFlexDirection(yoga_layout_prebuilt_1.default.FLEX_DIRECTION_ROW);
        }
        if (style.flexDirection === "row-reverse") {
          node2.setFlexDirection(yoga_layout_prebuilt_1.default.FLEX_DIRECTION_ROW_REVERSE);
        }
        if (style.flexDirection === "column") {
          node2.setFlexDirection(yoga_layout_prebuilt_1.default.FLEX_DIRECTION_COLUMN);
        }
        if (style.flexDirection === "column-reverse") {
          node2.setFlexDirection(yoga_layout_prebuilt_1.default.FLEX_DIRECTION_COLUMN_REVERSE);
        }
      }
      if ("flexBasis" in style) {
        if (typeof style.flexBasis === "number") {
          node2.setFlexBasis(style.flexBasis);
        } else if (typeof style.flexBasis === "string") {
          node2.setFlexBasisPercent(Number.parseInt(style.flexBasis, 10));
        } else {
          node2.setFlexBasis(NaN);
        }
      }
      if ("alignItems" in style) {
        if (style.alignItems === "stretch" || !style.alignItems) {
          node2.setAlignItems(yoga_layout_prebuilt_1.default.ALIGN_STRETCH);
        }
        if (style.alignItems === "flex-start") {
          node2.setAlignItems(yoga_layout_prebuilt_1.default.ALIGN_FLEX_START);
        }
        if (style.alignItems === "center") {
          node2.setAlignItems(yoga_layout_prebuilt_1.default.ALIGN_CENTER);
        }
        if (style.alignItems === "flex-end") {
          node2.setAlignItems(yoga_layout_prebuilt_1.default.ALIGN_FLEX_END);
        }
      }
      if ("alignSelf" in style) {
        if (style.alignSelf === "auto" || !style.alignSelf) {
          node2.setAlignSelf(yoga_layout_prebuilt_1.default.ALIGN_AUTO);
        }
        if (style.alignSelf === "flex-start") {
          node2.setAlignSelf(yoga_layout_prebuilt_1.default.ALIGN_FLEX_START);
        }
        if (style.alignSelf === "center") {
          node2.setAlignSelf(yoga_layout_prebuilt_1.default.ALIGN_CENTER);
        }
        if (style.alignSelf === "flex-end") {
          node2.setAlignSelf(yoga_layout_prebuilt_1.default.ALIGN_FLEX_END);
        }
      }
      if ("justifyContent" in style) {
        if (style.justifyContent === "flex-start" || !style.justifyContent) {
          node2.setJustifyContent(yoga_layout_prebuilt_1.default.JUSTIFY_FLEX_START);
        }
        if (style.justifyContent === "center") {
          node2.setJustifyContent(yoga_layout_prebuilt_1.default.JUSTIFY_CENTER);
        }
        if (style.justifyContent === "flex-end") {
          node2.setJustifyContent(yoga_layout_prebuilt_1.default.JUSTIFY_FLEX_END);
        }
        if (style.justifyContent === "space-between") {
          node2.setJustifyContent(yoga_layout_prebuilt_1.default.JUSTIFY_SPACE_BETWEEN);
        }
        if (style.justifyContent === "space-around") {
          node2.setJustifyContent(yoga_layout_prebuilt_1.default.JUSTIFY_SPACE_AROUND);
        }
      }
    }, "applyFlexStyles");
    var applyDimensionStyles = /* @__PURE__ */ __name((node2, style) => {
      var _a2, _b2;
      if ("width" in style) {
        if (typeof style.width === "number") {
          node2.setWidth(style.width);
        } else if (typeof style.width === "string") {
          node2.setWidthPercent(Number.parseInt(style.width, 10));
        } else {
          node2.setWidthAuto();
        }
      }
      if ("height" in style) {
        if (typeof style.height === "number") {
          node2.setHeight(style.height);
        } else if (typeof style.height === "string") {
          node2.setHeightPercent(Number.parseInt(style.height, 10));
        } else {
          node2.setHeightAuto();
        }
      }
      if ("minWidth" in style) {
        if (typeof style.minWidth === "string") {
          node2.setMinWidthPercent(Number.parseInt(style.minWidth, 10));
        } else {
          node2.setMinWidth((_a2 = style.minWidth) !== null && _a2 !== void 0 ? _a2 : 0);
        }
      }
      if ("minHeight" in style) {
        if (typeof style.minHeight === "string") {
          node2.setMinHeightPercent(Number.parseInt(style.minHeight, 10));
        } else {
          node2.setMinHeight((_b2 = style.minHeight) !== null && _b2 !== void 0 ? _b2 : 0);
        }
      }
    }, "applyDimensionStyles");
    var applyDisplayStyles = /* @__PURE__ */ __name((node2, style) => {
      if ("display" in style) {
        node2.setDisplay(style.display === "flex" ? yoga_layout_prebuilt_1.default.DISPLAY_FLEX : yoga_layout_prebuilt_1.default.DISPLAY_NONE);
      }
    }, "applyDisplayStyles");
    var applyBorderStyles = /* @__PURE__ */ __name((node2, style) => {
      if ("borderStyle" in style) {
        const borderWidth = typeof style.borderStyle === "string" ? 1 : 0;
        node2.setBorder(yoga_layout_prebuilt_1.default.EDGE_TOP, borderWidth);
        node2.setBorder(yoga_layout_prebuilt_1.default.EDGE_BOTTOM, borderWidth);
        node2.setBorder(yoga_layout_prebuilt_1.default.EDGE_LEFT, borderWidth);
        node2.setBorder(yoga_layout_prebuilt_1.default.EDGE_RIGHT, borderWidth);
      }
    }, "applyBorderStyles");
    exports2.default = (node2, style = {}) => {
      applyPositionStyles(node2, style);
      applyMarginStyles(node2, style);
      applyPaddingStyles(node2, style);
      applyFlexStyles(node2, style);
      applyDimensionStyles(node2, style);
      applyDisplayStyles(node2, style);
      applyBorderStyles(node2, style);
    };
  }
});

// ../../node_modules/.pnpm/color-name@1.1.4/node_modules/color-name/index.js
var require_color_name = __commonJS({
  "../../node_modules/.pnpm/color-name@1.1.4/node_modules/color-name/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = {
      "aliceblue": [240, 248, 255],
      "antiquewhite": [250, 235, 215],
      "aqua": [0, 255, 255],
      "aquamarine": [127, 255, 212],
      "azure": [240, 255, 255],
      "beige": [245, 245, 220],
      "bisque": [255, 228, 196],
      "black": [0, 0, 0],
      "blanchedalmond": [255, 235, 205],
      "blue": [0, 0, 255],
      "blueviolet": [138, 43, 226],
      "brown": [165, 42, 42],
      "burlywood": [222, 184, 135],
      "cadetblue": [95, 158, 160],
      "chartreuse": [127, 255, 0],
      "chocolate": [210, 105, 30],
      "coral": [255, 127, 80],
      "cornflowerblue": [100, 149, 237],
      "cornsilk": [255, 248, 220],
      "crimson": [220, 20, 60],
      "cyan": [0, 255, 255],
      "darkblue": [0, 0, 139],
      "darkcyan": [0, 139, 139],
      "darkgoldenrod": [184, 134, 11],
      "darkgray": [169, 169, 169],
      "darkgreen": [0, 100, 0],
      "darkgrey": [169, 169, 169],
      "darkkhaki": [189, 183, 107],
      "darkmagenta": [139, 0, 139],
      "darkolivegreen": [85, 107, 47],
      "darkorange": [255, 140, 0],
      "darkorchid": [153, 50, 204],
      "darkred": [139, 0, 0],
      "darksalmon": [233, 150, 122],
      "darkseagreen": [143, 188, 143],
      "darkslateblue": [72, 61, 139],
      "darkslategray": [47, 79, 79],
      "darkslategrey": [47, 79, 79],
      "darkturquoise": [0, 206, 209],
      "darkviolet": [148, 0, 211],
      "deeppink": [255, 20, 147],
      "deepskyblue": [0, 191, 255],
      "dimgray": [105, 105, 105],
      "dimgrey": [105, 105, 105],
      "dodgerblue": [30, 144, 255],
      "firebrick": [178, 34, 34],
      "floralwhite": [255, 250, 240],
      "forestgreen": [34, 139, 34],
      "fuchsia": [255, 0, 255],
      "gainsboro": [220, 220, 220],
      "ghostwhite": [248, 248, 255],
      "gold": [255, 215, 0],
      "goldenrod": [218, 165, 32],
      "gray": [128, 128, 128],
      "green": [0, 128, 0],
      "greenyellow": [173, 255, 47],
      "grey": [128, 128, 128],
      "honeydew": [240, 255, 240],
      "hotpink": [255, 105, 180],
      "indianred": [205, 92, 92],
      "indigo": [75, 0, 130],
      "ivory": [255, 255, 240],
      "khaki": [240, 230, 140],
      "lavender": [230, 230, 250],
      "lavenderblush": [255, 240, 245],
      "lawngreen": [124, 252, 0],
      "lemonchiffon": [255, 250, 205],
      "lightblue": [173, 216, 230],
      "lightcoral": [240, 128, 128],
      "lightcyan": [224, 255, 255],
      "lightgoldenrodyellow": [250, 250, 210],
      "lightgray": [211, 211, 211],
      "lightgreen": [144, 238, 144],
      "lightgrey": [211, 211, 211],
      "lightpink": [255, 182, 193],
      "lightsalmon": [255, 160, 122],
      "lightseagreen": [32, 178, 170],
      "lightskyblue": [135, 206, 250],
      "lightslategray": [119, 136, 153],
      "lightslategrey": [119, 136, 153],
      "lightsteelblue": [176, 196, 222],
      "lightyellow": [255, 255, 224],
      "lime": [0, 255, 0],
      "limegreen": [50, 205, 50],
      "linen": [250, 240, 230],
      "magenta": [255, 0, 255],
      "maroon": [128, 0, 0],
      "mediumaquamarine": [102, 205, 170],
      "mediumblue": [0, 0, 205],
      "mediumorchid": [186, 85, 211],
      "mediumpurple": [147, 112, 219],
      "mediumseagreen": [60, 179, 113],
      "mediumslateblue": [123, 104, 238],
      "mediumspringgreen": [0, 250, 154],
      "mediumturquoise": [72, 209, 204],
      "mediumvioletred": [199, 21, 133],
      "midnightblue": [25, 25, 112],
      "mintcream": [245, 255, 250],
      "mistyrose": [255, 228, 225],
      "moccasin": [255, 228, 181],
      "navajowhite": [255, 222, 173],
      "navy": [0, 0, 128],
      "oldlace": [253, 245, 230],
      "olive": [128, 128, 0],
      "olivedrab": [107, 142, 35],
      "orange": [255, 165, 0],
      "orangered": [255, 69, 0],
      "orchid": [218, 112, 214],
      "palegoldenrod": [238, 232, 170],
      "palegreen": [152, 251, 152],
      "paleturquoise": [175, 238, 238],
      "palevioletred": [219, 112, 147],
      "papayawhip": [255, 239, 213],
      "peachpuff": [255, 218, 185],
      "peru": [205, 133, 63],
      "pink": [255, 192, 203],
      "plum": [221, 160, 221],
      "powderblue": [176, 224, 230],
      "purple": [128, 0, 128],
      "rebeccapurple": [102, 51, 153],
      "red": [255, 0, 0],
      "rosybrown": [188, 143, 143],
      "royalblue": [65, 105, 225],
      "saddlebrown": [139, 69, 19],
      "salmon": [250, 128, 114],
      "sandybrown": [244, 164, 96],
      "seagreen": [46, 139, 87],
      "seashell": [255, 245, 238],
      "sienna": [160, 82, 45],
      "silver": [192, 192, 192],
      "skyblue": [135, 206, 235],
      "slateblue": [106, 90, 205],
      "slategray": [112, 128, 144],
      "slategrey": [112, 128, 144],
      "snow": [255, 250, 250],
      "springgreen": [0, 255, 127],
      "steelblue": [70, 130, 180],
      "tan": [210, 180, 140],
      "teal": [0, 128, 128],
      "thistle": [216, 191, 216],
      "tomato": [255, 99, 71],
      "turquoise": [64, 224, 208],
      "violet": [238, 130, 238],
      "wheat": [245, 222, 179],
      "white": [255, 255, 255],
      "whitesmoke": [245, 245, 245],
      "yellow": [255, 255, 0],
      "yellowgreen": [154, 205, 50]
    };
  }
});

// ../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/conversions.js
var require_conversions = __commonJS({
  "../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/conversions.js"(exports2, module3) {
    init_import_meta_url();
    var cssKeywords = require_color_name();
    var reverseKeywords = {};
    for (const key of Object.keys(cssKeywords)) {
      reverseKeywords[cssKeywords[key]] = key;
    }
    var convert = {
      rgb: { channels: 3, labels: "rgb" },
      hsl: { channels: 3, labels: "hsl" },
      hsv: { channels: 3, labels: "hsv" },
      hwb: { channels: 3, labels: "hwb" },
      cmyk: { channels: 4, labels: "cmyk" },
      xyz: { channels: 3, labels: "xyz" },
      lab: { channels: 3, labels: "lab" },
      lch: { channels: 3, labels: "lch" },
      hex: { channels: 1, labels: ["hex"] },
      keyword: { channels: 1, labels: ["keyword"] },
      ansi16: { channels: 1, labels: ["ansi16"] },
      ansi256: { channels: 1, labels: ["ansi256"] },
      hcg: { channels: 3, labels: ["h", "c", "g"] },
      apple: { channels: 3, labels: ["r16", "g16", "b16"] },
      gray: { channels: 1, labels: ["gray"] }
    };
    module3.exports = convert;
    for (const model of Object.keys(convert)) {
      if (!("channels" in convert[model])) {
        throw new Error("missing channels property: " + model);
      }
      if (!("labels" in convert[model])) {
        throw new Error("missing channel labels property: " + model);
      }
      if (convert[model].labels.length !== convert[model].channels) {
        throw new Error("channel and label counts mismatch: " + model);
      }
      const { channels, labels } = convert[model];
      delete convert[model].channels;
      delete convert[model].labels;
      Object.defineProperty(convert[model], "channels", { value: channels });
      Object.defineProperty(convert[model], "labels", { value: labels });
    }
    convert.rgb.hsl = function(rgb) {
      const r3 = rgb[0] / 255;
      const g2 = rgb[1] / 255;
      const b2 = rgb[2] / 255;
      const min = Math.min(r3, g2, b2);
      const max = Math.max(r3, g2, b2);
      const delta = max - min;
      let h2;
      let s;
      if (max === min) {
        h2 = 0;
      } else if (r3 === max) {
        h2 = (g2 - b2) / delta;
      } else if (g2 === max) {
        h2 = 2 + (b2 - r3) / delta;
      } else if (b2 === max) {
        h2 = 4 + (r3 - g2) / delta;
      }
      h2 = Math.min(h2 * 60, 360);
      if (h2 < 0) {
        h2 += 360;
      }
      const l2 = (min + max) / 2;
      if (max === min) {
        s = 0;
      } else if (l2 <= 0.5) {
        s = delta / (max + min);
      } else {
        s = delta / (2 - max - min);
      }
      return [h2, s * 100, l2 * 100];
    };
    convert.rgb.hsv = function(rgb) {
      let rdif;
      let gdif;
      let bdif;
      let h2;
      let s;
      const r3 = rgb[0] / 255;
      const g2 = rgb[1] / 255;
      const b2 = rgb[2] / 255;
      const v2 = Math.max(r3, g2, b2);
      const diff = v2 - Math.min(r3, g2, b2);
      const diffc = /* @__PURE__ */ __name(function(c2) {
        return (v2 - c2) / 6 / diff + 1 / 2;
      }, "diffc");
      if (diff === 0) {
        h2 = 0;
        s = 0;
      } else {
        s = diff / v2;
        rdif = diffc(r3);
        gdif = diffc(g2);
        bdif = diffc(b2);
        if (r3 === v2) {
          h2 = bdif - gdif;
        } else if (g2 === v2) {
          h2 = 1 / 3 + rdif - bdif;
        } else if (b2 === v2) {
          h2 = 2 / 3 + gdif - rdif;
        }
        if (h2 < 0) {
          h2 += 1;
        } else if (h2 > 1) {
          h2 -= 1;
        }
      }
      return [
        h2 * 360,
        s * 100,
        v2 * 100
      ];
    };
    convert.rgb.hwb = function(rgb) {
      const r3 = rgb[0];
      const g2 = rgb[1];
      let b2 = rgb[2];
      const h2 = convert.rgb.hsl(rgb)[0];
      const w2 = 1 / 255 * Math.min(r3, Math.min(g2, b2));
      b2 = 1 - 1 / 255 * Math.max(r3, Math.max(g2, b2));
      return [h2, w2 * 100, b2 * 100];
    };
    convert.rgb.cmyk = function(rgb) {
      const r3 = rgb[0] / 255;
      const g2 = rgb[1] / 255;
      const b2 = rgb[2] / 255;
      const k2 = Math.min(1 - r3, 1 - g2, 1 - b2);
      const c2 = (1 - r3 - k2) / (1 - k2) || 0;
      const m2 = (1 - g2 - k2) / (1 - k2) || 0;
      const y2 = (1 - b2 - k2) / (1 - k2) || 0;
      return [c2 * 100, m2 * 100, y2 * 100, k2 * 100];
    };
    function comparativeDistance(x2, y2) {
      return (x2[0] - y2[0]) ** 2 + (x2[1] - y2[1]) ** 2 + (x2[2] - y2[2]) ** 2;
    }
    __name(comparativeDistance, "comparativeDistance");
    convert.rgb.keyword = function(rgb) {
      const reversed = reverseKeywords[rgb];
      if (reversed) {
        return reversed;
      }
      let currentClosestDistance = Infinity;
      let currentClosestKeyword;
      for (const keyword of Object.keys(cssKeywords)) {
        const value = cssKeywords[keyword];
        const distance = comparativeDistance(rgb, value);
        if (distance < currentClosestDistance) {
          currentClosestDistance = distance;
          currentClosestKeyword = keyword;
        }
      }
      return currentClosestKeyword;
    };
    convert.keyword.rgb = function(keyword) {
      return cssKeywords[keyword];
    };
    convert.rgb.xyz = function(rgb) {
      let r3 = rgb[0] / 255;
      let g2 = rgb[1] / 255;
      let b2 = rgb[2] / 255;
      r3 = r3 > 0.04045 ? ((r3 + 0.055) / 1.055) ** 2.4 : r3 / 12.92;
      g2 = g2 > 0.04045 ? ((g2 + 0.055) / 1.055) ** 2.4 : g2 / 12.92;
      b2 = b2 > 0.04045 ? ((b2 + 0.055) / 1.055) ** 2.4 : b2 / 12.92;
      const x2 = r3 * 0.4124 + g2 * 0.3576 + b2 * 0.1805;
      const y2 = r3 * 0.2126 + g2 * 0.7152 + b2 * 0.0722;
      const z2 = r3 * 0.0193 + g2 * 0.1192 + b2 * 0.9505;
      return [x2 * 100, y2 * 100, z2 * 100];
    };
    convert.rgb.lab = function(rgb) {
      const xyz = convert.rgb.xyz(rgb);
      let x2 = xyz[0];
      let y2 = xyz[1];
      let z2 = xyz[2];
      x2 /= 95.047;
      y2 /= 100;
      z2 /= 108.883;
      x2 = x2 > 8856e-6 ? x2 ** (1 / 3) : 7.787 * x2 + 16 / 116;
      y2 = y2 > 8856e-6 ? y2 ** (1 / 3) : 7.787 * y2 + 16 / 116;
      z2 = z2 > 8856e-6 ? z2 ** (1 / 3) : 7.787 * z2 + 16 / 116;
      const l2 = 116 * y2 - 16;
      const a = 500 * (x2 - y2);
      const b2 = 200 * (y2 - z2);
      return [l2, a, b2];
    };
    convert.hsl.rgb = function(hsl) {
      const h2 = hsl[0] / 360;
      const s = hsl[1] / 100;
      const l2 = hsl[2] / 100;
      let t22;
      let t3;
      let val;
      if (s === 0) {
        val = l2 * 255;
        return [val, val, val];
      }
      if (l2 < 0.5) {
        t22 = l2 * (1 + s);
      } else {
        t22 = l2 + s - l2 * s;
      }
      const t1 = 2 * l2 - t22;
      const rgb = [0, 0, 0];
      for (let i = 0; i < 3; i++) {
        t3 = h2 + 1 / 3 * -(i - 1);
        if (t3 < 0) {
          t3++;
        }
        if (t3 > 1) {
          t3--;
        }
        if (6 * t3 < 1) {
          val = t1 + (t22 - t1) * 6 * t3;
        } else if (2 * t3 < 1) {
          val = t22;
        } else if (3 * t3 < 2) {
          val = t1 + (t22 - t1) * (2 / 3 - t3) * 6;
        } else {
          val = t1;
        }
        rgb[i] = val * 255;
      }
      return rgb;
    };
    convert.hsl.hsv = function(hsl) {
      const h2 = hsl[0];
      let s = hsl[1] / 100;
      let l2 = hsl[2] / 100;
      let smin = s;
      const lmin = Math.max(l2, 0.01);
      l2 *= 2;
      s *= l2 <= 1 ? l2 : 2 - l2;
      smin *= lmin <= 1 ? lmin : 2 - lmin;
      const v2 = (l2 + s) / 2;
      const sv = l2 === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l2 + s);
      return [h2, sv * 100, v2 * 100];
    };
    convert.hsv.rgb = function(hsv) {
      const h2 = hsv[0] / 60;
      const s = hsv[1] / 100;
      let v2 = hsv[2] / 100;
      const hi = Math.floor(h2) % 6;
      const f = h2 - Math.floor(h2);
      const p2 = 255 * v2 * (1 - s);
      const q2 = 255 * v2 * (1 - s * f);
      const t3 = 255 * v2 * (1 - s * (1 - f));
      v2 *= 255;
      switch (hi) {
        case 0:
          return [v2, t3, p2];
        case 1:
          return [q2, v2, p2];
        case 2:
          return [p2, v2, t3];
        case 3:
          return [p2, q2, v2];
        case 4:
          return [t3, p2, v2];
        case 5:
          return [v2, p2, q2];
      }
    };
    convert.hsv.hsl = function(hsv) {
      const h2 = hsv[0];
      const s = hsv[1] / 100;
      const v2 = hsv[2] / 100;
      const vmin = Math.max(v2, 0.01);
      let sl2;
      let l2;
      l2 = (2 - s) * v2;
      const lmin = (2 - s) * vmin;
      sl2 = s * vmin;
      sl2 /= lmin <= 1 ? lmin : 2 - lmin;
      sl2 = sl2 || 0;
      l2 /= 2;
      return [h2, sl2 * 100, l2 * 100];
    };
    convert.hwb.rgb = function(hwb) {
      const h2 = hwb[0] / 360;
      let wh = hwb[1] / 100;
      let bl = hwb[2] / 100;
      const ratio = wh + bl;
      let f;
      if (ratio > 1) {
        wh /= ratio;
        bl /= ratio;
      }
      const i = Math.floor(6 * h2);
      const v2 = 1 - bl;
      f = 6 * h2 - i;
      if ((i & 1) !== 0) {
        f = 1 - f;
      }
      const n2 = wh + f * (v2 - wh);
      let r3;
      let g2;
      let b2;
      switch (i) {
        default:
        case 6:
        case 0:
          r3 = v2;
          g2 = n2;
          b2 = wh;
          break;
        case 1:
          r3 = n2;
          g2 = v2;
          b2 = wh;
          break;
        case 2:
          r3 = wh;
          g2 = v2;
          b2 = n2;
          break;
        case 3:
          r3 = wh;
          g2 = n2;
          b2 = v2;
          break;
        case 4:
          r3 = n2;
          g2 = wh;
          b2 = v2;
          break;
        case 5:
          r3 = v2;
          g2 = wh;
          b2 = n2;
          break;
      }
      return [r3 * 255, g2 * 255, b2 * 255];
    };
    convert.cmyk.rgb = function(cmyk) {
      const c2 = cmyk[0] / 100;
      const m2 = cmyk[1] / 100;
      const y2 = cmyk[2] / 100;
      const k2 = cmyk[3] / 100;
      const r3 = 1 - Math.min(1, c2 * (1 - k2) + k2);
      const g2 = 1 - Math.min(1, m2 * (1 - k2) + k2);
      const b2 = 1 - Math.min(1, y2 * (1 - k2) + k2);
      return [r3 * 255, g2 * 255, b2 * 255];
    };
    convert.xyz.rgb = function(xyz) {
      const x2 = xyz[0] / 100;
      const y2 = xyz[1] / 100;
      const z2 = xyz[2] / 100;
      let r3;
      let g2;
      let b2;
      r3 = x2 * 3.2406 + y2 * -1.5372 + z2 * -0.4986;
      g2 = x2 * -0.9689 + y2 * 1.8758 + z2 * 0.0415;
      b2 = x2 * 0.0557 + y2 * -0.204 + z2 * 1.057;
      r3 = r3 > 31308e-7 ? 1.055 * r3 ** (1 / 2.4) - 0.055 : r3 * 12.92;
      g2 = g2 > 31308e-7 ? 1.055 * g2 ** (1 / 2.4) - 0.055 : g2 * 12.92;
      b2 = b2 > 31308e-7 ? 1.055 * b2 ** (1 / 2.4) - 0.055 : b2 * 12.92;
      r3 = Math.min(Math.max(0, r3), 1);
      g2 = Math.min(Math.max(0, g2), 1);
      b2 = Math.min(Math.max(0, b2), 1);
      return [r3 * 255, g2 * 255, b2 * 255];
    };
    convert.xyz.lab = function(xyz) {
      let x2 = xyz[0];
      let y2 = xyz[1];
      let z2 = xyz[2];
      x2 /= 95.047;
      y2 /= 100;
      z2 /= 108.883;
      x2 = x2 > 8856e-6 ? x2 ** (1 / 3) : 7.787 * x2 + 16 / 116;
      y2 = y2 > 8856e-6 ? y2 ** (1 / 3) : 7.787 * y2 + 16 / 116;
      z2 = z2 > 8856e-6 ? z2 ** (1 / 3) : 7.787 * z2 + 16 / 116;
      const l2 = 116 * y2 - 16;
      const a = 500 * (x2 - y2);
      const b2 = 200 * (y2 - z2);
      return [l2, a, b2];
    };
    convert.lab.xyz = function(lab) {
      const l2 = lab[0];
      const a = lab[1];
      const b2 = lab[2];
      let x2;
      let y2;
      let z2;
      y2 = (l2 + 16) / 116;
      x2 = a / 500 + y2;
      z2 = y2 - b2 / 200;
      const y22 = y2 ** 3;
      const x22 = x2 ** 3;
      const z22 = z2 ** 3;
      y2 = y22 > 8856e-6 ? y22 : (y2 - 16 / 116) / 7.787;
      x2 = x22 > 8856e-6 ? x22 : (x2 - 16 / 116) / 7.787;
      z2 = z22 > 8856e-6 ? z22 : (z2 - 16 / 116) / 7.787;
      x2 *= 95.047;
      y2 *= 100;
      z2 *= 108.883;
      return [x2, y2, z2];
    };
    convert.lab.lch = function(lab) {
      const l2 = lab[0];
      const a = lab[1];
      const b2 = lab[2];
      let h2;
      const hr = Math.atan2(b2, a);
      h2 = hr * 360 / 2 / Math.PI;
      if (h2 < 0) {
        h2 += 360;
      }
      const c2 = Math.sqrt(a * a + b2 * b2);
      return [l2, c2, h2];
    };
    convert.lch.lab = function(lch) {
      const l2 = lch[0];
      const c2 = lch[1];
      const h2 = lch[2];
      const hr = h2 / 360 * 2 * Math.PI;
      const a = c2 * Math.cos(hr);
      const b2 = c2 * Math.sin(hr);
      return [l2, a, b2];
    };
    convert.rgb.ansi16 = function(args, saturation = null) {
      const [r3, g2, b2] = args;
      let value = saturation === null ? convert.rgb.hsv(args)[2] : saturation;
      value = Math.round(value / 50);
      if (value === 0) {
        return 30;
      }
      let ansi2 = 30 + (Math.round(b2 / 255) << 2 | Math.round(g2 / 255) << 1 | Math.round(r3 / 255));
      if (value === 2) {
        ansi2 += 60;
      }
      return ansi2;
    };
    convert.hsv.ansi16 = function(args) {
      return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
    };
    convert.rgb.ansi256 = function(args) {
      const r3 = args[0];
      const g2 = args[1];
      const b2 = args[2];
      if (r3 === g2 && g2 === b2) {
        if (r3 < 8) {
          return 16;
        }
        if (r3 > 248) {
          return 231;
        }
        return Math.round((r3 - 8) / 247 * 24) + 232;
      }
      const ansi2 = 16 + 36 * Math.round(r3 / 255 * 5) + 6 * Math.round(g2 / 255 * 5) + Math.round(b2 / 255 * 5);
      return ansi2;
    };
    convert.ansi16.rgb = function(args) {
      let color = args % 10;
      if (color === 0 || color === 7) {
        if (args > 50) {
          color += 3.5;
        }
        color = color / 10.5 * 255;
        return [color, color, color];
      }
      const mult = (~~(args > 50) + 1) * 0.5;
      const r3 = (color & 1) * mult * 255;
      const g2 = (color >> 1 & 1) * mult * 255;
      const b2 = (color >> 2 & 1) * mult * 255;
      return [r3, g2, b2];
    };
    convert.ansi256.rgb = function(args) {
      if (args >= 232) {
        const c2 = (args - 232) * 10 + 8;
        return [c2, c2, c2];
      }
      args -= 16;
      let rem;
      const r3 = Math.floor(args / 36) / 5 * 255;
      const g2 = Math.floor((rem = args % 36) / 6) / 5 * 255;
      const b2 = rem % 6 / 5 * 255;
      return [r3, g2, b2];
    };
    convert.rgb.hex = function(args) {
      const integer = ((Math.round(args[0]) & 255) << 16) + ((Math.round(args[1]) & 255) << 8) + (Math.round(args[2]) & 255);
      const string = integer.toString(16).toUpperCase();
      return "000000".substring(string.length) + string;
    };
    convert.hex.rgb = function(args) {
      const match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
      if (!match) {
        return [0, 0, 0];
      }
      let colorString = match[0];
      if (match[0].length === 3) {
        colorString = colorString.split("").map((char) => {
          return char + char;
        }).join("");
      }
      const integer = parseInt(colorString, 16);
      const r3 = integer >> 16 & 255;
      const g2 = integer >> 8 & 255;
      const b2 = integer & 255;
      return [r3, g2, b2];
    };
    convert.rgb.hcg = function(rgb) {
      const r3 = rgb[0] / 255;
      const g2 = rgb[1] / 255;
      const b2 = rgb[2] / 255;
      const max = Math.max(Math.max(r3, g2), b2);
      const min = Math.min(Math.min(r3, g2), b2);
      const chroma = max - min;
      let grayscale;
      let hue;
      if (chroma < 1) {
        grayscale = min / (1 - chroma);
      } else {
        grayscale = 0;
      }
      if (chroma <= 0) {
        hue = 0;
      } else if (max === r3) {
        hue = (g2 - b2) / chroma % 6;
      } else if (max === g2) {
        hue = 2 + (b2 - r3) / chroma;
      } else {
        hue = 4 + (r3 - g2) / chroma;
      }
      hue /= 6;
      hue %= 1;
      return [hue * 360, chroma * 100, grayscale * 100];
    };
    convert.hsl.hcg = function(hsl) {
      const s = hsl[1] / 100;
      const l2 = hsl[2] / 100;
      const c2 = l2 < 0.5 ? 2 * s * l2 : 2 * s * (1 - l2);
      let f = 0;
      if (c2 < 1) {
        f = (l2 - 0.5 * c2) / (1 - c2);
      }
      return [hsl[0], c2 * 100, f * 100];
    };
    convert.hsv.hcg = function(hsv) {
      const s = hsv[1] / 100;
      const v2 = hsv[2] / 100;
      const c2 = s * v2;
      let f = 0;
      if (c2 < 1) {
        f = (v2 - c2) / (1 - c2);
      }
      return [hsv[0], c2 * 100, f * 100];
    };
    convert.hcg.rgb = function(hcg) {
      const h2 = hcg[0] / 360;
      const c2 = hcg[1] / 100;
      const g2 = hcg[2] / 100;
      if (c2 === 0) {
        return [g2 * 255, g2 * 255, g2 * 255];
      }
      const pure = [0, 0, 0];
      const hi = h2 % 1 * 6;
      const v2 = hi % 1;
      const w2 = 1 - v2;
      let mg = 0;
      switch (Math.floor(hi)) {
        case 0:
          pure[0] = 1;
          pure[1] = v2;
          pure[2] = 0;
          break;
        case 1:
          pure[0] = w2;
          pure[1] = 1;
          pure[2] = 0;
          break;
        case 2:
          pure[0] = 0;
          pure[1] = 1;
          pure[2] = v2;
          break;
        case 3:
          pure[0] = 0;
          pure[1] = w2;
          pure[2] = 1;
          break;
        case 4:
          pure[0] = v2;
          pure[1] = 0;
          pure[2] = 1;
          break;
        default:
          pure[0] = 1;
          pure[1] = 0;
          pure[2] = w2;
      }
      mg = (1 - c2) * g2;
      return [
        (c2 * pure[0] + mg) * 255,
        (c2 * pure[1] + mg) * 255,
        (c2 * pure[2] + mg) * 255
      ];
    };
    convert.hcg.hsv = function(hcg) {
      const c2 = hcg[1] / 100;
      const g2 = hcg[2] / 100;
      const v2 = c2 + g2 * (1 - c2);
      let f = 0;
      if (v2 > 0) {
        f = c2 / v2;
      }
      return [hcg[0], f * 100, v2 * 100];
    };
    convert.hcg.hsl = function(hcg) {
      const c2 = hcg[1] / 100;
      const g2 = hcg[2] / 100;
      const l2 = g2 * (1 - c2) + 0.5 * c2;
      let s = 0;
      if (l2 > 0 && l2 < 0.5) {
        s = c2 / (2 * l2);
      } else if (l2 >= 0.5 && l2 < 1) {
        s = c2 / (2 * (1 - l2));
      }
      return [hcg[0], s * 100, l2 * 100];
    };
    convert.hcg.hwb = function(hcg) {
      const c2 = hcg[1] / 100;
      const g2 = hcg[2] / 100;
      const v2 = c2 + g2 * (1 - c2);
      return [hcg[0], (v2 - c2) * 100, (1 - v2) * 100];
    };
    convert.hwb.hcg = function(hwb) {
      const w2 = hwb[1] / 100;
      const b2 = hwb[2] / 100;
      const v2 = 1 - b2;
      const c2 = v2 - w2;
      let g2 = 0;
      if (c2 < 1) {
        g2 = (v2 - c2) / (1 - c2);
      }
      return [hwb[0], c2 * 100, g2 * 100];
    };
    convert.apple.rgb = function(apple) {
      return [apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255];
    };
    convert.rgb.apple = function(rgb) {
      return [rgb[0] / 255 * 65535, rgb[1] / 255 * 65535, rgb[2] / 255 * 65535];
    };
    convert.gray.rgb = function(args) {
      return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
    };
    convert.gray.hsl = function(args) {
      return [0, 0, args[0]];
    };
    convert.gray.hsv = convert.gray.hsl;
    convert.gray.hwb = function(gray2) {
      return [0, 100, gray2[0]];
    };
    convert.gray.cmyk = function(gray2) {
      return [0, 0, 0, gray2[0]];
    };
    convert.gray.lab = function(gray2) {
      return [gray2[0], 0, 0];
    };
    convert.gray.hex = function(gray2) {
      const val = Math.round(gray2[0] / 100 * 255) & 255;
      const integer = (val << 16) + (val << 8) + val;
      const string = integer.toString(16).toUpperCase();
      return "000000".substring(string.length) + string;
    };
    convert.rgb.gray = function(rgb) {
      const val = (rgb[0] + rgb[1] + rgb[2]) / 3;
      return [val / 255 * 100];
    };
  }
});

// ../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/route.js
var require_route = __commonJS({
  "../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/route.js"(exports2, module3) {
    init_import_meta_url();
    var conversions = require_conversions();
    function buildGraph() {
      const graph = {};
      const models = Object.keys(conversions);
      for (let len = models.length, i = 0; i < len; i++) {
        graph[models[i]] = {
          // http://jsperf.com/1-vs-infinity
          // micro-opt, but this is simple.
          distance: -1,
          parent: null
        };
      }
      return graph;
    }
    __name(buildGraph, "buildGraph");
    function deriveBFS(fromModel) {
      const graph = buildGraph();
      const queue = [fromModel];
      graph[fromModel].distance = 0;
      while (queue.length) {
        const current = queue.pop();
        const adjacents = Object.keys(conversions[current]);
        for (let len = adjacents.length, i = 0; i < len; i++) {
          const adjacent = adjacents[i];
          const node2 = graph[adjacent];
          if (node2.distance === -1) {
            node2.distance = graph[current].distance + 1;
            node2.parent = current;
            queue.unshift(adjacent);
          }
        }
      }
      return graph;
    }
    __name(deriveBFS, "deriveBFS");
    function link(from, to) {
      return function(args) {
        return to(from(args));
      };
    }
    __name(link, "link");
    function wrapConversion(toModel, graph) {
      const path67 = [graph[toModel].parent, toModel];
      let fn2 = conversions[graph[toModel].parent][toModel];
      let cur = graph[toModel].parent;
      while (graph[cur].parent) {
        path67.unshift(graph[cur].parent);
        fn2 = link(conversions[graph[cur].parent][cur], fn2);
        cur = graph[cur].parent;
      }
      fn2.conversion = path67;
      return fn2;
    }
    __name(wrapConversion, "wrapConversion");
    module3.exports = function(fromModel) {
      const graph = deriveBFS(fromModel);
      const conversion = {};
      const models = Object.keys(graph);
      for (let len = models.length, i = 0; i < len; i++) {
        const toModel = models[i];
        const node2 = graph[toModel];
        if (node2.parent === null) {
          continue;
        }
        conversion[toModel] = wrapConversion(toModel, graph);
      }
      return conversion;
    };
  }
});

// ../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/index.js
var require_color_convert = __commonJS({
  "../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/index.js"(exports2, module3) {
    init_import_meta_url();
    var conversions = require_conversions();
    var route2 = require_route();
    var convert = {};
    var models = Object.keys(conversions);
    function wrapRaw(fn2) {
      const wrappedFn = /* @__PURE__ */ __name(function(...args) {
        const arg0 = args[0];
        if (arg0 === void 0 || arg0 === null) {
          return arg0;
        }
        if (arg0.length > 1) {
          args = arg0;
        }
        return fn2(args);
      }, "wrappedFn");
      if ("conversion" in fn2) {
        wrappedFn.conversion = fn2.conversion;
      }
      return wrappedFn;
    }
    __name(wrapRaw, "wrapRaw");
    function wrapRounded(fn2) {
      const wrappedFn = /* @__PURE__ */ __name(function(...args) {
        const arg0 = args[0];
        if (arg0 === void 0 || arg0 === null) {
          return arg0;
        }
        if (arg0.length > 1) {
          args = arg0;
        }
        const result = fn2(args);
        if (typeof result === "object") {
          for (let len = result.length, i = 0; i < len; i++) {
            result[i] = Math.round(result[i]);
          }
        }
        return result;
      }, "wrappedFn");
      if ("conversion" in fn2) {
        wrappedFn.conversion = fn2.conversion;
      }
      return wrappedFn;
    }
    __name(wrapRounded, "wrapRounded");
    models.forEach((fromModel) => {
      convert[fromModel] = {};
      Object.defineProperty(convert[fromModel], "channels", { value: conversions[fromModel].channels });
      Object.defineProperty(convert[fromModel], "labels", { value: conversions[fromModel].labels });
      const routes = route2(fromModel);
      const routeModels = Object.keys(routes);
      routeModels.forEach((toModel) => {
        const fn2 = routes[toModel];
        convert[fromModel][toModel] = wrapRounded(fn2);
        convert[fromModel][toModel].raw = wrapRaw(fn2);
      });
    });
    module3.exports = convert;
  }
});

// ../../node_modules/.pnpm/ansi-styles@4.3.0/node_modules/ansi-styles/index.js
var require_ansi_styles = __commonJS({
  "../../node_modules/.pnpm/ansi-styles@4.3.0/node_modules/ansi-styles/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var wrapAnsi162 = /* @__PURE__ */ __name((fn2, offset) => (...args) => {
      const code = fn2(...args);
      return `\x1B[${code + offset}m`;
    }, "wrapAnsi16");
    var wrapAnsi2562 = /* @__PURE__ */ __name((fn2, offset) => (...args) => {
      const code = fn2(...args);
      return `\x1B[${38 + offset};5;${code}m`;
    }, "wrapAnsi256");
    var wrapAnsi16m2 = /* @__PURE__ */ __name((fn2, offset) => (...args) => {
      const rgb = fn2(...args);
      return `\x1B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
    }, "wrapAnsi16m");
    var ansi2ansi = /* @__PURE__ */ __name((n2) => n2, "ansi2ansi");
    var rgb2rgb = /* @__PURE__ */ __name((r3, g2, b2) => [r3, g2, b2], "rgb2rgb");
    var setLazyProperty = /* @__PURE__ */ __name((object, property, get) => {
      Object.defineProperty(object, property, {
        get: () => {
          const value = get();
          Object.defineProperty(object, property, {
            value,
            enumerable: true,
            configurable: true
          });
          return value;
        },
        enumerable: true,
        configurable: true
      });
    }, "setLazyProperty");
    var colorConvert;
    var makeDynamicStyles = /* @__PURE__ */ __name((wrap4, targetSpace, identity, isBackground) => {
      if (colorConvert === void 0) {
        colorConvert = require_color_convert();
      }
      const offset = isBackground ? 10 : 0;
      const styles2 = {};
      for (const [sourceSpace, suite] of Object.entries(colorConvert)) {
        const name = sourceSpace === "ansi16" ? "ansi" : sourceSpace;
        if (sourceSpace === targetSpace) {
          styles2[name] = wrap4(identity, offset);
        } else if (typeof suite === "object") {
          styles2[name] = wrap4(suite[targetSpace], offset);
        }
      }
      return styles2;
    }, "makeDynamicStyles");
    function assembleStyles2() {
      const codes = /* @__PURE__ */ new Map();
      const styles2 = {
        modifier: {
          reset: [0, 0],
          // 21 isn't widely supported and 22 does the same thing
          bold: [1, 22],
          dim: [2, 22],
          italic: [3, 23],
          underline: [4, 24],
          inverse: [7, 27],
          hidden: [8, 28],
          strikethrough: [9, 29]
        },
        color: {
          black: [30, 39],
          red: [31, 39],
          green: [32, 39],
          yellow: [33, 39],
          blue: [34, 39],
          magenta: [35, 39],
          cyan: [36, 39],
          white: [37, 39],
          // Bright color
          blackBright: [90, 39],
          redBright: [91, 39],
          greenBright: [92, 39],
          yellowBright: [93, 39],
          blueBright: [94, 39],
          magentaBright: [95, 39],
          cyanBright: [96, 39],
          whiteBright: [97, 39]
        },
        bgColor: {
          bgBlack: [40, 49],
          bgRed: [41, 49],
          bgGreen: [42, 49],
          bgYellow: [43, 49],
          bgBlue: [44, 49],
          bgMagenta: [45, 49],
          bgCyan: [46, 49],
          bgWhite: [47, 49],
          // Bright color
          bgBlackBright: [100, 49],
          bgRedBright: [101, 49],
          bgGreenBright: [102, 49],
          bgYellowBright: [103, 49],
          bgBlueBright: [104, 49],
          bgMagentaBright: [105, 49],
          bgCyanBright: [106, 49],
          bgWhiteBright: [107, 49]
        }
      };
      styles2.color.gray = styles2.color.blackBright;
      styles2.bgColor.bgGray = styles2.bgColor.bgBlackBright;
      styles2.color.grey = styles2.color.blackBright;
      styles2.bgColor.bgGrey = styles2.bgColor.bgBlackBright;
      for (const [groupName, group] of Object.entries(styles2)) {
        for (const [styleName, style] of Object.entries(group)) {
          styles2[styleName] = {
            open: `\x1B[${style[0]}m`,
            close: `\x1B[${style[1]}m`
          };
          group[styleName] = styles2[styleName];
          codes.set(style[0], style[1]);
        }
        Object.defineProperty(styles2, groupName, {
          value: group,
          enumerable: false
        });
      }
      Object.defineProperty(styles2, "codes", {
        value: codes,
        enumerable: false
      });
      styles2.color.close = "\x1B[39m";
      styles2.bgColor.close = "\x1B[49m";
      setLazyProperty(styles2.color, "ansi", () => makeDynamicStyles(wrapAnsi162, "ansi16", ansi2ansi, false));
      setLazyProperty(styles2.color, "ansi256", () => makeDynamicStyles(wrapAnsi2562, "ansi256", ansi2ansi, false));
      setLazyProperty(styles2.color, "ansi16m", () => makeDynamicStyles(wrapAnsi16m2, "rgb", rgb2rgb, false));
      setLazyProperty(styles2.bgColor, "ansi", () => makeDynamicStyles(wrapAnsi162, "ansi16", ansi2ansi, true));
      setLazyProperty(styles2.bgColor, "ansi256", () => makeDynamicStyles(wrapAnsi2562, "ansi256", ansi2ansi, true));
      setLazyProperty(styles2.bgColor, "ansi16m", () => makeDynamicStyles(wrapAnsi16m2, "rgb", rgb2rgb, true));
      return styles2;
    }
    __name(assembleStyles2, "assembleStyles");
    Object.defineProperty(module3, "exports", {
      enumerable: true,
      get: assembleStyles2
    });
  }
});

// ../../node_modules/.pnpm/wrap-ansi@6.2.0/node_modules/wrap-ansi/index.js
var require_wrap_ansi = __commonJS({
  "../../node_modules/.pnpm/wrap-ansi@6.2.0/node_modules/wrap-ansi/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var stringWidth2 = require_string_width();
    var stripAnsi4 = require_strip_ansi();
    var ansiStyles2 = require_ansi_styles();
    var ESCAPES3 = /* @__PURE__ */ new Set([
      "\x1B",
      "\x9B"
    ]);
    var END_CODE2 = 39;
    var wrapAnsi3 = /* @__PURE__ */ __name((code) => `${ESCAPES3.values().next().value}[${code}m`, "wrapAnsi");
    var wordLengths2 = /* @__PURE__ */ __name((string) => string.split(" ").map((character) => stringWidth2(character)), "wordLengths");
    var wrapWord2 = /* @__PURE__ */ __name((rows, word, columns) => {
      const characters = [...word];
      let isInsideEscape = false;
      let visible = stringWidth2(stripAnsi4(rows[rows.length - 1]));
      for (const [index, character] of characters.entries()) {
        const characterLength = stringWidth2(character);
        if (visible + characterLength <= columns) {
          rows[rows.length - 1] += character;
        } else {
          rows.push(character);
          visible = 0;
        }
        if (ESCAPES3.has(character)) {
          isInsideEscape = true;
        } else if (isInsideEscape && character === "m") {
          isInsideEscape = false;
          continue;
        }
        if (isInsideEscape) {
          continue;
        }
        visible += characterLength;
        if (visible === columns && index < characters.length - 1) {
          rows.push("");
          visible = 0;
        }
      }
      if (!visible && rows[rows.length - 1].length > 0 && rows.length > 1) {
        rows[rows.length - 2] += rows.pop();
      }
    }, "wrapWord");
    var stringVisibleTrimSpacesRight2 = /* @__PURE__ */ __name((str) => {
      const words = str.split(" ");
      let last = words.length;
      while (last > 0) {
        if (stringWidth2(words[last - 1]) > 0) {
          break;
        }
        last--;
      }
      if (last === words.length) {
        return str;
      }
      return words.slice(0, last).join(" ") + words.slice(last).join("");
    }, "stringVisibleTrimSpacesRight");
    var exec2 = /* @__PURE__ */ __name((string, columns, options29 = {}) => {
      if (options29.trim !== false && string.trim() === "") {
        return "";
      }
      let pre = "";
      let ret = "";
      let escapeCode;
      const lengths = wordLengths2(string);
      let rows = [""];
      for (const [index, word] of string.split(" ").entries()) {
        if (options29.trim !== false) {
          rows[rows.length - 1] = rows[rows.length - 1].trimLeft();
        }
        let rowLength = stringWidth2(rows[rows.length - 1]);
        if (index !== 0) {
          if (rowLength >= columns && (options29.wordWrap === false || options29.trim === false)) {
            rows.push("");
            rowLength = 0;
          }
          if (rowLength > 0 || options29.trim === false) {
            rows[rows.length - 1] += " ";
            rowLength++;
          }
        }
        if (options29.hard && lengths[index] > columns) {
          const remainingColumns = columns - rowLength;
          const breaksStartingThisLine = 1 + Math.floor((lengths[index] - remainingColumns - 1) / columns);
          const breaksStartingNextLine = Math.floor((lengths[index] - 1) / columns);
          if (breaksStartingNextLine < breaksStartingThisLine) {
            rows.push("");
          }
          wrapWord2(rows, word, columns);
          continue;
        }
        if (rowLength + lengths[index] > columns && rowLength > 0 && lengths[index] > 0) {
          if (options29.wordWrap === false && rowLength < columns) {
            wrapWord2(rows, word, columns);
            continue;
          }
          rows.push("");
        }
        if (rowLength + lengths[index] > columns && options29.wordWrap === false) {
          wrapWord2(rows, word, columns);
          continue;
        }
        rows[rows.length - 1] += word;
      }
      if (options29.trim !== false) {
        rows = rows.map(stringVisibleTrimSpacesRight2);
      }
      pre = rows.join("\n");
      for (const [index, character] of [...pre].entries()) {
        ret += character;
        if (ESCAPES3.has(character)) {
          const code2 = parseFloat(/\d[^m]*/.exec(pre.slice(index, index + 4)));
          escapeCode = code2 === END_CODE2 ? null : code2;
        }
        const code = ansiStyles2.codes.get(Number(escapeCode));
        if (escapeCode && code) {
          if (pre[index + 1] === "\n") {
            ret += wrapAnsi3(code);
          } else if (character === "\n") {
            ret += wrapAnsi3(escapeCode);
          }
        }
      }
      return ret;
    }, "exec");
    module3.exports = (string, columns, options29) => {
      return String(string).normalize().replace(/\r\n/g, "\n").split("\n").map((line) => exec2(line, columns, options29)).join("\n");
    };
  }
});

// ../../node_modules/.pnpm/astral-regex@2.0.0/node_modules/astral-regex/index.js
var require_astral_regex = __commonJS({
  "../../node_modules/.pnpm/astral-regex@2.0.0/node_modules/astral-regex/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var regex2 = "[\uD800-\uDBFF][\uDC00-\uDFFF]";
    var astralRegex2 = /* @__PURE__ */ __name((options29) => options29 && options29.exact ? new RegExp(`^${regex2}$`) : new RegExp(regex2, "g"), "astralRegex");
    module3.exports = astralRegex2;
  }
});

// ../../node_modules/.pnpm/slice-ansi@3.0.0/node_modules/slice-ansi/index.js
var require_slice_ansi = __commonJS({
  "../../node_modules/.pnpm/slice-ansi@3.0.0/node_modules/slice-ansi/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var isFullwidthCodePoint2 = require_is_fullwidth_code_point();
    var astralRegex2 = require_astral_regex();
    var ansiStyles2 = require_ansi_styles();
    var ESCAPES3 = [
      "\x1B",
      "\x9B"
    ];
    var wrapAnsi3 = /* @__PURE__ */ __name((code) => `${ESCAPES3[0]}[${code}m`, "wrapAnsi");
    var checkAnsi2 = /* @__PURE__ */ __name((ansiCodes, isEscapes, endAnsiCode) => {
      let output = [];
      ansiCodes = [...ansiCodes];
      for (let ansiCode of ansiCodes) {
        const ansiCodeOrigin = ansiCode;
        if (ansiCode.match(";")) {
          ansiCode = ansiCode.split(";")[0][0] + "0";
        }
        const item = ansiStyles2.codes.get(parseInt(ansiCode, 10));
        if (item) {
          const indexEscape = ansiCodes.indexOf(item.toString());
          if (indexEscape >= 0) {
            ansiCodes.splice(indexEscape, 1);
          } else {
            output.push(wrapAnsi3(isEscapes ? item : ansiCodeOrigin));
          }
        } else if (isEscapes) {
          output.push(wrapAnsi3(0));
          break;
        } else {
          output.push(wrapAnsi3(ansiCodeOrigin));
        }
      }
      if (isEscapes) {
        output = output.filter((element, index) => output.indexOf(element) === index);
        if (endAnsiCode !== void 0) {
          const fistEscapeCode = wrapAnsi3(ansiStyles2.codes.get(parseInt(endAnsiCode, 10)));
          output = output.reduce((current, next) => next === fistEscapeCode ? [next, ...current] : [...current, next], []);
        }
      }
      return output.join("");
    }, "checkAnsi");
    module3.exports = (string, begin, end) => {
      const characters = [...string.normalize()];
      const ansiCodes = [];
      end = typeof end === "number" ? end : characters.length;
      let isInsideEscape = false;
      let ansiCode;
      let visible = 0;
      let output = "";
      for (const [index, character] of characters.entries()) {
        let leftEscape = false;
        if (ESCAPES3.includes(character)) {
          const code = /\d[^m]*/.exec(string.slice(index, index + 18));
          ansiCode = code && code.length > 0 ? code[0] : void 0;
          if (visible < end) {
            isInsideEscape = true;
            if (ansiCode !== void 0) {
              ansiCodes.push(ansiCode);
            }
          }
        } else if (isInsideEscape && character === "m") {
          isInsideEscape = false;
          leftEscape = true;
        }
        if (!isInsideEscape && !leftEscape) {
          ++visible;
        }
        if (!astralRegex2({ exact: true }).test(character) && isFullwidthCodePoint2(character.codePointAt())) {
          ++visible;
        }
        if (visible > begin && visible <= end) {
          output += character;
        } else if (visible === begin && !isInsideEscape && ansiCode !== void 0) {
          output = checkAnsi2(ansiCodes);
        } else if (visible >= end) {
          output += checkAnsi2(ansiCodes, true, ansiCode);
          break;
        }
      }
      return output;
    };
  }
});

// ../../node_modules/.pnpm/cli-truncate@2.1.0/node_modules/cli-truncate/index.js
var require_cli_truncate = __commonJS({
  "../../node_modules/.pnpm/cli-truncate@2.1.0/node_modules/cli-truncate/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var sliceAnsi2 = require_slice_ansi();
    var stringWidth2 = require_string_width();
    function getIndexOfNearestSpace(string, index, shouldSearchRight) {
      if (string.charAt(index) === " ") {
        return index;
      }
      for (let i = 1; i <= 3; i++) {
        if (shouldSearchRight) {
          if (string.charAt(index + i) === " ") {
            return index + i;
          }
        } else if (string.charAt(index - i) === " ") {
          return index - i;
        }
      }
      return index;
    }
    __name(getIndexOfNearestSpace, "getIndexOfNearestSpace");
    module3.exports = (text, columns, options29) => {
      options29 = {
        position: "end",
        preferTruncationOnSpace: false,
        ...options29
      };
      const { position, space: space2, preferTruncationOnSpace } = options29;
      let ellipsis = "\u2026";
      let ellipsisWidth = 1;
      if (typeof text !== "string") {
        throw new TypeError(`Expected \`input\` to be a string, got ${typeof text}`);
      }
      if (typeof columns !== "number") {
        throw new TypeError(`Expected \`columns\` to be a number, got ${typeof columns}`);
      }
      if (columns < 1) {
        return "";
      }
      if (columns === 1) {
        return ellipsis;
      }
      const length = stringWidth2(text);
      if (length <= columns) {
        return text;
      }
      if (position === "start") {
        if (preferTruncationOnSpace) {
          const nearestSpace = getIndexOfNearestSpace(text, length - columns + 1, true);
          return ellipsis + sliceAnsi2(text, nearestSpace, length).trim();
        }
        if (space2 === true) {
          ellipsis += " ";
          ellipsisWidth = 2;
        }
        return ellipsis + sliceAnsi2(text, length - columns + ellipsisWidth, length);
      }
      if (position === "middle") {
        if (space2 === true) {
          ellipsis = " " + ellipsis + " ";
          ellipsisWidth = 3;
        }
        const half = Math.floor(columns / 2);
        if (preferTruncationOnSpace) {
          const spaceNearFirstBreakPoint = getIndexOfNearestSpace(text, half);
          const spaceNearSecondBreakPoint = getIndexOfNearestSpace(text, length - (columns - half) + 1, true);
          return sliceAnsi2(text, 0, spaceNearFirstBreakPoint) + ellipsis + sliceAnsi2(text, spaceNearSecondBreakPoint, length).trim();
        }
        return sliceAnsi2(text, 0, half) + ellipsis + sliceAnsi2(text, length - (columns - half) + ellipsisWidth, length);
      }
      if (position === "end") {
        if (preferTruncationOnSpace) {
          const nearestSpace = getIndexOfNearestSpace(text, columns - 1);
          return sliceAnsi2(text, 0, nearestSpace) + ellipsis;
        }
        if (space2 === true) {
          ellipsis = " " + ellipsis;
          ellipsisWidth = 2;
        }
        return sliceAnsi2(text, 0, columns - ellipsisWidth) + ellipsis;
      }
      throw new Error(`Expected \`options.position\` to be either \`start\`, \`middle\` or \`end\`, got ${position}`);
    };
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/wrap-text.js
var require_wrap_text = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/wrap-text.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var wrap_ansi_1 = __importDefault(require_wrap_ansi());
    var cli_truncate_1 = __importDefault(require_cli_truncate());
    var cache2 = {};
    exports2.default = (text, maxWidth, wrapType) => {
      const cacheKey = text + String(maxWidth) + String(wrapType);
      if (cache2[cacheKey]) {
        return cache2[cacheKey];
      }
      let wrappedText = text;
      if (wrapType === "wrap") {
        wrappedText = wrap_ansi_1.default(text, maxWidth, {
          trim: false,
          hard: true
        });
      }
      if (wrapType.startsWith("truncate")) {
        let position = "end";
        if (wrapType === "truncate-middle") {
          position = "middle";
        }
        if (wrapType === "truncate-start") {
          position = "start";
        }
        wrappedText = cli_truncate_1.default(text, maxWidth, { position });
      }
      cache2[cacheKey] = wrappedText;
      return wrappedText;
    };
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/squash-text-nodes.js
var require_squash_text_nodes = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/squash-text-nodes.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    var squashTextNodes = /* @__PURE__ */ __name((node2) => {
      let text = "";
      if (node2.childNodes.length > 0) {
        for (const childNode of node2.childNodes) {
          let nodeText = "";
          if (childNode.nodeName === "#text") {
            nodeText = childNode.nodeValue;
          } else {
            if (childNode.nodeName === "ink-text" || childNode.nodeName === "ink-virtual-text") {
              nodeText = squashTextNodes(childNode);
            }
            if (nodeText.length > 0 && typeof childNode.internal_transform === "function") {
              nodeText = childNode.internal_transform(nodeText);
            }
          }
          text += nodeText;
        }
      }
      return text;
    }, "squashTextNodes");
    exports2.default = squashTextNodes;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/dom.js
var require_dom = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/dom.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.setTextNodeValue = exports2.createTextNode = exports2.setStyle = exports2.setAttribute = exports2.removeChildNode = exports2.insertBeforeNode = exports2.appendChildNode = exports2.createNode = exports2.TEXT_NAME = void 0;
    var yoga_layout_prebuilt_1 = __importDefault(require_wasm_sync2());
    var measure_text_1 = __importDefault(require_measure_text());
    var styles_1 = __importDefault(require_styles());
    var wrap_text_1 = __importDefault(require_wrap_text());
    var squash_text_nodes_1 = __importDefault(require_squash_text_nodes());
    exports2.TEXT_NAME = "#text";
    exports2.createNode = (nodeName) => {
      var _a2;
      const node2 = {
        nodeName,
        style: {},
        attributes: {},
        childNodes: [],
        parentNode: null,
        yogaNode: nodeName === "ink-virtual-text" ? void 0 : yoga_layout_prebuilt_1.default.Node.create()
      };
      if (nodeName === "ink-text") {
        (_a2 = node2.yogaNode) === null || _a2 === void 0 ? void 0 : _a2.setMeasureFunc(measureTextNode.bind(null, node2));
      }
      return node2;
    };
    exports2.appendChildNode = (node2, childNode) => {
      var _a2;
      if (childNode.parentNode) {
        exports2.removeChildNode(childNode.parentNode, childNode);
      }
      childNode.parentNode = node2;
      node2.childNodes.push(childNode);
      if (childNode.yogaNode) {
        (_a2 = node2.yogaNode) === null || _a2 === void 0 ? void 0 : _a2.insertChild(childNode.yogaNode, node2.yogaNode.getChildCount());
      }
      if (node2.nodeName === "ink-text" || node2.nodeName === "ink-virtual-text") {
        markNodeAsDirty(node2);
      }
    };
    exports2.insertBeforeNode = (node2, newChildNode, beforeChildNode) => {
      var _a2, _b2;
      if (newChildNode.parentNode) {
        exports2.removeChildNode(newChildNode.parentNode, newChildNode);
      }
      newChildNode.parentNode = node2;
      const index = node2.childNodes.indexOf(beforeChildNode);
      if (index >= 0) {
        node2.childNodes.splice(index, 0, newChildNode);
        if (newChildNode.yogaNode) {
          (_a2 = node2.yogaNode) === null || _a2 === void 0 ? void 0 : _a2.insertChild(newChildNode.yogaNode, index);
        }
        return;
      }
      node2.childNodes.push(newChildNode);
      if (newChildNode.yogaNode) {
        (_b2 = node2.yogaNode) === null || _b2 === void 0 ? void 0 : _b2.insertChild(newChildNode.yogaNode, node2.yogaNode.getChildCount());
      }
      if (node2.nodeName === "ink-text" || node2.nodeName === "ink-virtual-text") {
        markNodeAsDirty(node2);
      }
    };
    exports2.removeChildNode = (node2, removeNode) => {
      var _a2, _b2;
      if (removeNode.yogaNode) {
        (_b2 = (_a2 = removeNode.parentNode) === null || _a2 === void 0 ? void 0 : _a2.yogaNode) === null || _b2 === void 0 ? void 0 : _b2.removeChild(removeNode.yogaNode);
      }
      removeNode.parentNode = null;
      const index = node2.childNodes.indexOf(removeNode);
      if (index >= 0) {
        node2.childNodes.splice(index, 1);
      }
      if (node2.nodeName === "ink-text" || node2.nodeName === "ink-virtual-text") {
        markNodeAsDirty(node2);
      }
    };
    exports2.setAttribute = (node2, key, value) => {
      node2.attributes[key] = value;
    };
    exports2.setStyle = (node2, style) => {
      node2.style = style;
      if (node2.yogaNode) {
        styles_1.default(node2.yogaNode, style);
      }
    };
    exports2.createTextNode = (text) => {
      const node2 = {
        nodeName: "#text",
        nodeValue: text,
        yogaNode: void 0,
        parentNode: null,
        style: {}
      };
      exports2.setTextNodeValue(node2, text);
      return node2;
    };
    var measureTextNode = /* @__PURE__ */ __name(function(node2, width) {
      var _a2, _b2;
      const text = node2.nodeName === "#text" ? node2.nodeValue : squash_text_nodes_1.default(node2);
      const dimensions = measure_text_1.default(text);
      if (dimensions.width <= width) {
        return dimensions;
      }
      if (dimensions.width >= 1 && width > 0 && width < 1) {
        return dimensions;
      }
      const textWrap = (_b2 = (_a2 = node2.style) === null || _a2 === void 0 ? void 0 : _a2.textWrap) !== null && _b2 !== void 0 ? _b2 : "wrap";
      const wrappedText = wrap_text_1.default(text, width, textWrap);
      return measure_text_1.default(wrappedText);
    }, "measureTextNode");
    var findClosestYogaNode = /* @__PURE__ */ __name((node2) => {
      var _a2;
      if (!node2 || !node2.parentNode) {
        return void 0;
      }
      return (_a2 = node2.yogaNode) !== null && _a2 !== void 0 ? _a2 : findClosestYogaNode(node2.parentNode);
    }, "findClosestYogaNode");
    var markNodeAsDirty = /* @__PURE__ */ __name((node2) => {
      const yogaNode = findClosestYogaNode(node2);
      yogaNode === null || yogaNode === void 0 ? void 0 : yogaNode.markDirty();
    }, "markNodeAsDirty");
    exports2.setTextNodeValue = (node2, text) => {
      if (typeof text !== "string") {
        text = String(text);
      }
      node2.nodeValue = text;
      markNodeAsDirty(node2);
    };
  }
});

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

// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/buffer-util.js
var require_buffer_util = __commonJS({
  "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/buffer-util.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { EMPTY_BUFFER } = require_constants5();
    function concat(list, totalLength) {
      if (list.length === 0)
        return EMPTY_BUFFER;
      if (list.length === 1)
        return list[0];
      const target = Buffer.allocUnsafe(totalLength);
      let offset = 0;
      for (let i = 0; i < list.length; i++) {
        const buf = list[i];
        target.set(buf, offset);
        offset += buf.length;
      }
      if (offset < totalLength)
        return target.slice(0, offset);
      return target;
    }
    __name(concat, "concat");
    function _mask(source, mask, output, offset, length) {
      for (let i = 0; i < length; i++) {
        output[offset + i] = source[i] ^ mask[i & 3];
      }
    }
    __name(_mask, "_mask");
    function _unmask(buffer, mask) {
      const length = buffer.length;
      for (let i = 0; i < length; i++) {
        buffer[i] ^= mask[i & 3];
      }
    }
    __name(_unmask, "_unmask");
    function toArrayBuffer(buf) {
      if (buf.byteLength === buf.buffer.byteLength) {
        return buf.buffer;
      }
      return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
    }
    __name(toArrayBuffer, "toArrayBuffer");
    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;
    }
    __name(toBuffer, "toBuffer");
    try {
      const bufferUtil = require("bufferutil");
      const bu = bufferUtil.BufferUtil || bufferUtil;
      module3.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 (e3) {
      module3.exports = {
        concat,
        mask: _mask,
        toArrayBuffer,
        toBuffer,
        unmask: _unmask
      };
    }
  }
});

// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/limiter.js
var require_limiter = __commonJS({
  "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/limiter.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var kDone = Symbol("kDone");
    var kRun = 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]);
        }
      }
    };
    __name(Limiter, "Limiter");
    module3.exports = Limiter;
  }
});

// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/permessage-deflate.js
var require_permessage_deflate = __commonJS({
  "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/permessage-deflate.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var zlib = require("zlib");
    var bufferUtil = require_buffer_util();
    var Limiter = require_limiter();
    var { kStatusCode, NOOP } = require_constants5();
    var TRAILER = Buffer.from([0, 0, 255, 255]);
    var kPerMessageDeflate = Symbol("permessage-deflate");
    var kTotalLength = Symbol("total-length");
    var kCallback = Symbol("callback");
    var kBuffers = Symbol("buffers");
    var kError = 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(options29, isServer, maxPayload) {
        this._maxPayload = maxPayload | 0;
        this._options = options29 || {};
        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 endpoint = this._isServer ? "client" : "server";
        if (!this._inflate) {
          const key = `${endpoint}_max_window_bits`;
          const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key];
          this._inflate = zlib.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[`${endpoint}_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 endpoint = this._isServer ? "server" : "client";
        if (!this._deflate) {
          const key = `${endpoint}_max_window_bits`;
          const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key];
          this._deflate = zlib.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(zlib.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[`${endpoint}_no_context_takeover`]) {
            this._deflate.reset();
          }
          callback(null, data2);
        });
      }
    };
    __name(PerMessageDeflate, "PerMessageDeflate");
    module3.exports = PerMessageDeflate;
    function deflateOnData(chunk) {
      this[kBuffers].push(chunk);
      this[kTotalLength] += chunk.length;
    }
    __name(deflateOnData, "deflateOnData");
    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();
    }
    __name(inflateOnData, "inflateOnData");
    function inflateOnError(err) {
      this[kPerMessageDeflate]._inflate = null;
      err[kStatusCode] = 1007;
      this[kCallback](err);
    }
    __name(inflateOnError, "inflateOnError");
  }
});

// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/validation.js
var require_validation = __commonJS({
  "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/validation.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    function isValidStatusCode(code) {
      return code >= 1e3 && code <= 1014 && code !== 1004 && code !== 1005 && code !== 1006 || code >= 3e3 && code <= 4999;
    }
    __name(isValidStatusCode, "isValidStatusCode");
    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;
    }
    __name(_isValidUTF8, "_isValidUTF8");
    try {
      let isValidUTF8 = require("utf-8-validate");
      if (typeof isValidUTF8 === "object") {
        isValidUTF8 = isValidUTF8.Validation.isValidUTF8;
      }
      module3.exports = {
        isValidStatusCode,
        isValidUTF8(buf) {
          return buf.length < 150 ? _isValidUTF8(buf) : isValidUTF8(buf);
        }
      };
    } catch (e3) {
      module3.exports = {
        isValidStatusCode,
        isValidUTF8: _isValidUTF8
      };
    }
  }
});

// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/receiver.js
var require_receiver2 = __commonJS({
  "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/receiver.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { Writable } = require("stream");
    var PerMessageDeflate = require_permessage_deflate();
    var {
      BINARY_TYPES,
      EMPTY_BUFFER,
      kStatusCode,
      kWebSocket
    } = require_constants5();
    var { concat, toArrayBuffer, unmask } = require_buffer_util();
    var { isValidStatusCode, isValidUTF8 } = require_validation();
    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 Receiver2 = 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(n2) {
        this._bufferedBytes -= n2;
        if (n2 === this._buffers[0].length)
          return this._buffers.shift();
        if (n2 < this._buffers[0].length) {
          const buf = this._buffers[0];
          this._buffers[0] = buf.slice(n2);
          return buf.slice(0, n2);
        }
        const dst = Buffer.allocUnsafe(n2);
        do {
          const buf = this._buffers[0];
          const offset = dst.length - n2;
          if (n2 >= buf.length) {
            dst.set(this._buffers.shift(), offset);
          } else {
            dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n2), offset);
            this._buffers[0] = buf.slice(n2);
          }
          n2 -= buf.length;
        } while (n2 > 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 error2(
            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 error2(
            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 error2(
              RangeError,
              "RSV1 must be clear",
              true,
              1002,
              "WS_ERR_UNEXPECTED_RSV_1"
            );
          }
          if (!this._fragmented) {
            this._loop = false;
            return error2(
              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 error2(
              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 error2(
              RangeError,
              "FIN must be set",
              true,
              1002,
              "WS_ERR_EXPECTED_FIN"
            );
          }
          if (compressed) {
            this._loop = false;
            return error2(
              RangeError,
              "RSV1 must be clear",
              true,
              1002,
              "WS_ERR_UNEXPECTED_RSV_1"
            );
          }
          if (this._payloadLength > 125) {
            this._loop = false;
            return error2(
              RangeError,
              `invalid payload length ${this._payloadLength}`,
              true,
              1002,
              "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH"
            );
          }
        } else {
          this._loop = false;
          return error2(
            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 error2(
              RangeError,
              "MASK must be set",
              true,
              1002,
              "WS_ERR_EXPECTED_MASK"
            );
          }
        } else if (this._masked) {
          this._loop = false;
          return error2(
            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 error2(
            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 error2(
              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(
                error2(
                  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 error2(
                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 error2(
              RangeError,
              "invalid payload length 1",
              true,
              1002,
              "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH"
            );
          } else {
            const code = data.readUInt16BE(0);
            if (!isValidStatusCode(code)) {
              return error2(
                RangeError,
                `invalid status code ${code}`,
                true,
                1002,
                "WS_ERR_INVALID_CLOSE_CODE"
              );
            }
            const buf = data.slice(2);
            if (!isValidUTF8(buf)) {
              return error2(
                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;
      }
    };
    __name(Receiver2, "Receiver");
    module3.exports = Receiver2;
    function error2(ErrorCtor, message, prefix, statusCode, errorCode) {
      const err = new ErrorCtor(
        prefix ? `Invalid WebSocket frame: ${message}` : message
      );
      Error.captureStackTrace(err, error2);
      err.code = errorCode;
      err[kStatusCode] = statusCode;
      return err;
    }
    __name(error2, "error");
  }
});

// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/sender.js
var require_sender = __commonJS({
  "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/sender.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var net3 = require("net");
    var tls = require("tls");
    var { randomFillSync } = require("crypto");
    var PerMessageDeflate = require_permessage_deflate();
    var { EMPTY_BUFFER } = require_constants5();
    var { isValidStatusCode } = require_validation();
    var { mask: applyMask, toBuffer } = require_buffer_util();
    var mask = Buffer.alloc(4);
    var Sender2 = class {
      /**
       * 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, options29) {
        const merge = options29.mask && options29.readOnly;
        let offset = options29.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(merge ? data.length + offset : offset);
        target[0] = options29.fin ? options29.opcode | 128 : options29.opcode;
        if (options29.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 (!options29.mask)
          return [target, data];
        randomFillSync(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 (merge) {
          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(
          Sender2.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(
          Sender2.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(
          Sender2.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, options29, cb) {
        const buf = toBuffer(data);
        const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
        let opcode = options29.binary ? 2 : 1;
        let rsv1 = options29.compress;
        if (this._firstFragment) {
          this._firstFragment = false;
          if (rsv1 && perMessageDeflate) {
            rsv1 = buf.length >= perMessageDeflate._threshold;
          }
          this._compress = rsv1;
        } else {
          rsv1 = false;
          opcode = 0;
        }
        if (options29.fin)
          this._firstFragment = true;
        if (perMessageDeflate) {
          const opts = {
            fin: options29.fin,
            rsv1,
            opcode,
            mask: options29.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(
            Sender2.frame(buf, {
              fin: options29.fin,
              rsv1: false,
              opcode,
              mask: options29.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, options29, cb) {
        if (!compress) {
          this.sendFrame(Sender2.frame(data, options29), cb);
          return;
        }
        const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
        this._bufferedBytes += data.length;
        this._deflating = true;
        perMessageDeflate.compress(data, options29.fin, (_3, 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;
          options29.readOnly = false;
          this.sendFrame(Sender2.frame(buf, options29), 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(list, cb) {
        if (list.length === 2) {
          this._socket.cork();
          this._socket.write(list[0]);
          this._socket.write(list[1], cb);
          this._socket.uncork();
        } else {
          this._socket.write(list[0], cb);
        }
      }
    };
    __name(Sender2, "Sender");
    module3.exports = Sender2;
  }
});

// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/event-target.js
var require_event_target = __commonJS({
  "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/event-target.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var Event2 = 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;
      }
    };
    __name(Event2, "Event");
    var MessageEvent = class extends Event2 {
      /**
       * 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;
      }
    };
    __name(MessageEvent, "MessageEvent");
    var CloseEvent = class extends Event2 {
      /**
       * 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;
      }
    };
    __name(CloseEvent, "CloseEvent");
    var OpenEvent = class extends Event2 {
      /**
       * Create a new `OpenEvent`.
       *
       * @param {WebSocket} target A reference to the target to which the event was
       *     dispatched
       */
      constructor(target) {
        super("open", target);
      }
    };
    __name(OpenEvent, "OpenEvent");
    var ErrorEvent2 = class extends Event2 {
      /**
       * 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(error2, target) {
        super("error", target);
        this.message = error2.message;
        this.error = error2;
      }
    };
    __name(ErrorEvent2, "ErrorEvent");
    var EventTarget2 = {
      /**
       * 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, options29) {
        if (typeof listener !== "function")
          return;
        function onMessage(data) {
          listener.call(this, new MessageEvent(data, this));
        }
        __name(onMessage, "onMessage");
        function onClose(code, message) {
          listener.call(this, new CloseEvent(code, message, this));
        }
        __name(onClose, "onClose");
        function onError(error2) {
          listener.call(this, new ErrorEvent2(error2, this));
        }
        __name(onError, "onError");
        function onOpen() {
          listener.call(this, new OpenEvent(this));
        }
        __name(onOpen, "onOpen");
        const method = options29 && options29.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]);
          }
        }
      }
    };
    module3.exports = EventTarget2;
  }
});

// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/extension.js
var require_extension = __commonJS({
  "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/extension.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    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, name, elem) {
      if (dest[name] === void 0)
        dest[name] = [elem];
      else
        dest[name].push(elem);
    }
    __name(push, "push");
    function parse7(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 name = header.slice(start, end);
            if (code === 44) {
              push(offers, name, params);
              params = /* @__PURE__ */ Object.create(null);
            } else {
              extensionName = name;
            }
            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;
    }
    __name(parse7, "parse");
    function format10(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((k2) => {
              let values = params[k2];
              if (!Array.isArray(values))
                values = [values];
              return values.map((v2) => v2 === true ? k2 : `${k2}=${v2}`).join("; ");
            })
          ).join("; ");
        }).join(", ");
      }).join(", ");
    }
    __name(format10, "format");
    module3.exports = { format: format10, parse: parse7 };
  }
});

// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/websocket.js
var require_websocket2 = __commonJS({
  "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/websocket.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var EventEmitter7 = require("events");
    var https3 = require("https");
    var http4 = require("http");
    var net3 = require("net");
    var tls = require("tls");
    var { randomBytes, createHash: createHash3 } = require("crypto");
    var { Readable: Readable2 } = require("stream");
    var { URL: URL7 } = require("url");
    var PerMessageDeflate = require_permessage_deflate();
    var Receiver2 = require_receiver2();
    var Sender2 = require_sender();
    var {
      BINARY_TYPES,
      EMPTY_BUFFER,
      GUID,
      kStatusCode,
      kWebSocket,
      NOOP
    } = require_constants5();
    var { addEventListener, removeEventListener } = require_event_target();
    var { format: format10, parse: parse7 } = require_extension();
    var { toBuffer } = require_buffer_util();
    var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
    var protocolVersions = [8, 13];
    var closeTimeout = 30 * 1e3;
    var WebSocket3 = class extends EventEmitter7 {
      /**
       * 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, options29) {
        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 = WebSocket3.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) {
            options29 = protocols;
            protocols = void 0;
          }
          initAsClient(this, address, protocols, options29);
        } 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 Receiver2(
          this.binaryType,
          this._extensions,
          this._isServer,
          maxPayload
        );
        this._sender = new Sender2(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 = WebSocket3.OPEN;
        this.emit("open");
      }
      /**
       * Emit the `'close'` event.
       *
       * @private
       */
      emitClose() {
        if (!this._socket) {
          this._readyState = WebSocket3.CLOSED;
          this.emit("close", this._closeCode, this._closeMessage);
          return;
        }
        if (this._extensions[PerMessageDeflate.extensionName]) {
          this._extensions[PerMessageDeflate.extensionName].cleanup();
        }
        this._receiver.removeAllListeners();
        this._readyState = WebSocket3.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 === WebSocket3.CLOSED)
          return;
        if (this.readyState === WebSocket3.CONNECTING) {
          const msg = "WebSocket was closed before the connection was established";
          return abortHandshake(this, this._req, msg);
        }
        if (this.readyState === WebSocket3.CLOSING) {
          if (this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted)) {
            this._socket.end();
          }
          return;
        }
        this._readyState = WebSocket3.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 === WebSocket3.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 !== WebSocket3.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 === WebSocket3.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 !== WebSocket3.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, options29, cb) {
        if (this.readyState === WebSocket3.CONNECTING) {
          throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
        }
        if (typeof options29 === "function") {
          cb = options29;
          options29 = {};
        }
        if (typeof data === "number")
          data = data.toString();
        if (this.readyState !== WebSocket3.OPEN) {
          sendAfterClose(this, data, cb);
          return;
        }
        const opts = {
          binary: typeof data !== "string",
          mask: !this._isServer,
          compress: true,
          fin: true,
          ...options29
        };
        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 === WebSocket3.CLOSED)
          return;
        if (this.readyState === WebSocket3.CONNECTING) {
          const msg = "WebSocket was closed before the connection was established";
          return abortHandshake(this, this._req, msg);
        }
        if (this._socket) {
          this._readyState = WebSocket3.CLOSING;
          this._socket.destroy();
        }
      }
    };
    __name(WebSocket3, "WebSocket");
    Object.defineProperty(WebSocket3, "CONNECTING", {
      enumerable: true,
      value: readyStates.indexOf("CONNECTING")
    });
    Object.defineProperty(WebSocket3.prototype, "CONNECTING", {
      enumerable: true,
      value: readyStates.indexOf("CONNECTING")
    });
    Object.defineProperty(WebSocket3, "OPEN", {
      enumerable: true,
      value: readyStates.indexOf("OPEN")
    });
    Object.defineProperty(WebSocket3.prototype, "OPEN", {
      enumerable: true,
      value: readyStates.indexOf("OPEN")
    });
    Object.defineProperty(WebSocket3, "CLOSING", {
      enumerable: true,
      value: readyStates.indexOf("CLOSING")
    });
    Object.defineProperty(WebSocket3.prototype, "CLOSING", {
      enumerable: true,
      value: readyStates.indexOf("CLOSING")
    });
    Object.defineProperty(WebSocket3, "CLOSED", {
      enumerable: true,
      value: readyStates.indexOf("CLOSED")
    });
    Object.defineProperty(WebSocket3.prototype, "CLOSED", {
      enumerable: true,
      value: readyStates.indexOf("CLOSED")
    });
    [
      "binaryType",
      "bufferedAmount",
      "extensions",
      "protocol",
      "readyState",
      "url"
    ].forEach((property) => {
      Object.defineProperty(WebSocket3.prototype, property, { enumerable: true });
    });
    ["open", "error", "close", "message"].forEach((method) => {
      Object.defineProperty(WebSocket3.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);
        }
      });
    });
    WebSocket3.prototype.addEventListener = addEventListener;
    WebSocket3.prototype.removeEventListener = removeEventListener;
    module3.exports = WebSocket3;
    function initAsClient(websocket, address, protocols, options29) {
      const opts = {
        protocolVersion: protocolVersions[1],
        maxPayload: 100 * 1024 * 1024,
        perMessageDeflate: true,
        followRedirects: false,
        maxRedirects: 10,
        ...options29,
        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 URL7) {
        parsedUrl = address;
        websocket._url = address.href;
      } else {
        parsedUrl = new URL7(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 get = isSecure ? https3.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"] = format10({
          [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];
      }
      let req = websocket._req = get(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 URL7(location, address);
          } catch (err) {
            emitErrorAndClose(websocket, err);
            return;
          }
          initAsClient(websocket, addr, protocols, options29);
        } 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 !== WebSocket3.CONNECTING)
          return;
        req = websocket._req = null;
        const digest = createHash3("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 = parse7(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);
      });
    }
    __name(initAsClient, "initAsClient");
    function emitErrorAndClose(websocket, err) {
      websocket._readyState = WebSocket3.CLOSING;
      websocket.emit("error", err);
      websocket.emitClose();
    }
    __name(emitErrorAndClose, "emitErrorAndClose");
    function netConnect(options29) {
      options29.path = options29.socketPath;
      return net3.connect(options29);
    }
    __name(netConnect, "netConnect");
    function tlsConnect(options29) {
      options29.path = void 0;
      if (!options29.servername && options29.servername !== "") {
        options29.servername = net3.isIP(options29.host) ? "" : options29.host;
      }
      return tls.connect(options29);
    }
    __name(tlsConnect, "tlsConnect");
    function abortHandshake(websocket, stream2, message) {
      websocket._readyState = WebSocket3.CLOSING;
      const err = new Error(message);
      Error.captureStackTrace(err, abortHandshake);
      if (stream2.setHeader) {
        stream2.abort();
        if (stream2.socket && !stream2.socket.destroyed) {
          stream2.socket.destroy();
        }
        stream2.once("abort", websocket.emitClose.bind(websocket));
        websocket.emit("error", err);
      } else {
        stream2.destroy(err);
        stream2.once("error", websocket.emit.bind(websocket, "error"));
        stream2.once("close", websocket.emitClose.bind(websocket));
      }
    }
    __name(abortHandshake, "abortHandshake");
    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);
      }
    }
    __name(sendAfterClose, "sendAfterClose");
    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);
    }
    __name(receiverOnConclude, "receiverOnConclude");
    function receiverOnDrain() {
      this[kWebSocket]._socket.resume();
    }
    __name(receiverOnDrain, "receiverOnDrain");
    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);
    }
    __name(receiverOnError, "receiverOnError");
    function receiverOnFinish() {
      this[kWebSocket].emitClose();
    }
    __name(receiverOnFinish, "receiverOnFinish");
    function receiverOnMessage(data) {
      this[kWebSocket].emit("message", data);
    }
    __name(receiverOnMessage, "receiverOnMessage");
    function receiverOnPing(data) {
      const websocket = this[kWebSocket];
      websocket.pong(data, !websocket._isServer, NOOP);
      websocket.emit("ping", data);
    }
    __name(receiverOnPing, "receiverOnPing");
    function receiverOnPong(data) {
      this[kWebSocket].emit("pong", data);
    }
    __name(receiverOnPong, "receiverOnPong");
    function resume(stream2) {
      stream2.resume();
    }
    __name(resume, "resume");
    function socketOnClose() {
      const websocket = this[kWebSocket];
      this.removeListener("close", socketOnClose);
      this.removeListener("data", socketOnData);
      this.removeListener("end", socketOnEnd);
      websocket._readyState = WebSocket3.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);
      }
    }
    __name(socketOnClose, "socketOnClose");
    function socketOnData(chunk) {
      if (!this[kWebSocket]._receiver.write(chunk)) {
        this.pause();
      }
    }
    __name(socketOnData, "socketOnData");
    function socketOnEnd() {
      const websocket = this[kWebSocket];
      websocket._readyState = WebSocket3.CLOSING;
      websocket._receiver.end();
      this.end();
    }
    __name(socketOnEnd, "socketOnEnd");
    function socketOnError() {
      const websocket = this[kWebSocket];
      this.removeListener("error", socketOnError);
      this.on("error", NOOP);
      if (websocket) {
        websocket._readyState = WebSocket3.CLOSING;
        this.destroy();
      }
    }
    __name(socketOnError, "socketOnError");
  }
});

// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/stream.js
var require_stream = __commonJS({
  "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/stream.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { Duplex } = require("stream");
    function emitClose(stream2) {
      stream2.emit("close");
    }
    __name(emitClose, "emitClose");
    function duplexOnEnd() {
      if (!this.destroyed && this._writableState.finished) {
        this.destroy();
      }
    }
    __name(duplexOnEnd, "duplexOnEnd");
    function duplexOnError(err) {
      this.removeListener("error", duplexOnError);
      this.destroy();
      if (this.listenerCount("error") === 0) {
        this.emit("error", err);
      }
    }
    __name(duplexOnError, "duplexOnError");
    function createWebSocketStream2(ws, options29) {
      let resumeOnReceiverDrain = true;
      let terminateOnDestroy = true;
      function receiverOnDrain() {
        if (resumeOnReceiverDrain)
          ws._socket.resume();
      }
      __name(receiverOnDrain, "receiverOnDrain");
      if (ws.readyState === ws.CONNECTING) {
        ws.once("open", /* @__PURE__ */ __name(function open3() {
          ws._receiver.removeAllListeners("drain");
          ws._receiver.on("drain", receiverOnDrain);
        }, "open"));
      } else {
        ws._receiver.removeAllListeners("drain");
        ws._receiver.on("drain", receiverOnDrain);
      }
      const duplex = new Duplex({
        ...options29,
        autoDestroy: false,
        emitClose: false,
        objectMode: false,
        writableObjectMode: false
      });
      ws.on("message", /* @__PURE__ */ __name(function message(msg) {
        if (!duplex.push(msg)) {
          resumeOnReceiverDrain = false;
          ws._socket.pause();
        }
      }, "message"));
      ws.once("error", /* @__PURE__ */ __name(function error2(err) {
        if (duplex.destroyed)
          return;
        terminateOnDestroy = false;
        duplex.destroy(err);
      }, "error"));
      ws.once("close", /* @__PURE__ */ __name(function close2() {
        if (duplex.destroyed)
          return;
        duplex.push(null);
      }, "close"));
      duplex._destroy = function(err, callback) {
        if (ws.readyState === ws.CLOSED) {
          callback(err);
          process.nextTick(emitClose, duplex);
          return;
        }
        let called = false;
        ws.once("error", /* @__PURE__ */ __name(function error2(err2) {
          called = true;
          callback(err2);
        }, "error"));
        ws.once("close", /* @__PURE__ */ __name(function close2() {
          if (!called)
            callback(err);
          process.nextTick(emitClose, duplex);
        }, "close"));
        if (terminateOnDestroy)
          ws.terminate();
      };
      duplex._final = function(callback) {
        if (ws.readyState === ws.CONNECTING) {
          ws.once("open", /* @__PURE__ */ __name(function open3() {
            duplex._final(callback);
          }, "open"));
          return;
        }
        if (ws._socket === null)
          return;
        if (ws._socket._writableState.finished) {
          callback();
          if (duplex._readableState.endEmitted)
            duplex.destroy();
        } else {
          ws._socket.once("finish", /* @__PURE__ */ __name(function finish() {
            callback();
          }, "finish"));
          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", /* @__PURE__ */ __name(function open3() {
            duplex._write(chunk, encoding, callback);
          }, "open"));
          return;
        }
        ws.send(chunk, callback);
      };
      duplex.on("end", duplexOnEnd);
      duplex.on("error", duplexOnError);
      return duplex;
    }
    __name(createWebSocketStream2, "createWebSocketStream");
    module3.exports = createWebSocketStream2;
  }
});

// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/websocket-server.js
var require_websocket_server = __commonJS({
  "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/lib/websocket-server.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var EventEmitter7 = require("events");
    var http4 = require("http");
    var https3 = require("https");
    var net3 = require("net");
    var tls = require("tls");
    var { createHash: createHash3 } = require("crypto");
    var PerMessageDeflate = require_permessage_deflate();
    var WebSocket3 = require_websocket2();
    var { format: format10, parse: parse7 } = require_extension();
    var { GUID, kWebSocket } = require_constants5();
    var keyRegex = /^[+/0-9A-Za-z]{22}==$/;
    var RUNNING = 0;
    var CLOSING = 1;
    var CLOSED = 2;
    var WebSocketServer2 = class extends EventEmitter7 {
      /**
       * 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(options29, callback) {
        super();
        options29 = {
          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,
          ...options29
        };
        if (options29.port == null && !options29.server && !options29.noServer || options29.port != null && (options29.server || options29.noServer) || options29.server && options29.noServer) {
          throw new TypeError(
            'One and only one of the "port", "server", or "noServer" options must be specified'
          );
        }
        if (options29.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(
            options29.port,
            options29.host,
            options29.backlog,
            callback
          );
        } else if (options29.server) {
          this._server = options29.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 (options29.perMessageDeflate === true)
          options29.perMessageDeflate = {};
        if (options29.clientTracking)
          this.clients = /* @__PURE__ */ new Set();
        this.options = options29;
        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 server = this._server;
        if (server) {
          this._removeListeners();
          this._removeListeners = this._server = null;
          if (this.options.port != null) {
            server.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 version3 = +req.headers["sec-websocket-version"];
        const extensions = {};
        if (req.method !== "GET" || req.headers.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 = parse7(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 = createHash3("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 WebSocket3(null);
        let protocol = req.headers["sec-websocket-protocol"];
        if (protocol) {
          protocol = protocol.split(",").map(trim);
          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 = format10({
            [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);
      }
    };
    __name(WebSocketServer2, "WebSocketServer");
    module3.exports = WebSocketServer2;
    function addListeners(server, map) {
      for (const event of Object.keys(map))
        server.on(event, map[event]);
      return /* @__PURE__ */ __name(function removeListeners() {
        for (const event of Object.keys(map)) {
          server.removeListener(event, map[event]);
        }
      }, "removeListeners");
    }
    __name(addListeners, "addListeners");
    function emitClose(server) {
      server._state = CLOSED;
      server.emit("close");
    }
    __name(emitClose, "emitClose");
    function socketOnError() {
      this.destroy();
    }
    __name(socketOnError, "socketOnError");
    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((h2) => `${h2}: ${headers[h2]}`).join("\r\n") + "\r\n\r\n" + message
        );
      }
      socket.removeListener("error", socketOnError);
      socket.destroy();
    }
    __name(abortHandshake, "abortHandshake");
    function trim(str) {
      return str.trim();
    }
    __name(trim, "trim");
  }
});

// ../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/index.js
var require_ws = __commonJS({
  "../../node_modules/.pnpm/ws@7.5.6/node_modules/ws/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var WebSocket3 = require_websocket2();
    WebSocket3.createWebSocketStream = require_stream();
    WebSocket3.Server = require_websocket_server();
    WebSocket3.Receiver = require_receiver2();
    WebSocket3.Sender = require_sender();
    module3.exports = WebSocket3;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/devtools-window-polyfill.js
var require_devtools_window_polyfill = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/devtools-window-polyfill.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var ws_1 = __importDefault(require_ws());
    var customGlobal = global;
    if (!customGlobal.WebSocket) {
      customGlobal.WebSocket = ws_1.default;
    }
    if (!customGlobal.window) {
      customGlobal.window = global;
    }
    customGlobal.window.__REACT_DEVTOOLS_COMPONENT_FILTERS__ = [
      {
        // ComponentFilterElementType
        type: 1,
        // ElementTypeHostComponent
        value: 7,
        isEnabled: true
      },
      {
        // ComponentFilterDisplayName
        type: 2,
        value: "InternalApp",
        isEnabled: true,
        isValid: true
      },
      {
        // ComponentFilterDisplayName
        type: 2,
        value: "InternalAppContext",
        isEnabled: true,
        isValid: true
      },
      {
        // ComponentFilterDisplayName
        type: 2,
        value: "InternalStdoutContext",
        isEnabled: true,
        isValid: true
      },
      {
        // ComponentFilterDisplayName
        type: 2,
        value: "InternalStderrContext",
        isEnabled: true,
        isValid: true
      },
      {
        // ComponentFilterDisplayName
        type: 2,
        value: "InternalStdinContext",
        isEnabled: true,
        isValid: true
      },
      {
        // ComponentFilterDisplayName
        type: 2,
        value: "InternalFocusContext",
        isEnabled: true,
        isValid: true
      }
    ];
  }
});

// ../../node_modules/.pnpm/react-devtools-core@4.23.0/node_modules/react-devtools-core/dist/backend.js
var require_backend = __commonJS({
  "../../node_modules/.pnpm/react-devtools-core@4.23.0/node_modules/react-devtools-core/dist/backend.js"(exports2, module3) {
    init_import_meta_url();
    (/* @__PURE__ */ __name(function webpackUniversalModuleDefinition(root, factory) {
      if (typeof exports2 === "object" && typeof module3 === "object")
        module3.exports = factory();
      else if (typeof define === "function" && define.amd)
        define([], factory);
      else if (typeof exports2 === "object")
        exports2["ReactDevToolsBackend"] = factory();
      else
        root["ReactDevToolsBackend"] = factory();
    }, "webpackUniversalModuleDefinition"))(window, function() {
      return (
        /******/
        function(modules) {
          var installedModules = {};
          function __webpack_require__(moduleId) {
            if (installedModules[moduleId]) {
              return installedModules[moduleId].exports;
            }
            var module4 = installedModules[moduleId] = {
              /******/
              i: moduleId,
              /******/
              l: false,
              /******/
              exports: {}
              /******/
            };
            modules[moduleId].call(module4.exports, module4, module4.exports, __webpack_require__);
            module4.l = true;
            return module4.exports;
          }
          __name(__webpack_require__, "__webpack_require__");
          __webpack_require__.m = modules;
          __webpack_require__.c = installedModules;
          __webpack_require__.d = function(exports3, name, getter) {
            if (!__webpack_require__.o(exports3, name)) {
              Object.defineProperty(exports3, name, { enumerable: true, get: getter });
            }
          };
          __webpack_require__.r = function(exports3) {
            if (typeof Symbol !== "undefined" && Symbol.toStringTag) {
              Object.defineProperty(exports3, Symbol.toStringTag, { value: "Module" });
            }
            Object.defineProperty(exports3, "__esModule", { value: true });
          };
          __webpack_require__.t = function(value, mode) {
            if (mode & 1)
              value = __webpack_require__(value);
            if (mode & 8)
              return value;
            if (mode & 4 && typeof value === "object" && value && value.__esModule)
              return value;
            var ns = /* @__PURE__ */ Object.create(null);
            __webpack_require__.r(ns);
            Object.defineProperty(ns, "default", { enumerable: true, value });
            if (mode & 2 && typeof value != "string")
              for (var key in value)
                __webpack_require__.d(ns, key, function(key2) {
                  return value[key2];
                }.bind(null, key));
            return ns;
          };
          __webpack_require__.n = function(module4) {
            var getter = module4 && module4.__esModule ? (
              /******/
              /* @__PURE__ */ __name(function getDefault() {
                return module4["default"];
              }, "getDefault")
            ) : (
              /******/
              /* @__PURE__ */ __name(function getModuleExports() {
                return module4;
              }, "getModuleExports")
            );
            __webpack_require__.d(getter, "a", getter);
            return getter;
          };
          __webpack_require__.o = function(object, property) {
            return Object.prototype.hasOwnProperty.call(object, property);
          };
          __webpack_require__.p = "";
          return __webpack_require__(__webpack_require__.s = 33);
        }([
          /* 0 */
          /***/
          function(module4, __webpack_exports__, __webpack_require__) {
            "use strict";
            __webpack_require__.d(__webpack_exports__, "e", function() {
              return ElementTypeClass;
            });
            __webpack_require__.d(__webpack_exports__, "f", function() {
              return ElementTypeContext;
            });
            __webpack_require__.d(__webpack_exports__, "h", function() {
              return ElementTypeFunction;
            });
            __webpack_require__.d(__webpack_exports__, "g", function() {
              return ElementTypeForwardRef;
            });
            __webpack_require__.d(__webpack_exports__, "i", function() {
              return ElementTypeHostComponent;
            });
            __webpack_require__.d(__webpack_exports__, "j", function() {
              return ElementTypeMemo;
            });
            __webpack_require__.d(__webpack_exports__, "k", function() {
              return ElementTypeOtherOrUnknown;
            });
            __webpack_require__.d(__webpack_exports__, "l", function() {
              return ElementTypeProfiler;
            });
            __webpack_require__.d(__webpack_exports__, "m", function() {
              return ElementTypeRoot;
            });
            __webpack_require__.d(__webpack_exports__, "n", function() {
              return ElementTypeSuspense;
            });
            __webpack_require__.d(__webpack_exports__, "o", function() {
              return ElementTypeSuspenseList;
            });
            __webpack_require__.d(__webpack_exports__, "b", function() {
              return ComponentFilterElementType;
            });
            __webpack_require__.d(__webpack_exports__, "a", function() {
              return ComponentFilterDisplayName;
            });
            __webpack_require__.d(__webpack_exports__, "d", function() {
              return ComponentFilterLocation;
            });
            __webpack_require__.d(__webpack_exports__, "c", function() {
              return ComponentFilterHOC;
            });
            __webpack_require__.d(__webpack_exports__, "p", function() {
              return StrictMode;
            });
            var ElementTypeClass = 1;
            var ElementTypeContext = 2;
            var ElementTypeFunction = 5;
            var ElementTypeForwardRef = 6;
            var ElementTypeHostComponent = 7;
            var ElementTypeMemo = 8;
            var ElementTypeOtherOrUnknown = 9;
            var ElementTypeProfiler = 10;
            var ElementTypeRoot = 11;
            var ElementTypeSuspense = 12;
            var ElementTypeSuspenseList = 13;
            var ComponentFilterElementType = 1;
            var ComponentFilterDisplayName = 2;
            var ComponentFilterLocation = 3;
            var ComponentFilterHOC = 4;
            var StrictMode = 1;
          },
          /* 1 */
          /***/
          function(module4, __webpack_exports__, __webpack_require__) {
            "use strict";
            __webpack_require__.d(__webpack_exports__, "q", function() {
              return __DEBUG__;
            });
            __webpack_require__.d(__webpack_exports__, "j", function() {
              return TREE_OPERATION_ADD;
            });
            __webpack_require__.d(__webpack_exports__, "k", function() {
              return TREE_OPERATION_REMOVE;
            });
            __webpack_require__.d(__webpack_exports__, "m", function() {
              return TREE_OPERATION_REORDER_CHILDREN;
            });
            __webpack_require__.d(__webpack_exports__, "p", function() {
              return TREE_OPERATION_UPDATE_TREE_BASE_DURATION;
            });
            __webpack_require__.d(__webpack_exports__, "o", function() {
              return TREE_OPERATION_UPDATE_ERRORS_OR_WARNINGS;
            });
            __webpack_require__.d(__webpack_exports__, "l", function() {
              return TREE_OPERATION_REMOVE_ROOT;
            });
            __webpack_require__.d(__webpack_exports__, "n", function() {
              return TREE_OPERATION_SET_SUBTREE_MODE;
            });
            __webpack_require__.d(__webpack_exports__, "a", function() {
              return LOCAL_STORAGE_FILTER_PREFERENCES_KEY;
            });
            __webpack_require__.d(__webpack_exports__, "g", function() {
              return SESSION_STORAGE_LAST_SELECTION_KEY;
            });
            __webpack_require__.d(__webpack_exports__, "c", function() {
              return LOCAL_STORAGE_OPEN_IN_EDITOR_URL;
            });
            __webpack_require__.d(__webpack_exports__, "h", function() {
              return SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY;
            });
            __webpack_require__.d(__webpack_exports__, "i", function() {
              return SESSION_STORAGE_RELOAD_AND_PROFILE_KEY;
            });
            __webpack_require__.d(__webpack_exports__, "d", function() {
              return LOCAL_STORAGE_SHOULD_BREAK_ON_CONSOLE_ERRORS;
            });
            __webpack_require__.d(__webpack_exports__, "e", function() {
              return LOCAL_STORAGE_SHOULD_PATCH_CONSOLE_KEY;
            });
            __webpack_require__.d(__webpack_exports__, "f", function() {
              return LOCAL_STORAGE_SHOW_INLINE_WARNINGS_AND_ERRORS_KEY;
            });
            __webpack_require__.d(__webpack_exports__, "b", function() {
              return LOCAL_STORAGE_HIDE_CONSOLE_LOGS_IN_STRICT_MODE;
            });
            var CHROME_WEBSTORE_EXTENSION_ID = "fmkadmapgofadopljbjfkapdkoienihi";
            var INTERNAL_EXTENSION_ID = "dnjnjgbfilfphmojnmhliehogmojhclc";
            var LOCAL_EXTENSION_ID = "ikiahnapldjmdmpkmfhjdjilojjhgcbf";
            var __DEBUG__ = false;
            var __PERFORMANCE_PROFILE__ = false;
            var TREE_OPERATION_ADD = 1;
            var TREE_OPERATION_REMOVE = 2;
            var TREE_OPERATION_REORDER_CHILDREN = 3;
            var TREE_OPERATION_UPDATE_TREE_BASE_DURATION = 4;
            var TREE_OPERATION_UPDATE_ERRORS_OR_WARNINGS = 5;
            var TREE_OPERATION_REMOVE_ROOT = 6;
            var TREE_OPERATION_SET_SUBTREE_MODE = 7;
            var LOCAL_STORAGE_DEFAULT_TAB_KEY = "React::DevTools::defaultTab";
            var LOCAL_STORAGE_FILTER_PREFERENCES_KEY = "React::DevTools::componentFilters";
            var SESSION_STORAGE_LAST_SELECTION_KEY = "React::DevTools::lastSelection";
            var LOCAL_STORAGE_OPEN_IN_EDITOR_URL = "React::DevTools::openInEditorUrl";
            var LOCAL_STORAGE_PARSE_HOOK_NAMES_KEY = "React::DevTools::parseHookNames";
            var SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY = "React::DevTools::recordChangeDescriptions";
            var SESSION_STORAGE_RELOAD_AND_PROFILE_KEY = "React::DevTools::reloadAndProfile";
            var LOCAL_STORAGE_SHOULD_BREAK_ON_CONSOLE_ERRORS = "React::DevTools::breakOnConsoleErrors";
            var LOCAL_STORAGE_SHOULD_PATCH_CONSOLE_KEY = "React::DevTools::appendComponentStack";
            var LOCAL_STORAGE_SHOW_INLINE_WARNINGS_AND_ERRORS_KEY = "React::DevTools::showInlineWarningsAndErrors";
            var LOCAL_STORAGE_TRACE_UPDATES_ENABLED_KEY = "React::DevTools::traceUpdatesEnabled";
            var LOCAL_STORAGE_HIDE_CONSOLE_LOGS_IN_STRICT_MODE = "React::DevTools::hideConsoleLogsInStrictMode";
            var PROFILER_EXPORT_VERSION = 5;
            var CHANGE_LOG_URL = "https://github.com/facebook/react/blob/main/packages/react-devtools/CHANGELOG.md";
            var UNSUPPORTED_VERSION_URL = "https://reactjs.org/blog/2019/08/15/new-react-devtools.html#how-do-i-get-the-old-version-back";
            var REACT_DEVTOOLS_WORKPLACE_URL = "https://fburl.com/react-devtools-workplace-group";
            var THEME_STYLES = {
              light: {
                "--color-attribute-name": "#ef6632",
                "--color-attribute-name-not-editable": "#23272f",
                "--color-attribute-name-inverted": "rgba(255, 255, 255, 0.7)",
                "--color-attribute-value": "#1a1aa6",
                "--color-attribute-value-inverted": "#ffffff",
                "--color-attribute-editable-value": "#1a1aa6",
                "--color-background": "#ffffff",
                "--color-background-hover": "rgba(0, 136, 250, 0.1)",
                "--color-background-inactive": "#e5e5e5",
                "--color-background-invalid": "#fff0f0",
                "--color-background-selected": "#0088fa",
                "--color-button-background": "#ffffff",
                "--color-button-background-focus": "#ededed",
                "--color-button": "#5f6673",
                "--color-button-disabled": "#cfd1d5",
                "--color-button-active": "#0088fa",
                "--color-button-focus": "#23272f",
                "--color-button-hover": "#23272f",
                "--color-border": "#eeeeee",
                "--color-commit-did-not-render-fill": "#cfd1d5",
                "--color-commit-did-not-render-fill-text": "#000000",
                "--color-commit-did-not-render-pattern": "#cfd1d5",
                "--color-commit-did-not-render-pattern-text": "#333333",
                "--color-commit-gradient-0": "#37afa9",
                "--color-commit-gradient-1": "#63b19e",
                "--color-commit-gradient-2": "#80b393",
                "--color-commit-gradient-3": "#97b488",
                "--color-commit-gradient-4": "#abb67d",
                "--color-commit-gradient-5": "#beb771",
                "--color-commit-gradient-6": "#cfb965",
                "--color-commit-gradient-7": "#dfba57",
                "--color-commit-gradient-8": "#efbb49",
                "--color-commit-gradient-9": "#febc38",
                "--color-commit-gradient-text": "#000000",
                "--color-component-name": "#6a51b2",
                "--color-component-name-inverted": "#ffffff",
                "--color-component-badge-background": "rgba(0, 0, 0, 0.1)",
                "--color-component-badge-background-inverted": "rgba(255, 255, 255, 0.25)",
                "--color-component-badge-count": "#777d88",
                "--color-component-badge-count-inverted": "rgba(255, 255, 255, 0.7)",
                "--color-console-error-badge-text": "#ffffff",
                "--color-console-error-background": "#fff0f0",
                "--color-console-error-border": "#ffd6d6",
                "--color-console-error-icon": "#eb3941",
                "--color-console-error-text": "#fe2e31",
                "--color-console-warning-badge-text": "#000000",
                "--color-console-warning-background": "#fffbe5",
                "--color-console-warning-border": "#fff5c1",
                "--color-console-warning-icon": "#f4bd00",
                "--color-console-warning-text": "#64460c",
                "--color-context-background": "rgba(0,0,0,.9)",
                "--color-context-background-hover": "rgba(255, 255, 255, 0.1)",
                "--color-context-background-selected": "#178fb9",
                "--color-context-border": "#3d424a",
                "--color-context-text": "#ffffff",
                "--color-context-text-selected": "#ffffff",
                "--color-dim": "#777d88",
                "--color-dimmer": "#cfd1d5",
                "--color-dimmest": "#eff0f1",
                "--color-error-background": "hsl(0, 100%, 97%)",
                "--color-error-border": "hsl(0, 100%, 92%)",
                "--color-error-text": "#ff0000",
                "--color-expand-collapse-toggle": "#777d88",
                "--color-link": "#0000ff",
                "--color-modal-background": "rgba(255, 255, 255, 0.75)",
                "--color-bridge-version-npm-background": "#eff0f1",
                "--color-bridge-version-npm-text": "#000000",
                "--color-bridge-version-number": "#0088fa",
                "--color-primitive-hook-badge-background": "#e5e5e5",
                "--color-primitive-hook-badge-text": "#5f6673",
                "--color-record-active": "#fc3a4b",
                "--color-record-hover": "#3578e5",
                "--color-record-inactive": "#0088fa",
                "--color-resize-bar": "#eeeeee",
                "--color-resize-bar-active": "#dcdcdc",
                "--color-resize-bar-border": "#d1d1d1",
                "--color-resize-bar-dot": "#333333",
                "--color-timeline-internal-module": "#d1d1d1",
                "--color-timeline-internal-module-hover": "#c9c9c9",
                "--color-timeline-internal-module-text": "#444",
                "--color-timeline-native-event": "#ccc",
                "--color-timeline-native-event-hover": "#aaa",
                "--color-timeline-network-primary": "#fcf3dc",
                "--color-timeline-network-primary-hover": "#f0e7d1",
                "--color-timeline-network-secondary": "#efc457",
                "--color-timeline-network-secondary-hover": "#e3ba52",
                "--color-timeline-priority-background": "#f6f6f6",
                "--color-timeline-priority-border": "#eeeeee",
                "--color-timeline-user-timing": "#c9cacd",
                "--color-timeline-user-timing-hover": "#93959a",
                "--color-timeline-react-idle": "#d3e5f6",
                "--color-timeline-react-idle-hover": "#c3d9ef",
                "--color-timeline-react-render": "#9fc3f3",
                "--color-timeline-react-render-hover": "#83afe9",
                "--color-timeline-react-render-text": "#11365e",
                "--color-timeline-react-commit": "#c88ff0",
                "--color-timeline-react-commit-hover": "#b281d6",
                "--color-timeline-react-commit-text": "#3e2c4a",
                "--color-timeline-react-layout-effects": "#b281d6",
                "--color-timeline-react-layout-effects-hover": "#9d71bd",
                "--color-timeline-react-layout-effects-text": "#3e2c4a",
                "--color-timeline-react-passive-effects": "#b281d6",
                "--color-timeline-react-passive-effects-hover": "#9d71bd",
                "--color-timeline-react-passive-effects-text": "#3e2c4a",
                "--color-timeline-react-schedule": "#9fc3f3",
                "--color-timeline-react-schedule-hover": "#2683E2",
                "--color-timeline-react-suspense-rejected": "#f1cc14",
                "--color-timeline-react-suspense-rejected-hover": "#ffdf37",
                "--color-timeline-react-suspense-resolved": "#a6e59f",
                "--color-timeline-react-suspense-resolved-hover": "#89d281",
                "--color-timeline-react-suspense-unresolved": "#c9cacd",
                "--color-timeline-react-suspense-unresolved-hover": "#93959a",
                "--color-timeline-thrown-error": "#ee1638",
                "--color-timeline-thrown-error-hover": "#da1030",
                "--color-timeline-text-color": "#000000",
                "--color-timeline-text-dim-color": "#ccc",
                "--color-timeline-react-work-border": "#eeeeee",
                "--color-search-match": "yellow",
                "--color-search-match-current": "#f7923b",
                "--color-selected-tree-highlight-active": "rgba(0, 136, 250, 0.1)",
                "--color-selected-tree-highlight-inactive": "rgba(0, 0, 0, 0.05)",
                "--color-scroll-caret": "rgba(150, 150, 150, 0.5)",
                "--color-tab-selected-border": "#0088fa",
                "--color-text": "#000000",
                "--color-text-invalid": "#ff0000",
                "--color-text-selected": "#ffffff",
                "--color-toggle-background-invalid": "#fc3a4b",
                "--color-toggle-background-on": "#0088fa",
                "--color-toggle-background-off": "#cfd1d5",
                "--color-toggle-text": "#ffffff",
                "--color-warning-background": "#fb3655",
                "--color-warning-background-hover": "#f82042",
                "--color-warning-text-color": "#ffffff",
                "--color-warning-text-color-inverted": "#fd4d69",
                // The styles below should be kept in sync with 'root.css'
                // They are repeated there because they're used by e.g. tooltips or context menus
                // which get rendered outside of the DOM subtree (where normal theme/styles are written).
                "--color-scroll-thumb": "#c2c2c2",
                "--color-scroll-track": "#fafafa",
                "--color-tooltip-background": "rgba(0, 0, 0, 0.9)",
                "--color-tooltip-text": "#ffffff"
              },
              dark: {
                "--color-attribute-name": "#9d87d2",
                "--color-attribute-name-not-editable": "#ededed",
                "--color-attribute-name-inverted": "#282828",
                "--color-attribute-value": "#cedae0",
                "--color-attribute-value-inverted": "#ffffff",
                "--color-attribute-editable-value": "yellow",
                "--color-background": "#282c34",
                "--color-background-hover": "rgba(255, 255, 255, 0.1)",
                "--color-background-inactive": "#3d424a",
                "--color-background-invalid": "#5c0000",
                "--color-background-selected": "#178fb9",
                "--color-button-background": "#282c34",
                "--color-button-background-focus": "#3d424a",
                "--color-button": "#afb3b9",
                "--color-button-active": "#61dafb",
                "--color-button-disabled": "#4f5766",
                "--color-button-focus": "#a2e9fc",
                "--color-button-hover": "#ededed",
                "--color-border": "#3d424a",
                "--color-commit-did-not-render-fill": "#777d88",
                "--color-commit-did-not-render-fill-text": "#000000",
                "--color-commit-did-not-render-pattern": "#666c77",
                "--color-commit-did-not-render-pattern-text": "#ffffff",
                "--color-commit-gradient-0": "#37afa9",
                "--color-commit-gradient-1": "#63b19e",
                "--color-commit-gradient-2": "#80b393",
                "--color-commit-gradient-3": "#97b488",
                "--color-commit-gradient-4": "#abb67d",
                "--color-commit-gradient-5": "#beb771",
                "--color-commit-gradient-6": "#cfb965",
                "--color-commit-gradient-7": "#dfba57",
                "--color-commit-gradient-8": "#efbb49",
                "--color-commit-gradient-9": "#febc38",
                "--color-commit-gradient-text": "#000000",
                "--color-component-name": "#61dafb",
                "--color-component-name-inverted": "#282828",
                "--color-component-badge-background": "rgba(255, 255, 255, 0.25)",
                "--color-component-badge-background-inverted": "rgba(0, 0, 0, 0.25)",
                "--color-component-badge-count": "#8f949d",
                "--color-component-badge-count-inverted": "rgba(255, 255, 255, 0.7)",
                "--color-console-error-badge-text": "#000000",
                "--color-console-error-background": "#290000",
                "--color-console-error-border": "#5c0000",
                "--color-console-error-icon": "#eb3941",
                "--color-console-error-text": "#fc7f7f",
                "--color-console-warning-badge-text": "#000000",
                "--color-console-warning-background": "#332b00",
                "--color-console-warning-border": "#665500",
                "--color-console-warning-icon": "#f4bd00",
                "--color-console-warning-text": "#f5f2ed",
                "--color-context-background": "rgba(255,255,255,.95)",
                "--color-context-background-hover": "rgba(0, 136, 250, 0.1)",
                "--color-context-background-selected": "#0088fa",
                "--color-context-border": "#eeeeee",
                "--color-context-text": "#000000",
                "--color-context-text-selected": "#ffffff",
                "--color-dim": "#8f949d",
                "--color-dimmer": "#777d88",
                "--color-dimmest": "#4f5766",
                "--color-error-background": "#200",
                "--color-error-border": "#900",
                "--color-error-text": "#f55",
                "--color-expand-collapse-toggle": "#8f949d",
                "--color-link": "#61dafb",
                "--color-modal-background": "rgba(0, 0, 0, 0.75)",
                "--color-bridge-version-npm-background": "rgba(0, 0, 0, 0.25)",
                "--color-bridge-version-npm-text": "#ffffff",
                "--color-bridge-version-number": "yellow",
                "--color-primitive-hook-badge-background": "rgba(0, 0, 0, 0.25)",
                "--color-primitive-hook-badge-text": "rgba(255, 255, 255, 0.7)",
                "--color-record-active": "#fc3a4b",
                "--color-record-hover": "#a2e9fc",
                "--color-record-inactive": "#61dafb",
                "--color-resize-bar": "#282c34",
                "--color-resize-bar-active": "#31363f",
                "--color-resize-bar-border": "#3d424a",
                "--color-resize-bar-dot": "#cfd1d5",
                "--color-timeline-internal-module": "#303542",
                "--color-timeline-internal-module-hover": "#363b4a",
                "--color-timeline-internal-module-text": "#7f8899",
                "--color-timeline-native-event": "#b2b2b2",
                "--color-timeline-native-event-hover": "#949494",
                "--color-timeline-network-primary": "#fcf3dc",
                "--color-timeline-network-primary-hover": "#e3dbc5",
                "--color-timeline-network-secondary": "#efc457",
                "--color-timeline-network-secondary-hover": "#d6af4d",
                "--color-timeline-priority-background": "#1d2129",
                "--color-timeline-priority-border": "#282c34",
                "--color-timeline-user-timing": "#c9cacd",
                "--color-timeline-user-timing-hover": "#93959a",
                "--color-timeline-react-idle": "#3d485b",
                "--color-timeline-react-idle-hover": "#465269",
                "--color-timeline-react-render": "#2683E2",
                "--color-timeline-react-render-hover": "#1a76d4",
                "--color-timeline-react-render-text": "#11365e",
                "--color-timeline-react-commit": "#731fad",
                "--color-timeline-react-commit-hover": "#611b94",
                "--color-timeline-react-commit-text": "#e5c1ff",
                "--color-timeline-react-layout-effects": "#611b94",
                "--color-timeline-react-layout-effects-hover": "#51167a",
                "--color-timeline-react-layout-effects-text": "#e5c1ff",
                "--color-timeline-react-passive-effects": "#611b94",
                "--color-timeline-react-passive-effects-hover": "#51167a",
                "--color-timeline-react-passive-effects-text": "#e5c1ff",
                "--color-timeline-react-schedule": "#2683E2",
                "--color-timeline-react-schedule-hover": "#1a76d4",
                "--color-timeline-react-suspense-rejected": "#f1cc14",
                "--color-timeline-react-suspense-rejected-hover": "#e4c00f",
                "--color-timeline-react-suspense-resolved": "#a6e59f",
                "--color-timeline-react-suspense-resolved-hover": "#89d281",
                "--color-timeline-react-suspense-unresolved": "#c9cacd",
                "--color-timeline-react-suspense-unresolved-hover": "#93959a",
                "--color-timeline-thrown-error": "#fb3655",
                "--color-timeline-thrown-error-hover": "#f82042",
                "--color-timeline-text-color": "#282c34",
                "--color-timeline-text-dim-color": "#555b66",
                "--color-timeline-react-work-border": "#3d424a",
                "--color-search-match": "yellow",
                "--color-search-match-current": "#f7923b",
                "--color-selected-tree-highlight-active": "rgba(23, 143, 185, 0.15)",
                "--color-selected-tree-highlight-inactive": "rgba(255, 255, 255, 0.05)",
                "--color-scroll-caret": "#4f5766",
                "--color-shadow": "rgba(0, 0, 0, 0.5)",
                "--color-tab-selected-border": "#178fb9",
                "--color-text": "#ffffff",
                "--color-text-invalid": "#ff8080",
                "--color-text-selected": "#ffffff",
                "--color-toggle-background-invalid": "#fc3a4b",
                "--color-toggle-background-on": "#178fb9",
                "--color-toggle-background-off": "#777d88",
                "--color-toggle-text": "#ffffff",
                "--color-warning-background": "#ee1638",
                "--color-warning-background-hover": "#da1030",
                "--color-warning-text-color": "#ffffff",
                "--color-warning-text-color-inverted": "#ee1638",
                // The styles below should be kept in sync with 'root.css'
                // They are repeated there because they're used by e.g. tooltips or context menus
                // which get rendered outside of the DOM subtree (where normal theme/styles are written).
                "--color-scroll-thumb": "#afb3b9",
                "--color-scroll-track": "#313640",
                "--color-tooltip-background": "rgba(255, 255, 255, 0.95)",
                "--color-tooltip-text": "#000000"
              },
              compact: {
                "--font-size-monospace-small": "9px",
                "--font-size-monospace-normal": "11px",
                "--font-size-monospace-large": "15px",
                "--font-size-sans-small": "10px",
                "--font-size-sans-normal": "12px",
                "--font-size-sans-large": "14px",
                "--line-height-data": "18px"
              },
              comfortable: {
                "--font-size-monospace-small": "10px",
                "--font-size-monospace-normal": "13px",
                "--font-size-monospace-large": "17px",
                "--font-size-sans-small": "12px",
                "--font-size-sans-normal": "14px",
                "--font-size-sans-large": "16px",
                "--line-height-data": "22px"
              }
            };
            var COMFORTABLE_LINE_HEIGHT = parseInt(THEME_STYLES.comfortable["--line-height-data"], 10);
            var COMPACT_LINE_HEIGHT = parseInt(THEME_STYLES.compact["--line-height-data"], 10);
          },
          /* 2 */
          /***/
          function(module4, __webpack_exports__, __webpack_require__) {
            "use strict";
            (function(process11) {
              __webpack_require__.d(__webpack_exports__, "c", function() {
                return getAllEnumerableKeys;
              });
              __webpack_require__.d(__webpack_exports__, "f", function() {
                return getDisplayName;
              });
              __webpack_require__.d(__webpack_exports__, "i", function() {
                return getUID;
              });
              __webpack_require__.d(__webpack_exports__, "m", function() {
                return utfEncodeString;
              });
              __webpack_require__.d(__webpack_exports__, "j", function() {
                return printOperationsArray;
              });
              __webpack_require__.d(__webpack_exports__, "e", function() {
                return getDefaultComponentFilters;
              });
              __webpack_require__.d(__webpack_exports__, "h", function() {
                return getInObject;
              });
              __webpack_require__.d(__webpack_exports__, "a", function() {
                return deletePathInObject;
              });
              __webpack_require__.d(__webpack_exports__, "k", function() {
                return renamePathInObject;
              });
              __webpack_require__.d(__webpack_exports__, "l", function() {
                return setInObject;
              });
              __webpack_require__.d(__webpack_exports__, "d", function() {
                return getDataType;
              });
              __webpack_require__.d(__webpack_exports__, "g", function() {
                return getDisplayNameForReactElement;
              });
              __webpack_require__.d(__webpack_exports__, "b", function() {
                return formatDataForPreview;
              });
              var lru_cache__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(19);
              var lru_cache__WEBPACK_IMPORTED_MODULE_0___default = /* @__PURE__ */ __webpack_require__.n(lru_cache__WEBPACK_IMPORTED_MODULE_0__);
              var react_is__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
              var react_is__WEBPACK_IMPORTED_MODULE_1___default = /* @__PURE__ */ __webpack_require__.n(react_is__WEBPACK_IMPORTED_MODULE_1__);
              var shared_ReactSymbols__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(20);
              var _constants__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(1);
              var react_devtools_shared_src_types__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(0);
              var _storage__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(5);
              var _hydration__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(12);
              var _isArray__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(6);
              function _typeof7(obj) {
                "@babel/helpers - typeof";
                if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                  _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                    return typeof obj2;
                  }, "_typeof");
                } else {
                  _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                    return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
                  }, "_typeof");
                }
                return _typeof7(obj);
              }
              __name(_typeof7, "_typeof");
              function _toConsumableArray(arr) {
                return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray4(arr) || _nonIterableSpread();
              }
              __name(_toConsumableArray, "_toConsumableArray");
              function _nonIterableSpread() {
                throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
              }
              __name(_nonIterableSpread, "_nonIterableSpread");
              function _unsupportedIterableToArray4(o2, minLen) {
                if (!o2)
                  return;
                if (typeof o2 === "string")
                  return _arrayLikeToArray4(o2, minLen);
                var n2 = Object.prototype.toString.call(o2).slice(8, -1);
                if (n2 === "Object" && o2.constructor)
                  n2 = o2.constructor.name;
                if (n2 === "Map" || n2 === "Set")
                  return Array.from(o2);
                if (n2 === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n2))
                  return _arrayLikeToArray4(o2, minLen);
              }
              __name(_unsupportedIterableToArray4, "_unsupportedIterableToArray");
              function _iterableToArray(iter) {
                if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter))
                  return Array.from(iter);
              }
              __name(_iterableToArray, "_iterableToArray");
              function _arrayWithoutHoles(arr) {
                if (Array.isArray(arr))
                  return _arrayLikeToArray4(arr);
              }
              __name(_arrayWithoutHoles, "_arrayWithoutHoles");
              function _arrayLikeToArray4(arr, len) {
                if (len == null || len > arr.length)
                  len = arr.length;
                for (var i = 0, arr2 = new Array(len); i < len; i++) {
                  arr2[i] = arr[i];
                }
                return arr2;
              }
              __name(_arrayLikeToArray4, "_arrayLikeToArray");
              var cachedDisplayNames = /* @__PURE__ */ new WeakMap();
              var encodedStringCache = new lru_cache__WEBPACK_IMPORTED_MODULE_0___default.a({
                max: 1e3
              });
              function alphaSortKeys(a, b2) {
                if (a.toString() > b2.toString()) {
                  return 1;
                } else if (b2.toString() > a.toString()) {
                  return -1;
                } else {
                  return 0;
                }
              }
              __name(alphaSortKeys, "alphaSortKeys");
              function getAllEnumerableKeys(obj) {
                var keys = /* @__PURE__ */ new Set();
                var current = obj;
                var _loop = /* @__PURE__ */ __name(function _loop2() {
                  var currentKeys = [].concat(_toConsumableArray(Object.keys(current)), _toConsumableArray(Object.getOwnPropertySymbols(current)));
                  var descriptors2 = Object.getOwnPropertyDescriptors(current);
                  currentKeys.forEach(function(key) {
                    if (descriptors2[key].enumerable) {
                      keys.add(key);
                    }
                  });
                  current = Object.getPrototypeOf(current);
                }, "_loop");
                while (current != null) {
                  _loop();
                }
                return keys;
              }
              __name(getAllEnumerableKeys, "getAllEnumerableKeys");
              function getDisplayName(type) {
                var fallbackName = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "Anonymous";
                var nameFromCache = cachedDisplayNames.get(type);
                if (nameFromCache != null) {
                  return nameFromCache;
                }
                var displayName = fallbackName;
                if (typeof type.displayName === "string") {
                  displayName = type.displayName;
                } else if (typeof type.name === "string" && type.name !== "") {
                  displayName = type.name;
                }
                cachedDisplayNames.set(type, displayName);
                return displayName;
              }
              __name(getDisplayName, "getDisplayName");
              var uidCounter = 0;
              function getUID() {
                return ++uidCounter;
              }
              __name(getUID, "getUID");
              function utfDecodeString(array) {
                var string = "";
                for (var i = 0; i < array.length; i++) {
                  var char = array[i];
                  string += String.fromCodePoint(char);
                }
                return string;
              }
              __name(utfDecodeString, "utfDecodeString");
              function surrogatePairToCodePoint(charCode1, charCode2) {
                return ((charCode1 & 1023) << 10) + (charCode2 & 1023) + 65536;
              }
              __name(surrogatePairToCodePoint, "surrogatePairToCodePoint");
              function utfEncodeString(string) {
                var cached = encodedStringCache.get(string);
                if (cached !== void 0) {
                  return cached;
                }
                var encoded = [];
                var i = 0;
                var charCode;
                while (i < string.length) {
                  charCode = string.charCodeAt(i);
                  if ((charCode & 63488) === 55296) {
                    encoded.push(surrogatePairToCodePoint(charCode, string.charCodeAt(++i)));
                  } else {
                    encoded.push(charCode);
                  }
                  ++i;
                }
                encodedStringCache.set(string, encoded);
                return encoded;
              }
              __name(utfEncodeString, "utfEncodeString");
              function printOperationsArray(operations) {
                var rendererID = operations[0];
                var rootID = operations[1];
                var logs = ["operations for renderer:".concat(rendererID, " and root:").concat(rootID)];
                var i = 2;
                var stringTable = [
                  null
                  // ID = 0 corresponds to the null string.
                ];
                var stringTableSize = operations[i++];
                var stringTableEnd = i + stringTableSize;
                while (i < stringTableEnd) {
                  var nextLength = operations[i++];
                  var nextString = utfDecodeString(operations.slice(i, i + nextLength));
                  stringTable.push(nextString);
                  i += nextLength;
                }
                while (i < operations.length) {
                  var operation = operations[i];
                  switch (operation) {
                    case _constants__WEBPACK_IMPORTED_MODULE_3__[
                      /* TREE_OPERATION_ADD */
                      "j"
                    ]: {
                      var _id = operations[i + 1];
                      var type = operations[i + 2];
                      i += 3;
                      if (type === react_devtools_shared_src_types__WEBPACK_IMPORTED_MODULE_4__[
                        /* ElementTypeRoot */
                        "m"
                      ]) {
                        logs.push("Add new root node ".concat(_id));
                        i++;
                        i++;
                        i++;
                        i++;
                      } else {
                        var parentID = operations[i];
                        i++;
                        i++;
                        var displayNameStringID = operations[i];
                        var displayName = stringTable[displayNameStringID];
                        i++;
                        i++;
                        logs.push("Add node ".concat(_id, " (").concat(displayName || "null", ") as child of ").concat(parentID));
                      }
                      break;
                    }
                    case _constants__WEBPACK_IMPORTED_MODULE_3__[
                      /* TREE_OPERATION_REMOVE */
                      "k"
                    ]: {
                      var removeLength = operations[i + 1];
                      i += 2;
                      for (var removeIndex = 0; removeIndex < removeLength; removeIndex++) {
                        var _id2 = operations[i];
                        i += 1;
                        logs.push("Remove node ".concat(_id2));
                      }
                      break;
                    }
                    case _constants__WEBPACK_IMPORTED_MODULE_3__[
                      /* TREE_OPERATION_REMOVE_ROOT */
                      "l"
                    ]: {
                      i += 1;
                      logs.push("Remove root ".concat(rootID));
                      break;
                    }
                    case _constants__WEBPACK_IMPORTED_MODULE_3__[
                      /* TREE_OPERATION_SET_SUBTREE_MODE */
                      "n"
                    ]: {
                      var _id3 = operations[i + 1];
                      var mode = operations[i + 1];
                      i += 3;
                      logs.push("Mode ".concat(mode, " set for subtree with root ").concat(_id3));
                      break;
                    }
                    case _constants__WEBPACK_IMPORTED_MODULE_3__[
                      /* TREE_OPERATION_REORDER_CHILDREN */
                      "m"
                    ]: {
                      var _id4 = operations[i + 1];
                      var numChildren = operations[i + 2];
                      i += 3;
                      var children = operations.slice(i, i + numChildren);
                      i += numChildren;
                      logs.push("Re-order node ".concat(_id4, " children ").concat(children.join(",")));
                      break;
                    }
                    case _constants__WEBPACK_IMPORTED_MODULE_3__[
                      /* TREE_OPERATION_UPDATE_TREE_BASE_DURATION */
                      "p"
                    ]:
                      i += 3;
                      break;
                    case _constants__WEBPACK_IMPORTED_MODULE_3__[
                      /* TREE_OPERATION_UPDATE_ERRORS_OR_WARNINGS */
                      "o"
                    ]:
                      var id = operations[i + 1];
                      var numErrors = operations[i + 2];
                      var numWarnings = operations[i + 3];
                      i += 4;
                      logs.push("Node ".concat(id, " has ").concat(numErrors, " errors and ").concat(numWarnings, " warnings"));
                      break;
                    default:
                      throw Error('Unsupported Bridge operation "'.concat(operation, '"'));
                  }
                }
                console.log(logs.join("\n  "));
              }
              __name(printOperationsArray, "printOperationsArray");
              function getDefaultComponentFilters() {
                return [{
                  type: react_devtools_shared_src_types__WEBPACK_IMPORTED_MODULE_4__[
                    /* ComponentFilterElementType */
                    "b"
                  ],
                  value: react_devtools_shared_src_types__WEBPACK_IMPORTED_MODULE_4__[
                    /* ElementTypeHostComponent */
                    "i"
                  ],
                  isEnabled: true
                }];
              }
              __name(getDefaultComponentFilters, "getDefaultComponentFilters");
              function getSavedComponentFilters() {
                try {
                  var raw = Object(_storage__WEBPACK_IMPORTED_MODULE_5__[
                    /* localStorageGetItem */
                    "a"
                  ])(_constants__WEBPACK_IMPORTED_MODULE_3__[
                    /* LOCAL_STORAGE_FILTER_PREFERENCES_KEY */
                    "a"
                  ]);
                  if (raw != null) {
                    return JSON.parse(raw);
                  }
                } catch (error2) {
                }
                return getDefaultComponentFilters();
              }
              __name(getSavedComponentFilters, "getSavedComponentFilters");
              function saveComponentFilters(componentFilters) {
                Object(_storage__WEBPACK_IMPORTED_MODULE_5__[
                  /* localStorageSetItem */
                  "b"
                ])(_constants__WEBPACK_IMPORTED_MODULE_3__[
                  /* LOCAL_STORAGE_FILTER_PREFERENCES_KEY */
                  "a"
                ], JSON.stringify(componentFilters));
              }
              __name(saveComponentFilters, "saveComponentFilters");
              function getAppendComponentStack() {
                try {
                  var raw = Object(_storage__WEBPACK_IMPORTED_MODULE_5__[
                    /* localStorageGetItem */
                    "a"
                  ])(_constants__WEBPACK_IMPORTED_MODULE_3__[
                    /* LOCAL_STORAGE_SHOULD_PATCH_CONSOLE_KEY */
                    "e"
                  ]);
                  if (raw != null) {
                    return JSON.parse(raw);
                  }
                } catch (error2) {
                }
                return true;
              }
              __name(getAppendComponentStack, "getAppendComponentStack");
              function setAppendComponentStack(value) {
                Object(_storage__WEBPACK_IMPORTED_MODULE_5__[
                  /* localStorageSetItem */
                  "b"
                ])(_constants__WEBPACK_IMPORTED_MODULE_3__[
                  /* LOCAL_STORAGE_SHOULD_PATCH_CONSOLE_KEY */
                  "e"
                ], JSON.stringify(value));
              }
              __name(setAppendComponentStack, "setAppendComponentStack");
              function getBreakOnConsoleErrors() {
                try {
                  var raw = Object(_storage__WEBPACK_IMPORTED_MODULE_5__[
                    /* localStorageGetItem */
                    "a"
                  ])(_constants__WEBPACK_IMPORTED_MODULE_3__[
                    /* LOCAL_STORAGE_SHOULD_BREAK_ON_CONSOLE_ERRORS */
                    "d"
                  ]);
                  if (raw != null) {
                    return JSON.parse(raw);
                  }
                } catch (error2) {
                }
                return false;
              }
              __name(getBreakOnConsoleErrors, "getBreakOnConsoleErrors");
              function setBreakOnConsoleErrors(value) {
                Object(_storage__WEBPACK_IMPORTED_MODULE_5__[
                  /* localStorageSetItem */
                  "b"
                ])(_constants__WEBPACK_IMPORTED_MODULE_3__[
                  /* LOCAL_STORAGE_SHOULD_BREAK_ON_CONSOLE_ERRORS */
                  "d"
                ], JSON.stringify(value));
              }
              __name(setBreakOnConsoleErrors, "setBreakOnConsoleErrors");
              function getHideConsoleLogsInStrictMode() {
                try {
                  var raw = Object(_storage__WEBPACK_IMPORTED_MODULE_5__[
                    /* localStorageGetItem */
                    "a"
                  ])(_constants__WEBPACK_IMPORTED_MODULE_3__[
                    /* LOCAL_STORAGE_HIDE_CONSOLE_LOGS_IN_STRICT_MODE */
                    "b"
                  ]);
                  if (raw != null) {
                    return JSON.parse(raw);
                  }
                } catch (error2) {
                }
                return false;
              }
              __name(getHideConsoleLogsInStrictMode, "getHideConsoleLogsInStrictMode");
              function sethideConsoleLogsInStrictMode(value) {
                Object(_storage__WEBPACK_IMPORTED_MODULE_5__[
                  /* localStorageSetItem */
                  "b"
                ])(_constants__WEBPACK_IMPORTED_MODULE_3__[
                  /* LOCAL_STORAGE_HIDE_CONSOLE_LOGS_IN_STRICT_MODE */
                  "b"
                ], JSON.stringify(value));
              }
              __name(sethideConsoleLogsInStrictMode, "sethideConsoleLogsInStrictMode");
              function getShowInlineWarningsAndErrors() {
                try {
                  var raw = Object(_storage__WEBPACK_IMPORTED_MODULE_5__[
                    /* localStorageGetItem */
                    "a"
                  ])(_constants__WEBPACK_IMPORTED_MODULE_3__[
                    /* LOCAL_STORAGE_SHOW_INLINE_WARNINGS_AND_ERRORS_KEY */
                    "f"
                  ]);
                  if (raw != null) {
                    return JSON.parse(raw);
                  }
                } catch (error2) {
                }
                return true;
              }
              __name(getShowInlineWarningsAndErrors, "getShowInlineWarningsAndErrors");
              function setShowInlineWarningsAndErrors(value) {
                Object(_storage__WEBPACK_IMPORTED_MODULE_5__[
                  /* localStorageSetItem */
                  "b"
                ])(_constants__WEBPACK_IMPORTED_MODULE_3__[
                  /* LOCAL_STORAGE_SHOW_INLINE_WARNINGS_AND_ERRORS_KEY */
                  "f"
                ], JSON.stringify(value));
              }
              __name(setShowInlineWarningsAndErrors, "setShowInlineWarningsAndErrors");
              function getDefaultOpenInEditorURL() {
                return typeof process11.env.EDITOR_URL === "string" ? process11.env.EDITOR_URL : "";
              }
              __name(getDefaultOpenInEditorURL, "getDefaultOpenInEditorURL");
              function getOpenInEditorURL() {
                try {
                  var raw = Object(_storage__WEBPACK_IMPORTED_MODULE_5__[
                    /* localStorageGetItem */
                    "a"
                  ])(_constants__WEBPACK_IMPORTED_MODULE_3__[
                    /* LOCAL_STORAGE_OPEN_IN_EDITOR_URL */
                    "c"
                  ]);
                  if (raw != null) {
                    return JSON.parse(raw);
                  }
                } catch (error2) {
                }
                return getDefaultOpenInEditorURL();
              }
              __name(getOpenInEditorURL, "getOpenInEditorURL");
              function separateDisplayNameAndHOCs(displayName, type) {
                if (displayName === null) {
                  return [null, null];
                }
                var hocDisplayNames = null;
                switch (type) {
                  case react_devtools_shared_src_types__WEBPACK_IMPORTED_MODULE_4__[
                    /* ElementTypeClass */
                    "e"
                  ]:
                  case react_devtools_shared_src_types__WEBPACK_IMPORTED_MODULE_4__[
                    /* ElementTypeForwardRef */
                    "g"
                  ]:
                  case react_devtools_shared_src_types__WEBPACK_IMPORTED_MODULE_4__[
                    /* ElementTypeFunction */
                    "h"
                  ]:
                  case react_devtools_shared_src_types__WEBPACK_IMPORTED_MODULE_4__[
                    /* ElementTypeMemo */
                    "j"
                  ]:
                    if (displayName.indexOf("(") >= 0) {
                      var matches = displayName.match(/[^()]+/g);
                      if (matches != null) {
                        displayName = matches.pop();
                        hocDisplayNames = matches;
                      }
                    }
                    break;
                  default:
                    break;
                }
                if (type === react_devtools_shared_src_types__WEBPACK_IMPORTED_MODULE_4__[
                  /* ElementTypeMemo */
                  "j"
                ]) {
                  if (hocDisplayNames === null) {
                    hocDisplayNames = ["Memo"];
                  } else {
                    hocDisplayNames.unshift("Memo");
                  }
                } else if (type === react_devtools_shared_src_types__WEBPACK_IMPORTED_MODULE_4__[
                  /* ElementTypeForwardRef */
                  "g"
                ]) {
                  if (hocDisplayNames === null) {
                    hocDisplayNames = ["ForwardRef"];
                  } else {
                    hocDisplayNames.unshift("ForwardRef");
                  }
                }
                return [displayName, hocDisplayNames];
              }
              __name(separateDisplayNameAndHOCs, "separateDisplayNameAndHOCs");
              function shallowDiffers(prev, next) {
                for (var attribute in prev) {
                  if (!(attribute in next)) {
                    return true;
                  }
                }
                for (var _attribute in next) {
                  if (prev[_attribute] !== next[_attribute]) {
                    return true;
                  }
                }
                return false;
              }
              __name(shallowDiffers, "shallowDiffers");
              function getInObject(object, path67) {
                return path67.reduce(function(reduced, attr) {
                  if (reduced) {
                    if (hasOwnProperty.call(reduced, attr)) {
                      return reduced[attr];
                    }
                    if (typeof reduced[Symbol.iterator] === "function") {
                      return Array.from(reduced)[attr];
                    }
                  }
                  return null;
                }, object);
              }
              __name(getInObject, "getInObject");
              function deletePathInObject(object, path67) {
                var length = path67.length;
                var last = path67[length - 1];
                if (object != null) {
                  var parent = getInObject(object, path67.slice(0, length - 1));
                  if (parent) {
                    if (Object(_isArray__WEBPACK_IMPORTED_MODULE_7__[
                      /* default */
                      "a"
                    ])(parent)) {
                      parent.splice(last, 1);
                    } else {
                      delete parent[last];
                    }
                  }
                }
              }
              __name(deletePathInObject, "deletePathInObject");
              function renamePathInObject(object, oldPath, newPath) {
                var length = oldPath.length;
                if (object != null) {
                  var parent = getInObject(object, oldPath.slice(0, length - 1));
                  if (parent) {
                    var lastOld = oldPath[length - 1];
                    var lastNew = newPath[length - 1];
                    parent[lastNew] = parent[lastOld];
                    if (Object(_isArray__WEBPACK_IMPORTED_MODULE_7__[
                      /* default */
                      "a"
                    ])(parent)) {
                      parent.splice(lastOld, 1);
                    } else {
                      delete parent[lastOld];
                    }
                  }
                }
              }
              __name(renamePathInObject, "renamePathInObject");
              function setInObject(object, path67, value) {
                var length = path67.length;
                var last = path67[length - 1];
                if (object != null) {
                  var parent = getInObject(object, path67.slice(0, length - 1));
                  if (parent) {
                    parent[last] = value;
                  }
                }
              }
              __name(setInObject, "setInObject");
              function getDataType(data) {
                if (data === null) {
                  return "null";
                } else if (data === void 0) {
                  return "undefined";
                }
                if (Object(react_is__WEBPACK_IMPORTED_MODULE_1__["isElement"])(data)) {
                  return "react_element";
                }
                if (typeof HTMLElement !== "undefined" && data instanceof HTMLElement) {
                  return "html_element";
                }
                var type = _typeof7(data);
                switch (type) {
                  case "bigint":
                    return "bigint";
                  case "boolean":
                    return "boolean";
                  case "function":
                    return "function";
                  case "number":
                    if (Number.isNaN(data)) {
                      return "nan";
                    } else if (!Number.isFinite(data)) {
                      return "infinity";
                    } else {
                      return "number";
                    }
                  case "object":
                    if (Object(_isArray__WEBPACK_IMPORTED_MODULE_7__[
                      /* default */
                      "a"
                    ])(data)) {
                      return "array";
                    } else if (ArrayBuffer.isView(data)) {
                      return hasOwnProperty.call(data.constructor, "BYTES_PER_ELEMENT") ? "typed_array" : "data_view";
                    } else if (data.constructor && data.constructor.name === "ArrayBuffer") {
                      return "array_buffer";
                    } else if (typeof data[Symbol.iterator] === "function") {
                      var iterator = data[Symbol.iterator]();
                      if (!iterator) {
                      } else {
                        return iterator === data ? "opaque_iterator" : "iterator";
                      }
                    } else if (data.constructor && data.constructor.name === "RegExp") {
                      return "regexp";
                    } else {
                      var toStringValue = Object.prototype.toString.call(data);
                      if (toStringValue === "[object Date]") {
                        return "date";
                      } else if (toStringValue === "[object HTMLAllCollection]") {
                        return "html_all_collection";
                      }
                    }
                    return "object";
                  case "string":
                    return "string";
                  case "symbol":
                    return "symbol";
                  case "undefined":
                    if (Object.prototype.toString.call(data) === "[object HTMLAllCollection]") {
                      return "html_all_collection";
                    }
                    return "undefined";
                  default:
                    return "unknown";
                }
              }
              __name(getDataType, "getDataType");
              function getDisplayNameForReactElement(element) {
                var elementType = Object(react_is__WEBPACK_IMPORTED_MODULE_1__["typeOf"])(element);
                switch (elementType) {
                  case react_is__WEBPACK_IMPORTED_MODULE_1__["ContextConsumer"]:
                    return "ContextConsumer";
                  case react_is__WEBPACK_IMPORTED_MODULE_1__["ContextProvider"]:
                    return "ContextProvider";
                  case react_is__WEBPACK_IMPORTED_MODULE_1__["ForwardRef"]:
                    return "ForwardRef";
                  case react_is__WEBPACK_IMPORTED_MODULE_1__["Fragment"]:
                    return "Fragment";
                  case react_is__WEBPACK_IMPORTED_MODULE_1__["Lazy"]:
                    return "Lazy";
                  case react_is__WEBPACK_IMPORTED_MODULE_1__["Memo"]:
                    return "Memo";
                  case react_is__WEBPACK_IMPORTED_MODULE_1__["Portal"]:
                    return "Portal";
                  case react_is__WEBPACK_IMPORTED_MODULE_1__["Profiler"]:
                    return "Profiler";
                  case react_is__WEBPACK_IMPORTED_MODULE_1__["StrictMode"]:
                    return "StrictMode";
                  case react_is__WEBPACK_IMPORTED_MODULE_1__["Suspense"]:
                    return "Suspense";
                  case shared_ReactSymbols__WEBPACK_IMPORTED_MODULE_2__[
                    /* REACT_SUSPENSE_LIST_TYPE */
                    "a"
                  ]:
                    return "SuspenseList";
                  default:
                    var type = element.type;
                    if (typeof type === "string") {
                      return type;
                    } else if (typeof type === "function") {
                      return getDisplayName(type, "Anonymous");
                    } else if (type != null) {
                      return "NotImplementedInDevtools";
                    } else {
                      return "Element";
                    }
                }
              }
              __name(getDisplayNameForReactElement, "getDisplayNameForReactElement");
              var MAX_PREVIEW_STRING_LENGTH = 50;
              function truncateForDisplay(string) {
                var length = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : MAX_PREVIEW_STRING_LENGTH;
                if (string.length > length) {
                  return string.substr(0, length) + "\u2026";
                } else {
                  return string;
                }
              }
              __name(truncateForDisplay, "truncateForDisplay");
              function formatDataForPreview(data, showFormattedValue) {
                if (data != null && hasOwnProperty.call(data, _hydration__WEBPACK_IMPORTED_MODULE_6__[
                  /* meta */
                  "b"
                ].type)) {
                  return showFormattedValue ? data[_hydration__WEBPACK_IMPORTED_MODULE_6__[
                    /* meta */
                    "b"
                  ].preview_long] : data[_hydration__WEBPACK_IMPORTED_MODULE_6__[
                    /* meta */
                    "b"
                  ].preview_short];
                }
                var type = getDataType(data);
                switch (type) {
                  case "html_element":
                    return "<".concat(truncateForDisplay(data.tagName.toLowerCase()), " />");
                  case "function":
                    return truncateForDisplay("\u0192 ".concat(typeof data.name === "function" ? "" : data.name, "() {}"));
                  case "string":
                    return '"'.concat(data, '"');
                  case "bigint":
                    return truncateForDisplay(data.toString() + "n");
                  case "regexp":
                    return truncateForDisplay(data.toString());
                  case "symbol":
                    return truncateForDisplay(data.toString());
                  case "react_element":
                    return "<".concat(truncateForDisplay(getDisplayNameForReactElement(data) || "Unknown"), " />");
                  case "array_buffer":
                    return "ArrayBuffer(".concat(data.byteLength, ")");
                  case "data_view":
                    return "DataView(".concat(data.buffer.byteLength, ")");
                  case "array":
                    if (showFormattedValue) {
                      var formatted = "";
                      for (var i = 0; i < data.length; i++) {
                        if (i > 0) {
                          formatted += ", ";
                        }
                        formatted += formatDataForPreview(data[i], false);
                        if (formatted.length > MAX_PREVIEW_STRING_LENGTH) {
                          break;
                        }
                      }
                      return "[".concat(truncateForDisplay(formatted), "]");
                    } else {
                      var length = hasOwnProperty.call(data, _hydration__WEBPACK_IMPORTED_MODULE_6__[
                        /* meta */
                        "b"
                      ].size) ? data[_hydration__WEBPACK_IMPORTED_MODULE_6__[
                        /* meta */
                        "b"
                      ].size] : data.length;
                      return "Array(".concat(length, ")");
                    }
                  case "typed_array":
                    var shortName = "".concat(data.constructor.name, "(").concat(data.length, ")");
                    if (showFormattedValue) {
                      var _formatted = "";
                      for (var _i = 0; _i < data.length; _i++) {
                        if (_i > 0) {
                          _formatted += ", ";
                        }
                        _formatted += data[_i];
                        if (_formatted.length > MAX_PREVIEW_STRING_LENGTH) {
                          break;
                        }
                      }
                      return "".concat(shortName, " [").concat(truncateForDisplay(_formatted), "]");
                    } else {
                      return shortName;
                    }
                  case "iterator":
                    var name = data.constructor.name;
                    if (showFormattedValue) {
                      var array = Array.from(data);
                      var _formatted2 = "";
                      for (var _i2 = 0; _i2 < array.length; _i2++) {
                        var entryOrEntries = array[_i2];
                        if (_i2 > 0) {
                          _formatted2 += ", ";
                        }
                        if (Object(_isArray__WEBPACK_IMPORTED_MODULE_7__[
                          /* default */
                          "a"
                        ])(entryOrEntries)) {
                          var key = formatDataForPreview(entryOrEntries[0], true);
                          var value = formatDataForPreview(entryOrEntries[1], false);
                          _formatted2 += "".concat(key, " => ").concat(value);
                        } else {
                          _formatted2 += formatDataForPreview(entryOrEntries, false);
                        }
                        if (_formatted2.length > MAX_PREVIEW_STRING_LENGTH) {
                          break;
                        }
                      }
                      return "".concat(name, "(").concat(data.size, ") {").concat(truncateForDisplay(_formatted2), "}");
                    } else {
                      return "".concat(name, "(").concat(data.size, ")");
                    }
                  case "opaque_iterator": {
                    return data[Symbol.toStringTag];
                  }
                  case "date":
                    return data.toString();
                  case "object":
                    if (showFormattedValue) {
                      var keys = Array.from(getAllEnumerableKeys(data)).sort(alphaSortKeys);
                      var _formatted3 = "";
                      for (var _i3 = 0; _i3 < keys.length; _i3++) {
                        var _key = keys[_i3];
                        if (_i3 > 0) {
                          _formatted3 += ", ";
                        }
                        _formatted3 += "".concat(_key.toString(), ": ").concat(formatDataForPreview(data[_key], false));
                        if (_formatted3.length > MAX_PREVIEW_STRING_LENGTH) {
                          break;
                        }
                      }
                      return "{".concat(truncateForDisplay(_formatted3), "}");
                    } else {
                      return "{\u2026}";
                    }
                  case "boolean":
                  case "number":
                  case "infinity":
                  case "nan":
                  case "null":
                  case "undefined":
                    return data;
                  default:
                    try {
                      return truncateForDisplay(String(data));
                    } catch (error2) {
                      return "unserializable";
                    }
                }
              }
              __name(formatDataForPreview, "formatDataForPreview");
            }).call(this, __webpack_require__(17));
          },
          /* 3 */
          /***/
          function(module4, __webpack_exports__, __webpack_require__) {
            "use strict";
            __webpack_require__.d(__webpack_exports__, "a", function() {
              return CONCURRENT_MODE_NUMBER;
            });
            __webpack_require__.d(__webpack_exports__, "b", function() {
              return CONCURRENT_MODE_SYMBOL_STRING;
            });
            __webpack_require__.d(__webpack_exports__, "c", function() {
              return CONTEXT_NUMBER;
            });
            __webpack_require__.d(__webpack_exports__, "d", function() {
              return CONTEXT_SYMBOL_STRING;
            });
            __webpack_require__.d(__webpack_exports__, "e", function() {
              return DEPRECATED_ASYNC_MODE_SYMBOL_STRING;
            });
            __webpack_require__.d(__webpack_exports__, "f", function() {
              return FORWARD_REF_NUMBER;
            });
            __webpack_require__.d(__webpack_exports__, "g", function() {
              return FORWARD_REF_SYMBOL_STRING;
            });
            __webpack_require__.d(__webpack_exports__, "h", function() {
              return LAZY_NUMBER;
            });
            __webpack_require__.d(__webpack_exports__, "i", function() {
              return LAZY_SYMBOL_STRING;
            });
            __webpack_require__.d(__webpack_exports__, "j", function() {
              return MEMO_NUMBER;
            });
            __webpack_require__.d(__webpack_exports__, "k", function() {
              return MEMO_SYMBOL_STRING;
            });
            __webpack_require__.d(__webpack_exports__, "l", function() {
              return PROFILER_NUMBER;
            });
            __webpack_require__.d(__webpack_exports__, "m", function() {
              return PROFILER_SYMBOL_STRING;
            });
            __webpack_require__.d(__webpack_exports__, "n", function() {
              return PROVIDER_NUMBER;
            });
            __webpack_require__.d(__webpack_exports__, "o", function() {
              return PROVIDER_SYMBOL_STRING;
            });
            __webpack_require__.d(__webpack_exports__, "p", function() {
              return SCOPE_NUMBER;
            });
            __webpack_require__.d(__webpack_exports__, "q", function() {
              return SCOPE_SYMBOL_STRING;
            });
            __webpack_require__.d(__webpack_exports__, "r", function() {
              return STRICT_MODE_NUMBER;
            });
            __webpack_require__.d(__webpack_exports__, "s", function() {
              return STRICT_MODE_SYMBOL_STRING;
            });
            __webpack_require__.d(__webpack_exports__, "v", function() {
              return SUSPENSE_NUMBER;
            });
            __webpack_require__.d(__webpack_exports__, "w", function() {
              return SUSPENSE_SYMBOL_STRING;
            });
            __webpack_require__.d(__webpack_exports__, "t", function() {
              return SUSPENSE_LIST_NUMBER;
            });
            __webpack_require__.d(__webpack_exports__, "u", function() {
              return SUSPENSE_LIST_SYMBOL_STRING;
            });
            var CONCURRENT_MODE_NUMBER = 60111;
            var CONCURRENT_MODE_SYMBOL_STRING = "Symbol(react.concurrent_mode)";
            var CONTEXT_NUMBER = 60110;
            var CONTEXT_SYMBOL_STRING = "Symbol(react.context)";
            var DEPRECATED_ASYNC_MODE_SYMBOL_STRING = "Symbol(react.async_mode)";
            var ELEMENT_NUMBER = 60103;
            var ELEMENT_SYMBOL_STRING = "Symbol(react.element)";
            var DEBUG_TRACING_MODE_NUMBER = 60129;
            var DEBUG_TRACING_MODE_SYMBOL_STRING = "Symbol(react.debug_trace_mode)";
            var FORWARD_REF_NUMBER = 60112;
            var FORWARD_REF_SYMBOL_STRING = "Symbol(react.forward_ref)";
            var FRAGMENT_NUMBER = 60107;
            var FRAGMENT_SYMBOL_STRING = "Symbol(react.fragment)";
            var LAZY_NUMBER = 60116;
            var LAZY_SYMBOL_STRING = "Symbol(react.lazy)";
            var MEMO_NUMBER = 60115;
            var MEMO_SYMBOL_STRING = "Symbol(react.memo)";
            var PORTAL_NUMBER = 60106;
            var PORTAL_SYMBOL_STRING = "Symbol(react.portal)";
            var PROFILER_NUMBER = 60114;
            var PROFILER_SYMBOL_STRING = "Symbol(react.profiler)";
            var PROVIDER_NUMBER = 60109;
            var PROVIDER_SYMBOL_STRING = "Symbol(react.provider)";
            var SCOPE_NUMBER = 60119;
            var SCOPE_SYMBOL_STRING = "Symbol(react.scope)";
            var STRICT_MODE_NUMBER = 60108;
            var STRICT_MODE_SYMBOL_STRING = "Symbol(react.strict_mode)";
            var SUSPENSE_NUMBER = 60113;
            var SUSPENSE_SYMBOL_STRING = "Symbol(react.suspense)";
            var SUSPENSE_LIST_NUMBER = 60120;
            var SUSPENSE_LIST_SYMBOL_STRING = "Symbol(react.suspense_list)";
          },
          /* 4 */
          /***/
          function(module4, __webpack_exports__, __webpack_require__) {
            "use strict";
            __webpack_require__.d(__webpack_exports__, "a", function() {
              return cleanForBridge;
            });
            __webpack_require__.d(__webpack_exports__, "b", function() {
              return copyToClipboard;
            });
            __webpack_require__.d(__webpack_exports__, "c", function() {
              return copyWithDelete;
            });
            __webpack_require__.d(__webpack_exports__, "d", function() {
              return copyWithRename;
            });
            __webpack_require__.d(__webpack_exports__, "e", function() {
              return copyWithSet;
            });
            __webpack_require__.d(__webpack_exports__, "g", function() {
              return getEffectDurations;
            });
            __webpack_require__.d(__webpack_exports__, "f", function() {
              return format10;
            });
            __webpack_require__.d(__webpack_exports__, "h", function() {
              return isSynchronousXHRSupported;
            });
            var clipboard_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(18);
            var clipboard_js__WEBPACK_IMPORTED_MODULE_0___default = /* @__PURE__ */ __webpack_require__.n(clipboard_js__WEBPACK_IMPORTED_MODULE_0__);
            var _hydration__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(12);
            var shared_isArray__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9);
            function _typeof7(obj) {
              "@babel/helpers - typeof";
              if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return typeof obj2;
                }, "_typeof");
              } else {
                _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
                }, "_typeof");
              }
              return _typeof7(obj);
            }
            __name(_typeof7, "_typeof");
            function ownKeys11(object, enumerableOnly) {
              var keys = Object.keys(object);
              if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                if (enumerableOnly)
                  symbols = symbols.filter(function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                  });
                keys.push.apply(keys, symbols);
              }
              return keys;
            }
            __name(ownKeys11, "ownKeys");
            function _objectSpread11(target) {
              for (var i = 1; i < arguments.length; i++) {
                var source = arguments[i] != null ? arguments[i] : {};
                if (i % 2) {
                  ownKeys11(Object(source), true).forEach(function(key) {
                    _defineProperty11(target, key, source[key]);
                  });
                } else if (Object.getOwnPropertyDescriptors) {
                  Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
                } else {
                  ownKeys11(Object(source)).forEach(function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                  });
                }
              }
              return target;
            }
            __name(_objectSpread11, "_objectSpread");
            function _defineProperty11(obj, key, value) {
              if (key in obj) {
                Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
              } else {
                obj[key] = value;
              }
              return obj;
            }
            __name(_defineProperty11, "_defineProperty");
            function cleanForBridge(data, isPathAllowed) {
              var path67 = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [];
              if (data !== null) {
                var cleanedPaths = [];
                var unserializablePaths = [];
                var cleanedData = Object(_hydration__WEBPACK_IMPORTED_MODULE_1__[
                  /* dehydrate */
                  "a"
                ])(data, cleanedPaths, unserializablePaths, path67, isPathAllowed);
                return {
                  data: cleanedData,
                  cleaned: cleanedPaths,
                  unserializable: unserializablePaths
                };
              } else {
                return null;
              }
            }
            __name(cleanForBridge, "cleanForBridge");
            function copyToClipboard(value) {
              var safeToCopy = serializeToString(value);
              var text = safeToCopy === void 0 ? "undefined" : safeToCopy;
              var clipboardCopyText = window.__REACT_DEVTOOLS_GLOBAL_HOOK__.clipboardCopyText;
              if (typeof clipboardCopyText === "function") {
                clipboardCopyText(text).catch(function(err) {
                });
              } else {
                Object(clipboard_js__WEBPACK_IMPORTED_MODULE_0__["copy"])(text);
              }
            }
            __name(copyToClipboard, "copyToClipboard");
            function copyWithDelete(obj, path67) {
              var index = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0;
              var key = path67[index];
              var updated = Object(shared_isArray__WEBPACK_IMPORTED_MODULE_2__[
                /* default */
                "a"
              ])(obj) ? obj.slice() : _objectSpread11({}, obj);
              if (index + 1 === path67.length) {
                if (Object(shared_isArray__WEBPACK_IMPORTED_MODULE_2__[
                  /* default */
                  "a"
                ])(updated)) {
                  updated.splice(key, 1);
                } else {
                  delete updated[key];
                }
              } else {
                updated[key] = copyWithDelete(obj[key], path67, index + 1);
              }
              return updated;
            }
            __name(copyWithDelete, "copyWithDelete");
            function copyWithRename(obj, oldPath, newPath) {
              var index = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0;
              var oldKey = oldPath[index];
              var updated = Object(shared_isArray__WEBPACK_IMPORTED_MODULE_2__[
                /* default */
                "a"
              ])(obj) ? obj.slice() : _objectSpread11({}, obj);
              if (index + 1 === oldPath.length) {
                var newKey = newPath[index];
                updated[newKey] = updated[oldKey];
                if (Object(shared_isArray__WEBPACK_IMPORTED_MODULE_2__[
                  /* default */
                  "a"
                ])(updated)) {
                  updated.splice(oldKey, 1);
                } else {
                  delete updated[oldKey];
                }
              } else {
                updated[oldKey] = copyWithRename(obj[oldKey], oldPath, newPath, index + 1);
              }
              return updated;
            }
            __name(copyWithRename, "copyWithRename");
            function copyWithSet(obj, path67, value) {
              var index = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0;
              if (index >= path67.length) {
                return value;
              }
              var key = path67[index];
              var updated = Object(shared_isArray__WEBPACK_IMPORTED_MODULE_2__[
                /* default */
                "a"
              ])(obj) ? obj.slice() : _objectSpread11({}, obj);
              updated[key] = copyWithSet(obj[key], path67, value, index + 1);
              return updated;
            }
            __name(copyWithSet, "copyWithSet");
            function getEffectDurations(root) {
              var effectDuration = null;
              var passiveEffectDuration = null;
              var hostRoot = root.current;
              if (hostRoot != null) {
                var stateNode = hostRoot.stateNode;
                if (stateNode != null) {
                  effectDuration = stateNode.effectDuration != null ? stateNode.effectDuration : null;
                  passiveEffectDuration = stateNode.passiveEffectDuration != null ? stateNode.passiveEffectDuration : null;
                }
              }
              return {
                effectDuration,
                passiveEffectDuration
              };
            }
            __name(getEffectDurations, "getEffectDurations");
            function serializeToString(data) {
              var cache2 = /* @__PURE__ */ new Set();
              return JSON.stringify(data, function(key, value) {
                if (_typeof7(value) === "object" && value !== null) {
                  if (cache2.has(value)) {
                    return;
                  }
                  cache2.add(value);
                }
                if (typeof value === "bigint") {
                  return value.toString() + "n";
                }
                return value;
              });
            }
            __name(serializeToString, "serializeToString");
            function format10(maybeMessage) {
              for (var _len = arguments.length, inputArgs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                inputArgs[_key - 1] = arguments[_key];
              }
              var args = inputArgs.slice();
              var formatted = String(maybeMessage);
              if (typeof maybeMessage === "string") {
                if (args.length) {
                  var REGEXP = /(%?)(%([jds]))/g;
                  formatted = formatted.replace(REGEXP, function(match, escaped, ptn, flag) {
                    var arg = args.shift();
                    switch (flag) {
                      case "s":
                        arg += "";
                        break;
                      case "d":
                      case "i":
                        arg = parseInt(arg, 10).toString();
                        break;
                      case "f":
                        arg = parseFloat(arg).toString();
                        break;
                    }
                    if (!escaped) {
                      return arg;
                    }
                    args.unshift(arg);
                    return match;
                  });
                }
              }
              if (args.length) {
                for (var i = 0; i < args.length; i++) {
                  formatted += " " + String(args[i]);
                }
              }
              formatted = formatted.replace(/%{2,2}/g, "%");
              return String(formatted);
            }
            __name(format10, "format");
            function isSynchronousXHRSupported() {
              return !!(window.document && window.document.featurePolicy && window.document.featurePolicy.allowsFeature("sync-xhr"));
            }
            __name(isSynchronousXHRSupported, "isSynchronousXHRSupported");
          },
          /* 5 */
          /***/
          function(module4, __webpack_exports__, __webpack_require__) {
            "use strict";
            __webpack_require__.d(__webpack_exports__, "a", function() {
              return localStorageGetItem;
            });
            __webpack_require__.d(__webpack_exports__, "b", function() {
              return localStorageSetItem;
            });
            __webpack_require__.d(__webpack_exports__, "c", function() {
              return sessionStorageGetItem;
            });
            __webpack_require__.d(__webpack_exports__, "d", function() {
              return sessionStorageRemoveItem;
            });
            __webpack_require__.d(__webpack_exports__, "e", function() {
              return sessionStorageSetItem;
            });
            function localStorageGetItem(key) {
              try {
                return localStorage.getItem(key);
              } catch (error2) {
                return null;
              }
            }
            __name(localStorageGetItem, "localStorageGetItem");
            function localStorageRemoveItem(key) {
              try {
                localStorage.removeItem(key);
              } catch (error2) {
              }
            }
            __name(localStorageRemoveItem, "localStorageRemoveItem");
            function localStorageSetItem(key, value) {
              try {
                return localStorage.setItem(key, value);
              } catch (error2) {
              }
            }
            __name(localStorageSetItem, "localStorageSetItem");
            function sessionStorageGetItem(key) {
              try {
                return sessionStorage.getItem(key);
              } catch (error2) {
                return null;
              }
            }
            __name(sessionStorageGetItem, "sessionStorageGetItem");
            function sessionStorageRemoveItem(key) {
              try {
                sessionStorage.removeItem(key);
              } catch (error2) {
              }
            }
            __name(sessionStorageRemoveItem, "sessionStorageRemoveItem");
            function sessionStorageSetItem(key, value) {
              try {
                return sessionStorage.setItem(key, value);
              } catch (error2) {
              }
            }
            __name(sessionStorageSetItem, "sessionStorageSetItem");
          },
          /* 6 */
          /***/
          function(module4, __webpack_exports__, __webpack_require__) {
            "use strict";
            var isArray = Array.isArray;
            __webpack_exports__["a"] = isArray;
          },
          /* 7 */
          /***/
          function(module4, exports3, __webpack_require__) {
            "use strict";
            if (true) {
              module4.exports = __webpack_require__(27);
            } else {
            }
          },
          /* 8 */
          /***/
          function(module4, exports3, __webpack_require__) {
            "use strict";
            var getOwnPropertySymbols = Object.getOwnPropertySymbols;
            var hasOwnProperty2 = 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);
            }
            __name(toObject, "toObject");
            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(n2) {
                  return test2[n2];
                });
                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;
              }
            }
            __name(shouldUseNative, "shouldUseNative");
            module4.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 (hasOwnProperty2.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;
            };
          },
          /* 9 */
          /***/
          function(module4, __webpack_exports__, __webpack_require__) {
            "use strict";
            var isArrayImpl = Array.isArray;
            function isArray(a) {
              return isArrayImpl(a);
            }
            __name(isArray, "isArray");
            __webpack_exports__["a"] = isArray;
          },
          /* 10 */
          /***/
          function(module4, __webpack_exports__, __webpack_require__) {
            "use strict";
            (function(global2) {
              __webpack_require__.d(__webpack_exports__, "c", function() {
                return registerRenderer;
              });
              __webpack_require__.d(__webpack_exports__, "a", function() {
                return patch;
              });
              __webpack_require__.d(__webpack_exports__, "b", function() {
                return patchForStrictMode;
              });
              __webpack_require__.d(__webpack_exports__, "d", function() {
                return unpatchForStrictMode;
              });
              var _utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4);
              var _renderer__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(16);
              var _DevToolsFiberComponentStack__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(22);
              var react_devtools_feature_flags__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(13);
              function _createForOfIteratorHelper(o2, allowArrayLike) {
                var it2;
                if (typeof Symbol === "undefined" || o2[Symbol.iterator] == null) {
                  if (Array.isArray(o2) || (it2 = _unsupportedIterableToArray4(o2)) || allowArrayLike && o2 && typeof o2.length === "number") {
                    if (it2)
                      o2 = it2;
                    var i = 0;
                    var F = /* @__PURE__ */ __name(function F2() {
                    }, "F");
                    return { s: F, n: /* @__PURE__ */ __name(function n2() {
                      if (i >= o2.length)
                        return { done: true };
                      return { done: false, value: o2[i++] };
                    }, "n"), e: /* @__PURE__ */ __name(function e3(_e) {
                      throw _e;
                    }, "e"), f: F };
                  }
                  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
                }
                var normalCompletion = true, didErr = false, err;
                return { s: /* @__PURE__ */ __name(function s() {
                  it2 = o2[Symbol.iterator]();
                }, "s"), n: /* @__PURE__ */ __name(function n2() {
                  var step = it2.next();
                  normalCompletion = step.done;
                  return step;
                }, "n"), e: /* @__PURE__ */ __name(function e3(_e2) {
                  didErr = true;
                  err = _e2;
                }, "e"), f: /* @__PURE__ */ __name(function f() {
                  try {
                    if (!normalCompletion && it2.return != null)
                      it2.return();
                  } finally {
                    if (didErr)
                      throw err;
                  }
                }, "f") };
              }
              __name(_createForOfIteratorHelper, "_createForOfIteratorHelper");
              function _unsupportedIterableToArray4(o2, minLen) {
                if (!o2)
                  return;
                if (typeof o2 === "string")
                  return _arrayLikeToArray4(o2, minLen);
                var n2 = Object.prototype.toString.call(o2).slice(8, -1);
                if (n2 === "Object" && o2.constructor)
                  n2 = o2.constructor.name;
                if (n2 === "Map" || n2 === "Set")
                  return Array.from(o2);
                if (n2 === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n2))
                  return _arrayLikeToArray4(o2, minLen);
              }
              __name(_unsupportedIterableToArray4, "_unsupportedIterableToArray");
              function _arrayLikeToArray4(arr, len) {
                if (len == null || len > arr.length)
                  len = arr.length;
                for (var i = 0, arr2 = new Array(len); i < len; i++) {
                  arr2[i] = arr[i];
                }
                return arr2;
              }
              __name(_arrayLikeToArray4, "_arrayLikeToArray");
              var OVERRIDE_CONSOLE_METHODS = ["error", "trace", "warn"];
              var DIMMED_NODE_CONSOLE_COLOR = "\x1B[2m%s\x1B[0m";
              var PREFIX_REGEX = /\s{4}(in|at)\s{1}/;
              var ROW_COLUMN_NUMBER_REGEX = /:\d+:\d+(\n|$)/;
              function isStringComponentStack(text) {
                return PREFIX_REGEX.test(text) || ROW_COLUMN_NUMBER_REGEX.test(text);
              }
              __name(isStringComponentStack, "isStringComponentStack");
              var STYLE_DIRECTIVE_REGEX = /^%c/;
              function isStrictModeOverride(args, method2) {
                return args.length === 2 && STYLE_DIRECTIVE_REGEX.test(args[0]) && args[1] === "color: ".concat(getConsoleColor(method2) || "");
              }
              __name(isStrictModeOverride, "isStrictModeOverride");
              function getConsoleColor(method2) {
                switch (method2) {
                  case "warn":
                    return consoleSettingsRef.browserTheme === "light" ? "rgba(250, 180, 50, 0.75)" : "rgba(250, 180, 50, 0.5)";
                  case "error":
                    return consoleSettingsRef.browserTheme === "light" ? "rgba(250, 123, 130, 0.75)" : "rgba(250, 123, 130, 0.5)";
                  case "log":
                  default:
                    return consoleSettingsRef.browserTheme === "light" ? "rgba(125, 125, 125, 0.75)" : "rgba(125, 125, 125, 0.5)";
                }
              }
              __name(getConsoleColor, "getConsoleColor");
              var injectedRenderers = /* @__PURE__ */ new Map();
              var targetConsole = console;
              var targetConsoleMethods = {};
              for (var method in console) {
                targetConsoleMethods[method] = console[method];
              }
              var unpatchFn = null;
              var isNode = false;
              try {
                isNode = void 0 === global2;
              } catch (error2) {
              }
              function dangerous_setTargetConsoleForTesting(targetConsoleForTesting) {
                targetConsole = targetConsoleForTesting;
                targetConsoleMethods = {};
                for (var _method in targetConsole) {
                  targetConsoleMethods[_method] = console[_method];
                }
              }
              __name(dangerous_setTargetConsoleForTesting, "dangerous_setTargetConsoleForTesting");
              function registerRenderer(renderer, onErrorOrWarning) {
                var currentDispatcherRef = renderer.currentDispatcherRef, getCurrentFiber = renderer.getCurrentFiber, findFiberByHostInstance = renderer.findFiberByHostInstance, version3 = renderer.version;
                if (typeof findFiberByHostInstance !== "function") {
                  return;
                }
                if (currentDispatcherRef != null && typeof getCurrentFiber === "function") {
                  var _getInternalReactCons = Object(_renderer__WEBPACK_IMPORTED_MODULE_1__[
                    /* getInternalReactConstants */
                    "b"
                  ])(version3), ReactTypeOfWork = _getInternalReactCons.ReactTypeOfWork;
                  injectedRenderers.set(renderer, {
                    currentDispatcherRef,
                    getCurrentFiber,
                    workTagMap: ReactTypeOfWork,
                    onErrorOrWarning
                  });
                }
              }
              __name(registerRenderer, "registerRenderer");
              var consoleSettingsRef = {
                appendComponentStack: false,
                breakOnConsoleErrors: false,
                showInlineWarningsAndErrors: false,
                hideConsoleLogsInStrictMode: false,
                browserTheme: "dark"
              };
              function patch(_ref) {
                var appendComponentStack = _ref.appendComponentStack, breakOnConsoleErrors = _ref.breakOnConsoleErrors, showInlineWarningsAndErrors = _ref.showInlineWarningsAndErrors, hideConsoleLogsInStrictMode = _ref.hideConsoleLogsInStrictMode, browserTheme = _ref.browserTheme;
                consoleSettingsRef.appendComponentStack = appendComponentStack;
                consoleSettingsRef.breakOnConsoleErrors = breakOnConsoleErrors;
                consoleSettingsRef.showInlineWarningsAndErrors = showInlineWarningsAndErrors;
                consoleSettingsRef.hideConsoleLogsInStrictMode = hideConsoleLogsInStrictMode;
                consoleSettingsRef.browserTheme = browserTheme;
                if (appendComponentStack || breakOnConsoleErrors || showInlineWarningsAndErrors) {
                  if (unpatchFn !== null) {
                    return;
                  }
                  var originalConsoleMethods2 = {};
                  unpatchFn = /* @__PURE__ */ __name(function unpatchFn2() {
                    for (var _method2 in originalConsoleMethods2) {
                      try {
                        targetConsole[_method2] = originalConsoleMethods2[_method2];
                      } catch (error2) {
                      }
                    }
                  }, "unpatchFn");
                  OVERRIDE_CONSOLE_METHODS.forEach(function(method2) {
                    try {
                      var originalMethod = originalConsoleMethods2[method2] = targetConsole[method2].__REACT_DEVTOOLS_ORIGINAL_METHOD__ ? targetConsole[method2].__REACT_DEVTOOLS_ORIGINAL_METHOD__ : targetConsole[method2];
                      var overrideMethod = /* @__PURE__ */ __name(function overrideMethod2() {
                        var shouldAppendWarningStack = false;
                        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                          args[_key] = arguments[_key];
                        }
                        if (method2 !== "log") {
                          if (consoleSettingsRef.appendComponentStack) {
                            var lastArg = args.length > 0 ? args[args.length - 1] : null;
                            var alreadyHasComponentStack = typeof lastArg === "string" && isStringComponentStack(lastArg);
                            shouldAppendWarningStack = !alreadyHasComponentStack;
                          }
                        }
                        var shouldShowInlineWarningsAndErrors = consoleSettingsRef.showInlineWarningsAndErrors && (method2 === "error" || method2 === "warn");
                        var _iterator = _createForOfIteratorHelper(injectedRenderers.values()), _step;
                        try {
                          for (_iterator.s(); !(_step = _iterator.n()).done; ) {
                            var _step$value = _step.value, currentDispatcherRef = _step$value.currentDispatcherRef, getCurrentFiber = _step$value.getCurrentFiber, onErrorOrWarning = _step$value.onErrorOrWarning, workTagMap = _step$value.workTagMap;
                            var current = getCurrentFiber();
                            if (current != null) {
                              try {
                                if (shouldShowInlineWarningsAndErrors) {
                                  if (typeof onErrorOrWarning === "function") {
                                    onErrorOrWarning(
                                      current,
                                      method2,
                                      // Copy args before we mutate them (e.g. adding the component stack)
                                      args.slice()
                                    );
                                  }
                                }
                                if (shouldAppendWarningStack) {
                                  var componentStack = Object(_DevToolsFiberComponentStack__WEBPACK_IMPORTED_MODULE_2__[
                                    /* getStackByFiberInDevAndProd */
                                    "a"
                                  ])(workTagMap, current, currentDispatcherRef);
                                  if (componentStack !== "") {
                                    if (isStrictModeOverride(args, method2)) {
                                      args[0] = Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                                        /* format */
                                        "f"
                                      ])(args[0], componentStack);
                                    } else {
                                      args.push(componentStack);
                                    }
                                  }
                                }
                              } catch (error2) {
                                setTimeout(function() {
                                  throw error2;
                                }, 0);
                              } finally {
                                break;
                              }
                            }
                          }
                        } catch (err) {
                          _iterator.e(err);
                        } finally {
                          _iterator.f();
                        }
                        if (consoleSettingsRef.breakOnConsoleErrors) {
                          debugger;
                        }
                        originalMethod.apply(void 0, args);
                      }, "overrideMethod");
                      overrideMethod.__REACT_DEVTOOLS_ORIGINAL_METHOD__ = originalMethod;
                      originalMethod.__REACT_DEVTOOLS_OVERRIDE_METHOD__ = overrideMethod;
                      targetConsole[method2] = overrideMethod;
                    } catch (error2) {
                    }
                  });
                } else {
                  unpatch();
                }
              }
              __name(patch, "patch");
              function unpatch() {
                if (unpatchFn !== null) {
                  unpatchFn();
                  unpatchFn = null;
                }
              }
              __name(unpatch, "unpatch");
              var unpatchForStrictModeFn = null;
              function patchForStrictMode() {
                if (react_devtools_feature_flags__WEBPACK_IMPORTED_MODULE_3__[
                  /* consoleManagedByDevToolsDuringStrictMode */
                  "a"
                ]) {
                  var overrideConsoleMethods = ["error", "trace", "warn", "log"];
                  if (unpatchForStrictModeFn !== null) {
                    return;
                  }
                  var originalConsoleMethods2 = {};
                  unpatchForStrictModeFn = /* @__PURE__ */ __name(function unpatchForStrictModeFn2() {
                    for (var _method3 in originalConsoleMethods2) {
                      try {
                        targetConsole[_method3] = originalConsoleMethods2[_method3];
                      } catch (error2) {
                      }
                    }
                  }, "unpatchForStrictModeFn");
                  overrideConsoleMethods.forEach(function(method2) {
                    try {
                      var originalMethod = originalConsoleMethods2[method2] = targetConsole[method2].__REACT_DEVTOOLS_STRICT_MODE_ORIGINAL_METHOD__ ? targetConsole[method2].__REACT_DEVTOOLS_STRICT_MODE_ORIGINAL_METHOD__ : targetConsole[method2];
                      var overrideMethod = /* @__PURE__ */ __name(function overrideMethod2() {
                        if (!consoleSettingsRef.hideConsoleLogsInStrictMode) {
                          if (isNode) {
                            originalMethod(DIMMED_NODE_CONSOLE_COLOR, _utils__WEBPACK_IMPORTED_MODULE_0__[
                              /* format */
                              "f"
                            ].apply(void 0, arguments));
                          } else {
                            var color = getConsoleColor(method2);
                            if (color) {
                              originalMethod("%c".concat(_utils__WEBPACK_IMPORTED_MODULE_0__[
                                /* format */
                                "f"
                              ].apply(void 0, arguments)), "color: ".concat(color));
                            } else {
                              throw Error("Console color is not defined");
                            }
                          }
                        }
                      }, "overrideMethod");
                      overrideMethod.__REACT_DEVTOOLS_STRICT_MODE_ORIGINAL_METHOD__ = originalMethod;
                      originalMethod.__REACT_DEVTOOLS_STRICT_MODE_OVERRIDE_METHOD__ = overrideMethod;
                      targetConsole[method2] = overrideMethod;
                    } catch (error2) {
                    }
                  });
                }
              }
              __name(patchForStrictMode, "patchForStrictMode");
              function unpatchForStrictMode() {
                if (react_devtools_feature_flags__WEBPACK_IMPORTED_MODULE_3__[
                  /* consoleManagedByDevToolsDuringStrictMode */
                  "a"
                ]) {
                  if (unpatchForStrictModeFn !== null) {
                    unpatchForStrictModeFn();
                    unpatchForStrictModeFn = null;
                  }
                }
              }
              __name(unpatchForStrictMode, "unpatchForStrictMode");
            }).call(this, __webpack_require__(14));
          },
          /* 11 */
          /***/
          function(module4, exports3, __webpack_require__) {
            (function(process11) {
              function _typeof7(obj) {
                "@babel/helpers - typeof";
                if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                  _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                    return typeof obj2;
                  }, "_typeof");
                } else {
                  _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                    return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
                  }, "_typeof");
                }
                return _typeof7(obj);
              }
              __name(_typeof7, "_typeof");
              exports3 = module4.exports = SemVer;
              var debug;
              if ((typeof process11 === "undefined" ? "undefined" : _typeof7(process11)) === "object" && process11.env && process11.env.NODE_DEBUG && /\bsemver\b/i.test(process11.env.NODE_DEBUG)) {
                debug = /* @__PURE__ */ __name(function debug2() {
                  var args = Array.prototype.slice.call(arguments, 0);
                  args.unshift("SEMVER");
                  console.log.apply(console, args);
                }, "debug");
              } else {
                debug = /* @__PURE__ */ __name(function debug2() {
                }, "debug");
              }
              exports3.SEMVER_SPEC_VERSION = "2.0.0";
              var MAX_LENGTH = 256;
              var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
              9007199254740991;
              var MAX_SAFE_COMPONENT_LENGTH = 16;
              var re = exports3.re = [];
              var src = exports3.src = [];
              var t3 = exports3.tokens = {};
              var R2 = 0;
              function tok(n2) {
                t3[n2] = R2++;
              }
              __name(tok, "tok");
              tok("NUMERICIDENTIFIER");
              src[t3.NUMERICIDENTIFIER] = "0|[1-9]\\d*";
              tok("NUMERICIDENTIFIERLOOSE");
              src[t3.NUMERICIDENTIFIERLOOSE] = "[0-9]+";
              tok("NONNUMERICIDENTIFIER");
              src[t3.NONNUMERICIDENTIFIER] = "\\d*[a-zA-Z-][a-zA-Z0-9-]*";
              tok("MAINVERSION");
              src[t3.MAINVERSION] = "(" + src[t3.NUMERICIDENTIFIER] + ")\\.(" + src[t3.NUMERICIDENTIFIER] + ")\\.(" + src[t3.NUMERICIDENTIFIER] + ")";
              tok("MAINVERSIONLOOSE");
              src[t3.MAINVERSIONLOOSE] = "(" + src[t3.NUMERICIDENTIFIERLOOSE] + ")\\.(" + src[t3.NUMERICIDENTIFIERLOOSE] + ")\\.(" + src[t3.NUMERICIDENTIFIERLOOSE] + ")";
              tok("PRERELEASEIDENTIFIER");
              src[t3.PRERELEASEIDENTIFIER] = "(?:" + src[t3.NUMERICIDENTIFIER] + "|" + src[t3.NONNUMERICIDENTIFIER] + ")";
              tok("PRERELEASEIDENTIFIERLOOSE");
              src[t3.PRERELEASEIDENTIFIERLOOSE] = "(?:" + src[t3.NUMERICIDENTIFIERLOOSE] + "|" + src[t3.NONNUMERICIDENTIFIER] + ")";
              tok("PRERELEASE");
              src[t3.PRERELEASE] = "(?:-(" + src[t3.PRERELEASEIDENTIFIER] + "(?:\\." + src[t3.PRERELEASEIDENTIFIER] + ")*))";
              tok("PRERELEASELOOSE");
              src[t3.PRERELEASELOOSE] = "(?:-?(" + src[t3.PRERELEASEIDENTIFIERLOOSE] + "(?:\\." + src[t3.PRERELEASEIDENTIFIERLOOSE] + ")*))";
              tok("BUILDIDENTIFIER");
              src[t3.BUILDIDENTIFIER] = "[0-9A-Za-z-]+";
              tok("BUILD");
              src[t3.BUILD] = "(?:\\+(" + src[t3.BUILDIDENTIFIER] + "(?:\\." + src[t3.BUILDIDENTIFIER] + ")*))";
              tok("FULL");
              tok("FULLPLAIN");
              src[t3.FULLPLAIN] = "v?" + src[t3.MAINVERSION] + src[t3.PRERELEASE] + "?" + src[t3.BUILD] + "?";
              src[t3.FULL] = "^" + src[t3.FULLPLAIN] + "$";
              tok("LOOSEPLAIN");
              src[t3.LOOSEPLAIN] = "[v=\\s]*" + src[t3.MAINVERSIONLOOSE] + src[t3.PRERELEASELOOSE] + "?" + src[t3.BUILD] + "?";
              tok("LOOSE");
              src[t3.LOOSE] = "^" + src[t3.LOOSEPLAIN] + "$";
              tok("GTLT");
              src[t3.GTLT] = "((?:<|>)?=?)";
              tok("XRANGEIDENTIFIERLOOSE");
              src[t3.XRANGEIDENTIFIERLOOSE] = src[t3.NUMERICIDENTIFIERLOOSE] + "|x|X|\\*";
              tok("XRANGEIDENTIFIER");
              src[t3.XRANGEIDENTIFIER] = src[t3.NUMERICIDENTIFIER] + "|x|X|\\*";
              tok("XRANGEPLAIN");
              src[t3.XRANGEPLAIN] = "[v=\\s]*(" + src[t3.XRANGEIDENTIFIER] + ")(?:\\.(" + src[t3.XRANGEIDENTIFIER] + ")(?:\\.(" + src[t3.XRANGEIDENTIFIER] + ")(?:" + src[t3.PRERELEASE] + ")?" + src[t3.BUILD] + "?)?)?";
              tok("XRANGEPLAINLOOSE");
              src[t3.XRANGEPLAINLOOSE] = "[v=\\s]*(" + src[t3.XRANGEIDENTIFIERLOOSE] + ")(?:\\.(" + src[t3.XRANGEIDENTIFIERLOOSE] + ")(?:\\.(" + src[t3.XRANGEIDENTIFIERLOOSE] + ")(?:" + src[t3.PRERELEASELOOSE] + ")?" + src[t3.BUILD] + "?)?)?";
              tok("XRANGE");
              src[t3.XRANGE] = "^" + src[t3.GTLT] + "\\s*" + src[t3.XRANGEPLAIN] + "$";
              tok("XRANGELOOSE");
              src[t3.XRANGELOOSE] = "^" + src[t3.GTLT] + "\\s*" + src[t3.XRANGEPLAINLOOSE] + "$";
              tok("COERCE");
              src[t3.COERCE] = "(^|[^\\d])(\\d{1," + MAX_SAFE_COMPONENT_LENGTH + "})(?:\\.(\\d{1," + MAX_SAFE_COMPONENT_LENGTH + "}))?(?:\\.(\\d{1," + MAX_SAFE_COMPONENT_LENGTH + "}))?(?:$|[^\\d])";
              tok("COERCERTL");
              re[t3.COERCERTL] = new RegExp(src[t3.COERCE], "g");
              tok("LONETILDE");
              src[t3.LONETILDE] = "(?:~>?)";
              tok("TILDETRIM");
              src[t3.TILDETRIM] = "(\\s*)" + src[t3.LONETILDE] + "\\s+";
              re[t3.TILDETRIM] = new RegExp(src[t3.TILDETRIM], "g");
              var tildeTrimReplace = "$1~";
              tok("TILDE");
              src[t3.TILDE] = "^" + src[t3.LONETILDE] + src[t3.XRANGEPLAIN] + "$";
              tok("TILDELOOSE");
              src[t3.TILDELOOSE] = "^" + src[t3.LONETILDE] + src[t3.XRANGEPLAINLOOSE] + "$";
              tok("LONECARET");
              src[t3.LONECARET] = "(?:\\^)";
              tok("CARETTRIM");
              src[t3.CARETTRIM] = "(\\s*)" + src[t3.LONECARET] + "\\s+";
              re[t3.CARETTRIM] = new RegExp(src[t3.CARETTRIM], "g");
              var caretTrimReplace = "$1^";
              tok("CARET");
              src[t3.CARET] = "^" + src[t3.LONECARET] + src[t3.XRANGEPLAIN] + "$";
              tok("CARETLOOSE");
              src[t3.CARETLOOSE] = "^" + src[t3.LONECARET] + src[t3.XRANGEPLAINLOOSE] + "$";
              tok("COMPARATORLOOSE");
              src[t3.COMPARATORLOOSE] = "^" + src[t3.GTLT] + "\\s*(" + src[t3.LOOSEPLAIN] + ")$|^$";
              tok("COMPARATOR");
              src[t3.COMPARATOR] = "^" + src[t3.GTLT] + "\\s*(" + src[t3.FULLPLAIN] + ")$|^$";
              tok("COMPARATORTRIM");
              src[t3.COMPARATORTRIM] = "(\\s*)" + src[t3.GTLT] + "\\s*(" + src[t3.LOOSEPLAIN] + "|" + src[t3.XRANGEPLAIN] + ")";
              re[t3.COMPARATORTRIM] = new RegExp(src[t3.COMPARATORTRIM], "g");
              var comparatorTrimReplace = "$1$2$3";
              tok("HYPHENRANGE");
              src[t3.HYPHENRANGE] = "^\\s*(" + src[t3.XRANGEPLAIN] + ")\\s+-\\s+(" + src[t3.XRANGEPLAIN] + ")\\s*$";
              tok("HYPHENRANGELOOSE");
              src[t3.HYPHENRANGELOOSE] = "^\\s*(" + src[t3.XRANGEPLAINLOOSE] + ")\\s+-\\s+(" + src[t3.XRANGEPLAINLOOSE] + ")\\s*$";
              tok("STAR");
              src[t3.STAR] = "(<|>)?=?\\s*\\*";
              for (var i = 0; i < R2; i++) {
                debug(i, src[i]);
                if (!re[i]) {
                  re[i] = new RegExp(src[i]);
                }
              }
              exports3.parse = parse7;
              function parse7(version3, options29) {
                if (!options29 || _typeof7(options29) !== "object") {
                  options29 = {
                    loose: !!options29,
                    includePrerelease: false
                  };
                }
                if (version3 instanceof SemVer) {
                  return version3;
                }
                if (typeof version3 !== "string") {
                  return null;
                }
                if (version3.length > MAX_LENGTH) {
                  return null;
                }
                var r3 = options29.loose ? re[t3.LOOSE] : re[t3.FULL];
                if (!r3.test(version3)) {
                  return null;
                }
                try {
                  return new SemVer(version3, options29);
                } catch (er) {
                  return null;
                }
              }
              __name(parse7, "parse");
              exports3.valid = valid;
              function valid(version3, options29) {
                var v2 = parse7(version3, options29);
                return v2 ? v2.version : null;
              }
              __name(valid, "valid");
              exports3.clean = clean;
              function clean(version3, options29) {
                var s = parse7(version3.trim().replace(/^[=v]+/, ""), options29);
                return s ? s.version : null;
              }
              __name(clean, "clean");
              exports3.SemVer = SemVer;
              function SemVer(version3, options29) {
                if (!options29 || _typeof7(options29) !== "object") {
                  options29 = {
                    loose: !!options29,
                    includePrerelease: false
                  };
                }
                if (version3 instanceof SemVer) {
                  if (version3.loose === options29.loose) {
                    return version3;
                  } else {
                    version3 = version3.version;
                  }
                } else if (typeof version3 !== "string") {
                  throw new TypeError("Invalid Version: " + version3);
                }
                if (version3.length > MAX_LENGTH) {
                  throw new TypeError("version is longer than " + MAX_LENGTH + " characters");
                }
                if (!(this instanceof SemVer)) {
                  return new SemVer(version3, options29);
                }
                debug("SemVer", version3, options29);
                this.options = options29;
                this.loose = !!options29.loose;
                var m2 = version3.trim().match(options29.loose ? re[t3.LOOSE] : re[t3.FULL]);
                if (!m2) {
                  throw new TypeError("Invalid Version: " + version3);
                }
                this.raw = version3;
                this.major = +m2[1];
                this.minor = +m2[2];
                this.patch = +m2[3];
                if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
                  throw new TypeError("Invalid major version");
                }
                if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
                  throw new TypeError("Invalid minor version");
                }
                if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
                  throw new TypeError("Invalid patch version");
                }
                if (!m2[4]) {
                  this.prerelease = [];
                } else {
                  this.prerelease = m2[4].split(".").map(function(id) {
                    if (/^[0-9]+$/.test(id)) {
                      var num = +id;
                      if (num >= 0 && num < MAX_SAFE_INTEGER) {
                        return num;
                      }
                    }
                    return id;
                  });
                }
                this.build = m2[5] ? m2[5].split(".") : [];
                this.format();
              }
              __name(SemVer, "SemVer");
              SemVer.prototype.format = function() {
                this.version = this.major + "." + this.minor + "." + this.patch;
                if (this.prerelease.length) {
                  this.version += "-" + this.prerelease.join(".");
                }
                return this.version;
              };
              SemVer.prototype.toString = function() {
                return this.version;
              };
              SemVer.prototype.compare = function(other) {
                debug("SemVer.compare", this.version, this.options, other);
                if (!(other instanceof SemVer)) {
                  other = new SemVer(other, this.options);
                }
                return this.compareMain(other) || this.comparePre(other);
              };
              SemVer.prototype.compareMain = function(other) {
                if (!(other instanceof SemVer)) {
                  other = new SemVer(other, this.options);
                }
                return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
              };
              SemVer.prototype.comparePre = function(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;
                }
                var i2 = 0;
                do {
                  var a = this.prerelease[i2];
                  var b2 = other.prerelease[i2];
                  debug("prerelease compare", i2, a, b2);
                  if (a === void 0 && b2 === void 0) {
                    return 0;
                  } else if (b2 === void 0) {
                    return 1;
                  } else if (a === void 0) {
                    return -1;
                  } else if (a === b2) {
                    continue;
                  } else {
                    return compareIdentifiers(a, b2);
                  }
                } while (++i2);
              };
              SemVer.prototype.compareBuild = function(other) {
                if (!(other instanceof SemVer)) {
                  other = new SemVer(other, this.options);
                }
                var i2 = 0;
                do {
                  var a = this.build[i2];
                  var b2 = other.build[i2];
                  debug("prerelease compare", i2, a, b2);
                  if (a === void 0 && b2 === void 0) {
                    return 0;
                  } else if (b2 === void 0) {
                    return 1;
                  } else if (a === void 0) {
                    return -1;
                  } else if (a === b2) {
                    continue;
                  } else {
                    return compareIdentifiers(a, b2);
                  }
                } while (++i2);
              };
              SemVer.prototype.inc = function(release2, identifier) {
                switch (release2) {
                  case "premajor":
                    this.prerelease.length = 0;
                    this.patch = 0;
                    this.minor = 0;
                    this.major++;
                    this.inc("pre", identifier);
                    break;
                  case "preminor":
                    this.prerelease.length = 0;
                    this.patch = 0;
                    this.minor++;
                    this.inc("pre", identifier);
                    break;
                  case "prepatch":
                    this.prerelease.length = 0;
                    this.inc("patch", identifier);
                    this.inc("pre", identifier);
                    break;
                  case "prerelease":
                    if (this.prerelease.length === 0) {
                      this.inc("patch", identifier);
                    }
                    this.inc("pre", identifier);
                    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;
                  case "pre":
                    if (this.prerelease.length === 0) {
                      this.prerelease = [0];
                    } else {
                      var i2 = this.prerelease.length;
                      while (--i2 >= 0) {
                        if (typeof this.prerelease[i2] === "number") {
                          this.prerelease[i2]++;
                          i2 = -2;
                        }
                      }
                      if (i2 === -1) {
                        this.prerelease.push(0);
                      }
                    }
                    if (identifier) {
                      if (this.prerelease[0] === identifier) {
                        if (isNaN(this.prerelease[1])) {
                          this.prerelease = [identifier, 0];
                        }
                      } else {
                        this.prerelease = [identifier, 0];
                      }
                    }
                    break;
                  default:
                    throw new Error("invalid increment argument: " + release2);
                }
                this.format();
                this.raw = this.version;
                return this;
              };
              exports3.inc = inc;
              function inc(version3, release2, loose, identifier) {
                if (typeof loose === "string") {
                  identifier = loose;
                  loose = void 0;
                }
                try {
                  return new SemVer(version3, loose).inc(release2, identifier).version;
                } catch (er) {
                  return null;
                }
              }
              __name(inc, "inc");
              exports3.diff = diff;
              function diff(version1, version22) {
                if (eq(version1, version22)) {
                  return null;
                } else {
                  var v1 = parse7(version1);
                  var v2 = parse7(version22);
                  var prefix = "";
                  if (v1.prerelease.length || v2.prerelease.length) {
                    prefix = "pre";
                    var defaultResult = "prerelease";
                  }
                  for (var key in v1) {
                    if (key === "major" || key === "minor" || key === "patch") {
                      if (v1[key] !== v2[key]) {
                        return prefix + key;
                      }
                    }
                  }
                  return defaultResult;
                }
              }
              __name(diff, "diff");
              exports3.compareIdentifiers = compareIdentifiers;
              var numeric = /^[0-9]+$/;
              function compareIdentifiers(a, b2) {
                var anum = numeric.test(a);
                var bnum = numeric.test(b2);
                if (anum && bnum) {
                  a = +a;
                  b2 = +b2;
                }
                return a === b2 ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b2 ? -1 : 1;
              }
              __name(compareIdentifiers, "compareIdentifiers");
              exports3.rcompareIdentifiers = rcompareIdentifiers;
              function rcompareIdentifiers(a, b2) {
                return compareIdentifiers(b2, a);
              }
              __name(rcompareIdentifiers, "rcompareIdentifiers");
              exports3.major = major;
              function major(a, loose) {
                return new SemVer(a, loose).major;
              }
              __name(major, "major");
              exports3.minor = minor;
              function minor(a, loose) {
                return new SemVer(a, loose).minor;
              }
              __name(minor, "minor");
              exports3.patch = patch;
              function patch(a, loose) {
                return new SemVer(a, loose).patch;
              }
              __name(patch, "patch");
              exports3.compare = compare;
              function compare(a, b2, loose) {
                return new SemVer(a, loose).compare(new SemVer(b2, loose));
              }
              __name(compare, "compare");
              exports3.compareLoose = compareLoose;
              function compareLoose(a, b2) {
                return compare(a, b2, true);
              }
              __name(compareLoose, "compareLoose");
              exports3.compareBuild = compareBuild;
              function compareBuild(a, b2, loose) {
                var versionA = new SemVer(a, loose);
                var versionB = new SemVer(b2, loose);
                return versionA.compare(versionB) || versionA.compareBuild(versionB);
              }
              __name(compareBuild, "compareBuild");
              exports3.rcompare = rcompare;
              function rcompare(a, b2, loose) {
                return compare(b2, a, loose);
              }
              __name(rcompare, "rcompare");
              exports3.sort = sort;
              function sort(list, loose) {
                return list.sort(function(a, b2) {
                  return exports3.compareBuild(a, b2, loose);
                });
              }
              __name(sort, "sort");
              exports3.rsort = rsort;
              function rsort(list, loose) {
                return list.sort(function(a, b2) {
                  return exports3.compareBuild(b2, a, loose);
                });
              }
              __name(rsort, "rsort");
              exports3.gt = gt;
              function gt(a, b2, loose) {
                return compare(a, b2, loose) > 0;
              }
              __name(gt, "gt");
              exports3.lt = lt2;
              function lt2(a, b2, loose) {
                return compare(a, b2, loose) < 0;
              }
              __name(lt2, "lt");
              exports3.eq = eq;
              function eq(a, b2, loose) {
                return compare(a, b2, loose) === 0;
              }
              __name(eq, "eq");
              exports3.neq = neq;
              function neq(a, b2, loose) {
                return compare(a, b2, loose) !== 0;
              }
              __name(neq, "neq");
              exports3.gte = gte;
              function gte(a, b2, loose) {
                return compare(a, b2, loose) >= 0;
              }
              __name(gte, "gte");
              exports3.lte = lte;
              function lte(a, b2, loose) {
                return compare(a, b2, loose) <= 0;
              }
              __name(lte, "lte");
              exports3.cmp = cmp;
              function cmp(a, op, b2, loose) {
                switch (op) {
                  case "===":
                    if (_typeof7(a) === "object")
                      a = a.version;
                    if (_typeof7(b2) === "object")
                      b2 = b2.version;
                    return a === b2;
                  case "!==":
                    if (_typeof7(a) === "object")
                      a = a.version;
                    if (_typeof7(b2) === "object")
                      b2 = b2.version;
                    return a !== b2;
                  case "":
                  case "=":
                  case "==":
                    return eq(a, b2, loose);
                  case "!=":
                    return neq(a, b2, loose);
                  case ">":
                    return gt(a, b2, loose);
                  case ">=":
                    return gte(a, b2, loose);
                  case "<":
                    return lt2(a, b2, loose);
                  case "<=":
                    return lte(a, b2, loose);
                  default:
                    throw new TypeError("Invalid operator: " + op);
                }
              }
              __name(cmp, "cmp");
              exports3.Comparator = Comparator;
              function Comparator(comp, options29) {
                if (!options29 || _typeof7(options29) !== "object") {
                  options29 = {
                    loose: !!options29,
                    includePrerelease: false
                  };
                }
                if (comp instanceof Comparator) {
                  if (comp.loose === !!options29.loose) {
                    return comp;
                  } else {
                    comp = comp.value;
                  }
                }
                if (!(this instanceof Comparator)) {
                  return new Comparator(comp, options29);
                }
                debug("comparator", comp, options29);
                this.options = options29;
                this.loose = !!options29.loose;
                this.parse(comp);
                if (this.semver === ANY) {
                  this.value = "";
                } else {
                  this.value = this.operator + this.semver.version;
                }
                debug("comp", this);
              }
              __name(Comparator, "Comparator");
              var ANY = {};
              Comparator.prototype.parse = function(comp) {
                var r3 = this.options.loose ? re[t3.COMPARATORLOOSE] : re[t3.COMPARATOR];
                var m2 = comp.match(r3);
                if (!m2) {
                  throw new TypeError("Invalid comparator: " + comp);
                }
                this.operator = m2[1] !== void 0 ? m2[1] : "";
                if (this.operator === "=") {
                  this.operator = "";
                }
                if (!m2[2]) {
                  this.semver = ANY;
                } else {
                  this.semver = new SemVer(m2[2], this.options.loose);
                }
              };
              Comparator.prototype.toString = function() {
                return this.value;
              };
              Comparator.prototype.test = function(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);
              };
              Comparator.prototype.intersects = function(comp, options29) {
                if (!(comp instanceof Comparator)) {
                  throw new TypeError("a Comparator is required");
                }
                if (!options29 || _typeof7(options29) !== "object") {
                  options29 = {
                    loose: !!options29,
                    includePrerelease: false
                  };
                }
                var rangeTmp;
                if (this.operator === "") {
                  if (this.value === "") {
                    return true;
                  }
                  rangeTmp = new Range(comp.value, options29);
                  return satisfies(this.value, rangeTmp, options29);
                } else if (comp.operator === "") {
                  if (comp.value === "") {
                    return true;
                  }
                  rangeTmp = new Range(this.value, options29);
                  return satisfies(comp.semver, rangeTmp, options29);
                }
                var sameDirectionIncreasing = (this.operator === ">=" || this.operator === ">") && (comp.operator === ">=" || comp.operator === ">");
                var sameDirectionDecreasing = (this.operator === "<=" || this.operator === "<") && (comp.operator === "<=" || comp.operator === "<");
                var sameSemVer = this.semver.version === comp.semver.version;
                var differentDirectionsInclusive = (this.operator === ">=" || this.operator === "<=") && (comp.operator === ">=" || comp.operator === "<=");
                var oppositeDirectionsLessThan = cmp(this.semver, "<", comp.semver, options29) && (this.operator === ">=" || this.operator === ">") && (comp.operator === "<=" || comp.operator === "<");
                var oppositeDirectionsGreaterThan = cmp(this.semver, ">", comp.semver, options29) && (this.operator === "<=" || this.operator === "<") && (comp.operator === ">=" || comp.operator === ">");
                return sameDirectionIncreasing || sameDirectionDecreasing || sameSemVer && differentDirectionsInclusive || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;
              };
              exports3.Range = Range;
              function Range(range, options29) {
                if (!options29 || _typeof7(options29) !== "object") {
                  options29 = {
                    loose: !!options29,
                    includePrerelease: false
                  };
                }
                if (range instanceof Range) {
                  if (range.loose === !!options29.loose && range.includePrerelease === !!options29.includePrerelease) {
                    return range;
                  } else {
                    return new Range(range.raw, options29);
                  }
                }
                if (range instanceof Comparator) {
                  return new Range(range.value, options29);
                }
                if (!(this instanceof Range)) {
                  return new Range(range, options29);
                }
                this.options = options29;
                this.loose = !!options29.loose;
                this.includePrerelease = !!options29.includePrerelease;
                this.raw = range;
                this.set = range.split(/\s*\|\|\s*/).map(function(range2) {
                  return this.parseRange(range2.trim());
                }, this).filter(function(c2) {
                  return c2.length;
                });
                if (!this.set.length) {
                  throw new TypeError("Invalid SemVer Range: " + range);
                }
                this.format();
              }
              __name(Range, "Range");
              Range.prototype.format = function() {
                this.range = this.set.map(function(comps) {
                  return comps.join(" ").trim();
                }).join("||").trim();
                return this.range;
              };
              Range.prototype.toString = function() {
                return this.range;
              };
              Range.prototype.parseRange = function(range) {
                var loose = this.options.loose;
                range = range.trim();
                var hr = loose ? re[t3.HYPHENRANGELOOSE] : re[t3.HYPHENRANGE];
                range = range.replace(hr, hyphenReplace);
                debug("hyphen replace", range);
                range = range.replace(re[t3.COMPARATORTRIM], comparatorTrimReplace);
                debug("comparator trim", range, re[t3.COMPARATORTRIM]);
                range = range.replace(re[t3.TILDETRIM], tildeTrimReplace);
                range = range.replace(re[t3.CARETTRIM], caretTrimReplace);
                range = range.split(/\s+/).join(" ");
                var compRe = loose ? re[t3.COMPARATORLOOSE] : re[t3.COMPARATOR];
                var set = range.split(" ").map(function(comp) {
                  return parseComparator(comp, this.options);
                }, this).join(" ").split(/\s+/);
                if (this.options.loose) {
                  set = set.filter(function(comp) {
                    return !!comp.match(compRe);
                  });
                }
                set = set.map(function(comp) {
                  return new Comparator(comp, this.options);
                }, this);
                return set;
              };
              Range.prototype.intersects = function(range, options29) {
                if (!(range instanceof Range)) {
                  throw new TypeError("a Range is required");
                }
                return this.set.some(function(thisComparators) {
                  return isSatisfiable(thisComparators, options29) && range.set.some(function(rangeComparators) {
                    return isSatisfiable(rangeComparators, options29) && thisComparators.every(function(thisComparator) {
                      return rangeComparators.every(function(rangeComparator) {
                        return thisComparator.intersects(rangeComparator, options29);
                      });
                    });
                  });
                });
              };
              function isSatisfiable(comparators, options29) {
                var result = true;
                var remainingComparators = comparators.slice();
                var testComparator = remainingComparators.pop();
                while (result && remainingComparators.length) {
                  result = remainingComparators.every(function(otherComparator) {
                    return testComparator.intersects(otherComparator, options29);
                  });
                  testComparator = remainingComparators.pop();
                }
                return result;
              }
              __name(isSatisfiable, "isSatisfiable");
              exports3.toComparators = toComparators;
              function toComparators(range, options29) {
                return new Range(range, options29).set.map(function(comp) {
                  return comp.map(function(c2) {
                    return c2.value;
                  }).join(" ").trim().split(" ");
                });
              }
              __name(toComparators, "toComparators");
              function parseComparator(comp, options29) {
                debug("comp", comp, options29);
                comp = replaceCarets(comp, options29);
                debug("caret", comp);
                comp = replaceTildes(comp, options29);
                debug("tildes", comp);
                comp = replaceXRanges(comp, options29);
                debug("xrange", comp);
                comp = replaceStars(comp, options29);
                debug("stars", comp);
                return comp;
              }
              __name(parseComparator, "parseComparator");
              function isX(id) {
                return !id || id.toLowerCase() === "x" || id === "*";
              }
              __name(isX, "isX");
              function replaceTildes(comp, options29) {
                return comp.trim().split(/\s+/).map(function(comp2) {
                  return replaceTilde(comp2, options29);
                }).join(" ");
              }
              __name(replaceTildes, "replaceTildes");
              function replaceTilde(comp, options29) {
                var r3 = options29.loose ? re[t3.TILDELOOSE] : re[t3.TILDE];
                return comp.replace(r3, function(_3, M2, m2, p2, pr) {
                  debug("tilde", comp, _3, M2, m2, p2, pr);
                  var ret;
                  if (isX(M2)) {
                    ret = "";
                  } else if (isX(m2)) {
                    ret = ">=" + M2 + ".0.0 <" + (+M2 + 1) + ".0.0";
                  } else if (isX(p2)) {
                    ret = ">=" + M2 + "." + m2 + ".0 <" + M2 + "." + (+m2 + 1) + ".0";
                  } else if (pr) {
                    debug("replaceTilde pr", pr);
                    ret = ">=" + M2 + "." + m2 + "." + p2 + "-" + pr + " <" + M2 + "." + (+m2 + 1) + ".0";
                  } else {
                    ret = ">=" + M2 + "." + m2 + "." + p2 + " <" + M2 + "." + (+m2 + 1) + ".0";
                  }
                  debug("tilde return", ret);
                  return ret;
                });
              }
              __name(replaceTilde, "replaceTilde");
              function replaceCarets(comp, options29) {
                return comp.trim().split(/\s+/).map(function(comp2) {
                  return replaceCaret(comp2, options29);
                }).join(" ");
              }
              __name(replaceCarets, "replaceCarets");
              function replaceCaret(comp, options29) {
                debug("caret", comp, options29);
                var r3 = options29.loose ? re[t3.CARETLOOSE] : re[t3.CARET];
                return comp.replace(r3, function(_3, M2, m2, p2, pr) {
                  debug("caret", comp, _3, M2, m2, p2, pr);
                  var ret;
                  if (isX(M2)) {
                    ret = "";
                  } else if (isX(m2)) {
                    ret = ">=" + M2 + ".0.0 <" + (+M2 + 1) + ".0.0";
                  } else if (isX(p2)) {
                    if (M2 === "0") {
                      ret = ">=" + M2 + "." + m2 + ".0 <" + M2 + "." + (+m2 + 1) + ".0";
                    } else {
                      ret = ">=" + M2 + "." + m2 + ".0 <" + (+M2 + 1) + ".0.0";
                    }
                  } else if (pr) {
                    debug("replaceCaret pr", pr);
                    if (M2 === "0") {
                      if (m2 === "0") {
                        ret = ">=" + M2 + "." + m2 + "." + p2 + "-" + pr + " <" + M2 + "." + m2 + "." + (+p2 + 1);
                      } else {
                        ret = ">=" + M2 + "." + m2 + "." + p2 + "-" + pr + " <" + M2 + "." + (+m2 + 1) + ".0";
                      }
                    } else {
                      ret = ">=" + M2 + "." + m2 + "." + p2 + "-" + pr + " <" + (+M2 + 1) + ".0.0";
                    }
                  } else {
                    debug("no pr");
                    if (M2 === "0") {
                      if (m2 === "0") {
                        ret = ">=" + M2 + "." + m2 + "." + p2 + " <" + M2 + "." + m2 + "." + (+p2 + 1);
                      } else {
                        ret = ">=" + M2 + "." + m2 + "." + p2 + " <" + M2 + "." + (+m2 + 1) + ".0";
                      }
                    } else {
                      ret = ">=" + M2 + "." + m2 + "." + p2 + " <" + (+M2 + 1) + ".0.0";
                    }
                  }
                  debug("caret return", ret);
                  return ret;
                });
              }
              __name(replaceCaret, "replaceCaret");
              function replaceXRanges(comp, options29) {
                debug("replaceXRanges", comp, options29);
                return comp.split(/\s+/).map(function(comp2) {
                  return replaceXRange(comp2, options29);
                }).join(" ");
              }
              __name(replaceXRanges, "replaceXRanges");
              function replaceXRange(comp, options29) {
                comp = comp.trim();
                var r3 = options29.loose ? re[t3.XRANGELOOSE] : re[t3.XRANGE];
                return comp.replace(r3, function(ret, gtlt, M2, m2, p2, pr) {
                  debug("xRange", comp, ret, gtlt, M2, m2, p2, pr);
                  var xM = isX(M2);
                  var xm = xM || isX(m2);
                  var xp = xm || isX(p2);
                  var anyX = xp;
                  if (gtlt === "=" && anyX) {
                    gtlt = "";
                  }
                  pr = options29.includePrerelease ? "-0" : "";
                  if (xM) {
                    if (gtlt === ">" || gtlt === "<") {
                      ret = "<0.0.0-0";
                    } else {
                      ret = "*";
                    }
                  } else if (gtlt && anyX) {
                    if (xm) {
                      m2 = 0;
                    }
                    p2 = 0;
                    if (gtlt === ">") {
                      gtlt = ">=";
                      if (xm) {
                        M2 = +M2 + 1;
                        m2 = 0;
                        p2 = 0;
                      } else {
                        m2 = +m2 + 1;
                        p2 = 0;
                      }
                    } else if (gtlt === "<=") {
                      gtlt = "<";
                      if (xm) {
                        M2 = +M2 + 1;
                      } else {
                        m2 = +m2 + 1;
                      }
                    }
                    ret = gtlt + M2 + "." + m2 + "." + p2 + pr;
                  } else if (xm) {
                    ret = ">=" + M2 + ".0.0" + pr + " <" + (+M2 + 1) + ".0.0" + pr;
                  } else if (xp) {
                    ret = ">=" + M2 + "." + m2 + ".0" + pr + " <" + M2 + "." + (+m2 + 1) + ".0" + pr;
                  }
                  debug("xRange return", ret);
                  return ret;
                });
              }
              __name(replaceXRange, "replaceXRange");
              function replaceStars(comp, options29) {
                debug("replaceStars", comp, options29);
                return comp.trim().replace(re[t3.STAR], "");
              }
              __name(replaceStars, "replaceStars");
              function hyphenReplace($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) {
                if (isX(fM)) {
                  from = "";
                } else if (isX(fm)) {
                  from = ">=" + fM + ".0.0";
                } else if (isX(fp)) {
                  from = ">=" + fM + "." + fm + ".0";
                } else {
                  from = ">=" + from;
                }
                if (isX(tM)) {
                  to = "";
                } else if (isX(tm)) {
                  to = "<" + (+tM + 1) + ".0.0";
                } else if (isX(tp)) {
                  to = "<" + tM + "." + (+tm + 1) + ".0";
                } else if (tpr) {
                  to = "<=" + tM + "." + tm + "." + tp + "-" + tpr;
                } else {
                  to = "<=" + to;
                }
                return (from + " " + to).trim();
              }
              __name(hyphenReplace, "hyphenReplace");
              Range.prototype.test = function(version3) {
                if (!version3) {
                  return false;
                }
                if (typeof version3 === "string") {
                  try {
                    version3 = new SemVer(version3, this.options);
                  } catch (er) {
                    return false;
                  }
                }
                for (var i2 = 0; i2 < this.set.length; i2++) {
                  if (testSet(this.set[i2], version3, this.options)) {
                    return true;
                  }
                }
                return false;
              };
              function testSet(set, version3, options29) {
                for (var i2 = 0; i2 < set.length; i2++) {
                  if (!set[i2].test(version3)) {
                    return false;
                  }
                }
                if (version3.prerelease.length && !options29.includePrerelease) {
                  for (i2 = 0; i2 < set.length; i2++) {
                    debug(set[i2].semver);
                    if (set[i2].semver === ANY) {
                      continue;
                    }
                    if (set[i2].semver.prerelease.length > 0) {
                      var allowed = set[i2].semver;
                      if (allowed.major === version3.major && allowed.minor === version3.minor && allowed.patch === version3.patch) {
                        return true;
                      }
                    }
                  }
                  return false;
                }
                return true;
              }
              __name(testSet, "testSet");
              exports3.satisfies = satisfies;
              function satisfies(version3, range, options29) {
                try {
                  range = new Range(range, options29);
                } catch (er) {
                  return false;
                }
                return range.test(version3);
              }
              __name(satisfies, "satisfies");
              exports3.maxSatisfying = maxSatisfying;
              function maxSatisfying(versions, range, options29) {
                var max = null;
                var maxSV = null;
                try {
                  var rangeObj = new Range(range, options29);
                } catch (er) {
                  return null;
                }
                versions.forEach(function(v2) {
                  if (rangeObj.test(v2)) {
                    if (!max || maxSV.compare(v2) === -1) {
                      max = v2;
                      maxSV = new SemVer(max, options29);
                    }
                  }
                });
                return max;
              }
              __name(maxSatisfying, "maxSatisfying");
              exports3.minSatisfying = minSatisfying;
              function minSatisfying(versions, range, options29) {
                var min = null;
                var minSV = null;
                try {
                  var rangeObj = new Range(range, options29);
                } catch (er) {
                  return null;
                }
                versions.forEach(function(v2) {
                  if (rangeObj.test(v2)) {
                    if (!min || minSV.compare(v2) === 1) {
                      min = v2;
                      minSV = new SemVer(min, options29);
                    }
                  }
                });
                return min;
              }
              __name(minSatisfying, "minSatisfying");
              exports3.minVersion = minVersion;
              function minVersion(range, loose) {
                range = new Range(range, loose);
                var 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 (var i2 = 0; i2 < range.set.length; ++i2) {
                  var comparators = range.set[i2];
                  comparators.forEach(function(comparator) {
                    var 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();
                      case "":
                      case ">=":
                        if (!minver || gt(minver, compver)) {
                          minver = compver;
                        }
                        break;
                      case "<":
                      case "<=":
                        break;
                      default:
                        throw new Error("Unexpected operation: " + comparator.operator);
                    }
                  });
                }
                if (minver && range.test(minver)) {
                  return minver;
                }
                return null;
              }
              __name(minVersion, "minVersion");
              exports3.validRange = validRange;
              function validRange(range, options29) {
                try {
                  return new Range(range, options29).range || "*";
                } catch (er) {
                  return null;
                }
              }
              __name(validRange, "validRange");
              exports3.ltr = ltr;
              function ltr(version3, range, options29) {
                return outside(version3, range, "<", options29);
              }
              __name(ltr, "ltr");
              exports3.gtr = gtr;
              function gtr(version3, range, options29) {
                return outside(version3, range, ">", options29);
              }
              __name(gtr, "gtr");
              exports3.outside = outside;
              function outside(version3, range, hilo, options29) {
                version3 = new SemVer(version3, options29);
                range = new Range(range, options29);
                var gtfn, ltefn, ltfn, comp, ecomp;
                switch (hilo) {
                  case ">":
                    gtfn = gt;
                    ltefn = lte;
                    ltfn = lt2;
                    comp = ">";
                    ecomp = ">=";
                    break;
                  case "<":
                    gtfn = lt2;
                    ltefn = gte;
                    ltfn = gt;
                    comp = "<";
                    ecomp = "<=";
                    break;
                  default:
                    throw new TypeError('Must provide a hilo val of "<" or ">"');
                }
                if (satisfies(version3, range, options29)) {
                  return false;
                }
                for (var i2 = 0; i2 < range.set.length; ++i2) {
                  var comparators = range.set[i2];
                  var high = null;
                  var low = null;
                  comparators.forEach(function(comparator) {
                    if (comparator.semver === ANY) {
                      comparator = new Comparator(">=0.0.0");
                    }
                    high = high || comparator;
                    low = low || comparator;
                    if (gtfn(comparator.semver, high.semver, options29)) {
                      high = comparator;
                    } else if (ltfn(comparator.semver, low.semver, options29)) {
                      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;
              }
              __name(outside, "outside");
              exports3.prerelease = prerelease;
              function prerelease(version3, options29) {
                var parsed = parse7(version3, options29);
                return parsed && parsed.prerelease.length ? parsed.prerelease : null;
              }
              __name(prerelease, "prerelease");
              exports3.intersects = intersects;
              function intersects(r1, r23, options29) {
                r1 = new Range(r1, options29);
                r23 = new Range(r23, options29);
                return r1.intersects(r23);
              }
              __name(intersects, "intersects");
              exports3.coerce = coerce;
              function coerce(version3, options29) {
                if (version3 instanceof SemVer) {
                  return version3;
                }
                if (typeof version3 === "number") {
                  version3 = String(version3);
                }
                if (typeof version3 !== "string") {
                  return null;
                }
                options29 = options29 || {};
                var match = null;
                if (!options29.rtl) {
                  match = version3.match(re[t3.COERCE]);
                } else {
                  var next;
                  while ((next = re[t3.COERCERTL].exec(version3)) && (!match || match.index + match[0].length !== version3.length)) {
                    if (!match || next.index + next[0].length !== match.index + match[0].length) {
                      match = next;
                    }
                    re[t3.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
                  }
                  re[t3.COERCERTL].lastIndex = -1;
                }
                if (match === null) {
                  return null;
                }
                return parse7(match[2] + "." + (match[3] || "0") + "." + (match[4] || "0"), options29);
              }
              __name(coerce, "coerce");
            }).call(this, __webpack_require__(17));
          },
          /* 12 */
          /***/
          function(module4, __webpack_exports__, __webpack_require__) {
            "use strict";
            __webpack_require__.d(__webpack_exports__, "b", function() {
              return meta;
            });
            __webpack_require__.d(__webpack_exports__, "a", function() {
              return dehydrate;
            });
            var _utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
            function ownKeys11(object, enumerableOnly) {
              var keys = Object.keys(object);
              if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                if (enumerableOnly)
                  symbols = symbols.filter(function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                  });
                keys.push.apply(keys, symbols);
              }
              return keys;
            }
            __name(ownKeys11, "ownKeys");
            function _objectSpread11(target) {
              for (var i = 1; i < arguments.length; i++) {
                var source = arguments[i] != null ? arguments[i] : {};
                if (i % 2) {
                  ownKeys11(Object(source), true).forEach(function(key) {
                    _defineProperty11(target, key, source[key]);
                  });
                } else if (Object.getOwnPropertyDescriptors) {
                  Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
                } else {
                  ownKeys11(Object(source)).forEach(function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                  });
                }
              }
              return target;
            }
            __name(_objectSpread11, "_objectSpread");
            function _defineProperty11(obj, key, value) {
              if (key in obj) {
                Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
              } else {
                obj[key] = value;
              }
              return obj;
            }
            __name(_defineProperty11, "_defineProperty");
            var meta = {
              inspectable: Symbol("inspectable"),
              inspected: Symbol("inspected"),
              name: Symbol("name"),
              preview_long: Symbol("preview_long"),
              preview_short: Symbol("preview_short"),
              readonly: Symbol("readonly"),
              size: Symbol("size"),
              type: Symbol("type"),
              unserializable: Symbol("unserializable")
            };
            var LEVEL_THRESHOLD = 2;
            function createDehydrated(type, inspectable, data, cleaned, path67) {
              cleaned.push(path67);
              var dehydrated = {
                inspectable,
                type,
                preview_long: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                  /* formatDataForPreview */
                  "b"
                ])(data, true),
                preview_short: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                  /* formatDataForPreview */
                  "b"
                ])(data, false),
                name: !data.constructor || data.constructor.name === "Object" ? "" : data.constructor.name
              };
              if (type === "array" || type === "typed_array") {
                dehydrated.size = data.length;
              } else if (type === "object") {
                dehydrated.size = Object.keys(data).length;
              }
              if (type === "iterator" || type === "typed_array") {
                dehydrated.readonly = true;
              }
              return dehydrated;
            }
            __name(createDehydrated, "createDehydrated");
            function dehydrate(data, cleaned, unserializable, path67, isPathAllowed) {
              var level = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : 0;
              var type = Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                /* getDataType */
                "d"
              ])(data);
              var isPathAllowedCheck;
              switch (type) {
                case "html_element":
                  cleaned.push(path67);
                  return {
                    inspectable: false,
                    preview_short: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                      /* formatDataForPreview */
                      "b"
                    ])(data, false),
                    preview_long: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                      /* formatDataForPreview */
                      "b"
                    ])(data, true),
                    name: data.tagName,
                    type
                  };
                case "function":
                  cleaned.push(path67);
                  return {
                    inspectable: false,
                    preview_short: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                      /* formatDataForPreview */
                      "b"
                    ])(data, false),
                    preview_long: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                      /* formatDataForPreview */
                      "b"
                    ])(data, true),
                    name: typeof data.name === "function" || !data.name ? "function" : data.name,
                    type
                  };
                case "string":
                  isPathAllowedCheck = isPathAllowed(path67);
                  if (isPathAllowedCheck) {
                    return data;
                  } else {
                    return data.length <= 500 ? data : data.slice(0, 500) + "...";
                  }
                case "bigint":
                  cleaned.push(path67);
                  return {
                    inspectable: false,
                    preview_short: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                      /* formatDataForPreview */
                      "b"
                    ])(data, false),
                    preview_long: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                      /* formatDataForPreview */
                      "b"
                    ])(data, true),
                    name: data.toString(),
                    type
                  };
                case "symbol":
                  cleaned.push(path67);
                  return {
                    inspectable: false,
                    preview_short: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                      /* formatDataForPreview */
                      "b"
                    ])(data, false),
                    preview_long: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                      /* formatDataForPreview */
                      "b"
                    ])(data, true),
                    name: data.toString(),
                    type
                  };
                case "react_element":
                  cleaned.push(path67);
                  return {
                    inspectable: false,
                    preview_short: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                      /* formatDataForPreview */
                      "b"
                    ])(data, false),
                    preview_long: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                      /* formatDataForPreview */
                      "b"
                    ])(data, true),
                    name: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                      /* getDisplayNameForReactElement */
                      "g"
                    ])(data) || "Unknown",
                    type
                  };
                case "array_buffer":
                case "data_view":
                  cleaned.push(path67);
                  return {
                    inspectable: false,
                    preview_short: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                      /* formatDataForPreview */
                      "b"
                    ])(data, false),
                    preview_long: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                      /* formatDataForPreview */
                      "b"
                    ])(data, true),
                    name: type === "data_view" ? "DataView" : "ArrayBuffer",
                    size: data.byteLength,
                    type
                  };
                case "array":
                  isPathAllowedCheck = isPathAllowed(path67);
                  if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
                    return createDehydrated(type, true, data, cleaned, path67);
                  }
                  return data.map(function(item, i) {
                    return dehydrate(item, cleaned, unserializable, path67.concat([i]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
                  });
                case "html_all_collection":
                case "typed_array":
                case "iterator":
                  isPathAllowedCheck = isPathAllowed(path67);
                  if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
                    return createDehydrated(type, true, data, cleaned, path67);
                  } else {
                    var unserializableValue = {
                      unserializable: true,
                      type,
                      readonly: true,
                      size: type === "typed_array" ? data.length : void 0,
                      preview_short: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                        /* formatDataForPreview */
                        "b"
                      ])(data, false),
                      preview_long: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                        /* formatDataForPreview */
                        "b"
                      ])(data, true),
                      name: !data.constructor || data.constructor.name === "Object" ? "" : data.constructor.name
                    };
                    Array.from(data).forEach(function(item, i) {
                      return unserializableValue[i] = dehydrate(item, cleaned, unserializable, path67.concat([i]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
                    });
                    unserializable.push(path67);
                    return unserializableValue;
                  }
                case "opaque_iterator":
                  cleaned.push(path67);
                  return {
                    inspectable: false,
                    preview_short: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                      /* formatDataForPreview */
                      "b"
                    ])(data, false),
                    preview_long: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                      /* formatDataForPreview */
                      "b"
                    ])(data, true),
                    name: data[Symbol.toStringTag],
                    type
                  };
                case "date":
                  cleaned.push(path67);
                  return {
                    inspectable: false,
                    preview_short: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                      /* formatDataForPreview */
                      "b"
                    ])(data, false),
                    preview_long: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                      /* formatDataForPreview */
                      "b"
                    ])(data, true),
                    name: data.toString(),
                    type
                  };
                case "regexp":
                  cleaned.push(path67);
                  return {
                    inspectable: false,
                    preview_short: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                      /* formatDataForPreview */
                      "b"
                    ])(data, false),
                    preview_long: Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                      /* formatDataForPreview */
                      "b"
                    ])(data, true),
                    name: data.toString(),
                    type
                  };
                case "object":
                  isPathAllowedCheck = isPathAllowed(path67);
                  if (level >= LEVEL_THRESHOLD && !isPathAllowedCheck) {
                    return createDehydrated(type, true, data, cleaned, path67);
                  } else {
                    var object = {};
                    Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                      /* getAllEnumerableKeys */
                      "c"
                    ])(data).forEach(function(key) {
                      var name = key.toString();
                      object[name] = dehydrate(data[key], cleaned, unserializable, path67.concat([name]), isPathAllowed, isPathAllowedCheck ? 1 : level + 1);
                    });
                    return object;
                  }
                case "infinity":
                case "nan":
                case "undefined":
                  cleaned.push(path67);
                  return {
                    type
                  };
                default:
                  return data;
              }
            }
            __name(dehydrate, "dehydrate");
            function fillInPath(object, data, path67, value) {
              var target = Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                /* getInObject */
                "h"
              ])(object, path67);
              if (target != null) {
                if (!target[meta.unserializable]) {
                  delete target[meta.inspectable];
                  delete target[meta.inspected];
                  delete target[meta.name];
                  delete target[meta.preview_long];
                  delete target[meta.preview_short];
                  delete target[meta.readonly];
                  delete target[meta.size];
                  delete target[meta.type];
                }
              }
              if (value !== null && data.unserializable.length > 0) {
                var unserializablePath = data.unserializable[0];
                var isMatch = unserializablePath.length === path67.length;
                for (var i = 0; i < path67.length; i++) {
                  if (path67[i] !== unserializablePath[i]) {
                    isMatch = false;
                    break;
                  }
                }
                if (isMatch) {
                  upgradeUnserializable(value, value);
                }
              }
              Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                /* setInObject */
                "l"
              ])(object, path67, value);
            }
            __name(fillInPath, "fillInPath");
            function hydrate(object, cleaned, unserializable) {
              cleaned.forEach(function(path67) {
                var length = path67.length;
                var last = path67[length - 1];
                var parent = Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                  /* getInObject */
                  "h"
                ])(object, path67.slice(0, length - 1));
                if (!parent || !parent.hasOwnProperty(last)) {
                  return;
                }
                var value = parent[last];
                if (!value) {
                  return;
                } else if (value.type === "infinity") {
                  parent[last] = Infinity;
                } else if (value.type === "nan") {
                  parent[last] = NaN;
                } else if (value.type === "undefined") {
                  parent[last] = void 0;
                } else {
                  var replaced = {};
                  replaced[meta.inspectable] = !!value.inspectable;
                  replaced[meta.inspected] = false;
                  replaced[meta.name] = value.name;
                  replaced[meta.preview_long] = value.preview_long;
                  replaced[meta.preview_short] = value.preview_short;
                  replaced[meta.size] = value.size;
                  replaced[meta.readonly] = !!value.readonly;
                  replaced[meta.type] = value.type;
                  parent[last] = replaced;
                }
              });
              unserializable.forEach(function(path67) {
                var length = path67.length;
                var last = path67[length - 1];
                var parent = Object(_utils__WEBPACK_IMPORTED_MODULE_0__[
                  /* getInObject */
                  "h"
                ])(object, path67.slice(0, length - 1));
                if (!parent || !parent.hasOwnProperty(last)) {
                  return;
                }
                var node2 = parent[last];
                var replacement = _objectSpread11({}, node2);
                upgradeUnserializable(replacement, node2);
                parent[last] = replacement;
              });
              return object;
            }
            __name(hydrate, "hydrate");
            function upgradeUnserializable(destination, source) {
              var _Object$definePropert;
              Object.defineProperties(destination, (_Object$definePropert = {}, _defineProperty11(_Object$definePropert, meta.inspected, {
                configurable: true,
                enumerable: false,
                value: !!source.inspected
              }), _defineProperty11(_Object$definePropert, meta.name, {
                configurable: true,
                enumerable: false,
                value: source.name
              }), _defineProperty11(_Object$definePropert, meta.preview_long, {
                configurable: true,
                enumerable: false,
                value: source.preview_long
              }), _defineProperty11(_Object$definePropert, meta.preview_short, {
                configurable: true,
                enumerable: false,
                value: source.preview_short
              }), _defineProperty11(_Object$definePropert, meta.size, {
                configurable: true,
                enumerable: false,
                value: source.size
              }), _defineProperty11(_Object$definePropert, meta.readonly, {
                configurable: true,
                enumerable: false,
                value: !!source.readonly
              }), _defineProperty11(_Object$definePropert, meta.type, {
                configurable: true,
                enumerable: false,
                value: source.type
              }), _defineProperty11(_Object$definePropert, meta.unserializable, {
                configurable: true,
                enumerable: false,
                value: !!source.unserializable
              }), _Object$definePropert));
              delete destination.inspected;
              delete destination.name;
              delete destination.preview_long;
              delete destination.preview_short;
              delete destination.size;
              delete destination.readonly;
              delete destination.type;
              delete destination.unserializable;
            }
            __name(upgradeUnserializable, "upgradeUnserializable");
          },
          /* 13 */
          /***/
          function(module4, __webpack_exports__, __webpack_require__) {
            "use strict";
            __webpack_require__.d(__webpack_exports__, "a", function() {
              return consoleManagedByDevToolsDuringStrictMode;
            });
            __webpack_require__.d(__webpack_exports__, "b", function() {
              return enableProfilerChangedHookIndices;
            });
            __webpack_require__.d(__webpack_exports__, "c", function() {
              return enableStyleXFeatures;
            });
            var consoleManagedByDevToolsDuringStrictMode = false;
            var enableLogger = false;
            var enableNamedHooksFeature = true;
            var enableProfilerChangedHookIndices = true;
            var enableStyleXFeatures = false;
            var isInternalFacebookBuild = false;
            null;
          },
          /* 14 */
          /***/
          function(module4, exports3) {
            function _typeof7(obj) {
              "@babel/helpers - typeof";
              if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return typeof obj2;
                }, "_typeof");
              } else {
                _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
                }, "_typeof");
              }
              return _typeof7(obj);
            }
            __name(_typeof7, "_typeof");
            var g2;
            g2 = function() {
              return this;
            }();
            try {
              g2 = g2 || new Function("return this")();
            } catch (e3) {
              if ((typeof window === "undefined" ? "undefined" : _typeof7(window)) === "object")
                g2 = window;
            }
            module4.exports = g2;
          },
          /* 15 */
          /***/
          function(module4, exports3, __webpack_require__) {
            (function(global2) {
              function _typeof7(obj) {
                "@babel/helpers - typeof";
                if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                  _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                    return typeof obj2;
                  }, "_typeof");
                } else {
                  _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                    return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
                  }, "_typeof");
                }
                return _typeof7(obj);
              }
              __name(_typeof7, "_typeof");
              var FUNC_ERROR_TEXT = "Expected a function";
              var NAN = 0 / 0;
              var symbolTag = "[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 freeGlobal = (typeof global2 === "undefined" ? "undefined" : _typeof7(global2)) == "object" && global2 && global2.Object === Object && global2;
              var freeSelf = (typeof self === "undefined" ? "undefined" : _typeof7(self)) == "object" && self && self.Object === Object && self;
              var root = freeGlobal || freeSelf || Function("return this")();
              var objectProto = Object.prototype;
              var objectToString2 = objectProto.toString;
              var nativeMax = Math.max, nativeMin = Math.min;
              var now = /* @__PURE__ */ __name(function now2() {
                return root.Date.now();
              }, "now");
              function debounce(func, wait, options29) {
                var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
                if (typeof func != "function") {
                  throw new TypeError(FUNC_ERROR_TEXT);
                }
                wait = toNumber(wait) || 0;
                if (isObject2(options29)) {
                  leading = !!options29.leading;
                  maxing = "maxWait" in options29;
                  maxWait = maxing ? nativeMax(toNumber(options29.maxWait) || 0, wait) : maxWait;
                  trailing = "trailing" in options29 ? !!options29.trailing : trailing;
                }
                function invokeFunc(time) {
                  var args = lastArgs, thisArg = lastThis;
                  lastArgs = lastThis = void 0;
                  lastInvokeTime = time;
                  result = func.apply(thisArg, args);
                  return result;
                }
                __name(invokeFunc, "invokeFunc");
                function leadingEdge(time) {
                  lastInvokeTime = time;
                  timerId = setTimeout(timerExpired, wait);
                  return leading ? invokeFunc(time) : result;
                }
                __name(leadingEdge, "leadingEdge");
                function remainingWait(time) {
                  var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, result2 = wait - timeSinceLastCall;
                  return maxing ? nativeMin(result2, maxWait - timeSinceLastInvoke) : result2;
                }
                __name(remainingWait, "remainingWait");
                function shouldInvoke(time) {
                  var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
                  return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
                }
                __name(shouldInvoke, "shouldInvoke");
                function timerExpired() {
                  var time = now();
                  if (shouldInvoke(time)) {
                    return trailingEdge(time);
                  }
                  timerId = setTimeout(timerExpired, remainingWait(time));
                }
                __name(timerExpired, "timerExpired");
                function trailingEdge(time) {
                  timerId = void 0;
                  if (trailing && lastArgs) {
                    return invokeFunc(time);
                  }
                  lastArgs = lastThis = void 0;
                  return result;
                }
                __name(trailingEdge, "trailingEdge");
                function cancel3() {
                  if (timerId !== void 0) {
                    clearTimeout(timerId);
                  }
                  lastInvokeTime = 0;
                  lastArgs = lastCallTime = lastThis = timerId = void 0;
                }
                __name(cancel3, "cancel");
                function flush2() {
                  return timerId === void 0 ? result : trailingEdge(now());
                }
                __name(flush2, "flush");
                function debounced() {
                  var time = now(), isInvoking = shouldInvoke(time);
                  lastArgs = arguments;
                  lastThis = this;
                  lastCallTime = time;
                  if (isInvoking) {
                    if (timerId === void 0) {
                      return leadingEdge(lastCallTime);
                    }
                    if (maxing) {
                      timerId = setTimeout(timerExpired, wait);
                      return invokeFunc(lastCallTime);
                    }
                  }
                  if (timerId === void 0) {
                    timerId = setTimeout(timerExpired, wait);
                  }
                  return result;
                }
                __name(debounced, "debounced");
                debounced.cancel = cancel3;
                debounced.flush = flush2;
                return debounced;
              }
              __name(debounce, "debounce");
              function throttle(func, wait, options29) {
                var leading = true, trailing = true;
                if (typeof func != "function") {
                  throw new TypeError(FUNC_ERROR_TEXT);
                }
                if (isObject2(options29)) {
                  leading = "leading" in options29 ? !!options29.leading : leading;
                  trailing = "trailing" in options29 ? !!options29.trailing : trailing;
                }
                return debounce(func, wait, {
                  "leading": leading,
                  "maxWait": wait,
                  "trailing": trailing
                });
              }
              __name(throttle, "throttle");
              function isObject2(value) {
                var type = _typeof7(value);
                return !!value && (type == "object" || type == "function");
              }
              __name(isObject2, "isObject");
              function isObjectLike(value) {
                return !!value && _typeof7(value) == "object";
              }
              __name(isObjectLike, "isObjectLike");
              function isSymbol(value) {
                return _typeof7(value) == "symbol" || isObjectLike(value) && objectToString2.call(value) == symbolTag;
              }
              __name(isSymbol, "isSymbol");
              function toNumber(value) {
                if (typeof value == "number") {
                  return value;
                }
                if (isSymbol(value)) {
                  return NAN;
                }
                if (isObject2(value)) {
                  var other = typeof value.valueOf == "function" ? value.valueOf() : value;
                  value = isObject2(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;
              }
              __name(toNumber, "toNumber");
              module4.exports = throttle;
            }).call(this, __webpack_require__(14));
          },
          /* 16 */
          /***/
          function(module4, __webpack_exports__, __webpack_require__) {
            "use strict";
            __webpack_require__.d(__webpack_exports__, "b", function() {
              return (
                /* binding */
                getInternalReactConstants
              );
            });
            __webpack_require__.d(__webpack_exports__, "a", function() {
              return (
                /* binding */
                attach
              );
            });
            var semver2 = __webpack_require__(11);
            var types = __webpack_require__(0);
            var utils = __webpack_require__(2);
            var storage = __webpack_require__(5);
            var backend_utils = __webpack_require__(4);
            var constants3 = __webpack_require__(1);
            var react_debug_tools = __webpack_require__(21);
            var backend_console = __webpack_require__(10);
            var ReactSymbols = __webpack_require__(3);
            var DevToolsFeatureFlags_core_oss = __webpack_require__(13);
            function is2(x2, y2) {
              return x2 === y2 && (x2 !== 0 || 1 / x2 === 1 / y2) || x2 !== x2 && y2 !== y2;
            }
            __name(is2, "is");
            var objectIs = typeof Object.is === "function" ? Object.is : is2;
            var shared_objectIs = objectIs;
            var isArray = __webpack_require__(9);
            var hasOwnProperty_hasOwnProperty = Object.prototype.hasOwnProperty;
            var shared_hasOwnProperty = hasOwnProperty_hasOwnProperty;
            var src_isArray = __webpack_require__(6);
            var cachedStyleNameToValueMap = /* @__PURE__ */ new Map();
            function getStyleXData(data) {
              var sources = /* @__PURE__ */ new Set();
              var resolvedStyles = {};
              crawlData(data, sources, resolvedStyles);
              return {
                sources: Array.from(sources).sort(),
                resolvedStyles
              };
            }
            __name(getStyleXData, "getStyleXData");
            function crawlData(data, sources, resolvedStyles) {
              if (Object(src_isArray[
                "a"
                /* default */
              ])(data)) {
                data.forEach(function(entry) {
                  if (Object(src_isArray[
                    "a"
                    /* default */
                  ])(entry)) {
                    crawlData(entry, sources, resolvedStyles);
                  } else {
                    crawlObjectProperties(entry, sources, resolvedStyles);
                  }
                });
              } else {
                crawlObjectProperties(data, sources, resolvedStyles);
              }
              resolvedStyles = Object.fromEntries(Object.entries(resolvedStyles).sort());
            }
            __name(crawlData, "crawlData");
            function crawlObjectProperties(entry, sources, resolvedStyles) {
              var keys = Object.keys(entry);
              keys.forEach(function(key) {
                var value = entry[key];
                if (typeof value === "string") {
                  if (key === value) {
                    sources.add(key);
                  } else {
                    resolvedStyles[key] = getPropertyValueForStyleName(value);
                  }
                } else {
                  var nestedStyle = {};
                  resolvedStyles[key] = nestedStyle;
                  crawlData([value], sources, nestedStyle);
                }
              });
            }
            __name(crawlObjectProperties, "crawlObjectProperties");
            function getPropertyValueForStyleName(styleName) {
              if (cachedStyleNameToValueMap.has(styleName)) {
                return cachedStyleNameToValueMap.get(styleName);
              }
              for (var styleSheetIndex = 0; styleSheetIndex < document.styleSheets.length; styleSheetIndex++) {
                var styleSheet = document.styleSheets[styleSheetIndex];
                var rules = styleSheet.rules || styleSheet.cssRules;
                for (var ruleIndex = 0; ruleIndex < rules.length; ruleIndex++) {
                  var rule = rules[ruleIndex];
                  var cssText = rule.cssText, selectorText = rule.selectorText, style = rule.style;
                  if (selectorText != null) {
                    if (selectorText.startsWith(".".concat(styleName))) {
                      var match = cssText.match(/{ *([a-z\-]+):/);
                      if (match !== null) {
                        var property = match[1];
                        var value = style.getPropertyValue(property);
                        cachedStyleNameToValueMap.set(styleName, value);
                        return value;
                      } else {
                        return null;
                      }
                    }
                  }
                }
              }
              return null;
            }
            __name(getPropertyValueForStyleName, "getPropertyValueForStyleName");
            var REACT_TOTAL_NUM_LANES = 31;
            var SCHEDULING_PROFILER_VERSION = 1;
            var SNAPSHOT_MAX_HEIGHT = 60;
            function _typeof7(obj) {
              "@babel/helpers - typeof";
              if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return typeof obj2;
                }, "_typeof");
              } else {
                _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
                }, "_typeof");
              }
              return _typeof7(obj);
            }
            __name(_typeof7, "_typeof");
            function _slicedToArray3(arr, i) {
              return _arrayWithHoles3(arr) || _iterableToArrayLimit3(arr, i) || _unsupportedIterableToArray4(arr, i) || _nonIterableRest3();
            }
            __name(_slicedToArray3, "_slicedToArray");
            function _nonIterableRest3() {
              throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
            }
            __name(_nonIterableRest3, "_nonIterableRest");
            function _unsupportedIterableToArray4(o2, minLen) {
              if (!o2)
                return;
              if (typeof o2 === "string")
                return _arrayLikeToArray4(o2, minLen);
              var n2 = Object.prototype.toString.call(o2).slice(8, -1);
              if (n2 === "Object" && o2.constructor)
                n2 = o2.constructor.name;
              if (n2 === "Map" || n2 === "Set")
                return Array.from(o2);
              if (n2 === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n2))
                return _arrayLikeToArray4(o2, minLen);
            }
            __name(_unsupportedIterableToArray4, "_unsupportedIterableToArray");
            function _arrayLikeToArray4(arr, len) {
              if (len == null || len > arr.length)
                len = arr.length;
              for (var i = 0, arr2 = new Array(len); i < len; i++) {
                arr2[i] = arr[i];
              }
              return arr2;
            }
            __name(_arrayLikeToArray4, "_arrayLikeToArray");
            function _iterableToArrayLimit3(arr, i) {
              if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr)))
                return;
              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"] != null)
                    _i["return"]();
                } finally {
                  if (_d)
                    throw _e;
                }
              }
              return _arr;
            }
            __name(_iterableToArrayLimit3, "_iterableToArrayLimit");
            function _arrayWithHoles3(arr) {
              if (Array.isArray(arr))
                return arr;
            }
            __name(_arrayWithHoles3, "_arrayWithHoles");
            var performanceTarget = null;
            var supportsUserTiming = typeof performance !== "undefined" && typeof performance.mark === "function" && typeof performance.clearMarks === "function";
            var supportsUserTimingV3 = false;
            if (supportsUserTiming) {
              var CHECK_V3_MARK = "__v3";
              var markOptions = {};
              Object.defineProperty(markOptions, "startTime", {
                get: /* @__PURE__ */ __name(function get() {
                  supportsUserTimingV3 = true;
                  return 0;
                }, "get"),
                set: /* @__PURE__ */ __name(function set() {
                }, "set")
              });
              try {
                performance.mark(CHECK_V3_MARK, markOptions);
              } catch (error2) {
              } finally {
                performance.clearMarks(CHECK_V3_MARK);
              }
            }
            if (supportsUserTimingV3) {
              performanceTarget = performance;
            }
            function setPerformanceMock_ONLY_FOR_TESTING(performanceMock) {
              performanceTarget = performanceMock;
              supportsUserTiming = performanceMock !== null;
              supportsUserTimingV3 = performanceMock !== null;
            }
            __name(setPerformanceMock_ONLY_FOR_TESTING, "setPerformanceMock_ONLY_FOR_TESTING");
            function markAndClear(markName) {
              performanceTarget.mark(markName);
              performanceTarget.clearMarks(markName);
            }
            __name(markAndClear, "markAndClear");
            function createProfilingHooks(_ref) {
              var getDisplayNameForFiber = _ref.getDisplayNameForFiber, getLaneLabelMap = _ref.getLaneLabelMap, reactVersion = _ref.reactVersion;
              function markMetadata() {
                markAndClear("--react-version-".concat(reactVersion));
                markAndClear("--profiler-version-".concat(SCHEDULING_PROFILER_VERSION));
                if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.getInternalModuleRanges === "function") {
                  var ranges = __REACT_DEVTOOLS_GLOBAL_HOOK__.getInternalModuleRanges();
                  if (Object(isArray[
                    "a"
                    /* default */
                  ])(ranges)) {
                    for (var i = 0; i < ranges.length; i++) {
                      var range = ranges[i];
                      if (Object(isArray[
                        "a"
                        /* default */
                      ])(range) && range.length === 2) {
                        var _ranges$i = _slicedToArray3(ranges[i], 2), startStackFrame = _ranges$i[0], stopStackFrame = _ranges$i[1];
                        markAndClear("--react-internal-module-start-".concat(startStackFrame));
                        markAndClear("--react-internal-module-stop-".concat(stopStackFrame));
                      }
                    }
                  }
                }
                if (typeof getLaneLabelMap === "function") {
                  var map = getLaneLabelMap();
                  if (map != null) {
                    var labels = Array.from(map.values()).join(",");
                    markAndClear("--react-lane-labels-".concat(labels));
                  }
                }
              }
              __name(markMetadata, "markMetadata");
              function markCommitStarted(lanes) {
                if (supportsUserTimingV3) {
                  markAndClear("--commit-start-".concat(lanes));
                  markMetadata();
                }
              }
              __name(markCommitStarted, "markCommitStarted");
              function markCommitStopped() {
                if (supportsUserTimingV3) {
                  markAndClear("--commit-stop");
                }
              }
              __name(markCommitStopped, "markCommitStopped");
              function markComponentRenderStarted(fiber) {
                if (supportsUserTimingV3) {
                  var componentName = getDisplayNameForFiber(fiber) || "Unknown";
                  markAndClear("--component-render-start-".concat(componentName));
                }
              }
              __name(markComponentRenderStarted, "markComponentRenderStarted");
              function markComponentRenderStopped() {
                if (supportsUserTimingV3) {
                  markAndClear("--component-render-stop");
                }
              }
              __name(markComponentRenderStopped, "markComponentRenderStopped");
              function markComponentPassiveEffectMountStarted(fiber) {
                if (supportsUserTimingV3) {
                  var componentName = getDisplayNameForFiber(fiber) || "Unknown";
                  markAndClear("--component-passive-effect-mount-start-".concat(componentName));
                }
              }
              __name(markComponentPassiveEffectMountStarted, "markComponentPassiveEffectMountStarted");
              function markComponentPassiveEffectMountStopped() {
                if (supportsUserTimingV3) {
                  markAndClear("--component-passive-effect-mount-stop");
                }
              }
              __name(markComponentPassiveEffectMountStopped, "markComponentPassiveEffectMountStopped");
              function markComponentPassiveEffectUnmountStarted(fiber) {
                if (supportsUserTimingV3) {
                  var componentName = getDisplayNameForFiber(fiber) || "Unknown";
                  markAndClear("--component-passive-effect-unmount-start-".concat(componentName));
                }
              }
              __name(markComponentPassiveEffectUnmountStarted, "markComponentPassiveEffectUnmountStarted");
              function markComponentPassiveEffectUnmountStopped() {
                if (supportsUserTimingV3) {
                  markAndClear("--component-passive-effect-unmount-stop");
                }
              }
              __name(markComponentPassiveEffectUnmountStopped, "markComponentPassiveEffectUnmountStopped");
              function markComponentLayoutEffectMountStarted(fiber) {
                if (supportsUserTimingV3) {
                  var componentName = getDisplayNameForFiber(fiber) || "Unknown";
                  markAndClear("--component-layout-effect-mount-start-".concat(componentName));
                }
              }
              __name(markComponentLayoutEffectMountStarted, "markComponentLayoutEffectMountStarted");
              function markComponentLayoutEffectMountStopped() {
                if (supportsUserTimingV3) {
                  markAndClear("--component-layout-effect-mount-stop");
                }
              }
              __name(markComponentLayoutEffectMountStopped, "markComponentLayoutEffectMountStopped");
              function markComponentLayoutEffectUnmountStarted(fiber) {
                if (supportsUserTimingV3) {
                  var componentName = getDisplayNameForFiber(fiber) || "Unknown";
                  markAndClear("--component-layout-effect-unmount-start-".concat(componentName));
                }
              }
              __name(markComponentLayoutEffectUnmountStarted, "markComponentLayoutEffectUnmountStarted");
              function markComponentLayoutEffectUnmountStopped() {
                if (supportsUserTimingV3) {
                  markAndClear("--component-layout-effect-unmount-stop");
                }
              }
              __name(markComponentLayoutEffectUnmountStopped, "markComponentLayoutEffectUnmountStopped");
              function markComponentErrored(fiber, thrownValue, lanes) {
                if (supportsUserTimingV3) {
                  var componentName = getDisplayNameForFiber(fiber) || "Unknown";
                  var phase = fiber.alternate === null ? "mount" : "update";
                  var message = "";
                  if (thrownValue !== null && _typeof7(thrownValue) === "object" && typeof thrownValue.message === "string") {
                    message = thrownValue.message;
                  } else if (typeof thrownValue === "string") {
                    message = thrownValue;
                  }
                  markAndClear("--error-".concat(componentName, "-").concat(phase, "-").concat(message));
                }
              }
              __name(markComponentErrored, "markComponentErrored");
              var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
              var wakeableIDs = new PossiblyWeakMap();
              var wakeableID = 0;
              function getWakeableID(wakeable) {
                if (!wakeableIDs.has(wakeable)) {
                  wakeableIDs.set(wakeable, wakeableID++);
                }
                return wakeableIDs.get(wakeable);
              }
              __name(getWakeableID, "getWakeableID");
              function markComponentSuspended(fiber, wakeable, lanes) {
                if (supportsUserTimingV3) {
                  var eventType = wakeableIDs.has(wakeable) ? "resuspend" : "suspend";
                  var id = getWakeableID(wakeable);
                  var componentName = getDisplayNameForFiber(fiber) || "Unknown";
                  var phase = fiber.alternate === null ? "mount" : "update";
                  var displayName = wakeable.displayName || "";
                  markAndClear("--suspense-".concat(eventType, "-").concat(id, "-").concat(componentName, "-").concat(phase, "-").concat(lanes, "-").concat(displayName));
                  wakeable.then(function() {
                    return markAndClear("--suspense-resolved-".concat(id, "-").concat(componentName));
                  }, function() {
                    return markAndClear("--suspense-rejected-".concat(id, "-").concat(componentName));
                  });
                }
              }
              __name(markComponentSuspended, "markComponentSuspended");
              function markLayoutEffectsStarted(lanes) {
                if (supportsUserTimingV3) {
                  markAndClear("--layout-effects-start-".concat(lanes));
                }
              }
              __name(markLayoutEffectsStarted, "markLayoutEffectsStarted");
              function markLayoutEffectsStopped() {
                if (supportsUserTimingV3) {
                  markAndClear("--layout-effects-stop");
                }
              }
              __name(markLayoutEffectsStopped, "markLayoutEffectsStopped");
              function markPassiveEffectsStarted(lanes) {
                if (supportsUserTimingV3) {
                  markAndClear("--passive-effects-start-".concat(lanes));
                }
              }
              __name(markPassiveEffectsStarted, "markPassiveEffectsStarted");
              function markPassiveEffectsStopped() {
                if (supportsUserTimingV3) {
                  markAndClear("--passive-effects-stop");
                }
              }
              __name(markPassiveEffectsStopped, "markPassiveEffectsStopped");
              function markRenderStarted(lanes) {
                if (supportsUserTimingV3) {
                  markAndClear("--render-start-".concat(lanes));
                }
              }
              __name(markRenderStarted, "markRenderStarted");
              function markRenderYielded() {
                if (supportsUserTimingV3) {
                  markAndClear("--render-yield");
                }
              }
              __name(markRenderYielded, "markRenderYielded");
              function markRenderStopped() {
                if (supportsUserTimingV3) {
                  markAndClear("--render-stop");
                }
              }
              __name(markRenderStopped, "markRenderStopped");
              function markRenderScheduled(lane) {
                if (supportsUserTimingV3) {
                  markAndClear("--schedule-render-".concat(lane));
                }
              }
              __name(markRenderScheduled, "markRenderScheduled");
              function markForceUpdateScheduled(fiber, lane) {
                if (supportsUserTimingV3) {
                  var componentName = getDisplayNameForFiber(fiber) || "Unknown";
                  markAndClear("--schedule-forced-update-".concat(lane, "-").concat(componentName));
                }
              }
              __name(markForceUpdateScheduled, "markForceUpdateScheduled");
              function markStateUpdateScheduled(fiber, lane) {
                if (supportsUserTimingV3) {
                  var componentName = getDisplayNameForFiber(fiber) || "Unknown";
                  markAndClear("--schedule-state-update-".concat(lane, "-").concat(componentName));
                }
              }
              __name(markStateUpdateScheduled, "markStateUpdateScheduled");
              return {
                markCommitStarted,
                markCommitStopped,
                markComponentRenderStarted,
                markComponentRenderStopped,
                markComponentPassiveEffectMountStarted,
                markComponentPassiveEffectMountStopped,
                markComponentPassiveEffectUnmountStarted,
                markComponentPassiveEffectUnmountStopped,
                markComponentLayoutEffectMountStarted,
                markComponentLayoutEffectMountStopped,
                markComponentLayoutEffectUnmountStarted,
                markComponentLayoutEffectUnmountStopped,
                markComponentErrored,
                markComponentSuspended,
                markLayoutEffectsStarted,
                markLayoutEffectsStopped,
                markPassiveEffectsStarted,
                markPassiveEffectsStopped,
                markRenderStarted,
                markRenderYielded,
                markRenderStopped,
                markRenderScheduled,
                markForceUpdateScheduled,
                markStateUpdateScheduled
              };
            }
            __name(createProfilingHooks, "createProfilingHooks");
            function ownKeys11(object, enumerableOnly) {
              var keys = Object.keys(object);
              if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                if (enumerableOnly)
                  symbols = symbols.filter(function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                  });
                keys.push.apply(keys, symbols);
              }
              return keys;
            }
            __name(ownKeys11, "ownKeys");
            function _objectSpread11(target) {
              for (var i = 1; i < arguments.length; i++) {
                var source = arguments[i] != null ? arguments[i] : {};
                if (i % 2) {
                  ownKeys11(Object(source), true).forEach(function(key) {
                    _defineProperty11(target, key, source[key]);
                  });
                } else if (Object.getOwnPropertyDescriptors) {
                  Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
                } else {
                  ownKeys11(Object(source)).forEach(function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                  });
                }
              }
              return target;
            }
            __name(_objectSpread11, "_objectSpread");
            function _defineProperty11(obj, key, value) {
              if (key in obj) {
                Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
              } else {
                obj[key] = value;
              }
              return obj;
            }
            __name(_defineProperty11, "_defineProperty");
            function renderer_slicedToArray(arr, i) {
              return renderer_arrayWithHoles(arr) || renderer_iterableToArrayLimit(arr, i) || renderer_unsupportedIterableToArray(arr, i) || renderer_nonIterableRest();
            }
            __name(renderer_slicedToArray, "renderer_slicedToArray");
            function renderer_nonIterableRest() {
              throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
            }
            __name(renderer_nonIterableRest, "renderer_nonIterableRest");
            function renderer_iterableToArrayLimit(arr, i) {
              if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr)))
                return;
              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"] != null)
                    _i["return"]();
                } finally {
                  if (_d)
                    throw _e;
                }
              }
              return _arr;
            }
            __name(renderer_iterableToArrayLimit, "renderer_iterableToArrayLimit");
            function renderer_arrayWithHoles(arr) {
              if (Array.isArray(arr))
                return arr;
            }
            __name(renderer_arrayWithHoles, "renderer_arrayWithHoles");
            function _toConsumableArray(arr) {
              return _arrayWithoutHoles(arr) || _iterableToArray(arr) || renderer_unsupportedIterableToArray(arr) || _nonIterableSpread();
            }
            __name(_toConsumableArray, "_toConsumableArray");
            function _nonIterableSpread() {
              throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
            }
            __name(_nonIterableSpread, "_nonIterableSpread");
            function _iterableToArray(iter) {
              if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter))
                return Array.from(iter);
            }
            __name(_iterableToArray, "_iterableToArray");
            function _arrayWithoutHoles(arr) {
              if (Array.isArray(arr))
                return renderer_arrayLikeToArray(arr);
            }
            __name(_arrayWithoutHoles, "_arrayWithoutHoles");
            function _createForOfIteratorHelper(o2, allowArrayLike) {
              var it2;
              if (typeof Symbol === "undefined" || o2[Symbol.iterator] == null) {
                if (Array.isArray(o2) || (it2 = renderer_unsupportedIterableToArray(o2)) || allowArrayLike && o2 && typeof o2.length === "number") {
                  if (it2)
                    o2 = it2;
                  var i = 0;
                  var F = /* @__PURE__ */ __name(function F2() {
                  }, "F");
                  return { s: F, n: /* @__PURE__ */ __name(function n2() {
                    if (i >= o2.length)
                      return { done: true };
                    return { done: false, value: o2[i++] };
                  }, "n"), e: /* @__PURE__ */ __name(function e3(_e2) {
                    throw _e2;
                  }, "e"), f: F };
                }
                throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
              }
              var normalCompletion = true, didErr = false, err;
              return { s: /* @__PURE__ */ __name(function s() {
                it2 = o2[Symbol.iterator]();
              }, "s"), n: /* @__PURE__ */ __name(function n2() {
                var step = it2.next();
                normalCompletion = step.done;
                return step;
              }, "n"), e: /* @__PURE__ */ __name(function e3(_e3) {
                didErr = true;
                err = _e3;
              }, "e"), f: /* @__PURE__ */ __name(function f() {
                try {
                  if (!normalCompletion && it2.return != null)
                    it2.return();
                } finally {
                  if (didErr)
                    throw err;
                }
              }, "f") };
            }
            __name(_createForOfIteratorHelper, "_createForOfIteratorHelper");
            function renderer_unsupportedIterableToArray(o2, minLen) {
              if (!o2)
                return;
              if (typeof o2 === "string")
                return renderer_arrayLikeToArray(o2, minLen);
              var n2 = Object.prototype.toString.call(o2).slice(8, -1);
              if (n2 === "Object" && o2.constructor)
                n2 = o2.constructor.name;
              if (n2 === "Map" || n2 === "Set")
                return Array.from(o2);
              if (n2 === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n2))
                return renderer_arrayLikeToArray(o2, minLen);
            }
            __name(renderer_unsupportedIterableToArray, "renderer_unsupportedIterableToArray");
            function renderer_arrayLikeToArray(arr, len) {
              if (len == null || len > arr.length)
                len = arr.length;
              for (var i = 0, arr2 = new Array(len); i < len; i++) {
                arr2[i] = arr[i];
              }
              return arr2;
            }
            __name(renderer_arrayLikeToArray, "renderer_arrayLikeToArray");
            function renderer_typeof(obj) {
              "@babel/helpers - typeof";
              if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                renderer_typeof = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return typeof obj2;
                }, "_typeof");
              } else {
                renderer_typeof = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
                }, "_typeof");
              }
              return renderer_typeof(obj);
            }
            __name(renderer_typeof, "renderer_typeof");
            function getFiberFlags(fiber) {
              return fiber.flags !== void 0 ? fiber.flags : fiber.effectTag;
            }
            __name(getFiberFlags, "getFiberFlags");
            var getCurrentTime = (typeof performance === "undefined" ? "undefined" : renderer_typeof(performance)) === "object" && typeof performance.now === "function" ? function() {
              return performance.now();
            } : function() {
              return Date.now();
            };
            function getInternalReactConstants(version3) {
              var ReactTypeOfSideEffect = {
                DidCapture: 128,
                NoFlags: 0,
                PerformedWork: 1,
                Placement: 2,
                Incomplete: 8192,
                Hydrating: 4096
              };
              var ReactPriorityLevels = {
                ImmediatePriority: 99,
                UserBlockingPriority: 98,
                NormalPriority: 97,
                LowPriority: 96,
                IdlePriority: 95,
                NoPriority: 90
              };
              if (Object(semver2["gt"])(version3, "17.0.2")) {
                ReactPriorityLevels = {
                  ImmediatePriority: 1,
                  UserBlockingPriority: 2,
                  NormalPriority: 3,
                  LowPriority: 4,
                  IdlePriority: 5,
                  NoPriority: 0
                };
              }
              var StrictModeBits = 0;
              if (Object(semver2["gte"])(version3, "18.0.0-alpha")) {
                StrictModeBits = 24;
              } else if (Object(semver2["gte"])(version3, "16.9.0")) {
                StrictModeBits = 1;
              } else if (Object(semver2["gte"])(version3, "16.3.0")) {
                StrictModeBits = 2;
              }
              var ReactTypeOfWork = null;
              if (Object(semver2["gt"])(version3, "17.0.1")) {
                ReactTypeOfWork = {
                  CacheComponent: 24,
                  // Experimental
                  ClassComponent: 1,
                  ContextConsumer: 9,
                  ContextProvider: 10,
                  CoroutineComponent: -1,
                  // Removed
                  CoroutineHandlerPhase: -1,
                  // Removed
                  DehydratedSuspenseComponent: 18,
                  // Behind a flag
                  ForwardRef: 11,
                  Fragment: 7,
                  FunctionComponent: 0,
                  HostComponent: 5,
                  HostPortal: 4,
                  HostRoot: 3,
                  HostText: 6,
                  IncompleteClassComponent: 17,
                  IndeterminateComponent: 2,
                  LazyComponent: 16,
                  LegacyHiddenComponent: 23,
                  MemoComponent: 14,
                  Mode: 8,
                  OffscreenComponent: 22,
                  // Experimental
                  Profiler: 12,
                  ScopeComponent: 21,
                  // Experimental
                  SimpleMemoComponent: 15,
                  SuspenseComponent: 13,
                  SuspenseListComponent: 19,
                  // Experimental
                  YieldComponent: -1
                  // Removed
                };
              } else if (Object(semver2["gte"])(version3, "17.0.0-alpha")) {
                ReactTypeOfWork = {
                  CacheComponent: -1,
                  // Doesn't exist yet
                  ClassComponent: 1,
                  ContextConsumer: 9,
                  ContextProvider: 10,
                  CoroutineComponent: -1,
                  // Removed
                  CoroutineHandlerPhase: -1,
                  // Removed
                  DehydratedSuspenseComponent: 18,
                  // Behind a flag
                  ForwardRef: 11,
                  Fragment: 7,
                  FunctionComponent: 0,
                  HostComponent: 5,
                  HostPortal: 4,
                  HostRoot: 3,
                  HostText: 6,
                  IncompleteClassComponent: 17,
                  IndeterminateComponent: 2,
                  LazyComponent: 16,
                  LegacyHiddenComponent: 24,
                  MemoComponent: 14,
                  Mode: 8,
                  OffscreenComponent: 23,
                  // Experimental
                  Profiler: 12,
                  ScopeComponent: 21,
                  // Experimental
                  SimpleMemoComponent: 15,
                  SuspenseComponent: 13,
                  SuspenseListComponent: 19,
                  // Experimental
                  YieldComponent: -1
                  // Removed
                };
              } else if (Object(semver2["gte"])(version3, "16.6.0-beta.0")) {
                ReactTypeOfWork = {
                  CacheComponent: -1,
                  // Doesn't exist yet
                  ClassComponent: 1,
                  ContextConsumer: 9,
                  ContextProvider: 10,
                  CoroutineComponent: -1,
                  // Removed
                  CoroutineHandlerPhase: -1,
                  // Removed
                  DehydratedSuspenseComponent: 18,
                  // Behind a flag
                  ForwardRef: 11,
                  Fragment: 7,
                  FunctionComponent: 0,
                  HostComponent: 5,
                  HostPortal: 4,
                  HostRoot: 3,
                  HostText: 6,
                  IncompleteClassComponent: 17,
                  IndeterminateComponent: 2,
                  LazyComponent: 16,
                  LegacyHiddenComponent: -1,
                  MemoComponent: 14,
                  Mode: 8,
                  OffscreenComponent: -1,
                  // Experimental
                  Profiler: 12,
                  ScopeComponent: -1,
                  // Experimental
                  SimpleMemoComponent: 15,
                  SuspenseComponent: 13,
                  SuspenseListComponent: 19,
                  // Experimental
                  YieldComponent: -1
                  // Removed
                };
              } else if (Object(semver2["gte"])(version3, "16.4.3-alpha")) {
                ReactTypeOfWork = {
                  CacheComponent: -1,
                  // Doesn't exist yet
                  ClassComponent: 2,
                  ContextConsumer: 11,
                  ContextProvider: 12,
                  CoroutineComponent: -1,
                  // Removed
                  CoroutineHandlerPhase: -1,
                  // Removed
                  DehydratedSuspenseComponent: -1,
                  // Doesn't exist yet
                  ForwardRef: 13,
                  Fragment: 9,
                  FunctionComponent: 0,
                  HostComponent: 7,
                  HostPortal: 6,
                  HostRoot: 5,
                  HostText: 8,
                  IncompleteClassComponent: -1,
                  // Doesn't exist yet
                  IndeterminateComponent: 4,
                  LazyComponent: -1,
                  // Doesn't exist yet
                  LegacyHiddenComponent: -1,
                  MemoComponent: -1,
                  // Doesn't exist yet
                  Mode: 10,
                  OffscreenComponent: -1,
                  // Experimental
                  Profiler: 15,
                  ScopeComponent: -1,
                  // Experimental
                  SimpleMemoComponent: -1,
                  // Doesn't exist yet
                  SuspenseComponent: 16,
                  SuspenseListComponent: -1,
                  // Doesn't exist yet
                  YieldComponent: -1
                  // Removed
                };
              } else {
                ReactTypeOfWork = {
                  CacheComponent: -1,
                  // Doesn't exist yet
                  ClassComponent: 2,
                  ContextConsumer: 12,
                  ContextProvider: 13,
                  CoroutineComponent: 7,
                  CoroutineHandlerPhase: 8,
                  DehydratedSuspenseComponent: -1,
                  // Doesn't exist yet
                  ForwardRef: 14,
                  Fragment: 10,
                  FunctionComponent: 1,
                  HostComponent: 5,
                  HostPortal: 4,
                  HostRoot: 3,
                  HostText: 6,
                  IncompleteClassComponent: -1,
                  // Doesn't exist yet
                  IndeterminateComponent: 0,
                  LazyComponent: -1,
                  // Doesn't exist yet
                  LegacyHiddenComponent: -1,
                  MemoComponent: -1,
                  // Doesn't exist yet
                  Mode: 11,
                  OffscreenComponent: -1,
                  // Experimental
                  Profiler: 15,
                  ScopeComponent: -1,
                  // Experimental
                  SimpleMemoComponent: -1,
                  // Doesn't exist yet
                  SuspenseComponent: 16,
                  SuspenseListComponent: -1,
                  // Doesn't exist yet
                  YieldComponent: 9
                };
              }
              function getTypeSymbol(type) {
                var symbolOrNumber = renderer_typeof(type) === "object" && type !== null ? type.$$typeof : type;
                return renderer_typeof(symbolOrNumber) === "symbol" ? symbolOrNumber.toString() : symbolOrNumber;
              }
              __name(getTypeSymbol, "getTypeSymbol");
              var _ReactTypeOfWork = ReactTypeOfWork, CacheComponent = _ReactTypeOfWork.CacheComponent, ClassComponent = _ReactTypeOfWork.ClassComponent, IncompleteClassComponent = _ReactTypeOfWork.IncompleteClassComponent, FunctionComponent = _ReactTypeOfWork.FunctionComponent, IndeterminateComponent = _ReactTypeOfWork.IndeterminateComponent, ForwardRef = _ReactTypeOfWork.ForwardRef, HostRoot = _ReactTypeOfWork.HostRoot, HostComponent = _ReactTypeOfWork.HostComponent, HostPortal = _ReactTypeOfWork.HostPortal, HostText = _ReactTypeOfWork.HostText, Fragment = _ReactTypeOfWork.Fragment, LazyComponent = _ReactTypeOfWork.LazyComponent, LegacyHiddenComponent = _ReactTypeOfWork.LegacyHiddenComponent, MemoComponent = _ReactTypeOfWork.MemoComponent, OffscreenComponent = _ReactTypeOfWork.OffscreenComponent, Profiler = _ReactTypeOfWork.Profiler, ScopeComponent = _ReactTypeOfWork.ScopeComponent, SimpleMemoComponent = _ReactTypeOfWork.SimpleMemoComponent, SuspenseComponent = _ReactTypeOfWork.SuspenseComponent, SuspenseListComponent = _ReactTypeOfWork.SuspenseListComponent;
              function resolveFiberType(type) {
                var typeSymbol = getTypeSymbol(type);
                switch (typeSymbol) {
                  case ReactSymbols[
                    "j"
                    /* MEMO_NUMBER */
                  ]:
                  case ReactSymbols[
                    "k"
                    /* MEMO_SYMBOL_STRING */
                  ]:
                    return resolveFiberType(type.type);
                  case ReactSymbols[
                    "f"
                    /* FORWARD_REF_NUMBER */
                  ]:
                  case ReactSymbols[
                    "g"
                    /* FORWARD_REF_SYMBOL_STRING */
                  ]:
                    return type.render;
                  default:
                    return type;
                }
              }
              __name(resolveFiberType, "resolveFiberType");
              function getDisplayNameForFiber(fiber) {
                var elementType = fiber.elementType, type = fiber.type, tag = fiber.tag;
                var resolvedType = type;
                if (renderer_typeof(type) === "object" && type !== null) {
                  resolvedType = resolveFiberType(type);
                }
                var resolvedContext = null;
                switch (tag) {
                  case CacheComponent:
                    return "Cache";
                  case ClassComponent:
                  case IncompleteClassComponent:
                    return Object(utils[
                      "f"
                      /* getDisplayName */
                    ])(resolvedType);
                  case FunctionComponent:
                  case IndeterminateComponent:
                    return Object(utils[
                      "f"
                      /* getDisplayName */
                    ])(resolvedType);
                  case ForwardRef:
                    return type && type.displayName || Object(utils[
                      "f"
                      /* getDisplayName */
                    ])(resolvedType, "Anonymous");
                  case HostRoot:
                    var fiberRoot = fiber.stateNode;
                    if (fiberRoot != null && fiberRoot._debugRootType !== null) {
                      return fiberRoot._debugRootType;
                    }
                    return null;
                  case HostComponent:
                    return type;
                  case HostPortal:
                  case HostText:
                  case Fragment:
                    return null;
                  case LazyComponent:
                    return "Lazy";
                  case MemoComponent:
                  case SimpleMemoComponent:
                    return elementType && elementType.displayName || type && type.displayName || Object(utils[
                      "f"
                      /* getDisplayName */
                    ])(resolvedType, "Anonymous");
                  case SuspenseComponent:
                    return "Suspense";
                  case LegacyHiddenComponent:
                    return "LegacyHidden";
                  case OffscreenComponent:
                    return "Offscreen";
                  case ScopeComponent:
                    return "Scope";
                  case SuspenseListComponent:
                    return "SuspenseList";
                  case Profiler:
                    return "Profiler";
                  default:
                    var typeSymbol = getTypeSymbol(type);
                    switch (typeSymbol) {
                      case ReactSymbols[
                        "a"
                        /* CONCURRENT_MODE_NUMBER */
                      ]:
                      case ReactSymbols[
                        "b"
                        /* CONCURRENT_MODE_SYMBOL_STRING */
                      ]:
                      case ReactSymbols[
                        "e"
                        /* DEPRECATED_ASYNC_MODE_SYMBOL_STRING */
                      ]:
                        return null;
                      case ReactSymbols[
                        "n"
                        /* PROVIDER_NUMBER */
                      ]:
                      case ReactSymbols[
                        "o"
                        /* PROVIDER_SYMBOL_STRING */
                      ]:
                        resolvedContext = fiber.type._context || fiber.type.context;
                        return "".concat(resolvedContext.displayName || "Context", ".Provider");
                      case ReactSymbols[
                        "c"
                        /* CONTEXT_NUMBER */
                      ]:
                      case ReactSymbols[
                        "d"
                        /* CONTEXT_SYMBOL_STRING */
                      ]:
                        resolvedContext = fiber.type._context || fiber.type;
                        return "".concat(resolvedContext.displayName || "Context", ".Consumer");
                      case ReactSymbols[
                        "r"
                        /* STRICT_MODE_NUMBER */
                      ]:
                      case ReactSymbols[
                        "s"
                        /* STRICT_MODE_SYMBOL_STRING */
                      ]:
                        return null;
                      case ReactSymbols[
                        "l"
                        /* PROFILER_NUMBER */
                      ]:
                      case ReactSymbols[
                        "m"
                        /* PROFILER_SYMBOL_STRING */
                      ]:
                        return "Profiler(".concat(fiber.memoizedProps.id, ")");
                      case ReactSymbols[
                        "p"
                        /* SCOPE_NUMBER */
                      ]:
                      case ReactSymbols[
                        "q"
                        /* SCOPE_SYMBOL_STRING */
                      ]:
                        return "Scope";
                      default:
                        return null;
                    }
                }
              }
              __name(getDisplayNameForFiber, "getDisplayNameForFiber");
              return {
                getDisplayNameForFiber,
                getTypeSymbol,
                ReactPriorityLevels,
                ReactTypeOfWork,
                ReactTypeOfSideEffect,
                StrictModeBits
              };
            }
            __name(getInternalReactConstants, "getInternalReactConstants");
            function attach(hook, rendererID, renderer, global2) {
              var version3 = renderer.reconcilerVersion || renderer.version;
              var _getInternalReactCons = getInternalReactConstants(version3), getDisplayNameForFiber = _getInternalReactCons.getDisplayNameForFiber, getTypeSymbol = _getInternalReactCons.getTypeSymbol, ReactPriorityLevels = _getInternalReactCons.ReactPriorityLevels, ReactTypeOfWork = _getInternalReactCons.ReactTypeOfWork, ReactTypeOfSideEffect = _getInternalReactCons.ReactTypeOfSideEffect, StrictModeBits = _getInternalReactCons.StrictModeBits;
              var DidCapture = ReactTypeOfSideEffect.DidCapture, Hydrating = ReactTypeOfSideEffect.Hydrating, NoFlags = ReactTypeOfSideEffect.NoFlags, PerformedWork = ReactTypeOfSideEffect.PerformedWork, Placement = ReactTypeOfSideEffect.Placement;
              var CacheComponent = ReactTypeOfWork.CacheComponent, ClassComponent = ReactTypeOfWork.ClassComponent, ContextConsumer = ReactTypeOfWork.ContextConsumer, DehydratedSuspenseComponent = ReactTypeOfWork.DehydratedSuspenseComponent, ForwardRef = ReactTypeOfWork.ForwardRef, Fragment = ReactTypeOfWork.Fragment, FunctionComponent = ReactTypeOfWork.FunctionComponent, HostRoot = ReactTypeOfWork.HostRoot, HostPortal = ReactTypeOfWork.HostPortal, HostComponent = ReactTypeOfWork.HostComponent, HostText = ReactTypeOfWork.HostText, IncompleteClassComponent = ReactTypeOfWork.IncompleteClassComponent, IndeterminateComponent = ReactTypeOfWork.IndeterminateComponent, LegacyHiddenComponent = ReactTypeOfWork.LegacyHiddenComponent, MemoComponent = ReactTypeOfWork.MemoComponent, OffscreenComponent = ReactTypeOfWork.OffscreenComponent, SimpleMemoComponent = ReactTypeOfWork.SimpleMemoComponent, SuspenseComponent = ReactTypeOfWork.SuspenseComponent, SuspenseListComponent = ReactTypeOfWork.SuspenseListComponent;
              var ImmediatePriority = ReactPriorityLevels.ImmediatePriority, UserBlockingPriority = ReactPriorityLevels.UserBlockingPriority, NormalPriority = ReactPriorityLevels.NormalPriority, LowPriority = ReactPriorityLevels.LowPriority, IdlePriority = ReactPriorityLevels.IdlePriority, NoPriority = ReactPriorityLevels.NoPriority;
              var getLaneLabelMap = renderer.getLaneLabelMap, injectProfilingHooks = renderer.injectProfilingHooks, overrideHookState = renderer.overrideHookState, overrideHookStateDeletePath = renderer.overrideHookStateDeletePath, overrideHookStateRenamePath = renderer.overrideHookStateRenamePath, overrideProps = renderer.overrideProps, overridePropsDeletePath = renderer.overridePropsDeletePath, overridePropsRenamePath = renderer.overridePropsRenamePath, scheduleRefresh = renderer.scheduleRefresh, setErrorHandler = renderer.setErrorHandler, setSuspenseHandler = renderer.setSuspenseHandler, scheduleUpdate = renderer.scheduleUpdate;
              var supportsTogglingError = typeof setErrorHandler === "function" && typeof scheduleUpdate === "function";
              var supportsTogglingSuspense = typeof setSuspenseHandler === "function" && typeof scheduleUpdate === "function";
              if (typeof scheduleRefresh === "function") {
                renderer.scheduleRefresh = function() {
                  try {
                    hook.emit("fastRefreshScheduled");
                  } finally {
                    return scheduleRefresh.apply(void 0, arguments);
                  }
                };
              }
              if (typeof injectProfilingHooks === "function") {
                injectProfilingHooks(createProfilingHooks({
                  getDisplayNameForFiber,
                  getLaneLabelMap,
                  reactVersion: version3
                }));
              }
              var fibersWithChangedErrorOrWarningCounts = /* @__PURE__ */ new Set();
              var pendingFiberToErrorsMap = /* @__PURE__ */ new Map();
              var pendingFiberToWarningsMap = /* @__PURE__ */ new Map();
              var fiberIDToErrorsMap = /* @__PURE__ */ new Map();
              var fiberIDToWarningsMap = /* @__PURE__ */ new Map();
              function clearErrorsAndWarnings() {
                var _iterator = _createForOfIteratorHelper(fiberIDToErrorsMap.keys()), _step;
                try {
                  for (_iterator.s(); !(_step = _iterator.n()).done; ) {
                    var id = _step.value;
                    var _fiber = idToArbitraryFiberMap.get(id);
                    if (_fiber != null) {
                      fibersWithChangedErrorOrWarningCounts.add(_fiber);
                      updateMostRecentlyInspectedElementIfNecessary(id);
                    }
                  }
                } catch (err) {
                  _iterator.e(err);
                } finally {
                  _iterator.f();
                }
                var _iterator2 = _createForOfIteratorHelper(fiberIDToWarningsMap.keys()), _step2;
                try {
                  for (_iterator2.s(); !(_step2 = _iterator2.n()).done; ) {
                    var _id = _step2.value;
                    var _fiber2 = idToArbitraryFiberMap.get(_id);
                    if (_fiber2 != null) {
                      fibersWithChangedErrorOrWarningCounts.add(_fiber2);
                      updateMostRecentlyInspectedElementIfNecessary(_id);
                    }
                  }
                } catch (err) {
                  _iterator2.e(err);
                } finally {
                  _iterator2.f();
                }
                fiberIDToErrorsMap.clear();
                fiberIDToWarningsMap.clear();
                flushPendingEvents();
              }
              __name(clearErrorsAndWarnings, "clearErrorsAndWarnings");
              function clearMessageCountHelper(fiberID, pendingFiberToMessageCountMap, fiberIDToMessageCountMap) {
                var fiber = idToArbitraryFiberMap.get(fiberID);
                if (fiber != null) {
                  pendingFiberToErrorsMap.delete(fiber);
                  if (fiberIDToMessageCountMap.has(fiberID)) {
                    fiberIDToMessageCountMap.delete(fiberID);
                    fibersWithChangedErrorOrWarningCounts.add(fiber);
                    flushPendingEvents();
                    updateMostRecentlyInspectedElementIfNecessary(fiberID);
                  } else {
                    fibersWithChangedErrorOrWarningCounts.delete(fiber);
                  }
                }
              }
              __name(clearMessageCountHelper, "clearMessageCountHelper");
              function clearErrorsForFiberID(fiberID) {
                clearMessageCountHelper(fiberID, pendingFiberToErrorsMap, fiberIDToErrorsMap);
              }
              __name(clearErrorsForFiberID, "clearErrorsForFiberID");
              function clearWarningsForFiberID(fiberID) {
                clearMessageCountHelper(fiberID, pendingFiberToWarningsMap, fiberIDToWarningsMap);
              }
              __name(clearWarningsForFiberID, "clearWarningsForFiberID");
              function updateMostRecentlyInspectedElementIfNecessary(fiberID) {
                if (mostRecentlyInspectedElement !== null && mostRecentlyInspectedElement.id === fiberID) {
                  hasElementUpdatedSinceLastInspected = true;
                }
              }
              __name(updateMostRecentlyInspectedElementIfNecessary, "updateMostRecentlyInspectedElementIfNecessary");
              function onErrorOrWarning(fiber, type, args) {
                if (type === "error") {
                  var maybeID = getFiberIDUnsafe(fiber);
                  if (maybeID != null && forceErrorForFiberIDs.get(maybeID) === true) {
                    return;
                  }
                }
                var message = backend_utils[
                  "f"
                  /* format */
                ].apply(void 0, _toConsumableArray(args));
                if (constants3[
                  "q"
                  /* __DEBUG__ */
                ]) {
                  debug("onErrorOrWarning", fiber, null, "".concat(type, ': "').concat(message, '"'));
                }
                fibersWithChangedErrorOrWarningCounts.add(fiber);
                var fiberMap = type === "error" ? pendingFiberToErrorsMap : pendingFiberToWarningsMap;
                var messageMap = fiberMap.get(fiber);
                if (messageMap != null) {
                  var count = messageMap.get(message) || 0;
                  messageMap.set(message, count + 1);
                } else {
                  fiberMap.set(fiber, /* @__PURE__ */ new Map([[message, 1]]));
                }
                flushPendingErrorsAndWarningsAfterDelay();
              }
              __name(onErrorOrWarning, "onErrorOrWarning");
              if (true) {
                Object(backend_console[
                  "c"
                  /* registerRenderer */
                ])(renderer, onErrorOrWarning);
                var appendComponentStack = window.__REACT_DEVTOOLS_APPEND_COMPONENT_STACK__ !== false;
                var breakOnConsoleErrors = window.__REACT_DEVTOOLS_BREAK_ON_CONSOLE_ERRORS__ === true;
                var showInlineWarningsAndErrors = window.__REACT_DEVTOOLS_SHOW_INLINE_WARNINGS_AND_ERRORS__ !== false;
                var hideConsoleLogsInStrictMode = window.__REACT_DEVTOOLS_HIDE_CONSOLE_LOGS_IN_STRICT_MODE__ === true;
                var browserTheme = window.__REACT_DEVTOOLS_BROWSER_THEME__;
                Object(backend_console[
                  "a"
                  /* patch */
                ])({
                  appendComponentStack,
                  breakOnConsoleErrors,
                  showInlineWarningsAndErrors,
                  hideConsoleLogsInStrictMode,
                  browserTheme
                });
              }
              var debug = /* @__PURE__ */ __name(function debug2(name, fiber, parentFiber) {
                var extraString = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : "";
                if (constants3[
                  "q"
                  /* __DEBUG__ */
                ]) {
                  var displayName = fiber.tag + ":" + (getDisplayNameForFiber(fiber) || "null");
                  var maybeID = getFiberIDUnsafe(fiber) || "<no id>";
                  var parentDisplayName = parentFiber ? parentFiber.tag + ":" + (getDisplayNameForFiber(parentFiber) || "null") : "";
                  var maybeParentID = parentFiber ? getFiberIDUnsafe(parentFiber) || "<no-id>" : "";
                  console.groupCollapsed("[renderer] %c".concat(name, " %c").concat(displayName, " (").concat(maybeID, ") %c").concat(parentFiber ? "".concat(parentDisplayName, " (").concat(maybeParentID, ")") : "", " %c").concat(extraString), "color: red; font-weight: bold;", "color: blue;", "color: purple;", "color: black;");
                  console.log(new Error().stack.split("\n").slice(1).join("\n"));
                  console.groupEnd();
                }
              }, "debug");
              var hideElementsWithDisplayNames = /* @__PURE__ */ new Set();
              var hideElementsWithPaths = /* @__PURE__ */ new Set();
              var hideElementsWithTypes = /* @__PURE__ */ new Set();
              var traceUpdatesEnabled = false;
              var traceUpdatesForNodes = /* @__PURE__ */ new Set();
              function applyComponentFilters(componentFilters) {
                hideElementsWithTypes.clear();
                hideElementsWithDisplayNames.clear();
                hideElementsWithPaths.clear();
                componentFilters.forEach(function(componentFilter) {
                  if (!componentFilter.isEnabled) {
                    return;
                  }
                  switch (componentFilter.type) {
                    case types[
                      "a"
                      /* ComponentFilterDisplayName */
                    ]:
                      if (componentFilter.isValid && componentFilter.value !== "") {
                        hideElementsWithDisplayNames.add(new RegExp(componentFilter.value, "i"));
                      }
                      break;
                    case types[
                      "b"
                      /* ComponentFilterElementType */
                    ]:
                      hideElementsWithTypes.add(componentFilter.value);
                      break;
                    case types[
                      "d"
                      /* ComponentFilterLocation */
                    ]:
                      if (componentFilter.isValid && componentFilter.value !== "") {
                        hideElementsWithPaths.add(new RegExp(componentFilter.value, "i"));
                      }
                      break;
                    case types[
                      "c"
                      /* ComponentFilterHOC */
                    ]:
                      hideElementsWithDisplayNames.add(new RegExp("\\("));
                      break;
                    default:
                      console.warn('Invalid component filter type "'.concat(componentFilter.type, '"'));
                      break;
                  }
                });
              }
              __name(applyComponentFilters, "applyComponentFilters");
              if (window.__REACT_DEVTOOLS_COMPONENT_FILTERS__ != null) {
                applyComponentFilters(window.__REACT_DEVTOOLS_COMPONENT_FILTERS__);
              } else {
                applyComponentFilters(Object(utils[
                  "e"
                  /* getDefaultComponentFilters */
                ])());
              }
              function updateComponentFilters(componentFilters) {
                if (isProfiling) {
                  throw Error("Cannot modify filter preferences while profiling");
                }
                hook.getFiberRoots(rendererID).forEach(function(root) {
                  currentRootID = getOrGenerateFiberID(root.current);
                  pushOperation(constants3[
                    "l"
                    /* TREE_OPERATION_REMOVE_ROOT */
                  ]);
                  flushPendingEvents(root);
                  currentRootID = -1;
                });
                applyComponentFilters(componentFilters);
                rootDisplayNameCounter.clear();
                hook.getFiberRoots(rendererID).forEach(function(root) {
                  currentRootID = getOrGenerateFiberID(root.current);
                  setRootPseudoKey(currentRootID, root.current);
                  mountFiberRecursively(root.current, null, false, false);
                  flushPendingEvents(root);
                  currentRootID = -1;
                });
                reevaluateErrorsAndWarnings();
                flushPendingEvents();
              }
              __name(updateComponentFilters, "updateComponentFilters");
              function shouldFilterFiber(fiber) {
                var _debugSource = fiber._debugSource, tag = fiber.tag, type = fiber.type;
                switch (tag) {
                  case DehydratedSuspenseComponent:
                    return true;
                  case HostPortal:
                  case HostText:
                  case Fragment:
                  case LegacyHiddenComponent:
                  case OffscreenComponent:
                    return true;
                  case HostRoot:
                    return false;
                  default:
                    var typeSymbol = getTypeSymbol(type);
                    switch (typeSymbol) {
                      case ReactSymbols[
                        "a"
                        /* CONCURRENT_MODE_NUMBER */
                      ]:
                      case ReactSymbols[
                        "b"
                        /* CONCURRENT_MODE_SYMBOL_STRING */
                      ]:
                      case ReactSymbols[
                        "e"
                        /* DEPRECATED_ASYNC_MODE_SYMBOL_STRING */
                      ]:
                      case ReactSymbols[
                        "r"
                        /* STRICT_MODE_NUMBER */
                      ]:
                      case ReactSymbols[
                        "s"
                        /* STRICT_MODE_SYMBOL_STRING */
                      ]:
                        return true;
                      default:
                        break;
                    }
                }
                var elementType = getElementTypeForFiber(fiber);
                if (hideElementsWithTypes.has(elementType)) {
                  return true;
                }
                if (hideElementsWithDisplayNames.size > 0) {
                  var displayName = getDisplayNameForFiber(fiber);
                  if (displayName != null) {
                    var _iterator3 = _createForOfIteratorHelper(hideElementsWithDisplayNames), _step3;
                    try {
                      for (_iterator3.s(); !(_step3 = _iterator3.n()).done; ) {
                        var displayNameRegExp = _step3.value;
                        if (displayNameRegExp.test(displayName)) {
                          return true;
                        }
                      }
                    } catch (err) {
                      _iterator3.e(err);
                    } finally {
                      _iterator3.f();
                    }
                  }
                }
                if (_debugSource != null && hideElementsWithPaths.size > 0) {
                  var fileName = _debugSource.fileName;
                  var _iterator4 = _createForOfIteratorHelper(hideElementsWithPaths), _step4;
                  try {
                    for (_iterator4.s(); !(_step4 = _iterator4.n()).done; ) {
                      var pathRegExp = _step4.value;
                      if (pathRegExp.test(fileName)) {
                        return true;
                      }
                    }
                  } catch (err) {
                    _iterator4.e(err);
                  } finally {
                    _iterator4.f();
                  }
                }
                return false;
              }
              __name(shouldFilterFiber, "shouldFilterFiber");
              function getElementTypeForFiber(fiber) {
                var type = fiber.type, tag = fiber.tag;
                switch (tag) {
                  case ClassComponent:
                  case IncompleteClassComponent:
                    return types[
                      "e"
                      /* ElementTypeClass */
                    ];
                  case FunctionComponent:
                  case IndeterminateComponent:
                    return types[
                      "h"
                      /* ElementTypeFunction */
                    ];
                  case ForwardRef:
                    return types[
                      "g"
                      /* ElementTypeForwardRef */
                    ];
                  case HostRoot:
                    return types[
                      "m"
                      /* ElementTypeRoot */
                    ];
                  case HostComponent:
                    return types[
                      "i"
                      /* ElementTypeHostComponent */
                    ];
                  case HostPortal:
                  case HostText:
                  case Fragment:
                    return types[
                      "k"
                      /* ElementTypeOtherOrUnknown */
                    ];
                  case MemoComponent:
                  case SimpleMemoComponent:
                    return types[
                      "j"
                      /* ElementTypeMemo */
                    ];
                  case SuspenseComponent:
                    return types[
                      "n"
                      /* ElementTypeSuspense */
                    ];
                  case SuspenseListComponent:
                    return types[
                      "o"
                      /* ElementTypeSuspenseList */
                    ];
                  default:
                    var typeSymbol = getTypeSymbol(type);
                    switch (typeSymbol) {
                      case ReactSymbols[
                        "a"
                        /* CONCURRENT_MODE_NUMBER */
                      ]:
                      case ReactSymbols[
                        "b"
                        /* CONCURRENT_MODE_SYMBOL_STRING */
                      ]:
                      case ReactSymbols[
                        "e"
                        /* DEPRECATED_ASYNC_MODE_SYMBOL_STRING */
                      ]:
                        return types[
                          "k"
                          /* ElementTypeOtherOrUnknown */
                        ];
                      case ReactSymbols[
                        "n"
                        /* PROVIDER_NUMBER */
                      ]:
                      case ReactSymbols[
                        "o"
                        /* PROVIDER_SYMBOL_STRING */
                      ]:
                        return types[
                          "f"
                          /* ElementTypeContext */
                        ];
                      case ReactSymbols[
                        "c"
                        /* CONTEXT_NUMBER */
                      ]:
                      case ReactSymbols[
                        "d"
                        /* CONTEXT_SYMBOL_STRING */
                      ]:
                        return types[
                          "f"
                          /* ElementTypeContext */
                        ];
                      case ReactSymbols[
                        "r"
                        /* STRICT_MODE_NUMBER */
                      ]:
                      case ReactSymbols[
                        "s"
                        /* STRICT_MODE_SYMBOL_STRING */
                      ]:
                        return types[
                          "k"
                          /* ElementTypeOtherOrUnknown */
                        ];
                      case ReactSymbols[
                        "l"
                        /* PROFILER_NUMBER */
                      ]:
                      case ReactSymbols[
                        "m"
                        /* PROFILER_SYMBOL_STRING */
                      ]:
                        return types[
                          "l"
                          /* ElementTypeProfiler */
                        ];
                      default:
                        return types[
                          "k"
                          /* ElementTypeOtherOrUnknown */
                        ];
                    }
                }
              }
              __name(getElementTypeForFiber, "getElementTypeForFiber");
              var fiberToIDMap = /* @__PURE__ */ new Map();
              var idToArbitraryFiberMap = /* @__PURE__ */ new Map();
              var idToTreeBaseDurationMap = /* @__PURE__ */ new Map();
              var idToRootMap = /* @__PURE__ */ new Map();
              var currentRootID = -1;
              function getOrGenerateFiberID(fiber) {
                var id = null;
                if (fiberToIDMap.has(fiber)) {
                  id = fiberToIDMap.get(fiber);
                } else {
                  var _alternate = fiber.alternate;
                  if (_alternate !== null && fiberToIDMap.has(_alternate)) {
                    id = fiberToIDMap.get(_alternate);
                  }
                }
                var didGenerateID = false;
                if (id === null) {
                  didGenerateID = true;
                  id = Object(utils[
                    "i"
                    /* getUID */
                  ])();
                }
                var refinedID = id;
                if (!fiberToIDMap.has(fiber)) {
                  fiberToIDMap.set(fiber, refinedID);
                  idToArbitraryFiberMap.set(refinedID, fiber);
                }
                var alternate = fiber.alternate;
                if (alternate !== null) {
                  if (!fiberToIDMap.has(alternate)) {
                    fiberToIDMap.set(alternate, refinedID);
                  }
                }
                if (constants3[
                  "q"
                  /* __DEBUG__ */
                ]) {
                  if (didGenerateID) {
                    debug("getOrGenerateFiberID()", fiber, fiber.return, "Generated a new UID");
                  }
                }
                return refinedID;
              }
              __name(getOrGenerateFiberID, "getOrGenerateFiberID");
              function getFiberIDThrows(fiber) {
                var maybeID = getFiberIDUnsafe(fiber);
                if (maybeID !== null) {
                  return maybeID;
                }
                throw Error('Could not find ID for Fiber "'.concat(getDisplayNameForFiber(fiber) || "", '"'));
              }
              __name(getFiberIDThrows, "getFiberIDThrows");
              function getFiberIDUnsafe(fiber) {
                if (fiberToIDMap.has(fiber)) {
                  return fiberToIDMap.get(fiber);
                } else {
                  var alternate = fiber.alternate;
                  if (alternate !== null && fiberToIDMap.has(alternate)) {
                    return fiberToIDMap.get(alternate);
                  }
                }
                return null;
              }
              __name(getFiberIDUnsafe, "getFiberIDUnsafe");
              function untrackFiberID(fiber) {
                if (constants3[
                  "q"
                  /* __DEBUG__ */
                ]) {
                  debug("untrackFiberID()", fiber, fiber.return, "schedule after delay");
                }
                untrackFibersSet.add(fiber);
                var alternate = fiber.alternate;
                if (alternate !== null) {
                  untrackFibersSet.add(alternate);
                }
                if (untrackFibersTimeoutID === null) {
                  untrackFibersTimeoutID = setTimeout(untrackFibers, 1e3);
                }
              }
              __name(untrackFiberID, "untrackFiberID");
              var untrackFibersSet = /* @__PURE__ */ new Set();
              var untrackFibersTimeoutID = null;
              function untrackFibers() {
                if (untrackFibersTimeoutID !== null) {
                  clearTimeout(untrackFibersTimeoutID);
                  untrackFibersTimeoutID = null;
                }
                untrackFibersSet.forEach(function(fiber) {
                  var fiberID = getFiberIDUnsafe(fiber);
                  if (fiberID !== null) {
                    idToArbitraryFiberMap.delete(fiberID);
                    clearErrorsForFiberID(fiberID);
                    clearWarningsForFiberID(fiberID);
                  }
                  fiberToIDMap.delete(fiber);
                  var alternate = fiber.alternate;
                  if (alternate !== null) {
                    fiberToIDMap.delete(alternate);
                  }
                  if (forceErrorForFiberIDs.has(fiberID)) {
                    forceErrorForFiberIDs.delete(fiberID);
                    if (forceErrorForFiberIDs.size === 0 && setErrorHandler != null) {
                      setErrorHandler(shouldErrorFiberAlwaysNull);
                    }
                  }
                });
                untrackFibersSet.clear();
              }
              __name(untrackFibers, "untrackFibers");
              function getChangeDescription(prevFiber, nextFiber) {
                switch (getElementTypeForFiber(nextFiber)) {
                  case types[
                    "e"
                    /* ElementTypeClass */
                  ]:
                  case types[
                    "h"
                    /* ElementTypeFunction */
                  ]:
                  case types[
                    "j"
                    /* ElementTypeMemo */
                  ]:
                  case types[
                    "g"
                    /* ElementTypeForwardRef */
                  ]:
                    if (prevFiber === null) {
                      return {
                        context: null,
                        didHooksChange: false,
                        isFirstMount: true,
                        props: null,
                        state: null
                      };
                    } else {
                      var data = {
                        context: getContextChangedKeys(nextFiber),
                        didHooksChange: false,
                        isFirstMount: false,
                        props: getChangedKeys(prevFiber.memoizedProps, nextFiber.memoizedProps),
                        state: getChangedKeys(prevFiber.memoizedState, nextFiber.memoizedState)
                      };
                      if (DevToolsFeatureFlags_core_oss[
                        "b"
                        /* enableProfilerChangedHookIndices */
                      ]) {
                        var indices = getChangedHooksIndices(prevFiber.memoizedState, nextFiber.memoizedState);
                        data.hooks = indices;
                        data.didHooksChange = indices !== null && indices.length > 0;
                      } else {
                        data.didHooksChange = didHooksChange(prevFiber.memoizedState, nextFiber.memoizedState);
                      }
                      return data;
                    }
                  default:
                    return null;
                }
              }
              __name(getChangeDescription, "getChangeDescription");
              function updateContextsForFiber(fiber) {
                switch (getElementTypeForFiber(fiber)) {
                  case types[
                    "e"
                    /* ElementTypeClass */
                  ]:
                  case types[
                    "g"
                    /* ElementTypeForwardRef */
                  ]:
                  case types[
                    "h"
                    /* ElementTypeFunction */
                  ]:
                  case types[
                    "j"
                    /* ElementTypeMemo */
                  ]:
                    if (idToContextsMap !== null) {
                      var id = getFiberIDThrows(fiber);
                      var contexts = getContextsForFiber(fiber);
                      if (contexts !== null) {
                        idToContextsMap.set(id, contexts);
                      }
                    }
                    break;
                  default:
                    break;
                }
              }
              __name(updateContextsForFiber, "updateContextsForFiber");
              var NO_CONTEXT = {};
              function getContextsForFiber(fiber) {
                var legacyContext = NO_CONTEXT;
                var modernContext = NO_CONTEXT;
                switch (getElementTypeForFiber(fiber)) {
                  case types[
                    "e"
                    /* ElementTypeClass */
                  ]:
                    var instance = fiber.stateNode;
                    if (instance != null) {
                      if (instance.constructor && instance.constructor.contextType != null) {
                        modernContext = instance.context;
                      } else {
                        legacyContext = instance.context;
                        if (legacyContext && Object.keys(legacyContext).length === 0) {
                          legacyContext = NO_CONTEXT;
                        }
                      }
                    }
                    return [legacyContext, modernContext];
                  case types[
                    "g"
                    /* ElementTypeForwardRef */
                  ]:
                  case types[
                    "h"
                    /* ElementTypeFunction */
                  ]:
                  case types[
                    "j"
                    /* ElementTypeMemo */
                  ]:
                    var dependencies = fiber.dependencies;
                    if (dependencies && dependencies.firstContext) {
                      modernContext = dependencies.firstContext;
                    }
                    return [legacyContext, modernContext];
                  default:
                    return null;
                }
              }
              __name(getContextsForFiber, "getContextsForFiber");
              function crawlToInitializeContextsMap(fiber) {
                var id = getFiberIDUnsafe(fiber);
                if (id !== null) {
                  updateContextsForFiber(fiber);
                  var current = fiber.child;
                  while (current !== null) {
                    crawlToInitializeContextsMap(current);
                    current = current.sibling;
                  }
                }
              }
              __name(crawlToInitializeContextsMap, "crawlToInitializeContextsMap");
              function getContextChangedKeys(fiber) {
                if (idToContextsMap !== null) {
                  var id = getFiberIDThrows(fiber);
                  var prevContexts = idToContextsMap.has(id) ? idToContextsMap.get(id) : null;
                  var nextContexts = getContextsForFiber(fiber);
                  if (prevContexts == null || nextContexts == null) {
                    return null;
                  }
                  var _prevContexts = renderer_slicedToArray(prevContexts, 2), prevLegacyContext = _prevContexts[0], prevModernContext = _prevContexts[1];
                  var _nextContexts = renderer_slicedToArray(nextContexts, 2), nextLegacyContext = _nextContexts[0], nextModernContext = _nextContexts[1];
                  switch (getElementTypeForFiber(fiber)) {
                    case types[
                      "e"
                      /* ElementTypeClass */
                    ]:
                      if (prevContexts && nextContexts) {
                        if (nextLegacyContext !== NO_CONTEXT) {
                          return getChangedKeys(prevLegacyContext, nextLegacyContext);
                        } else if (nextModernContext !== NO_CONTEXT) {
                          return prevModernContext !== nextModernContext;
                        }
                      }
                      break;
                    case types[
                      "g"
                      /* ElementTypeForwardRef */
                    ]:
                    case types[
                      "h"
                      /* ElementTypeFunction */
                    ]:
                    case types[
                      "j"
                      /* ElementTypeMemo */
                    ]:
                      if (nextModernContext !== NO_CONTEXT) {
                        var prevContext = prevModernContext;
                        var nextContext = nextModernContext;
                        while (prevContext && nextContext) {
                          if (!shared_objectIs(prevContext.memoizedValue, nextContext.memoizedValue)) {
                            return true;
                          }
                          prevContext = prevContext.next;
                          nextContext = nextContext.next;
                        }
                        return false;
                      }
                      break;
                    default:
                      break;
                  }
                }
                return null;
              }
              __name(getContextChangedKeys, "getContextChangedKeys");
              function areHookInputsEqual(nextDeps, prevDeps) {
                if (prevDeps === null) {
                  return false;
                }
                for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
                  if (shared_objectIs(nextDeps[i], prevDeps[i])) {
                    continue;
                  }
                  return false;
                }
                return true;
              }
              __name(areHookInputsEqual, "areHookInputsEqual");
              function isEffect(memoizedState) {
                if (memoizedState === null || renderer_typeof(memoizedState) !== "object") {
                  return false;
                }
                var deps = memoizedState.deps;
                var boundHasOwnProperty = shared_hasOwnProperty.bind(memoizedState);
                return boundHasOwnProperty("create") && boundHasOwnProperty("destroy") && boundHasOwnProperty("deps") && boundHasOwnProperty("next") && boundHasOwnProperty("tag") && (deps === null || Object(isArray[
                  "a"
                  /* default */
                ])(deps));
              }
              __name(isEffect, "isEffect");
              function didHookChange(prev, next) {
                var prevMemoizedState = prev.memoizedState;
                var nextMemoizedState = next.memoizedState;
                if (isEffect(prevMemoizedState) && isEffect(nextMemoizedState)) {
                  return prevMemoizedState !== nextMemoizedState && !areHookInputsEqual(nextMemoizedState.deps, prevMemoizedState.deps);
                }
                return nextMemoizedState !== prevMemoizedState;
              }
              __name(didHookChange, "didHookChange");
              function didHooksChange(prev, next) {
                if (prev == null || next == null) {
                  return false;
                }
                if (next.hasOwnProperty("baseState") && next.hasOwnProperty("memoizedState") && next.hasOwnProperty("next") && next.hasOwnProperty("queue")) {
                  while (next !== null) {
                    if (didHookChange(prev, next)) {
                      return true;
                    } else {
                      next = next.next;
                      prev = prev.next;
                    }
                  }
                }
                return false;
              }
              __name(didHooksChange, "didHooksChange");
              function getChangedHooksIndices(prev, next) {
                if (DevToolsFeatureFlags_core_oss[
                  "b"
                  /* enableProfilerChangedHookIndices */
                ]) {
                  if (prev == null || next == null) {
                    return null;
                  }
                  var indices = [];
                  var index = 0;
                  if (next.hasOwnProperty("baseState") && next.hasOwnProperty("memoizedState") && next.hasOwnProperty("next") && next.hasOwnProperty("queue")) {
                    while (next !== null) {
                      if (didHookChange(prev, next)) {
                        indices.push(index);
                      }
                      next = next.next;
                      prev = prev.next;
                      index++;
                    }
                  }
                  return indices;
                }
                return null;
              }
              __name(getChangedHooksIndices, "getChangedHooksIndices");
              function getChangedKeys(prev, next) {
                if (prev == null || next == null) {
                  return null;
                }
                if (next.hasOwnProperty("baseState") && next.hasOwnProperty("memoizedState") && next.hasOwnProperty("next") && next.hasOwnProperty("queue")) {
                  return null;
                }
                var keys = new Set([].concat(_toConsumableArray(Object.keys(prev)), _toConsumableArray(Object.keys(next))));
                var changedKeys = [];
                var _iterator5 = _createForOfIteratorHelper(keys), _step5;
                try {
                  for (_iterator5.s(); !(_step5 = _iterator5.n()).done; ) {
                    var key = _step5.value;
                    if (prev[key] !== next[key]) {
                      changedKeys.push(key);
                    }
                  }
                } catch (err) {
                  _iterator5.e(err);
                } finally {
                  _iterator5.f();
                }
                return changedKeys;
              }
              __name(getChangedKeys, "getChangedKeys");
              function didFiberRender(prevFiber, nextFiber) {
                switch (nextFiber.tag) {
                  case ClassComponent:
                  case FunctionComponent:
                  case ContextConsumer:
                  case MemoComponent:
                  case SimpleMemoComponent:
                    return (getFiberFlags(nextFiber) & PerformedWork) === PerformedWork;
                  default:
                    return prevFiber.memoizedProps !== nextFiber.memoizedProps || prevFiber.memoizedState !== nextFiber.memoizedState || prevFiber.ref !== nextFiber.ref;
                }
              }
              __name(didFiberRender, "didFiberRender");
              var pendingOperations = [];
              var pendingRealUnmountedIDs = [];
              var pendingSimulatedUnmountedIDs = [];
              var pendingOperationsQueue = [];
              var pendingStringTable = /* @__PURE__ */ new Map();
              var pendingStringTableLength = 0;
              var pendingUnmountedRootID = null;
              function pushOperation(op) {
                if (false) {
                }
                pendingOperations.push(op);
              }
              __name(pushOperation, "pushOperation");
              function flushOrQueueOperations(operations) {
                if (operations.length === 3) {
                  if (!isProfiling || currentCommitProfilingMetadata == null || currentCommitProfilingMetadata.durations.length === 0) {
                    return;
                  }
                }
                if (pendingOperationsQueue !== null) {
                  pendingOperationsQueue.push(operations);
                } else {
                  hook.emit("operations", operations);
                }
              }
              __name(flushOrQueueOperations, "flushOrQueueOperations");
              var flushPendingErrorsAndWarningsAfterDelayTimeoutID = null;
              function clearPendingErrorsAndWarningsAfterDelay() {
                if (flushPendingErrorsAndWarningsAfterDelayTimeoutID !== null) {
                  clearTimeout(flushPendingErrorsAndWarningsAfterDelayTimeoutID);
                  flushPendingErrorsAndWarningsAfterDelayTimeoutID = null;
                }
              }
              __name(clearPendingErrorsAndWarningsAfterDelay, "clearPendingErrorsAndWarningsAfterDelay");
              function flushPendingErrorsAndWarningsAfterDelay() {
                clearPendingErrorsAndWarningsAfterDelay();
                flushPendingErrorsAndWarningsAfterDelayTimeoutID = setTimeout(function() {
                  flushPendingErrorsAndWarningsAfterDelayTimeoutID = null;
                  if (pendingOperations.length > 0) {
                    return;
                  }
                  recordPendingErrorsAndWarnings();
                  if (pendingOperations.length === 0) {
                    return;
                  }
                  var operations = new Array(3 + pendingOperations.length);
                  operations[0] = rendererID;
                  operations[1] = currentRootID;
                  operations[2] = 0;
                  for (var j2 = 0; j2 < pendingOperations.length; j2++) {
                    operations[3 + j2] = pendingOperations[j2];
                  }
                  flushOrQueueOperations(operations);
                  pendingOperations.length = 0;
                }, 1e3);
              }
              __name(flushPendingErrorsAndWarningsAfterDelay, "flushPendingErrorsAndWarningsAfterDelay");
              function reevaluateErrorsAndWarnings() {
                fibersWithChangedErrorOrWarningCounts.clear();
                fiberIDToErrorsMap.forEach(function(countMap, fiberID) {
                  var fiber = idToArbitraryFiberMap.get(fiberID);
                  if (fiber != null) {
                    fibersWithChangedErrorOrWarningCounts.add(fiber);
                  }
                });
                fiberIDToWarningsMap.forEach(function(countMap, fiberID) {
                  var fiber = idToArbitraryFiberMap.get(fiberID);
                  if (fiber != null) {
                    fibersWithChangedErrorOrWarningCounts.add(fiber);
                  }
                });
                recordPendingErrorsAndWarnings();
              }
              __name(reevaluateErrorsAndWarnings, "reevaluateErrorsAndWarnings");
              function mergeMapsAndGetCountHelper(fiber, fiberID, pendingFiberToMessageCountMap, fiberIDToMessageCountMap) {
                var newCount = 0;
                var messageCountMap = fiberIDToMessageCountMap.get(fiberID);
                var pendingMessageCountMap = pendingFiberToMessageCountMap.get(fiber);
                if (pendingMessageCountMap != null) {
                  if (messageCountMap == null) {
                    messageCountMap = pendingMessageCountMap;
                    fiberIDToMessageCountMap.set(fiberID, pendingMessageCountMap);
                  } else {
                    var refinedMessageCountMap = messageCountMap;
                    pendingMessageCountMap.forEach(function(pendingCount, message) {
                      var previousCount = refinedMessageCountMap.get(message) || 0;
                      refinedMessageCountMap.set(message, previousCount + pendingCount);
                    });
                  }
                }
                if (!shouldFilterFiber(fiber)) {
                  if (messageCountMap != null) {
                    messageCountMap.forEach(function(count) {
                      newCount += count;
                    });
                  }
                }
                pendingFiberToMessageCountMap.delete(fiber);
                return newCount;
              }
              __name(mergeMapsAndGetCountHelper, "mergeMapsAndGetCountHelper");
              function recordPendingErrorsAndWarnings() {
                clearPendingErrorsAndWarningsAfterDelay();
                fibersWithChangedErrorOrWarningCounts.forEach(function(fiber) {
                  var fiberID = getFiberIDUnsafe(fiber);
                  if (fiberID === null) {
                  } else {
                    var errorCount = mergeMapsAndGetCountHelper(fiber, fiberID, pendingFiberToErrorsMap, fiberIDToErrorsMap);
                    var warningCount = mergeMapsAndGetCountHelper(fiber, fiberID, pendingFiberToWarningsMap, fiberIDToWarningsMap);
                    pushOperation(constants3[
                      "o"
                      /* TREE_OPERATION_UPDATE_ERRORS_OR_WARNINGS */
                    ]);
                    pushOperation(fiberID);
                    pushOperation(errorCount);
                    pushOperation(warningCount);
                  }
                  pendingFiberToErrorsMap.delete(fiber);
                  pendingFiberToWarningsMap.delete(fiber);
                });
                fibersWithChangedErrorOrWarningCounts.clear();
              }
              __name(recordPendingErrorsAndWarnings, "recordPendingErrorsAndWarnings");
              function flushPendingEvents(root) {
                recordPendingErrorsAndWarnings();
                if (pendingOperations.length === 0 && pendingRealUnmountedIDs.length === 0 && pendingSimulatedUnmountedIDs.length === 0 && pendingUnmountedRootID === null) {
                  if (!isProfiling) {
                    return;
                  }
                }
                var numUnmountIDs = pendingRealUnmountedIDs.length + pendingSimulatedUnmountedIDs.length + (pendingUnmountedRootID === null ? 0 : 1);
                var operations = new Array(
                  // Identify which renderer this update is coming from.
                  2 + // [rendererID, rootFiberID]
                  // How big is the string table?
                  1 + // [stringTableLength]
                  // Then goes the actual string table.
                  pendingStringTableLength + // All unmounts are batched in a single message.
                  // [TREE_OPERATION_REMOVE, removedIDLength, ...ids]
                  (numUnmountIDs > 0 ? 2 + numUnmountIDs : 0) + // Regular operations
                  pendingOperations.length
                );
                var i = 0;
                operations[i++] = rendererID;
                operations[i++] = currentRootID;
                operations[i++] = pendingStringTableLength;
                pendingStringTable.forEach(function(entry, stringKey) {
                  var encodedString = entry.encodedString;
                  var length = encodedString.length;
                  operations[i++] = length;
                  for (var j3 = 0; j3 < length; j3++) {
                    operations[i + j3] = encodedString[j3];
                  }
                  i += length;
                });
                if (numUnmountIDs > 0) {
                  operations[i++] = constants3[
                    "k"
                    /* TREE_OPERATION_REMOVE */
                  ];
                  operations[i++] = numUnmountIDs;
                  for (var j2 = pendingRealUnmountedIDs.length - 1; j2 >= 0; j2--) {
                    operations[i++] = pendingRealUnmountedIDs[j2];
                  }
                  for (var _j = 0; _j < pendingSimulatedUnmountedIDs.length; _j++) {
                    operations[i + _j] = pendingSimulatedUnmountedIDs[_j];
                  }
                  i += pendingSimulatedUnmountedIDs.length;
                  if (pendingUnmountedRootID !== null) {
                    operations[i] = pendingUnmountedRootID;
                    i++;
                  }
                }
                for (var _j2 = 0; _j2 < pendingOperations.length; _j2++) {
                  operations[i + _j2] = pendingOperations[_j2];
                }
                i += pendingOperations.length;
                flushOrQueueOperations(operations);
                pendingOperations.length = 0;
                pendingRealUnmountedIDs.length = 0;
                pendingSimulatedUnmountedIDs.length = 0;
                pendingUnmountedRootID = null;
                pendingStringTable.clear();
                pendingStringTableLength = 0;
              }
              __name(flushPendingEvents, "flushPendingEvents");
              function getStringID(string) {
                if (string === null) {
                  return 0;
                }
                var existingEntry = pendingStringTable.get(string);
                if (existingEntry !== void 0) {
                  return existingEntry.id;
                }
                var id = pendingStringTable.size + 1;
                var encodedString = Object(utils[
                  "m"
                  /* utfEncodeString */
                ])(string);
                pendingStringTable.set(string, {
                  encodedString,
                  id
                });
                pendingStringTableLength += encodedString.length + 1;
                return id;
              }
              __name(getStringID, "getStringID");
              function recordMount(fiber, parentFiber) {
                var isRoot = fiber.tag === HostRoot;
                var id = getOrGenerateFiberID(fiber);
                if (constants3[
                  "q"
                  /* __DEBUG__ */
                ]) {
                  debug("recordMount()", fiber, parentFiber);
                }
                var hasOwnerMetadata = fiber.hasOwnProperty("_debugOwner");
                var isProfilingSupported = fiber.hasOwnProperty("treeBaseDuration");
                if (isRoot) {
                  pushOperation(constants3[
                    "j"
                    /* TREE_OPERATION_ADD */
                  ]);
                  pushOperation(id);
                  pushOperation(types[
                    "m"
                    /* ElementTypeRoot */
                  ]);
                  pushOperation((fiber.mode & StrictModeBits) !== 0 ? 1 : 0);
                  pushOperation(isProfilingSupported ? 1 : 0);
                  pushOperation(StrictModeBits !== 0 ? 1 : 0);
                  pushOperation(hasOwnerMetadata ? 1 : 0);
                  if (isProfiling) {
                    if (displayNamesByRootID !== null) {
                      displayNamesByRootID.set(id, getDisplayNameForRoot(fiber));
                    }
                  }
                } else {
                  var key = fiber.key;
                  var displayName = getDisplayNameForFiber(fiber);
                  var elementType = getElementTypeForFiber(fiber);
                  var _debugOwner = fiber._debugOwner;
                  var ownerID = _debugOwner != null ? getOrGenerateFiberID(_debugOwner) : 0;
                  var parentID = parentFiber ? getFiberIDThrows(parentFiber) : 0;
                  var displayNameStringID = getStringID(displayName);
                  var keyString = key === null ? null : String(key);
                  var keyStringID = getStringID(keyString);
                  pushOperation(constants3[
                    "j"
                    /* TREE_OPERATION_ADD */
                  ]);
                  pushOperation(id);
                  pushOperation(elementType);
                  pushOperation(parentID);
                  pushOperation(ownerID);
                  pushOperation(displayNameStringID);
                  pushOperation(keyStringID);
                  if ((fiber.mode & StrictModeBits) !== 0 && (parentFiber.mode & StrictModeBits) === 0) {
                    pushOperation(constants3[
                      "n"
                      /* TREE_OPERATION_SET_SUBTREE_MODE */
                    ]);
                    pushOperation(id);
                    pushOperation(types[
                      "p"
                      /* StrictMode */
                    ]);
                  }
                }
                if (isProfilingSupported) {
                  idToRootMap.set(id, currentRootID);
                  recordProfilingDurations(fiber);
                }
              }
              __name(recordMount, "recordMount");
              function recordUnmount(fiber, isSimulated) {
                if (constants3[
                  "q"
                  /* __DEBUG__ */
                ]) {
                  debug("recordUnmount()", fiber, null, isSimulated ? "unmount is simulated" : "");
                }
                if (trackedPathMatchFiber !== null) {
                  if (fiber === trackedPathMatchFiber || fiber === trackedPathMatchFiber.alternate) {
                    setTrackedPath(null);
                  }
                }
                var unsafeID = getFiberIDUnsafe(fiber);
                if (unsafeID === null) {
                  return;
                }
                var id = unsafeID;
                var isRoot = fiber.tag === HostRoot;
                if (isRoot) {
                  pendingUnmountedRootID = id;
                } else if (!shouldFilterFiber(fiber)) {
                  if (isSimulated) {
                    pendingSimulatedUnmountedIDs.push(id);
                  } else {
                    pendingRealUnmountedIDs.push(id);
                  }
                }
                if (!fiber._debugNeedsRemount) {
                  untrackFiberID(fiber);
                  var isProfilingSupported = fiber.hasOwnProperty("treeBaseDuration");
                  if (isProfilingSupported) {
                    idToRootMap.delete(id);
                    idToTreeBaseDurationMap.delete(id);
                  }
                }
              }
              __name(recordUnmount, "recordUnmount");
              function mountFiberRecursively(firstChild, parentFiber, traverseSiblings, traceNearestHostComponentUpdate) {
                var fiber = firstChild;
                while (fiber !== null) {
                  getOrGenerateFiberID(fiber);
                  if (constants3[
                    "q"
                    /* __DEBUG__ */
                  ]) {
                    debug("mountFiberRecursively()", fiber, parentFiber);
                  }
                  var mightSiblingsBeOnTrackedPath = updateTrackedPathStateBeforeMount(fiber);
                  var shouldIncludeInTree = !shouldFilterFiber(fiber);
                  if (shouldIncludeInTree) {
                    recordMount(fiber, parentFiber);
                  }
                  if (traceUpdatesEnabled) {
                    if (traceNearestHostComponentUpdate) {
                      var elementType = getElementTypeForFiber(fiber);
                      if (elementType === types[
                        "i"
                        /* ElementTypeHostComponent */
                      ]) {
                        traceUpdatesForNodes.add(fiber.stateNode);
                        traceNearestHostComponentUpdate = false;
                      }
                    }
                  }
                  var isSuspense = fiber.tag === ReactTypeOfWork.SuspenseComponent;
                  if (isSuspense) {
                    var isTimedOut = fiber.memoizedState !== null;
                    if (isTimedOut) {
                      var primaryChildFragment = fiber.child;
                      var fallbackChildFragment = primaryChildFragment ? primaryChildFragment.sibling : null;
                      var fallbackChild = fallbackChildFragment ? fallbackChildFragment.child : null;
                      if (fallbackChild !== null) {
                        mountFiberRecursively(fallbackChild, shouldIncludeInTree ? fiber : parentFiber, true, traceNearestHostComponentUpdate);
                      }
                    } else {
                      var primaryChild = null;
                      var areSuspenseChildrenConditionallyWrapped = OffscreenComponent === -1;
                      if (areSuspenseChildrenConditionallyWrapped) {
                        primaryChild = fiber.child;
                      } else if (fiber.child !== null) {
                        primaryChild = fiber.child.child;
                      }
                      if (primaryChild !== null) {
                        mountFiberRecursively(primaryChild, shouldIncludeInTree ? fiber : parentFiber, true, traceNearestHostComponentUpdate);
                      }
                    }
                  } else {
                    if (fiber.child !== null) {
                      mountFiberRecursively(fiber.child, shouldIncludeInTree ? fiber : parentFiber, true, traceNearestHostComponentUpdate);
                    }
                  }
                  updateTrackedPathStateAfterMount(mightSiblingsBeOnTrackedPath);
                  fiber = traverseSiblings ? fiber.sibling : null;
                }
              }
              __name(mountFiberRecursively, "mountFiberRecursively");
              function unmountFiberChildrenRecursively(fiber) {
                if (constants3[
                  "q"
                  /* __DEBUG__ */
                ]) {
                  debug("unmountFiberChildrenRecursively()", fiber);
                }
                var isTimedOutSuspense = fiber.tag === ReactTypeOfWork.SuspenseComponent && fiber.memoizedState !== null;
                var child = fiber.child;
                if (isTimedOutSuspense) {
                  var primaryChildFragment = fiber.child;
                  var fallbackChildFragment = primaryChildFragment ? primaryChildFragment.sibling : null;
                  child = fallbackChildFragment ? fallbackChildFragment.child : null;
                }
                while (child !== null) {
                  if (child.return !== null) {
                    unmountFiberChildrenRecursively(child);
                    recordUnmount(child, true);
                  }
                  child = child.sibling;
                }
              }
              __name(unmountFiberChildrenRecursively, "unmountFiberChildrenRecursively");
              function recordProfilingDurations(fiber) {
                var id = getFiberIDThrows(fiber);
                var actualDuration = fiber.actualDuration, treeBaseDuration = fiber.treeBaseDuration;
                idToTreeBaseDurationMap.set(id, treeBaseDuration || 0);
                if (isProfiling) {
                  var alternate = fiber.alternate;
                  if (alternate == null || treeBaseDuration !== alternate.treeBaseDuration) {
                    var convertedTreeBaseDuration = Math.floor((treeBaseDuration || 0) * 1e3);
                    pushOperation(constants3[
                      "p"
                      /* TREE_OPERATION_UPDATE_TREE_BASE_DURATION */
                    ]);
                    pushOperation(id);
                    pushOperation(convertedTreeBaseDuration);
                  }
                  if (alternate == null || didFiberRender(alternate, fiber)) {
                    if (actualDuration != null) {
                      var selfDuration = actualDuration;
                      var child = fiber.child;
                      while (child !== null) {
                        selfDuration -= child.actualDuration || 0;
                        child = child.sibling;
                      }
                      var metadata = currentCommitProfilingMetadata;
                      metadata.durations.push(id, actualDuration, selfDuration);
                      metadata.maxActualDuration = Math.max(metadata.maxActualDuration, actualDuration);
                      if (recordChangeDescriptions) {
                        var changeDescription = getChangeDescription(alternate, fiber);
                        if (changeDescription !== null) {
                          if (metadata.changeDescriptions !== null) {
                            metadata.changeDescriptions.set(id, changeDescription);
                          }
                        }
                        updateContextsForFiber(fiber);
                      }
                    }
                  }
                }
              }
              __name(recordProfilingDurations, "recordProfilingDurations");
              function recordResetChildren(fiber, childSet) {
                if (constants3[
                  "q"
                  /* __DEBUG__ */
                ]) {
                  debug("recordResetChildren()", childSet, fiber);
                }
                var nextChildren = [];
                var child = childSet;
                while (child !== null) {
                  findReorderedChildrenRecursively(child, nextChildren);
                  child = child.sibling;
                }
                var numChildren = nextChildren.length;
                if (numChildren < 2) {
                  return;
                }
                pushOperation(constants3[
                  "m"
                  /* TREE_OPERATION_REORDER_CHILDREN */
                ]);
                pushOperation(getFiberIDThrows(fiber));
                pushOperation(numChildren);
                for (var i = 0; i < nextChildren.length; i++) {
                  pushOperation(nextChildren[i]);
                }
              }
              __name(recordResetChildren, "recordResetChildren");
              function findReorderedChildrenRecursively(fiber, nextChildren) {
                if (!shouldFilterFiber(fiber)) {
                  nextChildren.push(getFiberIDThrows(fiber));
                } else {
                  var child = fiber.child;
                  var isTimedOutSuspense = fiber.tag === SuspenseComponent && fiber.memoizedState !== null;
                  if (isTimedOutSuspense) {
                    var primaryChildFragment = fiber.child;
                    var fallbackChildFragment = primaryChildFragment ? primaryChildFragment.sibling : null;
                    var fallbackChild = fallbackChildFragment ? fallbackChildFragment.child : null;
                    if (fallbackChild !== null) {
                      child = fallbackChild;
                    }
                  }
                  while (child !== null) {
                    findReorderedChildrenRecursively(child, nextChildren);
                    child = child.sibling;
                  }
                }
              }
              __name(findReorderedChildrenRecursively, "findReorderedChildrenRecursively");
              function updateFiberRecursively(nextFiber, prevFiber, parentFiber, traceNearestHostComponentUpdate) {
                var id = getOrGenerateFiberID(nextFiber);
                if (constants3[
                  "q"
                  /* __DEBUG__ */
                ]) {
                  debug("updateFiberRecursively()", nextFiber, parentFiber);
                }
                if (traceUpdatesEnabled) {
                  var elementType = getElementTypeForFiber(nextFiber);
                  if (traceNearestHostComponentUpdate) {
                    if (elementType === types[
                      "i"
                      /* ElementTypeHostComponent */
                    ]) {
                      traceUpdatesForNodes.add(nextFiber.stateNode);
                      traceNearestHostComponentUpdate = false;
                    }
                  } else {
                    if (elementType === types[
                      "h"
                      /* ElementTypeFunction */
                    ] || elementType === types[
                      "e"
                      /* ElementTypeClass */
                    ] || elementType === types[
                      "f"
                      /* ElementTypeContext */
                    ] || elementType === types[
                      "j"
                      /* ElementTypeMemo */
                    ] || elementType === types[
                      "g"
                      /* ElementTypeForwardRef */
                    ]) {
                      traceNearestHostComponentUpdate = didFiberRender(prevFiber, nextFiber);
                    }
                  }
                }
                if (mostRecentlyInspectedElement !== null && mostRecentlyInspectedElement.id === id && didFiberRender(prevFiber, nextFiber)) {
                  hasElementUpdatedSinceLastInspected = true;
                }
                var shouldIncludeInTree = !shouldFilterFiber(nextFiber);
                var isSuspense = nextFiber.tag === SuspenseComponent;
                var shouldResetChildren = false;
                var prevDidTimeout = isSuspense && prevFiber.memoizedState !== null;
                var nextDidTimeOut = isSuspense && nextFiber.memoizedState !== null;
                if (prevDidTimeout && nextDidTimeOut) {
                  var nextFiberChild = nextFiber.child;
                  var nextFallbackChildSet = nextFiberChild ? nextFiberChild.sibling : null;
                  var prevFiberChild = prevFiber.child;
                  var prevFallbackChildSet = prevFiberChild ? prevFiberChild.sibling : null;
                  if (nextFallbackChildSet != null && prevFallbackChildSet != null && updateFiberRecursively(nextFallbackChildSet, prevFallbackChildSet, nextFiber, traceNearestHostComponentUpdate)) {
                    shouldResetChildren = true;
                  }
                } else if (prevDidTimeout && !nextDidTimeOut) {
                  var nextPrimaryChildSet = nextFiber.child;
                  if (nextPrimaryChildSet !== null) {
                    mountFiberRecursively(nextPrimaryChildSet, shouldIncludeInTree ? nextFiber : parentFiber, true, traceNearestHostComponentUpdate);
                  }
                  shouldResetChildren = true;
                } else if (!prevDidTimeout && nextDidTimeOut) {
                  unmountFiberChildrenRecursively(prevFiber);
                  var _nextFiberChild = nextFiber.child;
                  var _nextFallbackChildSet = _nextFiberChild ? _nextFiberChild.sibling : null;
                  if (_nextFallbackChildSet != null) {
                    mountFiberRecursively(_nextFallbackChildSet, shouldIncludeInTree ? nextFiber : parentFiber, true, traceNearestHostComponentUpdate);
                    shouldResetChildren = true;
                  }
                } else {
                  if (nextFiber.child !== prevFiber.child) {
                    var nextChild = nextFiber.child;
                    var prevChildAtSameIndex = prevFiber.child;
                    while (nextChild) {
                      if (nextChild.alternate) {
                        var prevChild = nextChild.alternate;
                        if (updateFiberRecursively(nextChild, prevChild, shouldIncludeInTree ? nextFiber : parentFiber, traceNearestHostComponentUpdate)) {
                          shouldResetChildren = true;
                        }
                        if (prevChild !== prevChildAtSameIndex) {
                          shouldResetChildren = true;
                        }
                      } else {
                        mountFiberRecursively(nextChild, shouldIncludeInTree ? nextFiber : parentFiber, false, traceNearestHostComponentUpdate);
                        shouldResetChildren = true;
                      }
                      nextChild = nextChild.sibling;
                      if (!shouldResetChildren && prevChildAtSameIndex !== null) {
                        prevChildAtSameIndex = prevChildAtSameIndex.sibling;
                      }
                    }
                    if (prevChildAtSameIndex !== null) {
                      shouldResetChildren = true;
                    }
                  } else {
                    if (traceUpdatesEnabled) {
                      if (traceNearestHostComponentUpdate) {
                        var hostFibers = findAllCurrentHostFibers(getFiberIDThrows(nextFiber));
                        hostFibers.forEach(function(hostFiber) {
                          traceUpdatesForNodes.add(hostFiber.stateNode);
                        });
                      }
                    }
                  }
                }
                if (shouldIncludeInTree) {
                  var isProfilingSupported = nextFiber.hasOwnProperty("treeBaseDuration");
                  if (isProfilingSupported) {
                    recordProfilingDurations(nextFiber);
                  }
                }
                if (shouldResetChildren) {
                  if (shouldIncludeInTree) {
                    var nextChildSet = nextFiber.child;
                    if (nextDidTimeOut) {
                      var _nextFiberChild2 = nextFiber.child;
                      nextChildSet = _nextFiberChild2 ? _nextFiberChild2.sibling : null;
                    }
                    if (nextChildSet != null) {
                      recordResetChildren(nextFiber, nextChildSet);
                    }
                    return false;
                  } else {
                    return true;
                  }
                } else {
                  return false;
                }
              }
              __name(updateFiberRecursively, "updateFiberRecursively");
              function cleanup() {
              }
              __name(cleanup, "cleanup");
              function rootSupportsProfiling(root) {
                if (root.memoizedInteractions != null) {
                  return true;
                } else if (root.current != null && root.current.hasOwnProperty("treeBaseDuration")) {
                  return true;
                } else {
                  return false;
                }
              }
              __name(rootSupportsProfiling, "rootSupportsProfiling");
              function flushInitialOperations() {
                var localPendingOperationsQueue = pendingOperationsQueue;
                pendingOperationsQueue = null;
                if (localPendingOperationsQueue !== null && localPendingOperationsQueue.length > 0) {
                  localPendingOperationsQueue.forEach(function(operations) {
                    hook.emit("operations", operations);
                  });
                } else {
                  if (trackedPath !== null) {
                    mightBeOnTrackedPath = true;
                  }
                  hook.getFiberRoots(rendererID).forEach(function(root) {
                    currentRootID = getOrGenerateFiberID(root.current);
                    setRootPseudoKey(currentRootID, root.current);
                    if (isProfiling && rootSupportsProfiling(root)) {
                      currentCommitProfilingMetadata = {
                        changeDescriptions: recordChangeDescriptions ? /* @__PURE__ */ new Map() : null,
                        durations: [],
                        commitTime: getCurrentTime() - profilingStartTime,
                        maxActualDuration: 0,
                        priorityLevel: null,
                        updaters: getUpdatersList(root),
                        effectDuration: null,
                        passiveEffectDuration: null
                      };
                    }
                    mountFiberRecursively(root.current, null, false, false);
                    flushPendingEvents(root);
                    currentRootID = -1;
                  });
                }
              }
              __name(flushInitialOperations, "flushInitialOperations");
              function getUpdatersList(root) {
                return root.memoizedUpdaters != null ? Array.from(root.memoizedUpdaters).filter(function(fiber) {
                  return getFiberIDUnsafe(fiber) !== null;
                }).map(fiberToSerializedElement) : null;
              }
              __name(getUpdatersList, "getUpdatersList");
              function handleCommitFiberUnmount(fiber) {
                recordUnmount(fiber, false);
              }
              __name(handleCommitFiberUnmount, "handleCommitFiberUnmount");
              function handlePostCommitFiberRoot(root) {
                if (isProfiling && rootSupportsProfiling(root)) {
                  if (currentCommitProfilingMetadata !== null) {
                    var _getEffectDurations = Object(backend_utils[
                      "g"
                      /* getEffectDurations */
                    ])(root), effectDuration = _getEffectDurations.effectDuration, passiveEffectDuration = _getEffectDurations.passiveEffectDuration;
                    currentCommitProfilingMetadata.effectDuration = effectDuration;
                    currentCommitProfilingMetadata.passiveEffectDuration = passiveEffectDuration;
                  }
                }
              }
              __name(handlePostCommitFiberRoot, "handlePostCommitFiberRoot");
              function handleCommitFiberRoot(root, priorityLevel) {
                var current = root.current;
                var alternate = current.alternate;
                untrackFibers();
                currentRootID = getOrGenerateFiberID(current);
                if (trackedPath !== null) {
                  mightBeOnTrackedPath = true;
                }
                if (traceUpdatesEnabled) {
                  traceUpdatesForNodes.clear();
                }
                var isProfilingSupported = rootSupportsProfiling(root);
                if (isProfiling && isProfilingSupported) {
                  currentCommitProfilingMetadata = {
                    changeDescriptions: recordChangeDescriptions ? /* @__PURE__ */ new Map() : null,
                    durations: [],
                    commitTime: getCurrentTime() - profilingStartTime,
                    maxActualDuration: 0,
                    priorityLevel: priorityLevel == null ? null : formatPriorityLevel(priorityLevel),
                    updaters: getUpdatersList(root),
                    // Initialize to null; if new enough React version is running,
                    // these values will be read during separate handlePostCommitFiberRoot() call.
                    effectDuration: null,
                    passiveEffectDuration: null
                  };
                }
                if (alternate) {
                  var wasMounted = alternate.memoizedState != null && alternate.memoizedState.element != null;
                  var isMounted = current.memoizedState != null && current.memoizedState.element != null;
                  if (!wasMounted && isMounted) {
                    setRootPseudoKey(currentRootID, current);
                    mountFiberRecursively(current, null, false, false);
                  } else if (wasMounted && isMounted) {
                    updateFiberRecursively(current, alternate, null, false);
                  } else if (wasMounted && !isMounted) {
                    removeRootPseudoKey(currentRootID);
                    recordUnmount(current, false);
                  }
                } else {
                  setRootPseudoKey(currentRootID, current);
                  mountFiberRecursively(current, null, false, false);
                }
                if (isProfiling && isProfilingSupported) {
                  if (currentCommitProfilingMetadata != null && currentCommitProfilingMetadata.durations.length > 0) {
                    var commitProfilingMetadata = rootToCommitProfilingMetadataMap.get(currentRootID);
                    if (commitProfilingMetadata != null) {
                      commitProfilingMetadata.push(currentCommitProfilingMetadata);
                    } else {
                      rootToCommitProfilingMetadataMap.set(currentRootID, [currentCommitProfilingMetadata]);
                    }
                  }
                }
                flushPendingEvents(root);
                if (traceUpdatesEnabled) {
                  hook.emit("traceUpdates", traceUpdatesForNodes);
                }
                currentRootID = -1;
              }
              __name(handleCommitFiberRoot, "handleCommitFiberRoot");
              function findAllCurrentHostFibers(id) {
                var fibers = [];
                var fiber = findCurrentFiberUsingSlowPathById(id);
                if (!fiber) {
                  return fibers;
                }
                var node2 = fiber;
                while (true) {
                  if (node2.tag === HostComponent || node2.tag === HostText) {
                    fibers.push(node2);
                  } else if (node2.child) {
                    node2.child.return = node2;
                    node2 = node2.child;
                    continue;
                  }
                  if (node2 === fiber) {
                    return fibers;
                  }
                  while (!node2.sibling) {
                    if (!node2.return || node2.return === fiber) {
                      return fibers;
                    }
                    node2 = node2.return;
                  }
                  node2.sibling.return = node2.return;
                  node2 = node2.sibling;
                }
                return fibers;
              }
              __name(findAllCurrentHostFibers, "findAllCurrentHostFibers");
              function findNativeNodesForFiberID(id) {
                try {
                  var _fiber3 = findCurrentFiberUsingSlowPathById(id);
                  if (_fiber3 === null) {
                    return null;
                  }
                  var isTimedOutSuspense = _fiber3.tag === SuspenseComponent && _fiber3.memoizedState !== null;
                  if (isTimedOutSuspense) {
                    var maybeFallbackFiber = _fiber3.child && _fiber3.child.sibling;
                    if (maybeFallbackFiber != null) {
                      _fiber3 = maybeFallbackFiber;
                    }
                  }
                  var hostFibers = findAllCurrentHostFibers(id);
                  return hostFibers.map(function(hostFiber) {
                    return hostFiber.stateNode;
                  }).filter(Boolean);
                } catch (err) {
                  return null;
                }
              }
              __name(findNativeNodesForFiberID, "findNativeNodesForFiberID");
              function getDisplayNameForFiberID(id) {
                var fiber = idToArbitraryFiberMap.get(id);
                return fiber != null ? getDisplayNameForFiber(fiber) : null;
              }
              __name(getDisplayNameForFiberID, "getDisplayNameForFiberID");
              function getFiberIDForNative(hostInstance) {
                var findNearestUnfilteredAncestor = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
                var fiber = renderer.findFiberByHostInstance(hostInstance);
                if (fiber != null) {
                  if (findNearestUnfilteredAncestor) {
                    while (fiber !== null && shouldFilterFiber(fiber)) {
                      fiber = fiber.return;
                    }
                  }
                  return getFiberIDThrows(fiber);
                }
                return null;
              }
              __name(getFiberIDForNative, "getFiberIDForNative");
              function assertIsMounted(fiber) {
                if (getNearestMountedFiber(fiber) !== fiber) {
                  throw new Error("Unable to find node on an unmounted component.");
                }
              }
              __name(assertIsMounted, "assertIsMounted");
              function getNearestMountedFiber(fiber) {
                var node2 = fiber;
                var nearestMounted = fiber;
                if (!fiber.alternate) {
                  var nextNode = node2;
                  do {
                    node2 = nextNode;
                    if ((node2.flags & (Placement | Hydrating)) !== NoFlags) {
                      nearestMounted = node2.return;
                    }
                    nextNode = node2.return;
                  } while (nextNode);
                } else {
                  while (node2.return) {
                    node2 = node2.return;
                  }
                }
                if (node2.tag === HostRoot) {
                  return nearestMounted;
                }
                return null;
              }
              __name(getNearestMountedFiber, "getNearestMountedFiber");
              function findCurrentFiberUsingSlowPathById(id) {
                var fiber = idToArbitraryFiberMap.get(id);
                if (fiber == null) {
                  console.warn('Could not find Fiber with id "'.concat(id, '"'));
                  return null;
                }
                var alternate = fiber.alternate;
                if (!alternate) {
                  var nearestMounted = getNearestMountedFiber(fiber);
                  if (nearestMounted === null) {
                    throw new Error("Unable to find node on an unmounted component.");
                  }
                  if (nearestMounted !== fiber) {
                    return null;
                  }
                  return fiber;
                }
                var a = fiber;
                var b2 = alternate;
                while (true) {
                  var parentA = a.return;
                  if (parentA === null) {
                    break;
                  }
                  var parentB = parentA.alternate;
                  if (parentB === null) {
                    var nextParent = parentA.return;
                    if (nextParent !== null) {
                      a = b2 = nextParent;
                      continue;
                    }
                    break;
                  }
                  if (parentA.child === parentB.child) {
                    var child = parentA.child;
                    while (child) {
                      if (child === a) {
                        assertIsMounted(parentA);
                        return fiber;
                      }
                      if (child === b2) {
                        assertIsMounted(parentA);
                        return alternate;
                      }
                      child = child.sibling;
                    }
                    throw new Error("Unable to find node on an unmounted component.");
                  }
                  if (a.return !== b2.return) {
                    a = parentA;
                    b2 = parentB;
                  } else {
                    var didFindChild = false;
                    var _child = parentA.child;
                    while (_child) {
                      if (_child === a) {
                        didFindChild = true;
                        a = parentA;
                        b2 = parentB;
                        break;
                      }
                      if (_child === b2) {
                        didFindChild = true;
                        b2 = parentA;
                        a = parentB;
                        break;
                      }
                      _child = _child.sibling;
                    }
                    if (!didFindChild) {
                      _child = parentB.child;
                      while (_child) {
                        if (_child === a) {
                          didFindChild = true;
                          a = parentB;
                          b2 = parentA;
                          break;
                        }
                        if (_child === b2) {
                          didFindChild = true;
                          b2 = parentB;
                          a = parentA;
                          break;
                        }
                        _child = _child.sibling;
                      }
                      if (!didFindChild) {
                        throw new Error("Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue.");
                      }
                    }
                  }
                  if (a.alternate !== b2) {
                    throw new Error("Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue.");
                  }
                }
                if (a.tag !== HostRoot) {
                  throw new Error("Unable to find node on an unmounted component.");
                }
                if (a.stateNode.current === a) {
                  return fiber;
                }
                return alternate;
              }
              __name(findCurrentFiberUsingSlowPathById, "findCurrentFiberUsingSlowPathById");
              function prepareViewAttributeSource(id, path67) {
                if (isMostRecentlyInspectedElement(id)) {
                  window.$attribute = Object(utils[
                    "h"
                    /* getInObject */
                  ])(mostRecentlyInspectedElement, path67);
                }
              }
              __name(prepareViewAttributeSource, "prepareViewAttributeSource");
              function prepareViewElementSource(id) {
                var fiber = idToArbitraryFiberMap.get(id);
                if (fiber == null) {
                  console.warn('Could not find Fiber with id "'.concat(id, '"'));
                  return;
                }
                var elementType = fiber.elementType, tag = fiber.tag, type = fiber.type;
                switch (tag) {
                  case ClassComponent:
                  case IncompleteClassComponent:
                  case IndeterminateComponent:
                  case FunctionComponent:
                    global2.$type = type;
                    break;
                  case ForwardRef:
                    global2.$type = type.render;
                    break;
                  case MemoComponent:
                  case SimpleMemoComponent:
                    global2.$type = elementType != null && elementType.type != null ? elementType.type : type;
                    break;
                  default:
                    global2.$type = null;
                    break;
                }
              }
              __name(prepareViewElementSource, "prepareViewElementSource");
              function fiberToSerializedElement(fiber) {
                return {
                  displayName: getDisplayNameForFiber(fiber) || "Anonymous",
                  id: getFiberIDThrows(fiber),
                  key: fiber.key,
                  type: getElementTypeForFiber(fiber)
                };
              }
              __name(fiberToSerializedElement, "fiberToSerializedElement");
              function getOwnersList(id) {
                var fiber = findCurrentFiberUsingSlowPathById(id);
                if (fiber == null) {
                  return null;
                }
                var _debugOwner = fiber._debugOwner;
                var owners = [fiberToSerializedElement(fiber)];
                if (_debugOwner) {
                  var owner = _debugOwner;
                  while (owner !== null) {
                    owners.unshift(fiberToSerializedElement(owner));
                    owner = owner._debugOwner || null;
                  }
                }
                return owners;
              }
              __name(getOwnersList, "getOwnersList");
              function getInstanceAndStyle(id) {
                var instance = null;
                var style = null;
                var fiber = findCurrentFiberUsingSlowPathById(id);
                if (fiber !== null) {
                  instance = fiber.stateNode;
                  if (fiber.memoizedProps !== null) {
                    style = fiber.memoizedProps.style;
                  }
                }
                return {
                  instance,
                  style
                };
              }
              __name(getInstanceAndStyle, "getInstanceAndStyle");
              function isErrorBoundary(fiber) {
                var tag = fiber.tag, type = fiber.type;
                switch (tag) {
                  case ClassComponent:
                  case IncompleteClassComponent:
                    var instance = fiber.stateNode;
                    return typeof type.getDerivedStateFromError === "function" || instance !== null && typeof instance.componentDidCatch === "function";
                  default:
                    return false;
                }
              }
              __name(isErrorBoundary, "isErrorBoundary");
              function getNearestErrorBoundaryID(fiber) {
                var parent = fiber.return;
                while (parent !== null) {
                  if (isErrorBoundary(parent)) {
                    return getFiberIDUnsafe(parent);
                  }
                  parent = parent.return;
                }
                return null;
              }
              __name(getNearestErrorBoundaryID, "getNearestErrorBoundaryID");
              function inspectElementRaw(id) {
                var fiber = findCurrentFiberUsingSlowPathById(id);
                if (fiber == null) {
                  return null;
                }
                var _debugOwner = fiber._debugOwner, _debugSource = fiber._debugSource, stateNode = fiber.stateNode, key = fiber.key, memoizedProps = fiber.memoizedProps, memoizedState = fiber.memoizedState, dependencies = fiber.dependencies, tag = fiber.tag, type = fiber.type;
                var elementType = getElementTypeForFiber(fiber);
                var usesHooks = (tag === FunctionComponent || tag === SimpleMemoComponent || tag === ForwardRef) && (!!memoizedState || !!dependencies);
                var showState = !usesHooks && tag !== CacheComponent;
                var typeSymbol = getTypeSymbol(type);
                var canViewSource = false;
                var context2 = null;
                if (tag === ClassComponent || tag === FunctionComponent || tag === IncompleteClassComponent || tag === IndeterminateComponent || tag === MemoComponent || tag === ForwardRef || tag === SimpleMemoComponent) {
                  canViewSource = true;
                  if (stateNode && stateNode.context != null) {
                    var shouldHideContext = elementType === types[
                      "e"
                      /* ElementTypeClass */
                    ] && !(type.contextTypes || type.contextType);
                    if (!shouldHideContext) {
                      context2 = stateNode.context;
                    }
                  }
                } else if (typeSymbol === ReactSymbols[
                  "c"
                  /* CONTEXT_NUMBER */
                ] || typeSymbol === ReactSymbols[
                  "d"
                  /* CONTEXT_SYMBOL_STRING */
                ]) {
                  var consumerResolvedContext = type._context || type;
                  context2 = consumerResolvedContext._currentValue || null;
                  var _current = fiber.return;
                  while (_current !== null) {
                    var currentType = _current.type;
                    var currentTypeSymbol = getTypeSymbol(currentType);
                    if (currentTypeSymbol === ReactSymbols[
                      "n"
                      /* PROVIDER_NUMBER */
                    ] || currentTypeSymbol === ReactSymbols[
                      "o"
                      /* PROVIDER_SYMBOL_STRING */
                    ]) {
                      var providerResolvedContext = currentType._context || currentType.context;
                      if (providerResolvedContext === consumerResolvedContext) {
                        context2 = _current.memoizedProps.value;
                        break;
                      }
                    }
                    _current = _current.return;
                  }
                }
                var hasLegacyContext = false;
                if (context2 !== null) {
                  hasLegacyContext = !!type.contextTypes;
                  context2 = {
                    value: context2
                  };
                }
                var owners = null;
                if (_debugOwner) {
                  owners = [];
                  var owner = _debugOwner;
                  while (owner !== null) {
                    owners.push(fiberToSerializedElement(owner));
                    owner = owner._debugOwner || null;
                  }
                }
                var isTimedOutSuspense = tag === SuspenseComponent && memoizedState !== null;
                var hooks = null;
                if (usesHooks) {
                  var originalConsoleMethods2 = {};
                  for (var method in console) {
                    try {
                      originalConsoleMethods2[method] = console[method];
                      console[method] = function() {
                      };
                    } catch (error2) {
                    }
                  }
                  try {
                    hooks = Object(react_debug_tools["inspectHooksOfFiber"])(
                      fiber,
                      renderer.currentDispatcherRef,
                      true
                      // Include source location info for hooks
                    );
                  } finally {
                    for (var _method in originalConsoleMethods2) {
                      try {
                        console[_method] = originalConsoleMethods2[_method];
                      } catch (error2) {
                      }
                    }
                  }
                }
                var rootType = null;
                var current = fiber;
                while (current.return !== null) {
                  current = current.return;
                }
                var fiberRoot = current.stateNode;
                if (fiberRoot != null && fiberRoot._debugRootType !== null) {
                  rootType = fiberRoot._debugRootType;
                }
                var errors = fiberIDToErrorsMap.get(id) || /* @__PURE__ */ new Map();
                var warnings = fiberIDToWarningsMap.get(id) || /* @__PURE__ */ new Map();
                var isErrored = (fiber.flags & DidCapture) !== NoFlags || forceErrorForFiberIDs.get(id) === true;
                var targetErrorBoundaryID;
                if (isErrorBoundary(fiber)) {
                  targetErrorBoundaryID = isErrored ? id : getNearestErrorBoundaryID(fiber);
                } else {
                  targetErrorBoundaryID = getNearestErrorBoundaryID(fiber);
                }
                var plugins = {
                  stylex: null
                };
                if (DevToolsFeatureFlags_core_oss[
                  "c"
                  /* enableStyleXFeatures */
                ]) {
                  if (memoizedProps.hasOwnProperty("xstyle")) {
                    plugins.stylex = getStyleXData(memoizedProps.xstyle);
                  }
                }
                return {
                  id,
                  // Does the current renderer support editable hooks and function props?
                  canEditHooks: typeof overrideHookState === "function",
                  canEditFunctionProps: typeof overrideProps === "function",
                  // Does the current renderer support advanced editing interface?
                  canEditHooksAndDeletePaths: typeof overrideHookStateDeletePath === "function",
                  canEditHooksAndRenamePaths: typeof overrideHookStateRenamePath === "function",
                  canEditFunctionPropsDeletePaths: typeof overridePropsDeletePath === "function",
                  canEditFunctionPropsRenamePaths: typeof overridePropsRenamePath === "function",
                  canToggleError: supportsTogglingError && targetErrorBoundaryID != null,
                  // Is this error boundary in error state.
                  isErrored,
                  targetErrorBoundaryID,
                  canToggleSuspense: supportsTogglingSuspense && // If it's showing the real content, we can always flip fallback.
                  (!isTimedOutSuspense || // If it's showing fallback because we previously forced it to,
                  // allow toggling it back to remove the fallback override.
                  forceFallbackForSuspenseIDs.has(id)),
                  // Can view component source location.
                  canViewSource,
                  // Does the component have legacy context attached to it.
                  hasLegacyContext,
                  key: key != null ? key : null,
                  displayName: getDisplayNameForFiber(fiber),
                  type: elementType,
                  // Inspectable properties.
                  // TODO Review sanitization approach for the below inspectable values.
                  context: context2,
                  hooks,
                  props: memoizedProps,
                  state: showState ? memoizedState : null,
                  errors: Array.from(errors.entries()),
                  warnings: Array.from(warnings.entries()),
                  // List of owners
                  owners,
                  // Location of component in source code.
                  source: _debugSource || null,
                  rootType,
                  rendererPackageName: renderer.rendererPackageName,
                  rendererVersion: renderer.version,
                  plugins
                };
              }
              __name(inspectElementRaw, "inspectElementRaw");
              var mostRecentlyInspectedElement = null;
              var hasElementUpdatedSinceLastInspected = false;
              var currentlyInspectedPaths = {};
              function isMostRecentlyInspectedElement(id) {
                return mostRecentlyInspectedElement !== null && mostRecentlyInspectedElement.id === id;
              }
              __name(isMostRecentlyInspectedElement, "isMostRecentlyInspectedElement");
              function isMostRecentlyInspectedElementCurrent(id) {
                return isMostRecentlyInspectedElement(id) && !hasElementUpdatedSinceLastInspected;
              }
              __name(isMostRecentlyInspectedElementCurrent, "isMostRecentlyInspectedElementCurrent");
              function mergeInspectedPaths(path67) {
                var current = currentlyInspectedPaths;
                path67.forEach(function(key) {
                  if (!current[key]) {
                    current[key] = {};
                  }
                  current = current[key];
                });
              }
              __name(mergeInspectedPaths, "mergeInspectedPaths");
              function createIsPathAllowed(key, secondaryCategory) {
                return /* @__PURE__ */ __name(function isPathAllowed(path67) {
                  switch (secondaryCategory) {
                    case "hooks":
                      if (path67.length === 1) {
                        return true;
                      }
                      if (path67[path67.length - 2] === "hookSource" && path67[path67.length - 1] === "fileName") {
                        return true;
                      }
                      if (path67[path67.length - 1] === "subHooks" || path67[path67.length - 2] === "subHooks") {
                        return true;
                      }
                      break;
                    default:
                      break;
                  }
                  var current = key === null ? currentlyInspectedPaths : currentlyInspectedPaths[key];
                  if (!current) {
                    return false;
                  }
                  for (var i = 0; i < path67.length; i++) {
                    current = current[path67[i]];
                    if (!current) {
                      return false;
                    }
                  }
                  return true;
                }, "isPathAllowed");
              }
              __name(createIsPathAllowed, "createIsPathAllowed");
              function updateSelectedElement(inspectedElement) {
                var hooks = inspectedElement.hooks, id = inspectedElement.id, props = inspectedElement.props;
                var fiber = idToArbitraryFiberMap.get(id);
                if (fiber == null) {
                  console.warn('Could not find Fiber with id "'.concat(id, '"'));
                  return;
                }
                var elementType = fiber.elementType, stateNode = fiber.stateNode, tag = fiber.tag, type = fiber.type;
                switch (tag) {
                  case ClassComponent:
                  case IncompleteClassComponent:
                  case IndeterminateComponent:
                    global2.$r = stateNode;
                    break;
                  case FunctionComponent:
                    global2.$r = {
                      hooks,
                      props,
                      type
                    };
                    break;
                  case ForwardRef:
                    global2.$r = {
                      hooks,
                      props,
                      type: type.render
                    };
                    break;
                  case MemoComponent:
                  case SimpleMemoComponent:
                    global2.$r = {
                      hooks,
                      props,
                      type: elementType != null && elementType.type != null ? elementType.type : type
                    };
                    break;
                  default:
                    global2.$r = null;
                    break;
                }
              }
              __name(updateSelectedElement, "updateSelectedElement");
              function storeAsGlobal(id, path67, count) {
                if (isMostRecentlyInspectedElement(id)) {
                  var value = Object(utils[
                    "h"
                    /* getInObject */
                  ])(mostRecentlyInspectedElement, path67);
                  var key = "$reactTemp".concat(count);
                  window[key] = value;
                  console.log(key);
                  console.log(value);
                }
              }
              __name(storeAsGlobal, "storeAsGlobal");
              function copyElementPath(id, path67) {
                if (isMostRecentlyInspectedElement(id)) {
                  Object(backend_utils[
                    "b"
                    /* copyToClipboard */
                  ])(Object(utils[
                    "h"
                    /* getInObject */
                  ])(mostRecentlyInspectedElement, path67));
                }
              }
              __name(copyElementPath, "copyElementPath");
              function inspectElement(requestID, id, path67, forceFullData) {
                if (path67 !== null) {
                  mergeInspectedPaths(path67);
                }
                if (isMostRecentlyInspectedElement(id) && !forceFullData) {
                  if (!hasElementUpdatedSinceLastInspected) {
                    if (path67 !== null) {
                      var secondaryCategory = null;
                      if (path67[0] === "hooks") {
                        secondaryCategory = "hooks";
                      }
                      return {
                        id,
                        responseID: requestID,
                        type: "hydrated-path",
                        path: path67,
                        value: Object(backend_utils[
                          "a"
                          /* cleanForBridge */
                        ])(Object(utils[
                          "h"
                          /* getInObject */
                        ])(mostRecentlyInspectedElement, path67), createIsPathAllowed(null, secondaryCategory), path67)
                      };
                    } else {
                      return {
                        id,
                        responseID: requestID,
                        type: "no-change"
                      };
                    }
                  }
                } else {
                  currentlyInspectedPaths = {};
                }
                hasElementUpdatedSinceLastInspected = false;
                try {
                  mostRecentlyInspectedElement = inspectElementRaw(id);
                } catch (error2) {
                  console.error("Error inspecting element.\n\n", error2);
                  return {
                    type: "error",
                    id,
                    responseID: requestID,
                    message: error2.message,
                    stack: error2.stack
                  };
                }
                if (mostRecentlyInspectedElement === null) {
                  return {
                    id,
                    responseID: requestID,
                    type: "not-found"
                  };
                }
                updateSelectedElement(mostRecentlyInspectedElement);
                var cleanedInspectedElement = _objectSpread11({}, mostRecentlyInspectedElement);
                cleanedInspectedElement.context = Object(backend_utils[
                  "a"
                  /* cleanForBridge */
                ])(cleanedInspectedElement.context, createIsPathAllowed("context", null));
                cleanedInspectedElement.hooks = Object(backend_utils[
                  "a"
                  /* cleanForBridge */
                ])(cleanedInspectedElement.hooks, createIsPathAllowed("hooks", "hooks"));
                cleanedInspectedElement.props = Object(backend_utils[
                  "a"
                  /* cleanForBridge */
                ])(cleanedInspectedElement.props, createIsPathAllowed("props", null));
                cleanedInspectedElement.state = Object(backend_utils[
                  "a"
                  /* cleanForBridge */
                ])(cleanedInspectedElement.state, createIsPathAllowed("state", null));
                return {
                  id,
                  responseID: requestID,
                  type: "full-data",
                  value: cleanedInspectedElement
                };
              }
              __name(inspectElement, "inspectElement");
              function logElementToConsole(id) {
                var result = isMostRecentlyInspectedElementCurrent(id) ? mostRecentlyInspectedElement : inspectElementRaw(id);
                if (result === null) {
                  console.warn('Could not find Fiber with id "'.concat(id, '"'));
                  return;
                }
                var supportsGroup = typeof console.groupCollapsed === "function";
                if (supportsGroup) {
                  console.groupCollapsed(
                    "[Click to expand] %c<".concat(result.displayName || "Component", " />"),
                    // --dom-tag-name-color is the CSS variable Chrome styles HTML elements with in the console.
                    "color: var(--dom-tag-name-color); font-weight: normal;"
                  );
                }
                if (result.props !== null) {
                  console.log("Props:", result.props);
                }
                if (result.state !== null) {
                  console.log("State:", result.state);
                }
                if (result.hooks !== null) {
                  console.log("Hooks:", result.hooks);
                }
                var nativeNodes = findNativeNodesForFiberID(id);
                if (nativeNodes !== null) {
                  console.log("Nodes:", nativeNodes);
                }
                if (result.source !== null) {
                  console.log("Location:", result.source);
                }
                if (window.chrome || /firefox/i.test(navigator.userAgent)) {
                  console.log("Right-click any value to save it as a global variable for further inspection.");
                }
                if (supportsGroup) {
                  console.groupEnd();
                }
              }
              __name(logElementToConsole, "logElementToConsole");
              function deletePath(type, id, hookID, path67) {
                var fiber = findCurrentFiberUsingSlowPathById(id);
                if (fiber !== null) {
                  var instance = fiber.stateNode;
                  switch (type) {
                    case "context":
                      path67 = path67.slice(1);
                      switch (fiber.tag) {
                        case ClassComponent:
                          if (path67.length === 0) {
                          } else {
                            Object(utils[
                              "a"
                              /* deletePathInObject */
                            ])(instance.context, path67);
                          }
                          instance.forceUpdate();
                          break;
                        case FunctionComponent:
                          break;
                      }
                      break;
                    case "hooks":
                      if (typeof overrideHookStateDeletePath === "function") {
                        overrideHookStateDeletePath(fiber, hookID, path67);
                      }
                      break;
                    case "props":
                      if (instance === null) {
                        if (typeof overridePropsDeletePath === "function") {
                          overridePropsDeletePath(fiber, path67);
                        }
                      } else {
                        fiber.pendingProps = Object(backend_utils[
                          "c"
                          /* copyWithDelete */
                        ])(instance.props, path67);
                        instance.forceUpdate();
                      }
                      break;
                    case "state":
                      Object(utils[
                        "a"
                        /* deletePathInObject */
                      ])(instance.state, path67);
                      instance.forceUpdate();
                      break;
                  }
                }
              }
              __name(deletePath, "deletePath");
              function renamePath(type, id, hookID, oldPath, newPath) {
                var fiber = findCurrentFiberUsingSlowPathById(id);
                if (fiber !== null) {
                  var instance = fiber.stateNode;
                  switch (type) {
                    case "context":
                      oldPath = oldPath.slice(1);
                      newPath = newPath.slice(1);
                      switch (fiber.tag) {
                        case ClassComponent:
                          if (oldPath.length === 0) {
                          } else {
                            Object(utils[
                              "k"
                              /* renamePathInObject */
                            ])(instance.context, oldPath, newPath);
                          }
                          instance.forceUpdate();
                          break;
                        case FunctionComponent:
                          break;
                      }
                      break;
                    case "hooks":
                      if (typeof overrideHookStateRenamePath === "function") {
                        overrideHookStateRenamePath(fiber, hookID, oldPath, newPath);
                      }
                      break;
                    case "props":
                      if (instance === null) {
                        if (typeof overridePropsRenamePath === "function") {
                          overridePropsRenamePath(fiber, oldPath, newPath);
                        }
                      } else {
                        fiber.pendingProps = Object(backend_utils[
                          "d"
                          /* copyWithRename */
                        ])(instance.props, oldPath, newPath);
                        instance.forceUpdate();
                      }
                      break;
                    case "state":
                      Object(utils[
                        "k"
                        /* renamePathInObject */
                      ])(instance.state, oldPath, newPath);
                      instance.forceUpdate();
                      break;
                  }
                }
              }
              __name(renamePath, "renamePath");
              function overrideValueAtPath(type, id, hookID, path67, value) {
                var fiber = findCurrentFiberUsingSlowPathById(id);
                if (fiber !== null) {
                  var instance = fiber.stateNode;
                  switch (type) {
                    case "context":
                      path67 = path67.slice(1);
                      switch (fiber.tag) {
                        case ClassComponent:
                          if (path67.length === 0) {
                            instance.context = value;
                          } else {
                            Object(utils[
                              "l"
                              /* setInObject */
                            ])(instance.context, path67, value);
                          }
                          instance.forceUpdate();
                          break;
                        case FunctionComponent:
                          break;
                      }
                      break;
                    case "hooks":
                      if (typeof overrideHookState === "function") {
                        overrideHookState(fiber, hookID, path67, value);
                      }
                      break;
                    case "props":
                      switch (fiber.tag) {
                        case ClassComponent:
                          fiber.pendingProps = Object(backend_utils[
                            "e"
                            /* copyWithSet */
                          ])(instance.props, path67, value);
                          instance.forceUpdate();
                          break;
                        default:
                          if (typeof overrideProps === "function") {
                            overrideProps(fiber, path67, value);
                          }
                          break;
                      }
                      break;
                    case "state":
                      switch (fiber.tag) {
                        case ClassComponent:
                          Object(utils[
                            "l"
                            /* setInObject */
                          ])(instance.state, path67, value);
                          instance.forceUpdate();
                          break;
                      }
                      break;
                  }
                }
              }
              __name(overrideValueAtPath, "overrideValueAtPath");
              var currentCommitProfilingMetadata = null;
              var displayNamesByRootID = null;
              var idToContextsMap = null;
              var initialTreeBaseDurationsMap = null;
              var initialIDToRootMap = null;
              var isProfiling = false;
              var profilingStartTime = 0;
              var recordChangeDescriptions = false;
              var rootToCommitProfilingMetadataMap = null;
              function getProfilingData() {
                var dataForRoots = [];
                if (rootToCommitProfilingMetadataMap === null) {
                  throw Error("getProfilingData() called before any profiling data was recorded");
                }
                rootToCommitProfilingMetadataMap.forEach(function(commitProfilingMetadata, rootID) {
                  var commitData = [];
                  var initialTreeBaseDurations = [];
                  var displayName = displayNamesByRootID !== null && displayNamesByRootID.get(rootID) || "Unknown";
                  if (initialTreeBaseDurationsMap != null) {
                    initialTreeBaseDurationsMap.forEach(function(treeBaseDuration, id) {
                      if (initialIDToRootMap != null && initialIDToRootMap.get(id) === rootID) {
                        initialTreeBaseDurations.push([id, treeBaseDuration]);
                      }
                    });
                  }
                  commitProfilingMetadata.forEach(function(commitProfilingData, commitIndex) {
                    var changeDescriptions = commitProfilingData.changeDescriptions, durations = commitProfilingData.durations, effectDuration = commitProfilingData.effectDuration, maxActualDuration = commitProfilingData.maxActualDuration, passiveEffectDuration = commitProfilingData.passiveEffectDuration, priorityLevel = commitProfilingData.priorityLevel, commitTime = commitProfilingData.commitTime, updaters = commitProfilingData.updaters;
                    var fiberActualDurations = [];
                    var fiberSelfDurations = [];
                    for (var i = 0; i < durations.length; i += 3) {
                      var fiberID = durations[i];
                      fiberActualDurations.push([fiberID, durations[i + 1]]);
                      fiberSelfDurations.push([fiberID, durations[i + 2]]);
                    }
                    commitData.push({
                      changeDescriptions: changeDescriptions !== null ? Array.from(changeDescriptions.entries()) : null,
                      duration: maxActualDuration,
                      effectDuration,
                      fiberActualDurations,
                      fiberSelfDurations,
                      passiveEffectDuration,
                      priorityLevel,
                      timestamp: commitTime,
                      updaters
                    });
                  });
                  dataForRoots.push({
                    commitData,
                    displayName,
                    initialTreeBaseDurations,
                    rootID
                  });
                });
                return {
                  dataForRoots,
                  rendererID
                };
              }
              __name(getProfilingData, "getProfilingData");
              function startProfiling(shouldRecordChangeDescriptions) {
                if (isProfiling) {
                  return;
                }
                recordChangeDescriptions = shouldRecordChangeDescriptions;
                displayNamesByRootID = /* @__PURE__ */ new Map();
                initialTreeBaseDurationsMap = new Map(idToTreeBaseDurationMap);
                initialIDToRootMap = new Map(idToRootMap);
                idToContextsMap = /* @__PURE__ */ new Map();
                hook.getFiberRoots(rendererID).forEach(function(root) {
                  var rootID = getFiberIDThrows(root.current);
                  displayNamesByRootID.set(rootID, getDisplayNameForRoot(root.current));
                  if (shouldRecordChangeDescriptions) {
                    crawlToInitializeContextsMap(root.current);
                  }
                });
                isProfiling = true;
                profilingStartTime = getCurrentTime();
                rootToCommitProfilingMetadataMap = /* @__PURE__ */ new Map();
              }
              __name(startProfiling, "startProfiling");
              function stopProfiling() {
                isProfiling = false;
                recordChangeDescriptions = false;
              }
              __name(stopProfiling, "stopProfiling");
              if (Object(storage[
                "c"
                /* sessionStorageGetItem */
              ])(constants3[
                "i"
                /* SESSION_STORAGE_RELOAD_AND_PROFILE_KEY */
              ]) === "true") {
                startProfiling(Object(storage[
                  "c"
                  /* sessionStorageGetItem */
                ])(constants3[
                  "h"
                  /* SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY */
                ]) === "true");
              }
              function shouldErrorFiberAlwaysNull() {
                return null;
              }
              __name(shouldErrorFiberAlwaysNull, "shouldErrorFiberAlwaysNull");
              var forceErrorForFiberIDs = /* @__PURE__ */ new Map();
              function shouldErrorFiberAccordingToMap(fiber) {
                if (typeof setErrorHandler !== "function") {
                  throw new Error("Expected overrideError() to not get called for earlier React versions.");
                }
                var id = getFiberIDUnsafe(fiber);
                if (id === null) {
                  return null;
                }
                var status2 = null;
                if (forceErrorForFiberIDs.has(id)) {
                  status2 = forceErrorForFiberIDs.get(id);
                  if (status2 === false) {
                    forceErrorForFiberIDs.delete(id);
                    if (forceErrorForFiberIDs.size === 0) {
                      setErrorHandler(shouldErrorFiberAlwaysNull);
                    }
                  }
                }
                return status2;
              }
              __name(shouldErrorFiberAccordingToMap, "shouldErrorFiberAccordingToMap");
              function overrideError(id, forceError) {
                if (typeof setErrorHandler !== "function" || typeof scheduleUpdate !== "function") {
                  throw new Error("Expected overrideError() to not get called for earlier React versions.");
                }
                forceErrorForFiberIDs.set(id, forceError);
                if (forceErrorForFiberIDs.size === 1) {
                  setErrorHandler(shouldErrorFiberAccordingToMap);
                }
                var fiber = idToArbitraryFiberMap.get(id);
                if (fiber != null) {
                  scheduleUpdate(fiber);
                }
              }
              __name(overrideError, "overrideError");
              function shouldSuspendFiberAlwaysFalse() {
                return false;
              }
              __name(shouldSuspendFiberAlwaysFalse, "shouldSuspendFiberAlwaysFalse");
              var forceFallbackForSuspenseIDs = /* @__PURE__ */ new Set();
              function shouldSuspendFiberAccordingToSet(fiber) {
                var maybeID = getFiberIDUnsafe(fiber);
                return maybeID !== null && forceFallbackForSuspenseIDs.has(maybeID);
              }
              __name(shouldSuspendFiberAccordingToSet, "shouldSuspendFiberAccordingToSet");
              function overrideSuspense(id, forceFallback) {
                if (typeof setSuspenseHandler !== "function" || typeof scheduleUpdate !== "function") {
                  throw new Error("Expected overrideSuspense() to not get called for earlier React versions.");
                }
                if (forceFallback) {
                  forceFallbackForSuspenseIDs.add(id);
                  if (forceFallbackForSuspenseIDs.size === 1) {
                    setSuspenseHandler(shouldSuspendFiberAccordingToSet);
                  }
                } else {
                  forceFallbackForSuspenseIDs.delete(id);
                  if (forceFallbackForSuspenseIDs.size === 0) {
                    setSuspenseHandler(shouldSuspendFiberAlwaysFalse);
                  }
                }
                var fiber = idToArbitraryFiberMap.get(id);
                if (fiber != null) {
                  scheduleUpdate(fiber);
                }
              }
              __name(overrideSuspense, "overrideSuspense");
              var trackedPath = null;
              var trackedPathMatchFiber = null;
              var trackedPathMatchDepth = -1;
              var mightBeOnTrackedPath = false;
              function setTrackedPath(path67) {
                if (path67 === null) {
                  trackedPathMatchFiber = null;
                  trackedPathMatchDepth = -1;
                  mightBeOnTrackedPath = false;
                }
                trackedPath = path67;
              }
              __name(setTrackedPath, "setTrackedPath");
              function updateTrackedPathStateBeforeMount(fiber) {
                if (trackedPath === null || !mightBeOnTrackedPath) {
                  return false;
                }
                var returnFiber = fiber.return;
                var returnAlternate = returnFiber !== null ? returnFiber.alternate : null;
                if (trackedPathMatchFiber === returnFiber || trackedPathMatchFiber === returnAlternate && returnAlternate !== null) {
                  var actualFrame = getPathFrame(fiber);
                  var expectedFrame = trackedPath[trackedPathMatchDepth + 1];
                  if (expectedFrame === void 0) {
                    throw new Error("Expected to see a frame at the next depth.");
                  }
                  if (actualFrame.index === expectedFrame.index && actualFrame.key === expectedFrame.key && actualFrame.displayName === expectedFrame.displayName) {
                    trackedPathMatchFiber = fiber;
                    trackedPathMatchDepth++;
                    if (trackedPathMatchDepth === trackedPath.length - 1) {
                      mightBeOnTrackedPath = false;
                    } else {
                      mightBeOnTrackedPath = true;
                    }
                    return false;
                  }
                }
                mightBeOnTrackedPath = false;
                return true;
              }
              __name(updateTrackedPathStateBeforeMount, "updateTrackedPathStateBeforeMount");
              function updateTrackedPathStateAfterMount(mightSiblingsBeOnTrackedPath) {
                mightBeOnTrackedPath = mightSiblingsBeOnTrackedPath;
              }
              __name(updateTrackedPathStateAfterMount, "updateTrackedPathStateAfterMount");
              var rootPseudoKeys = /* @__PURE__ */ new Map();
              var rootDisplayNameCounter = /* @__PURE__ */ new Map();
              function setRootPseudoKey(id, fiber) {
                var name = getDisplayNameForRoot(fiber);
                var counter = rootDisplayNameCounter.get(name) || 0;
                rootDisplayNameCounter.set(name, counter + 1);
                var pseudoKey = "".concat(name, ":").concat(counter);
                rootPseudoKeys.set(id, pseudoKey);
              }
              __name(setRootPseudoKey, "setRootPseudoKey");
              function removeRootPseudoKey(id) {
                var pseudoKey = rootPseudoKeys.get(id);
                if (pseudoKey === void 0) {
                  throw new Error("Expected root pseudo key to be known.");
                }
                var name = pseudoKey.substring(0, pseudoKey.lastIndexOf(":"));
                var counter = rootDisplayNameCounter.get(name);
                if (counter === void 0) {
                  throw new Error("Expected counter to be known.");
                }
                if (counter > 1) {
                  rootDisplayNameCounter.set(name, counter - 1);
                } else {
                  rootDisplayNameCounter.delete(name);
                }
                rootPseudoKeys.delete(id);
              }
              __name(removeRootPseudoKey, "removeRootPseudoKey");
              function getDisplayNameForRoot(fiber) {
                var preferredDisplayName = null;
                var fallbackDisplayName = null;
                var child = fiber.child;
                for (var i = 0; i < 3; i++) {
                  if (child === null) {
                    break;
                  }
                  var displayName = getDisplayNameForFiber(child);
                  if (displayName !== null) {
                    if (typeof child.type === "function") {
                      preferredDisplayName = displayName;
                    } else if (fallbackDisplayName === null) {
                      fallbackDisplayName = displayName;
                    }
                  }
                  if (preferredDisplayName !== null) {
                    break;
                  }
                  child = child.child;
                }
                return preferredDisplayName || fallbackDisplayName || "Anonymous";
              }
              __name(getDisplayNameForRoot, "getDisplayNameForRoot");
              function getPathFrame(fiber) {
                var key = fiber.key;
                var displayName = getDisplayNameForFiber(fiber);
                var index = fiber.index;
                switch (fiber.tag) {
                  case HostRoot:
                    var id = getFiberIDThrows(fiber);
                    var pseudoKey = rootPseudoKeys.get(id);
                    if (pseudoKey === void 0) {
                      throw new Error("Expected mounted root to have known pseudo key.");
                    }
                    displayName = pseudoKey;
                    break;
                  case HostComponent:
                    displayName = fiber.type;
                    break;
                  default:
                    break;
                }
                return {
                  displayName,
                  key,
                  index
                };
              }
              __name(getPathFrame, "getPathFrame");
              function getPathForElement(id) {
                var fiber = idToArbitraryFiberMap.get(id);
                if (fiber == null) {
                  return null;
                }
                var keyPath = [];
                while (fiber !== null) {
                  keyPath.push(getPathFrame(fiber));
                  fiber = fiber.return;
                }
                keyPath.reverse();
                return keyPath;
              }
              __name(getPathForElement, "getPathForElement");
              function getBestMatchForTrackedPath() {
                if (trackedPath === null) {
                  return null;
                }
                if (trackedPathMatchFiber === null) {
                  return null;
                }
                var fiber = trackedPathMatchFiber;
                while (fiber !== null && shouldFilterFiber(fiber)) {
                  fiber = fiber.return;
                }
                if (fiber === null) {
                  return null;
                }
                return {
                  id: getFiberIDThrows(fiber),
                  isFullMatch: trackedPathMatchDepth === trackedPath.length - 1
                };
              }
              __name(getBestMatchForTrackedPath, "getBestMatchForTrackedPath");
              var formatPriorityLevel = /* @__PURE__ */ __name(function formatPriorityLevel2(priorityLevel) {
                if (priorityLevel == null) {
                  return "Unknown";
                }
                switch (priorityLevel) {
                  case ImmediatePriority:
                    return "Immediate";
                  case UserBlockingPriority:
                    return "User-Blocking";
                  case NormalPriority:
                    return "Normal";
                  case LowPriority:
                    return "Low";
                  case IdlePriority:
                    return "Idle";
                  case NoPriority:
                  default:
                    return "Unknown";
                }
              }, "formatPriorityLevel");
              function setTraceUpdatesEnabled(isEnabled) {
                traceUpdatesEnabled = isEnabled;
              }
              __name(setTraceUpdatesEnabled, "setTraceUpdatesEnabled");
              return {
                cleanup,
                clearErrorsAndWarnings,
                clearErrorsForFiberID,
                clearWarningsForFiberID,
                copyElementPath,
                deletePath,
                findNativeNodesForFiberID,
                flushInitialOperations,
                getBestMatchForTrackedPath,
                getDisplayNameForFiberID,
                getFiberIDForNative,
                getInstanceAndStyle,
                getOwnersList,
                getPathForElement,
                getProfilingData,
                handleCommitFiberRoot,
                handleCommitFiberUnmount,
                handlePostCommitFiberRoot,
                inspectElement,
                logElementToConsole,
                patchConsoleForStrictMode: backend_console[
                  "b"
                  /* patchForStrictMode */
                ],
                prepareViewAttributeSource,
                prepareViewElementSource,
                overrideError,
                overrideSuspense,
                overrideValueAtPath,
                renamePath,
                renderer,
                setTraceUpdatesEnabled,
                setTrackedPath,
                startProfiling,
                stopProfiling,
                storeAsGlobal,
                unpatchConsoleForStrictMode: backend_console[
                  "d"
                  /* unpatchForStrictMode */
                ],
                updateComponentFilters
              };
            }
            __name(attach, "attach");
          },
          /* 17 */
          /***/
          function(module4, exports3) {
            var process11 = module4.exports = {};
            var cachedSetTimeout;
            var cachedClearTimeout;
            function defaultSetTimout() {
              throw new Error("setTimeout has not been defined");
            }
            __name(defaultSetTimout, "defaultSetTimout");
            function defaultClearTimeout() {
              throw new Error("clearTimeout has not been defined");
            }
            __name(defaultClearTimeout, "defaultClearTimeout");
            (function() {
              try {
                if (typeof setTimeout === "function") {
                  cachedSetTimeout = setTimeout;
                } else {
                  cachedSetTimeout = defaultSetTimout;
                }
              } catch (e3) {
                cachedSetTimeout = defaultSetTimout;
              }
              try {
                if (typeof clearTimeout === "function") {
                  cachedClearTimeout = clearTimeout;
                } else {
                  cachedClearTimeout = defaultClearTimeout;
                }
              } catch (e3) {
                cachedClearTimeout = defaultClearTimeout;
              }
            })();
            function runTimeout(fun) {
              if (cachedSetTimeout === setTimeout) {
                return setTimeout(fun, 0);
              }
              if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
                cachedSetTimeout = setTimeout;
                return setTimeout(fun, 0);
              }
              try {
                return cachedSetTimeout(fun, 0);
              } catch (e3) {
                try {
                  return cachedSetTimeout.call(null, fun, 0);
                } catch (e4) {
                  return cachedSetTimeout.call(this, fun, 0);
                }
              }
            }
            __name(runTimeout, "runTimeout");
            function runClearTimeout(marker) {
              if (cachedClearTimeout === clearTimeout) {
                return clearTimeout(marker);
              }
              if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
                cachedClearTimeout = clearTimeout;
                return clearTimeout(marker);
              }
              try {
                return cachedClearTimeout(marker);
              } catch (e3) {
                try {
                  return cachedClearTimeout.call(null, marker);
                } catch (e4) {
                  return cachedClearTimeout.call(this, marker);
                }
              }
            }
            __name(runClearTimeout, "runClearTimeout");
            var queue = [];
            var draining = false;
            var currentQueue;
            var queueIndex = -1;
            function cleanUpNextTick() {
              if (!draining || !currentQueue) {
                return;
              }
              draining = false;
              if (currentQueue.length) {
                queue = currentQueue.concat(queue);
              } else {
                queueIndex = -1;
              }
              if (queue.length) {
                drainQueue();
              }
            }
            __name(cleanUpNextTick, "cleanUpNextTick");
            function drainQueue() {
              if (draining) {
                return;
              }
              var timeout = runTimeout(cleanUpNextTick);
              draining = true;
              var len = queue.length;
              while (len) {
                currentQueue = queue;
                queue = [];
                while (++queueIndex < len) {
                  if (currentQueue) {
                    currentQueue[queueIndex].run();
                  }
                }
                queueIndex = -1;
                len = queue.length;
              }
              currentQueue = null;
              draining = false;
              runClearTimeout(timeout);
            }
            __name(drainQueue, "drainQueue");
            process11.nextTick = function(fun) {
              var args = new Array(arguments.length - 1);
              if (arguments.length > 1) {
                for (var i = 1; i < arguments.length; i++) {
                  args[i - 1] = arguments[i];
                }
              }
              queue.push(new Item(fun, args));
              if (queue.length === 1 && !draining) {
                runTimeout(drainQueue);
              }
            };
            function Item(fun, array) {
              this.fun = fun;
              this.array = array;
            }
            __name(Item, "Item");
            Item.prototype.run = function() {
              this.fun.apply(null, this.array);
            };
            process11.title = "browser";
            process11.browser = true;
            process11.env = {};
            process11.argv = [];
            process11.version = "";
            process11.versions = {};
            function noop() {
            }
            __name(noop, "noop");
            process11.on = noop;
            process11.addListener = noop;
            process11.once = noop;
            process11.off = noop;
            process11.removeListener = noop;
            process11.removeAllListeners = noop;
            process11.emit = noop;
            process11.prependListener = noop;
            process11.prependOnceListener = noop;
            process11.listeners = function(name) {
              return [];
            };
            process11.binding = function(name) {
              throw new Error("process.binding is not supported");
            };
            process11.cwd = function() {
              return "/";
            };
            process11.chdir = function(dir) {
              throw new Error("process.chdir is not supported");
            };
            process11.umask = function() {
              return 0;
            };
          },
          /* 18 */
          /***/
          function(module4, exports3, __webpack_require__) {
            (function(setImmediate2) {
              function _typeof7(obj) {
                "@babel/helpers - typeof";
                if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                  _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                    return typeof obj2;
                  }, "_typeof");
                } else {
                  _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                    return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
                  }, "_typeof");
                }
                return _typeof7(obj);
              }
              __name(_typeof7, "_typeof");
              (function(name, definition) {
                if (true) {
                  module4.exports = definition();
                } else {
                }
              })("clipboard", function() {
                if (typeof document === "undefined" || !document.addEventListener) {
                  return null;
                }
                var clipboard6 = {};
                clipboard6.copy = function() {
                  var _intercept = false;
                  var _data = null;
                  var _bogusSelection = false;
                  function cleanup() {
                    _intercept = false;
                    _data = null;
                    if (_bogusSelection) {
                      window.getSelection().removeAllRanges();
                    }
                    _bogusSelection = false;
                  }
                  __name(cleanup, "cleanup");
                  document.addEventListener("copy", function(e3) {
                    if (_intercept) {
                      for (var key in _data) {
                        e3.clipboardData.setData(key, _data[key]);
                      }
                      e3.preventDefault();
                    }
                  });
                  function bogusSelect() {
                    var sel = document.getSelection();
                    if (!document.queryCommandEnabled("copy") && sel.isCollapsed) {
                      var range = document.createRange();
                      range.selectNodeContents(document.body);
                      sel.removeAllRanges();
                      sel.addRange(range);
                      _bogusSelection = true;
                    }
                  }
                  __name(bogusSelect, "bogusSelect");
                  ;
                  return function(data) {
                    return new Promise(function(resolve19, reject) {
                      _intercept = true;
                      if (typeof data === "string") {
                        _data = {
                          "text/plain": data
                        };
                      } else if (data instanceof Node) {
                        _data = {
                          "text/html": new XMLSerializer().serializeToString(data)
                        };
                      } else if (data instanceof Object) {
                        _data = data;
                      } else {
                        reject("Invalid data type. Must be string, DOM node, or an object mapping MIME types to strings.");
                      }
                      function triggerCopy(tryBogusSelect) {
                        try {
                          if (document.execCommand("copy")) {
                            cleanup();
                            resolve19();
                          } else {
                            if (!tryBogusSelect) {
                              bogusSelect();
                              triggerCopy(true);
                            } else {
                              cleanup();
                              throw new Error("Unable to copy. Perhaps it's not available in your browser?");
                            }
                          }
                        } catch (e3) {
                          cleanup();
                          reject(e3);
                        }
                      }
                      __name(triggerCopy, "triggerCopy");
                      triggerCopy(false);
                    });
                  };
                }();
                clipboard6.paste = function() {
                  var _intercept = false;
                  var _resolve2;
                  var _dataType;
                  document.addEventListener("paste", function(e3) {
                    if (_intercept) {
                      _intercept = false;
                      e3.preventDefault();
                      var resolve19 = _resolve2;
                      _resolve2 = null;
                      resolve19(e3.clipboardData.getData(_dataType));
                    }
                  });
                  return function(dataType) {
                    return new Promise(function(resolve19, reject) {
                      _intercept = true;
                      _resolve2 = resolve19;
                      _dataType = dataType || "text/plain";
                      try {
                        if (!document.execCommand("paste")) {
                          _intercept = false;
                          reject(new Error("Unable to paste. Pasting only works in Internet Explorer at the moment."));
                        }
                      } catch (e3) {
                        _intercept = false;
                        reject(new Error(e3));
                      }
                    });
                  };
                }();
                if (typeof ClipboardEvent === "undefined" && typeof window.clipboardData !== "undefined" && typeof window.clipboardData.setData !== "undefined") {
                  (function(a) {
                    function b2(a2, b3) {
                      return function() {
                        a2.apply(b3, arguments);
                      };
                    }
                    __name(b2, "b");
                    function c2(a2) {
                      if ("object" != _typeof7(this))
                        throw new TypeError("Promises must be constructed via new");
                      if ("function" != typeof a2)
                        throw new TypeError("not a function");
                      this._state = null, this._value = null, this._deferreds = [], i(a2, b2(e3, this), b2(f, this));
                    }
                    __name(c2, "c");
                    function d2(a2) {
                      var b3 = this;
                      return null === this._state ? void this._deferreds.push(a2) : void j2(function() {
                        var c3 = b3._state ? a2.onFulfilled : a2.onRejected;
                        if (null === c3)
                          return void (b3._state ? a2.resolve : a2.reject)(b3._value);
                        var d3;
                        try {
                          d3 = c3(b3._value);
                        } catch (e4) {
                          return void a2.reject(e4);
                        }
                        a2.resolve(d3);
                      });
                    }
                    __name(d2, "d");
                    function e3(a2) {
                      try {
                        if (a2 === this)
                          throw new TypeError("A promise cannot be resolved with itself.");
                        if (a2 && ("object" == _typeof7(a2) || "function" == typeof a2)) {
                          var c3 = a2.then;
                          if ("function" == typeof c3)
                            return void i(b2(c3, a2), b2(e3, this), b2(f, this));
                        }
                        this._state = true, this._value = a2, g2.call(this);
                      } catch (d3) {
                        f.call(this, d3);
                      }
                    }
                    __name(e3, "e");
                    function f(a2) {
                      this._state = false, this._value = a2, g2.call(this);
                    }
                    __name(f, "f");
                    function g2() {
                      for (var a2 = 0, b3 = this._deferreds.length; b3 > a2; a2++) {
                        d2.call(this, this._deferreds[a2]);
                      }
                      this._deferreds = null;
                    }
                    __name(g2, "g");
                    function h2(a2, b3, c3, d3) {
                      this.onFulfilled = "function" == typeof a2 ? a2 : null, this.onRejected = "function" == typeof b3 ? b3 : null, this.resolve = c3, this.reject = d3;
                    }
                    __name(h2, "h");
                    function i(a2, b3, c3) {
                      var d3 = false;
                      try {
                        a2(function(a3) {
                          d3 || (d3 = true, b3(a3));
                        }, function(a3) {
                          d3 || (d3 = true, c3(a3));
                        });
                      } catch (e4) {
                        if (d3)
                          return;
                        d3 = true, c3(e4);
                      }
                    }
                    __name(i, "i");
                    var j2 = c2.immediateFn || "function" == typeof setImmediate2 && setImmediate2 || function(a2) {
                      setTimeout(a2, 1);
                    }, k2 = Array.isArray || function(a2) {
                      return "[object Array]" === Object.prototype.toString.call(a2);
                    };
                    c2.prototype["catch"] = function(a2) {
                      return this.then(null, a2);
                    }, c2.prototype.then = function(a2, b3) {
                      var e4 = this;
                      return new c2(function(c3, f2) {
                        d2.call(e4, new h2(a2, b3, c3, f2));
                      });
                    }, c2.all = function() {
                      var a2 = Array.prototype.slice.call(1 === arguments.length && k2(arguments[0]) ? arguments[0] : arguments);
                      return new c2(function(b3, c3) {
                        function d3(f3, g3) {
                          try {
                            if (g3 && ("object" == _typeof7(g3) || "function" == typeof g3)) {
                              var h3 = g3.then;
                              if ("function" == typeof h3)
                                return void h3.call(g3, function(a3) {
                                  d3(f3, a3);
                                }, c3);
                            }
                            a2[f3] = g3, 0 === --e4 && b3(a2);
                          } catch (i2) {
                            c3(i2);
                          }
                        }
                        __name(d3, "d");
                        if (0 === a2.length)
                          return b3([]);
                        for (var e4 = a2.length, f2 = 0; f2 < a2.length; f2++) {
                          d3(f2, a2[f2]);
                        }
                      });
                    }, c2.resolve = function(a2) {
                      return a2 && "object" == _typeof7(a2) && a2.constructor === c2 ? a2 : new c2(function(b3) {
                        b3(a2);
                      });
                    }, c2.reject = function(a2) {
                      return new c2(function(b3, c3) {
                        c3(a2);
                      });
                    }, c2.race = function(a2) {
                      return new c2(function(b3, c3) {
                        for (var d3 = 0, e4 = a2.length; e4 > d3; d3++) {
                          a2[d3].then(b3, c3);
                        }
                      });
                    }, module4.exports ? module4.exports = c2 : a.Promise || (a.Promise = c2);
                  })(this);
                  clipboard6.copy = function(data) {
                    return new Promise(function(resolve19, reject) {
                      if (typeof data !== "string" && !("text/plain" in data)) {
                        throw new Error("You must provide a text/plain type.");
                      }
                      var strData = typeof data === "string" ? data : data["text/plain"];
                      var copySucceeded = window.clipboardData.setData("Text", strData);
                      if (copySucceeded) {
                        resolve19();
                      } else {
                        reject(new Error("Copying was rejected."));
                      }
                    });
                  };
                  clipboard6.paste = function() {
                    return new Promise(function(resolve19, reject) {
                      var strData = window.clipboardData.getData("Text");
                      if (strData) {
                        resolve19(strData);
                      } else {
                        reject(new Error("Pasting was rejected."));
                      }
                    });
                  };
                }
                return clipboard6;
              });
            }).call(this, __webpack_require__(23).setImmediate);
          },
          /* 19 */
          /***/
          function(module4, exports3, __webpack_require__) {
            "use strict";
            function _classCallCheck5(instance, Constructor) {
              if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
              }
            }
            __name(_classCallCheck5, "_classCallCheck");
            function _defineProperties5(target, props) {
              for (var i = 0; i < props.length; i++) {
                var descriptor2 = props[i];
                descriptor2.enumerable = descriptor2.enumerable || false;
                descriptor2.configurable = true;
                if ("value" in descriptor2)
                  descriptor2.writable = true;
                Object.defineProperty(target, descriptor2.key, descriptor2);
              }
            }
            __name(_defineProperties5, "_defineProperties");
            function _createClass5(Constructor, protoProps, staticProps) {
              if (protoProps)
                _defineProperties5(Constructor.prototype, protoProps);
              if (staticProps)
                _defineProperties5(Constructor, staticProps);
              return Constructor;
            }
            __name(_createClass5, "_createClass");
            var Yallist = __webpack_require__(25);
            var MAX = Symbol("max");
            var LENGTH = Symbol("length");
            var LENGTH_CALCULATOR = Symbol("lengthCalculator");
            var ALLOW_STALE = Symbol("allowStale");
            var MAX_AGE = Symbol("maxAge");
            var DISPOSE = Symbol("dispose");
            var NO_DISPOSE_ON_SET = Symbol("noDisposeOnSet");
            var LRU_LIST = Symbol("lruList");
            var CACHE = Symbol("cache");
            var UPDATE_AGE_ON_GET = Symbol("updateAgeOnGet");
            var naiveLength = /* @__PURE__ */ __name(function naiveLength2() {
              return 1;
            }, "naiveLength");
            var LRUCache = /* @__PURE__ */ function() {
              function LRUCache2(options29) {
                _classCallCheck5(this, LRUCache2);
                if (typeof options29 === "number")
                  options29 = {
                    max: options29
                  };
                if (!options29)
                  options29 = {};
                if (options29.max && (typeof options29.max !== "number" || options29.max < 0))
                  throw new TypeError("max must be a non-negative number");
                var max = this[MAX] = options29.max || Infinity;
                var lc = options29.length || naiveLength;
                this[LENGTH_CALCULATOR] = typeof lc !== "function" ? naiveLength : lc;
                this[ALLOW_STALE] = options29.stale || false;
                if (options29.maxAge && typeof options29.maxAge !== "number")
                  throw new TypeError("maxAge must be a number");
                this[MAX_AGE] = options29.maxAge || 0;
                this[DISPOSE] = options29.dispose;
                this[NO_DISPOSE_ON_SET] = options29.noDisposeOnSet || false;
                this[UPDATE_AGE_ON_GET] = options29.updateAgeOnGet || false;
                this.reset();
              }
              __name(LRUCache2, "LRUCache");
              _createClass5(LRUCache2, [{
                key: "rforEach",
                value: /* @__PURE__ */ __name(function rforEach(fn2, thisp) {
                  thisp = thisp || this;
                  for (var walker = this[LRU_LIST].tail; walker !== null; ) {
                    var prev = walker.prev;
                    forEachStep(this, fn2, walker, thisp);
                    walker = prev;
                  }
                }, "rforEach")
              }, {
                key: "forEach",
                value: /* @__PURE__ */ __name(function forEach(fn2, thisp) {
                  thisp = thisp || this;
                  for (var walker = this[LRU_LIST].head; walker !== null; ) {
                    var next = walker.next;
                    forEachStep(this, fn2, walker, thisp);
                    walker = next;
                  }
                }, "forEach")
              }, {
                key: "keys",
                value: /* @__PURE__ */ __name(function keys() {
                  return this[LRU_LIST].toArray().map(function(k2) {
                    return k2.key;
                  });
                }, "keys")
              }, {
                key: "values",
                value: /* @__PURE__ */ __name(function values() {
                  return this[LRU_LIST].toArray().map(function(k2) {
                    return k2.value;
                  });
                }, "values")
              }, {
                key: "reset",
                value: /* @__PURE__ */ __name(function reset() {
                  var _this = this;
                  if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) {
                    this[LRU_LIST].forEach(function(hit) {
                      return _this[DISPOSE](hit.key, hit.value);
                    });
                  }
                  this[CACHE] = /* @__PURE__ */ new Map();
                  this[LRU_LIST] = new Yallist();
                  this[LENGTH] = 0;
                }, "reset")
              }, {
                key: "dump",
                value: /* @__PURE__ */ __name(function dump() {
                  var _this2 = this;
                  return this[LRU_LIST].map(function(hit) {
                    return isStale(_this2, hit) ? false : {
                      k: hit.key,
                      v: hit.value,
                      e: hit.now + (hit.maxAge || 0)
                    };
                  }).toArray().filter(function(h2) {
                    return h2;
                  });
                }, "dump")
              }, {
                key: "dumpLru",
                value: /* @__PURE__ */ __name(function dumpLru() {
                  return this[LRU_LIST];
                }, "dumpLru")
              }, {
                key: "set",
                value: /* @__PURE__ */ __name(function set(key, value, maxAge) {
                  maxAge = maxAge || this[MAX_AGE];
                  if (maxAge && typeof maxAge !== "number")
                    throw new TypeError("maxAge must be a number");
                  var now = maxAge ? Date.now() : 0;
                  var len = this[LENGTH_CALCULATOR](value, key);
                  if (this[CACHE].has(key)) {
                    if (len > this[MAX]) {
                      _del(this, this[CACHE].get(key));
                      return false;
                    }
                    var node2 = this[CACHE].get(key);
                    var item = node2.value;
                    if (this[DISPOSE]) {
                      if (!this[NO_DISPOSE_ON_SET])
                        this[DISPOSE](key, item.value);
                    }
                    item.now = now;
                    item.maxAge = maxAge;
                    item.value = value;
                    this[LENGTH] += len - item.length;
                    item.length = len;
                    this.get(key);
                    trim(this);
                    return true;
                  }
                  var hit = new Entry(key, value, len, now, maxAge);
                  if (hit.length > this[MAX]) {
                    if (this[DISPOSE])
                      this[DISPOSE](key, value);
                    return false;
                  }
                  this[LENGTH] += hit.length;
                  this[LRU_LIST].unshift(hit);
                  this[CACHE].set(key, this[LRU_LIST].head);
                  trim(this);
                  return true;
                }, "set")
              }, {
                key: "has",
                value: /* @__PURE__ */ __name(function has(key) {
                  if (!this[CACHE].has(key))
                    return false;
                  var hit = this[CACHE].get(key).value;
                  return !isStale(this, hit);
                }, "has")
              }, {
                key: "get",
                value: /* @__PURE__ */ __name(function get(key) {
                  return _get(this, key, true);
                }, "get")
              }, {
                key: "peek",
                value: /* @__PURE__ */ __name(function peek(key) {
                  return _get(this, key, false);
                }, "peek")
              }, {
                key: "pop",
                value: /* @__PURE__ */ __name(function pop() {
                  var node2 = this[LRU_LIST].tail;
                  if (!node2)
                    return null;
                  _del(this, node2);
                  return node2.value;
                }, "pop")
              }, {
                key: "del",
                value: /* @__PURE__ */ __name(function del(key) {
                  _del(this, this[CACHE].get(key));
                }, "del")
              }, {
                key: "load",
                value: /* @__PURE__ */ __name(function load(arr) {
                  this.reset();
                  var now = Date.now();
                  for (var l2 = arr.length - 1; l2 >= 0; l2--) {
                    var hit = arr[l2];
                    var expiresAt = hit.e || 0;
                    if (expiresAt === 0)
                      this.set(hit.k, hit.v);
                    else {
                      var maxAge = expiresAt - now;
                      if (maxAge > 0) {
                        this.set(hit.k, hit.v, maxAge);
                      }
                    }
                  }
                }, "load")
              }, {
                key: "prune",
                value: /* @__PURE__ */ __name(function prune() {
                  var _this3 = this;
                  this[CACHE].forEach(function(value, key) {
                    return _get(_this3, key, false);
                  });
                }, "prune")
              }, {
                key: "max",
                set: /* @__PURE__ */ __name(function set(mL) {
                  if (typeof mL !== "number" || mL < 0)
                    throw new TypeError("max must be a non-negative number");
                  this[MAX] = mL || Infinity;
                  trim(this);
                }, "set"),
                get: /* @__PURE__ */ __name(function get() {
                  return this[MAX];
                }, "get")
              }, {
                key: "allowStale",
                set: /* @__PURE__ */ __name(function set(allowStale) {
                  this[ALLOW_STALE] = !!allowStale;
                }, "set"),
                get: /* @__PURE__ */ __name(function get() {
                  return this[ALLOW_STALE];
                }, "get")
              }, {
                key: "maxAge",
                set: /* @__PURE__ */ __name(function set(mA) {
                  if (typeof mA !== "number")
                    throw new TypeError("maxAge must be a non-negative number");
                  this[MAX_AGE] = mA;
                  trim(this);
                }, "set"),
                get: /* @__PURE__ */ __name(function get() {
                  return this[MAX_AGE];
                }, "get")
                // resize the cache when the lengthCalculator changes.
              }, {
                key: "lengthCalculator",
                set: /* @__PURE__ */ __name(function set(lC) {
                  var _this4 = this;
                  if (typeof lC !== "function")
                    lC = naiveLength;
                  if (lC !== this[LENGTH_CALCULATOR]) {
                    this[LENGTH_CALCULATOR] = lC;
                    this[LENGTH] = 0;
                    this[LRU_LIST].forEach(function(hit) {
                      hit.length = _this4[LENGTH_CALCULATOR](hit.value, hit.key);
                      _this4[LENGTH] += hit.length;
                    });
                  }
                  trim(this);
                }, "set"),
                get: /* @__PURE__ */ __name(function get() {
                  return this[LENGTH_CALCULATOR];
                }, "get")
              }, {
                key: "length",
                get: /* @__PURE__ */ __name(function get() {
                  return this[LENGTH];
                }, "get")
              }, {
                key: "itemCount",
                get: /* @__PURE__ */ __name(function get() {
                  return this[LRU_LIST].length;
                }, "get")
              }]);
              return LRUCache2;
            }();
            var _get = /* @__PURE__ */ __name(function _get2(self2, key, doUse) {
              var node2 = self2[CACHE].get(key);
              if (node2) {
                var hit = node2.value;
                if (isStale(self2, hit)) {
                  _del(self2, node2);
                  if (!self2[ALLOW_STALE])
                    return void 0;
                } else {
                  if (doUse) {
                    if (self2[UPDATE_AGE_ON_GET])
                      node2.value.now = Date.now();
                    self2[LRU_LIST].unshiftNode(node2);
                  }
                }
                return hit.value;
              }
            }, "_get");
            var isStale = /* @__PURE__ */ __name(function isStale2(self2, hit) {
              if (!hit || !hit.maxAge && !self2[MAX_AGE])
                return false;
              var diff = Date.now() - hit.now;
              return hit.maxAge ? diff > hit.maxAge : self2[MAX_AGE] && diff > self2[MAX_AGE];
            }, "isStale");
            var trim = /* @__PURE__ */ __name(function trim2(self2) {
              if (self2[LENGTH] > self2[MAX]) {
                for (var walker = self2[LRU_LIST].tail; self2[LENGTH] > self2[MAX] && walker !== null; ) {
                  var prev = walker.prev;
                  _del(self2, walker);
                  walker = prev;
                }
              }
            }, "trim");
            var _del = /* @__PURE__ */ __name(function _del2(self2, node2) {
              if (node2) {
                var hit = node2.value;
                if (self2[DISPOSE])
                  self2[DISPOSE](hit.key, hit.value);
                self2[LENGTH] -= hit.length;
                self2[CACHE].delete(hit.key);
                self2[LRU_LIST].removeNode(node2);
              }
            }, "_del");
            var Entry = /* @__PURE__ */ __name(function Entry2(key, value, length, now, maxAge) {
              _classCallCheck5(this, Entry2);
              this.key = key;
              this.value = value;
              this.length = length;
              this.now = now;
              this.maxAge = maxAge || 0;
            }, "Entry");
            var forEachStep = /* @__PURE__ */ __name(function forEachStep2(self2, fn2, node2, thisp) {
              var hit = node2.value;
              if (isStale(self2, hit)) {
                _del(self2, node2);
                if (!self2[ALLOW_STALE])
                  hit = void 0;
              }
              if (hit)
                fn2.call(thisp, hit.value, hit.key, self2);
            }, "forEachStep");
            module4.exports = LRUCache;
          },
          /* 20 */
          /***/
          function(module4, __webpack_exports__, __webpack_require__) {
            "use strict";
            __webpack_require__.d(__webpack_exports__, "a", function() {
              return REACT_SUSPENSE_LIST_TYPE;
            });
            function _typeof7(obj) {
              "@babel/helpers - typeof";
              if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return typeof obj2;
                }, "_typeof");
              } else {
                _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
                }, "_typeof");
              }
              return _typeof7(obj);
            }
            __name(_typeof7, "_typeof");
            var REACT_ELEMENT_TYPE = 60103;
            var REACT_PORTAL_TYPE = 60106;
            var REACT_FRAGMENT_TYPE = 60107;
            var REACT_STRICT_MODE_TYPE = 60108;
            var REACT_PROFILER_TYPE = 60114;
            var REACT_PROVIDER_TYPE = 60109;
            var REACT_CONTEXT_TYPE = 60110;
            var REACT_FORWARD_REF_TYPE = 60112;
            var REACT_SUSPENSE_TYPE = 60113;
            var REACT_SUSPENSE_LIST_TYPE = 60120;
            var REACT_MEMO_TYPE = 60115;
            var REACT_LAZY_TYPE = 60116;
            var REACT_SCOPE_TYPE = 60119;
            var REACT_DEBUG_TRACING_MODE_TYPE = 60129;
            var REACT_OFFSCREEN_TYPE = 60130;
            var REACT_LEGACY_HIDDEN_TYPE = 60131;
            var REACT_CACHE_TYPE = 60132;
            if (typeof Symbol === "function" && Symbol.for) {
              var symbolFor = Symbol.for;
              REACT_ELEMENT_TYPE = symbolFor("react.element");
              REACT_PORTAL_TYPE = symbolFor("react.portal");
              REACT_FRAGMENT_TYPE = symbolFor("react.fragment");
              REACT_STRICT_MODE_TYPE = symbolFor("react.strict_mode");
              REACT_PROFILER_TYPE = symbolFor("react.profiler");
              REACT_PROVIDER_TYPE = symbolFor("react.provider");
              REACT_CONTEXT_TYPE = symbolFor("react.context");
              REACT_FORWARD_REF_TYPE = symbolFor("react.forward_ref");
              REACT_SUSPENSE_TYPE = symbolFor("react.suspense");
              REACT_SUSPENSE_LIST_TYPE = symbolFor("react.suspense_list");
              REACT_MEMO_TYPE = symbolFor("react.memo");
              REACT_LAZY_TYPE = symbolFor("react.lazy");
              REACT_SCOPE_TYPE = symbolFor("react.scope");
              REACT_DEBUG_TRACING_MODE_TYPE = symbolFor("react.debug_trace_mode");
              REACT_OFFSCREEN_TYPE = symbolFor("react.offscreen");
              REACT_LEGACY_HIDDEN_TYPE = symbolFor("react.legacy_hidden");
              REACT_CACHE_TYPE = symbolFor("react.cache");
            }
            var MAYBE_ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
            var FAUX_ITERATOR_SYMBOL = "@@iterator";
            function getIteratorFn(maybeIterable) {
              if (maybeIterable === null || _typeof7(maybeIterable) !== "object") {
                return null;
              }
              var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
              if (typeof maybeIterator === "function") {
                return maybeIterator;
              }
              return null;
            }
            __name(getIteratorFn, "getIteratorFn");
          },
          /* 21 */
          /***/
          function(module4, exports3, __webpack_require__) {
            "use strict";
            if (true) {
              module4.exports = __webpack_require__(28);
            } else {
            }
          },
          /* 22 */
          /***/
          function(module4, __webpack_exports__, __webpack_require__) {
            "use strict";
            __webpack_require__.d(__webpack_exports__, "a", function() {
              return (
                /* binding */
                getStackByFiberInDevAndProd
              );
            });
            var ReactSymbols = __webpack_require__(3);
            function ownKeys11(object, enumerableOnly) {
              var keys = Object.keys(object);
              if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                if (enumerableOnly)
                  symbols = symbols.filter(function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                  });
                keys.push.apply(keys, symbols);
              }
              return keys;
            }
            __name(ownKeys11, "ownKeys");
            function _objectSpread11(target) {
              for (var i = 1; i < arguments.length; i++) {
                var source = arguments[i] != null ? arguments[i] : {};
                if (i % 2) {
                  ownKeys11(Object(source), true).forEach(function(key) {
                    _defineProperty11(target, key, source[key]);
                  });
                } else if (Object.getOwnPropertyDescriptors) {
                  Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
                } else {
                  ownKeys11(Object(source)).forEach(function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                  });
                }
              }
              return target;
            }
            __name(_objectSpread11, "_objectSpread");
            function _defineProperty11(obj, key, value) {
              if (key in obj) {
                Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
              } else {
                obj[key] = value;
              }
              return obj;
            }
            __name(_defineProperty11, "_defineProperty");
            var disabledDepth = 0;
            var prevLog;
            var prevInfo;
            var prevWarn;
            var prevError;
            var prevGroup;
            var prevGroupCollapsed;
            var prevGroupEnd;
            function disabledLog() {
            }
            __name(disabledLog, "disabledLog");
            disabledLog.__reactDisabledLog = true;
            function disableLogs() {
              if (disabledDepth === 0) {
                prevLog = console.log;
                prevInfo = console.info;
                prevWarn = console.warn;
                prevError = console.error;
                prevGroup = console.group;
                prevGroupCollapsed = console.groupCollapsed;
                prevGroupEnd = console.groupEnd;
                var props = {
                  configurable: true,
                  enumerable: true,
                  value: disabledLog,
                  writable: true
                };
                Object.defineProperties(console, {
                  info: props,
                  log: props,
                  warn: props,
                  error: props,
                  group: props,
                  groupCollapsed: props,
                  groupEnd: props
                });
              }
              disabledDepth++;
            }
            __name(disableLogs, "disableLogs");
            function reenableLogs() {
              disabledDepth--;
              if (disabledDepth === 0) {
                var props = {
                  configurable: true,
                  enumerable: true,
                  writable: true
                };
                Object.defineProperties(console, {
                  log: _objectSpread11(_objectSpread11({}, props), {}, {
                    value: prevLog
                  }),
                  info: _objectSpread11(_objectSpread11({}, props), {}, {
                    value: prevInfo
                  }),
                  warn: _objectSpread11(_objectSpread11({}, props), {}, {
                    value: prevWarn
                  }),
                  error: _objectSpread11(_objectSpread11({}, props), {}, {
                    value: prevError
                  }),
                  group: _objectSpread11(_objectSpread11({}, props), {}, {
                    value: prevGroup
                  }),
                  groupCollapsed: _objectSpread11(_objectSpread11({}, props), {}, {
                    value: prevGroupCollapsed
                  }),
                  groupEnd: _objectSpread11(_objectSpread11({}, props), {}, {
                    value: prevGroupEnd
                  })
                });
              }
              if (disabledDepth < 0) {
                console.error("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
              }
            }
            __name(reenableLogs, "reenableLogs");
            function _typeof7(obj) {
              "@babel/helpers - typeof";
              if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return typeof obj2;
                }, "_typeof");
              } else {
                _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
                }, "_typeof");
              }
              return _typeof7(obj);
            }
            __name(_typeof7, "_typeof");
            var prefix;
            function describeBuiltInComponentFrame(name, source, ownerFn) {
              if (prefix === void 0) {
                try {
                  throw Error();
                } catch (x2) {
                  var match = x2.stack.trim().match(/\n( *(at )?)/);
                  prefix = match && match[1] || "";
                }
              }
              return "\n" + prefix + name;
            }
            __name(describeBuiltInComponentFrame, "describeBuiltInComponentFrame");
            var reentry = false;
            var componentFrameCache;
            if (false) {
              var PossiblyWeakMap;
            }
            function describeNativeComponentFrame(fn2, construct, currentDispatcherRef) {
              if (!fn2 || reentry) {
                return "";
              }
              if (false) {
                var frame;
              }
              var control;
              var previousPrepareStackTrace = Error.prepareStackTrace;
              Error.prepareStackTrace = void 0;
              reentry = true;
              var previousDispatcher = currentDispatcherRef.current;
              currentDispatcherRef.current = null;
              disableLogs();
              try {
                if (construct) {
                  var Fake = /* @__PURE__ */ __name(function Fake2() {
                    throw Error();
                  }, "Fake");
                  Object.defineProperty(Fake.prototype, "props", {
                    set: /* @__PURE__ */ __name(function set() {
                      throw Error();
                    }, "set")
                  });
                  if ((typeof Reflect === "undefined" ? "undefined" : _typeof7(Reflect)) === "object" && Reflect.construct) {
                    try {
                      Reflect.construct(Fake, []);
                    } catch (x2) {
                      control = x2;
                    }
                    Reflect.construct(fn2, [], Fake);
                  } else {
                    try {
                      Fake.call();
                    } catch (x2) {
                      control = x2;
                    }
                    fn2.call(Fake.prototype);
                  }
                } else {
                  try {
                    throw Error();
                  } catch (x2) {
                    control = x2;
                  }
                  fn2();
                }
              } catch (sample) {
                if (sample && control && typeof sample.stack === "string") {
                  var sampleLines = sample.stack.split("\n");
                  var controlLines = control.stack.split("\n");
                  var s = sampleLines.length - 1;
                  var c2 = controlLines.length - 1;
                  while (s >= 1 && c2 >= 0 && sampleLines[s] !== controlLines[c2]) {
                    c2--;
                  }
                  for (; s >= 1 && c2 >= 0; s--, c2--) {
                    if (sampleLines[s] !== controlLines[c2]) {
                      if (s !== 1 || c2 !== 1) {
                        do {
                          s--;
                          c2--;
                          if (c2 < 0 || sampleLines[s] !== controlLines[c2]) {
                            var _frame = "\n" + sampleLines[s].replace(" at new ", " at ");
                            if (false) {
                            }
                            return _frame;
                          }
                        } while (s >= 1 && c2 >= 0);
                      }
                      break;
                    }
                  }
                }
              } finally {
                reentry = false;
                Error.prepareStackTrace = previousPrepareStackTrace;
                currentDispatcherRef.current = previousDispatcher;
                reenableLogs();
              }
              var name = fn2 ? fn2.displayName || fn2.name : "";
              var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
              if (false) {
              }
              return syntheticFrame;
            }
            __name(describeNativeComponentFrame, "describeNativeComponentFrame");
            function describeClassComponentFrame(ctor, source, ownerFn, currentDispatcherRef) {
              return describeNativeComponentFrame(ctor, true, currentDispatcherRef);
            }
            __name(describeClassComponentFrame, "describeClassComponentFrame");
            function describeFunctionComponentFrame(fn2, source, ownerFn, currentDispatcherRef) {
              return describeNativeComponentFrame(fn2, false, currentDispatcherRef);
            }
            __name(describeFunctionComponentFrame, "describeFunctionComponentFrame");
            function shouldConstruct(Component2) {
              var prototype = Component2.prototype;
              return !!(prototype && prototype.isReactComponent);
            }
            __name(shouldConstruct, "shouldConstruct");
            function describeUnknownElementTypeFrameInDEV(type, source, ownerFn, currentDispatcherRef) {
              if (true) {
                return "";
              }
              if (type == null) {
                return "";
              }
              if (typeof type === "function") {
                return describeNativeComponentFrame(type, shouldConstruct(type), currentDispatcherRef);
              }
              if (typeof type === "string") {
                return describeBuiltInComponentFrame(type, source, ownerFn);
              }
              switch (type) {
                case ReactSymbols[
                  "v"
                  /* SUSPENSE_NUMBER */
                ]:
                case ReactSymbols[
                  "w"
                  /* SUSPENSE_SYMBOL_STRING */
                ]:
                  return describeBuiltInComponentFrame("Suspense", source, ownerFn);
                case ReactSymbols[
                  "t"
                  /* SUSPENSE_LIST_NUMBER */
                ]:
                case ReactSymbols[
                  "u"
                  /* SUSPENSE_LIST_SYMBOL_STRING */
                ]:
                  return describeBuiltInComponentFrame("SuspenseList", source, ownerFn);
              }
              if (_typeof7(type) === "object") {
                switch (type.$$typeof) {
                  case ReactSymbols[
                    "f"
                    /* FORWARD_REF_NUMBER */
                  ]:
                  case ReactSymbols[
                    "g"
                    /* FORWARD_REF_SYMBOL_STRING */
                  ]:
                    return describeFunctionComponentFrame(type.render, source, ownerFn, currentDispatcherRef);
                  case ReactSymbols[
                    "j"
                    /* MEMO_NUMBER */
                  ]:
                  case ReactSymbols[
                    "k"
                    /* MEMO_SYMBOL_STRING */
                  ]:
                    return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn, currentDispatcherRef);
                  case ReactSymbols[
                    "h"
                    /* LAZY_NUMBER */
                  ]:
                  case ReactSymbols[
                    "i"
                    /* LAZY_SYMBOL_STRING */
                  ]: {
                    var lazyComponent = type;
                    var payload = lazyComponent._payload;
                    var init3 = lazyComponent._init;
                    try {
                      return describeUnknownElementTypeFrameInDEV(init3(payload), source, ownerFn, currentDispatcherRef);
                    } catch (x2) {
                    }
                  }
                }
              }
              return "";
            }
            __name(describeUnknownElementTypeFrameInDEV, "describeUnknownElementTypeFrameInDEV");
            function describeFiber(workTagMap, workInProgress, currentDispatcherRef) {
              var HostComponent = workTagMap.HostComponent, LazyComponent = workTagMap.LazyComponent, SuspenseComponent = workTagMap.SuspenseComponent, SuspenseListComponent = workTagMap.SuspenseListComponent, FunctionComponent = workTagMap.FunctionComponent, IndeterminateComponent = workTagMap.IndeterminateComponent, SimpleMemoComponent = workTagMap.SimpleMemoComponent, ForwardRef = workTagMap.ForwardRef, ClassComponent = workTagMap.ClassComponent;
              var owner = false ? void 0 : null;
              var source = false ? void 0 : null;
              switch (workInProgress.tag) {
                case HostComponent:
                  return describeBuiltInComponentFrame(workInProgress.type, source, owner);
                case LazyComponent:
                  return describeBuiltInComponentFrame("Lazy", source, owner);
                case SuspenseComponent:
                  return describeBuiltInComponentFrame("Suspense", source, owner);
                case SuspenseListComponent:
                  return describeBuiltInComponentFrame("SuspenseList", source, owner);
                case FunctionComponent:
                case IndeterminateComponent:
                case SimpleMemoComponent:
                  return describeFunctionComponentFrame(workInProgress.type, source, owner, currentDispatcherRef);
                case ForwardRef:
                  return describeFunctionComponentFrame(workInProgress.type.render, source, owner, currentDispatcherRef);
                case ClassComponent:
                  return describeClassComponentFrame(workInProgress.type, source, owner, currentDispatcherRef);
                default:
                  return "";
              }
            }
            __name(describeFiber, "describeFiber");
            function getStackByFiberInDevAndProd(workTagMap, workInProgress, currentDispatcherRef) {
              try {
                var info = "";
                var node2 = workInProgress;
                do {
                  info += describeFiber(workTagMap, node2, currentDispatcherRef);
                  node2 = node2.return;
                } while (node2);
                return info;
              } catch (x2) {
                return "\nError generating stack: " + x2.message + "\n" + x2.stack;
              }
            }
            __name(getStackByFiberInDevAndProd, "getStackByFiberInDevAndProd");
          },
          /* 23 */
          /***/
          function(module4, exports3, __webpack_require__) {
            (function(global2) {
              var scope = typeof global2 !== "undefined" && global2 || typeof self !== "undefined" && self || window;
              var apply = Function.prototype.apply;
              exports3.setTimeout = function() {
                return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);
              };
              exports3.setInterval = function() {
                return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);
              };
              exports3.clearTimeout = exports3.clearInterval = function(timeout) {
                if (timeout) {
                  timeout.close();
                }
              };
              function Timeout(id, clearFn) {
                this._id = id;
                this._clearFn = clearFn;
              }
              __name(Timeout, "Timeout");
              Timeout.prototype.unref = Timeout.prototype.ref = function() {
              };
              Timeout.prototype.close = function() {
                this._clearFn.call(scope, this._id);
              };
              exports3.enroll = function(item, msecs) {
                clearTimeout(item._idleTimeoutId);
                item._idleTimeout = msecs;
              };
              exports3.unenroll = function(item) {
                clearTimeout(item._idleTimeoutId);
                item._idleTimeout = -1;
              };
              exports3._unrefActive = exports3.active = function(item) {
                clearTimeout(item._idleTimeoutId);
                var msecs = item._idleTimeout;
                if (msecs >= 0) {
                  item._idleTimeoutId = setTimeout(/* @__PURE__ */ __name(function onTimeout() {
                    if (item._onTimeout)
                      item._onTimeout();
                  }, "onTimeout"), msecs);
                }
              };
              __webpack_require__(24);
              exports3.setImmediate = typeof self !== "undefined" && self.setImmediate || typeof global2 !== "undefined" && global2.setImmediate || this && this.setImmediate;
              exports3.clearImmediate = typeof self !== "undefined" && self.clearImmediate || typeof global2 !== "undefined" && global2.clearImmediate || this && this.clearImmediate;
            }).call(this, __webpack_require__(14));
          },
          /* 24 */
          /***/
          function(module4, exports3, __webpack_require__) {
            (function(global2, process11) {
              (function(global3, undefined2) {
                "use strict";
                if (global3.setImmediate) {
                  return;
                }
                var nextHandle = 1;
                var tasksByHandle = {};
                var currentlyRunningATask = false;
                var doc = global3.document;
                var registerImmediate;
                function setImmediate2(callback) {
                  if (typeof callback !== "function") {
                    callback = new Function("" + callback);
                  }
                  var args = new Array(arguments.length - 1);
                  for (var i = 0; i < args.length; i++) {
                    args[i] = arguments[i + 1];
                  }
                  var task = {
                    callback,
                    args
                  };
                  tasksByHandle[nextHandle] = task;
                  registerImmediate(nextHandle);
                  return nextHandle++;
                }
                __name(setImmediate2, "setImmediate");
                function clearImmediate2(handle) {
                  delete tasksByHandle[handle];
                }
                __name(clearImmediate2, "clearImmediate");
                function run(task) {
                  var callback = task.callback;
                  var args = task.args;
                  switch (args.length) {
                    case 0:
                      callback();
                      break;
                    case 1:
                      callback(args[0]);
                      break;
                    case 2:
                      callback(args[0], args[1]);
                      break;
                    case 3:
                      callback(args[0], args[1], args[2]);
                      break;
                    default:
                      callback.apply(undefined2, args);
                      break;
                  }
                }
                __name(run, "run");
                function runIfPresent(handle) {
                  if (currentlyRunningATask) {
                    setTimeout(runIfPresent, 0, handle);
                  } else {
                    var task = tasksByHandle[handle];
                    if (task) {
                      currentlyRunningATask = true;
                      try {
                        run(task);
                      } finally {
                        clearImmediate2(handle);
                        currentlyRunningATask = false;
                      }
                    }
                  }
                }
                __name(runIfPresent, "runIfPresent");
                function installNextTickImplementation() {
                  registerImmediate = /* @__PURE__ */ __name(function registerImmediate2(handle) {
                    process11.nextTick(function() {
                      runIfPresent(handle);
                    });
                  }, "registerImmediate");
                }
                __name(installNextTickImplementation, "installNextTickImplementation");
                function canUsePostMessage() {
                  if (global3.postMessage && !global3.importScripts) {
                    var postMessageIsAsynchronous = true;
                    var oldOnMessage = global3.onmessage;
                    global3.onmessage = function() {
                      postMessageIsAsynchronous = false;
                    };
                    global3.postMessage("", "*");
                    global3.onmessage = oldOnMessage;
                    return postMessageIsAsynchronous;
                  }
                }
                __name(canUsePostMessage, "canUsePostMessage");
                function installPostMessageImplementation() {
                  var messagePrefix = "setImmediate$" + Math.random() + "$";
                  var onGlobalMessage = /* @__PURE__ */ __name(function onGlobalMessage2(event) {
                    if (event.source === global3 && typeof event.data === "string" && event.data.indexOf(messagePrefix) === 0) {
                      runIfPresent(+event.data.slice(messagePrefix.length));
                    }
                  }, "onGlobalMessage");
                  if (global3.addEventListener) {
                    global3.addEventListener("message", onGlobalMessage, false);
                  } else {
                    global3.attachEvent("onmessage", onGlobalMessage);
                  }
                  registerImmediate = /* @__PURE__ */ __name(function registerImmediate2(handle) {
                    global3.postMessage(messagePrefix + handle, "*");
                  }, "registerImmediate");
                }
                __name(installPostMessageImplementation, "installPostMessageImplementation");
                function installMessageChannelImplementation() {
                  var channel = new MessageChannel();
                  channel.port1.onmessage = function(event) {
                    var handle = event.data;
                    runIfPresent(handle);
                  };
                  registerImmediate = /* @__PURE__ */ __name(function registerImmediate2(handle) {
                    channel.port2.postMessage(handle);
                  }, "registerImmediate");
                }
                __name(installMessageChannelImplementation, "installMessageChannelImplementation");
                function installReadyStateChangeImplementation() {
                  var html = doc.documentElement;
                  registerImmediate = /* @__PURE__ */ __name(function registerImmediate2(handle) {
                    var script = doc.createElement("script");
                    script.onreadystatechange = function() {
                      runIfPresent(handle);
                      script.onreadystatechange = null;
                      html.removeChild(script);
                      script = null;
                    };
                    html.appendChild(script);
                  }, "registerImmediate");
                }
                __name(installReadyStateChangeImplementation, "installReadyStateChangeImplementation");
                function installSetTimeoutImplementation() {
                  registerImmediate = /* @__PURE__ */ __name(function registerImmediate2(handle) {
                    setTimeout(runIfPresent, 0, handle);
                  }, "registerImmediate");
                }
                __name(installSetTimeoutImplementation, "installSetTimeoutImplementation");
                var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global3);
                attachTo = attachTo && attachTo.setTimeout ? attachTo : global3;
                if ({}.toString.call(global3.process) === "[object process]") {
                  installNextTickImplementation();
                } else if (canUsePostMessage()) {
                  installPostMessageImplementation();
                } else if (global3.MessageChannel) {
                  installMessageChannelImplementation();
                } else if (doc && "onreadystatechange" in doc.createElement("script")) {
                  installReadyStateChangeImplementation();
                } else {
                  installSetTimeoutImplementation();
                }
                attachTo.setImmediate = setImmediate2;
                attachTo.clearImmediate = clearImmediate2;
              })(typeof self === "undefined" ? typeof global2 === "undefined" ? this : global2 : self);
            }).call(this, __webpack_require__(14), __webpack_require__(17));
          },
          /* 25 */
          /***/
          function(module4, exports3, __webpack_require__) {
            "use strict";
            module4.exports = Yallist;
            Yallist.Node = Node3;
            Yallist.create = Yallist;
            function Yallist(list) {
              var self2 = this;
              if (!(self2 instanceof Yallist)) {
                self2 = new Yallist();
              }
              self2.tail = null;
              self2.head = null;
              self2.length = 0;
              if (list && typeof list.forEach === "function") {
                list.forEach(function(item) {
                  self2.push(item);
                });
              } else if (arguments.length > 0) {
                for (var i = 0, l2 = arguments.length; i < l2; i++) {
                  self2.push(arguments[i]);
                }
              }
              return self2;
            }
            __name(Yallist, "Yallist");
            Yallist.prototype.removeNode = function(node2) {
              if (node2.list !== this) {
                throw new Error("removing node which does not belong to this list");
              }
              var next = node2.next;
              var prev = node2.prev;
              if (next) {
                next.prev = prev;
              }
              if (prev) {
                prev.next = next;
              }
              if (node2 === this.head) {
                this.head = next;
              }
              if (node2 === this.tail) {
                this.tail = prev;
              }
              node2.list.length--;
              node2.next = null;
              node2.prev = null;
              node2.list = null;
              return next;
            };
            Yallist.prototype.unshiftNode = function(node2) {
              if (node2 === this.head) {
                return;
              }
              if (node2.list) {
                node2.list.removeNode(node2);
              }
              var head = this.head;
              node2.list = this;
              node2.next = head;
              if (head) {
                head.prev = node2;
              }
              this.head = node2;
              if (!this.tail) {
                this.tail = node2;
              }
              this.length++;
            };
            Yallist.prototype.pushNode = function(node2) {
              if (node2 === this.tail) {
                return;
              }
              if (node2.list) {
                node2.list.removeNode(node2);
              }
              var tail = this.tail;
              node2.list = this;
              node2.prev = tail;
              if (tail) {
                tail.next = node2;
              }
              this.tail = node2;
              if (!this.head) {
                this.head = node2;
              }
              this.length++;
            };
            Yallist.prototype.push = function() {
              for (var i = 0, l2 = arguments.length; i < l2; i++) {
                push(this, arguments[i]);
              }
              return this.length;
            };
            Yallist.prototype.unshift = function() {
              for (var i = 0, l2 = arguments.length; i < l2; i++) {
                unshift(this, arguments[i]);
              }
              return this.length;
            };
            Yallist.prototype.pop = function() {
              if (!this.tail) {
                return void 0;
              }
              var res = this.tail.value;
              this.tail = this.tail.prev;
              if (this.tail) {
                this.tail.next = null;
              } else {
                this.head = null;
              }
              this.length--;
              return res;
            };
            Yallist.prototype.shift = function() {
              if (!this.head) {
                return void 0;
              }
              var res = this.head.value;
              this.head = this.head.next;
              if (this.head) {
                this.head.prev = null;
              } else {
                this.tail = null;
              }
              this.length--;
              return res;
            };
            Yallist.prototype.forEach = function(fn2, thisp) {
              thisp = thisp || this;
              for (var walker = this.head, i = 0; walker !== null; i++) {
                fn2.call(thisp, walker.value, i, this);
                walker = walker.next;
              }
            };
            Yallist.prototype.forEachReverse = function(fn2, thisp) {
              thisp = thisp || this;
              for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
                fn2.call(thisp, walker.value, i, this);
                walker = walker.prev;
              }
            };
            Yallist.prototype.get = function(n2) {
              for (var i = 0, walker = this.head; walker !== null && i < n2; i++) {
                walker = walker.next;
              }
              if (i === n2 && walker !== null) {
                return walker.value;
              }
            };
            Yallist.prototype.getReverse = function(n2) {
              for (var i = 0, walker = this.tail; walker !== null && i < n2; i++) {
                walker = walker.prev;
              }
              if (i === n2 && walker !== null) {
                return walker.value;
              }
            };
            Yallist.prototype.map = function(fn2, thisp) {
              thisp = thisp || this;
              var res = new Yallist();
              for (var walker = this.head; walker !== null; ) {
                res.push(fn2.call(thisp, walker.value, this));
                walker = walker.next;
              }
              return res;
            };
            Yallist.prototype.mapReverse = function(fn2, thisp) {
              thisp = thisp || this;
              var res = new Yallist();
              for (var walker = this.tail; walker !== null; ) {
                res.push(fn2.call(thisp, walker.value, this));
                walker = walker.prev;
              }
              return res;
            };
            Yallist.prototype.reduce = function(fn2, initial) {
              var acc;
              var walker = this.head;
              if (arguments.length > 1) {
                acc = initial;
              } else if (this.head) {
                walker = this.head.next;
                acc = this.head.value;
              } else {
                throw new TypeError("Reduce of empty list with no initial value");
              }
              for (var i = 0; walker !== null; i++) {
                acc = fn2(acc, walker.value, i);
                walker = walker.next;
              }
              return acc;
            };
            Yallist.prototype.reduceReverse = function(fn2, initial) {
              var acc;
              var walker = this.tail;
              if (arguments.length > 1) {
                acc = initial;
              } else if (this.tail) {
                walker = this.tail.prev;
                acc = this.tail.value;
              } else {
                throw new TypeError("Reduce of empty list with no initial value");
              }
              for (var i = this.length - 1; walker !== null; i--) {
                acc = fn2(acc, walker.value, i);
                walker = walker.prev;
              }
              return acc;
            };
            Yallist.prototype.toArray = function() {
              var arr = new Array(this.length);
              for (var i = 0, walker = this.head; walker !== null; i++) {
                arr[i] = walker.value;
                walker = walker.next;
              }
              return arr;
            };
            Yallist.prototype.toArrayReverse = function() {
              var arr = new Array(this.length);
              for (var i = 0, walker = this.tail; walker !== null; i++) {
                arr[i] = walker.value;
                walker = walker.prev;
              }
              return arr;
            };
            Yallist.prototype.slice = function(from, to) {
              to = to || this.length;
              if (to < 0) {
                to += this.length;
              }
              from = from || 0;
              if (from < 0) {
                from += this.length;
              }
              var ret = new Yallist();
              if (to < from || to < 0) {
                return ret;
              }
              if (from < 0) {
                from = 0;
              }
              if (to > this.length) {
                to = this.length;
              }
              for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
                walker = walker.next;
              }
              for (; walker !== null && i < to; i++, walker = walker.next) {
                ret.push(walker.value);
              }
              return ret;
            };
            Yallist.prototype.sliceReverse = function(from, to) {
              to = to || this.length;
              if (to < 0) {
                to += this.length;
              }
              from = from || 0;
              if (from < 0) {
                from += this.length;
              }
              var ret = new Yallist();
              if (to < from || to < 0) {
                return ret;
              }
              if (from < 0) {
                from = 0;
              }
              if (to > this.length) {
                to = this.length;
              }
              for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
                walker = walker.prev;
              }
              for (; walker !== null && i > from; i--, walker = walker.prev) {
                ret.push(walker.value);
              }
              return ret;
            };
            Yallist.prototype.splice = function(start, deleteCount) {
              if (start > this.length) {
                start = this.length - 1;
              }
              if (start < 0) {
                start = this.length + start;
              }
              for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
                walker = walker.next;
              }
              var ret = [];
              for (var i = 0; walker && i < deleteCount; i++) {
                ret.push(walker.value);
                walker = this.removeNode(walker);
              }
              if (walker === null) {
                walker = this.tail;
              }
              if (walker !== this.head && walker !== this.tail) {
                walker = walker.prev;
              }
              for (var i = 2; i < arguments.length; i++) {
                walker = insert(this, walker, arguments[i]);
              }
              return ret;
            };
            Yallist.prototype.reverse = function() {
              var head = this.head;
              var tail = this.tail;
              for (var walker = head; walker !== null; walker = walker.prev) {
                var p2 = walker.prev;
                walker.prev = walker.next;
                walker.next = p2;
              }
              this.head = tail;
              this.tail = head;
              return this;
            };
            function insert(self2, node2, value) {
              var inserted = node2 === self2.head ? new Node3(value, null, node2, self2) : new Node3(value, node2, node2.next, self2);
              if (inserted.next === null) {
                self2.tail = inserted;
              }
              if (inserted.prev === null) {
                self2.head = inserted;
              }
              self2.length++;
              return inserted;
            }
            __name(insert, "insert");
            function push(self2, item) {
              self2.tail = new Node3(item, self2.tail, null, self2);
              if (!self2.head) {
                self2.head = self2.tail;
              }
              self2.length++;
            }
            __name(push, "push");
            function unshift(self2, item) {
              self2.head = new Node3(item, null, self2.head, self2);
              if (!self2.tail) {
                self2.tail = self2.head;
              }
              self2.length++;
            }
            __name(unshift, "unshift");
            function Node3(value, prev, next, list) {
              if (!(this instanceof Node3)) {
                return new Node3(value, prev, next, list);
              }
              this.list = list;
              this.value = value;
              if (prev) {
                prev.next = this;
                this.prev = prev;
              } else {
                this.prev = null;
              }
              if (next) {
                next.prev = this;
                this.next = next;
              } else {
                this.next = null;
              }
            }
            __name(Node3, "Node");
            try {
              __webpack_require__(26)(Yallist);
            } catch (er) {
            }
          },
          /* 26 */
          /***/
          function(module4, exports3, __webpack_require__) {
            "use strict";
            module4.exports = function(Yallist) {
              Yallist.prototype[Symbol.iterator] = /* @__PURE__ */ regeneratorRuntime.mark(/* @__PURE__ */ __name(function _callee() {
                var walker;
                return regeneratorRuntime.wrap(/* @__PURE__ */ __name(function _callee$(_context) {
                  while (1) {
                    switch (_context.prev = _context.next) {
                      case 0:
                        walker = this.head;
                      case 1:
                        if (!walker) {
                          _context.next = 7;
                          break;
                        }
                        _context.next = 4;
                        return walker.value;
                      case 4:
                        walker = walker.next;
                        _context.next = 1;
                        break;
                      case 7:
                      case "end":
                        return _context.stop();
                    }
                  }
                }, "_callee$"), _callee, this);
              }, "_callee"));
            };
          },
          /* 27 */
          /***/
          function(module4, exports3, __webpack_require__) {
            "use strict";
            function _typeof7(obj) {
              "@babel/helpers - typeof";
              if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return typeof obj2;
                }, "_typeof");
              } else {
                _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
                }, "_typeof");
              }
              return _typeof7(obj);
            }
            __name(_typeof7, "_typeof");
            var b2 = 60103, c2 = 60106, d2 = 60107, e3 = 60108, f = 60114, g2 = 60109, h2 = 60110, k2 = 60112, l2 = 60113, m2 = 60120, n2 = 60115, p2 = 60116, q2 = 60129, r3 = 60130, u = 60131, v2 = 60132;
            if ("function" === typeof Symbol && Symbol.for) {
              var w2 = Symbol.for;
              b2 = w2("react.element");
              c2 = w2("react.portal");
              d2 = w2("react.fragment");
              e3 = w2("react.strict_mode");
              f = w2("react.profiler");
              g2 = w2("react.provider");
              h2 = w2("react.context");
              k2 = w2("react.forward_ref");
              l2 = w2("react.suspense");
              m2 = w2("react.suspense_list");
              n2 = w2("react.memo");
              p2 = w2("react.lazy");
              q2 = w2("react.debug_trace_mode");
              r3 = w2("react.offscreen");
              u = w2("react.legacy_hidden");
              v2 = w2("react.cache");
            }
            var x2 = 0;
            "function" === typeof Symbol && (x2 = Symbol.for("react.module.reference"));
            function y2(a) {
              if ("object" === _typeof7(a) && null !== a) {
                var t3 = a.$$typeof;
                switch (t3) {
                  case b2:
                    switch (a = a.type, a) {
                      case d2:
                      case f:
                      case e3:
                      case l2:
                      case m2:
                        return a;
                      default:
                        switch (a = a && a.$$typeof, a) {
                          case h2:
                          case k2:
                          case p2:
                          case n2:
                          case g2:
                            return a;
                          default:
                            return t3;
                        }
                    }
                  case c2:
                    return t3;
                }
              }
            }
            __name(y2, "y");
            var z2 = g2, A2 = b2, B2 = k2, C2 = d2, D = p2, E2 = n2, F = c2, G2 = f, H2 = e3, I2 = l2, J2 = m2;
            exports3.ContextConsumer = h2;
            exports3.ContextProvider = z2;
            exports3.Element = A2;
            exports3.ForwardRef = B2;
            exports3.Fragment = C2;
            exports3.Lazy = D;
            exports3.Memo = E2;
            exports3.Portal = F;
            exports3.Profiler = G2;
            exports3.StrictMode = H2;
            exports3.Suspense = I2;
            exports3.SuspenseList = J2;
            exports3.isAsyncMode = function() {
              return false;
            };
            exports3.isConcurrentMode = function() {
              return false;
            };
            exports3.isContextConsumer = function(a) {
              return y2(a) === h2;
            };
            exports3.isContextProvider = function(a) {
              return y2(a) === g2;
            };
            exports3.isElement = function(a) {
              return "object" === _typeof7(a) && null !== a && a.$$typeof === b2;
            };
            exports3.isForwardRef = function(a) {
              return y2(a) === k2;
            };
            exports3.isFragment = function(a) {
              return y2(a) === d2;
            };
            exports3.isLazy = function(a) {
              return y2(a) === p2;
            };
            exports3.isMemo = function(a) {
              return y2(a) === n2;
            };
            exports3.isPortal = function(a) {
              return y2(a) === c2;
            };
            exports3.isProfiler = function(a) {
              return y2(a) === f;
            };
            exports3.isStrictMode = function(a) {
              return y2(a) === e3;
            };
            exports3.isSuspense = function(a) {
              return y2(a) === l2;
            };
            exports3.isSuspenseList = function(a) {
              return y2(a) === m2;
            };
            exports3.isValidElementType = function(a) {
              return "string" === typeof a || "function" === typeof a || a === d2 || a === f || a === q2 || a === e3 || a === l2 || a === m2 || a === u || a === r3 || a === v2 || "object" === _typeof7(a) && null !== a && (a.$$typeof === p2 || a.$$typeof === n2 || a.$$typeof === g2 || a.$$typeof === h2 || a.$$typeof === k2 || a.$$typeof === x2 || void 0 !== a.getModuleId) ? true : false;
            };
            exports3.typeOf = y2;
          },
          /* 28 */
          /***/
          function(module4, exports3, __webpack_require__) {
            "use strict";
            function _typeof7(obj) {
              "@babel/helpers - typeof";
              if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return typeof obj2;
                }, "_typeof");
              } else {
                _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
                }, "_typeof");
              }
              return _typeof7(obj);
            }
            __name(_typeof7, "_typeof");
            var h2 = __webpack_require__(8), l2 = __webpack_require__(29), q2 = __webpack_require__(31).__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, w2 = [], x2 = null;
            function y2() {
              if (null === x2) {
                var a = /* @__PURE__ */ new Map();
                try {
                  z2.useContext({
                    _currentValue: null
                  }), z2.useState(null), z2.useReducer(function(a2) {
                    return a2;
                  }, null), z2.useRef(null), "function" === typeof z2.useCacheRefresh && z2.useCacheRefresh(), z2.useLayoutEffect(function() {
                  }), z2.useInsertionEffect(function() {
                  }), z2.useEffect(function() {
                  }), z2.useImperativeHandle(void 0, function() {
                    return null;
                  }), z2.useDebugValue(null), z2.useCallback(function() {
                  }), z2.useMemo(function() {
                    return null;
                  });
                } finally {
                  var b2 = w2;
                  w2 = [];
                }
                for (var e3 = 0; e3 < b2.length; e3++) {
                  var f = b2[e3];
                  a.set(f.primitive, l2.parse(f.stackError));
                }
                x2 = a;
              }
              return x2;
            }
            __name(y2, "y");
            var A2 = null;
            function B2() {
              var a = A2;
              null !== a && (A2 = a.next);
              return a;
            }
            __name(B2, "B");
            var z2 = {
              getCacheForType: /* @__PURE__ */ __name(function getCacheForType() {
                throw Error("Not implemented.");
              }, "getCacheForType"),
              readContext: /* @__PURE__ */ __name(function readContext(a) {
                return a._currentValue;
              }, "readContext"),
              useCacheRefresh: /* @__PURE__ */ __name(function useCacheRefresh() {
                var a = B2();
                w2.push({
                  primitive: "CacheRefresh",
                  stackError: Error(),
                  value: null !== a ? a.memoizedState : function() {
                  }
                });
                return function() {
                };
              }, "useCacheRefresh"),
              useCallback: /* @__PURE__ */ __name(function useCallback2(a) {
                var b2 = B2();
                w2.push({
                  primitive: "Callback",
                  stackError: Error(),
                  value: null !== b2 ? b2.memoizedState[0] : a
                });
                return a;
              }, "useCallback"),
              useContext: /* @__PURE__ */ __name(function useContext(a) {
                w2.push({
                  primitive: "Context",
                  stackError: Error(),
                  value: a._currentValue
                });
                return a._currentValue;
              }, "useContext"),
              useEffect: /* @__PURE__ */ __name(function useEffect6(a) {
                B2();
                w2.push({
                  primitive: "Effect",
                  stackError: Error(),
                  value: a
                });
              }, "useEffect"),
              useImperativeHandle: /* @__PURE__ */ __name(function useImperativeHandle(a) {
                B2();
                var b2 = void 0;
                null !== a && "object" === _typeof7(a) && (b2 = a.current);
                w2.push({
                  primitive: "ImperativeHandle",
                  stackError: Error(),
                  value: b2
                });
              }, "useImperativeHandle"),
              useDebugValue: /* @__PURE__ */ __name(function useDebugValue(a, b2) {
                w2.push({
                  primitive: "DebugValue",
                  stackError: Error(),
                  value: "function" === typeof b2 ? b2(a) : a
                });
              }, "useDebugValue"),
              useLayoutEffect: /* @__PURE__ */ __name(function useLayoutEffect(a) {
                B2();
                w2.push({
                  primitive: "LayoutEffect",
                  stackError: Error(),
                  value: a
                });
              }, "useLayoutEffect"),
              useInsertionEffect: /* @__PURE__ */ __name(function useInsertionEffect(a) {
                B2();
                w2.push({
                  primitive: "InsertionEffect",
                  stackError: Error(),
                  value: a
                });
              }, "useInsertionEffect"),
              useMemo: /* @__PURE__ */ __name(function useMemo2(a) {
                var b2 = B2();
                a = null !== b2 ? b2.memoizedState[0] : a();
                w2.push({
                  primitive: "Memo",
                  stackError: Error(),
                  value: a
                });
                return a;
              }, "useMemo"),
              useReducer: /* @__PURE__ */ __name(function useReducer(a, b2, e3) {
                a = B2();
                b2 = null !== a ? a.memoizedState : void 0 !== e3 ? e3(b2) : b2;
                w2.push({
                  primitive: "Reducer",
                  stackError: Error(),
                  value: b2
                });
                return [b2, function() {
                }];
              }, "useReducer"),
              useRef: /* @__PURE__ */ __name(function useRef5(a) {
                var b2 = B2();
                a = null !== b2 ? b2.memoizedState : {
                  current: a
                };
                w2.push({
                  primitive: "Ref",
                  stackError: Error(),
                  value: a.current
                });
                return a;
              }, "useRef"),
              useState: /* @__PURE__ */ __name(function useState6(a) {
                var b2 = B2();
                a = null !== b2 ? b2.memoizedState : "function" === typeof a ? a() : a;
                w2.push({
                  primitive: "State",
                  stackError: Error(),
                  value: a
                });
                return [a, function() {
                }];
              }, "useState"),
              useTransition: /* @__PURE__ */ __name(function useTransition() {
                B2();
                B2();
                w2.push({
                  primitive: "Transition",
                  stackError: Error(),
                  value: void 0
                });
                return [false, function() {
                }];
              }, "useTransition"),
              useMutableSource: /* @__PURE__ */ __name(function useMutableSource(a, b2) {
                B2();
                B2();
                B2();
                B2();
                a = b2(a._source);
                w2.push({
                  primitive: "MutableSource",
                  stackError: Error(),
                  value: a
                });
                return a;
              }, "useMutableSource"),
              useSyncExternalStore: /* @__PURE__ */ __name(function useSyncExternalStore(a, b2) {
                B2();
                B2();
                a = b2();
                w2.push({
                  primitive: "SyncExternalStore",
                  stackError: Error(),
                  value: a
                });
                return a;
              }, "useSyncExternalStore"),
              useDeferredValue: /* @__PURE__ */ __name(function useDeferredValue(a) {
                B2();
                B2();
                w2.push({
                  primitive: "DeferredValue",
                  stackError: Error(),
                  value: a
                });
                return a;
              }, "useDeferredValue"),
              useId: /* @__PURE__ */ __name(function useId() {
                var a = B2();
                a = null !== a ? a.memoizedState : "";
                w2.push({
                  primitive: "Id",
                  stackError: Error(),
                  value: a
                });
                return a;
              }, "useId")
            }, C2 = 0;
            function D(a, b2, e3) {
              var f = b2[e3].source, c2 = 0;
              a:
                for (; c2 < a.length; c2++) {
                  if (a[c2].source === f) {
                    for (var m2 = e3 + 1, r3 = c2 + 1; m2 < b2.length && r3 < a.length; m2++, r3++) {
                      if (a[r3].source !== b2[m2].source)
                        continue a;
                    }
                    return c2;
                  }
                }
              return -1;
            }
            __name(D, "D");
            function E2(a, b2) {
              if (!a)
                return false;
              b2 = "use" + b2;
              return a.length < b2.length ? false : a.lastIndexOf(b2) === a.length - b2.length;
            }
            __name(E2, "E");
            function F(a, b2, e3) {
              for (var f = [], c2 = null, m2 = f, r3 = 0, t3 = [], v2 = 0; v2 < b2.length; v2++) {
                var u = b2[v2];
                var d2 = a;
                var k2 = l2.parse(u.stackError);
                b: {
                  var n2 = k2, p2 = D(n2, d2, C2);
                  if (-1 !== p2)
                    d2 = p2;
                  else {
                    for (var g2 = 0; g2 < d2.length && 5 > g2; g2++) {
                      if (p2 = D(n2, d2, g2), -1 !== p2) {
                        C2 = g2;
                        d2 = p2;
                        break b;
                      }
                    }
                    d2 = -1;
                  }
                }
                b: {
                  n2 = k2;
                  p2 = y2().get(u.primitive);
                  if (void 0 !== p2)
                    for (g2 = 0; g2 < p2.length && g2 < n2.length; g2++) {
                      if (p2[g2].source !== n2[g2].source) {
                        g2 < n2.length - 1 && E2(n2[g2].functionName, u.primitive) && g2++;
                        g2 < n2.length - 1 && E2(n2[g2].functionName, u.primitive) && g2++;
                        n2 = g2;
                        break b;
                      }
                    }
                  n2 = -1;
                }
                k2 = -1 === d2 || -1 === n2 || 2 > d2 - n2 ? null : k2.slice(n2, d2 - 1);
                if (null !== k2) {
                  d2 = 0;
                  if (null !== c2) {
                    for (; d2 < k2.length && d2 < c2.length && k2[k2.length - d2 - 1].source === c2[c2.length - d2 - 1].source; ) {
                      d2++;
                    }
                    for (c2 = c2.length - 1; c2 > d2; c2--) {
                      m2 = t3.pop();
                    }
                  }
                  for (c2 = k2.length - d2 - 1; 1 <= c2; c2--) {
                    d2 = [], n2 = k2[c2], (p2 = k2[c2 - 1].functionName) ? (g2 = p2.lastIndexOf("."), -1 === g2 && (g2 = 0), "use" === p2.substr(g2, 3) && (g2 += 3), p2 = p2.substr(g2)) : p2 = "", p2 = {
                      id: null,
                      isStateEditable: false,
                      name: p2,
                      value: void 0,
                      subHooks: d2
                    }, e3 && (p2.hookSource = {
                      lineNumber: n2.lineNumber,
                      columnNumber: n2.columnNumber,
                      functionName: n2.functionName,
                      fileName: n2.fileName
                    }), m2.push(p2), t3.push(m2), m2 = d2;
                  }
                  c2 = k2;
                }
                d2 = u.primitive;
                u = {
                  id: "Context" === d2 || "DebugValue" === d2 ? null : r3++,
                  isStateEditable: "Reducer" === d2 || "State" === d2,
                  name: d2,
                  value: u.value,
                  subHooks: []
                };
                e3 && (d2 = {
                  lineNumber: null,
                  functionName: null,
                  fileName: null,
                  columnNumber: null
                }, k2 && 1 <= k2.length && (k2 = k2[0], d2.lineNumber = k2.lineNumber, d2.functionName = k2.functionName, d2.fileName = k2.fileName, d2.columnNumber = k2.columnNumber), u.hookSource = d2);
                m2.push(u);
              }
              G2(f, null);
              return f;
            }
            __name(F, "F");
            function G2(a, b2) {
              for (var e3 = [], f = 0; f < a.length; f++) {
                var c2 = a[f];
                "DebugValue" === c2.name && 0 === c2.subHooks.length ? (a.splice(f, 1), f--, e3.push(c2)) : G2(c2.subHooks, c2);
              }
              null !== b2 && (1 === e3.length ? b2.value = e3[0].value : 1 < e3.length && (b2.value = e3.map(function(a2) {
                return a2.value;
              })));
            }
            __name(G2, "G");
            function H2(a, b2, e3) {
              var f = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : false;
              null == e3 && (e3 = q2.ReactCurrentDispatcher);
              var c2 = e3.current;
              e3.current = z2;
              try {
                var m2 = Error();
                a(b2);
              } finally {
                var r3 = w2;
                w2 = [];
                e3.current = c2;
              }
              c2 = l2.parse(m2);
              return F(c2, r3, f);
            }
            __name(H2, "H");
            function I2(a) {
              a.forEach(function(a2, e3) {
                return e3._currentValue = a2;
              });
            }
            __name(I2, "I");
            exports3.inspectHooks = H2;
            exports3.inspectHooksOfFiber = function(a, b2) {
              var e3 = 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : false;
              null == b2 && (b2 = q2.ReactCurrentDispatcher);
              if (0 !== a.tag && 15 !== a.tag && 11 !== a.tag)
                throw Error("Unknown Fiber. Needs to be a function component to inspect hooks.");
              y2();
              var f = a.type, c2 = a.memoizedProps;
              if (f !== a.elementType && f && f.defaultProps) {
                c2 = h2({}, c2);
                var m2 = f.defaultProps;
                for (r3 in m2) {
                  void 0 === c2[r3] && (c2[r3] = m2[r3]);
                }
              }
              A2 = a.memoizedState;
              var r3 = /* @__PURE__ */ new Map();
              try {
                for (m2 = a; m2; ) {
                  if (10 === m2.tag) {
                    var t3 = m2.type._context;
                    r3.has(t3) || (r3.set(t3, t3._currentValue), t3._currentValue = m2.memoizedProps.value);
                  }
                  m2 = m2.return;
                }
                if (11 === a.tag) {
                  var v2 = f.render;
                  f = c2;
                  var u = a.ref;
                  t3 = b2;
                  var d2 = t3.current;
                  t3.current = z2;
                  try {
                    var k2 = Error();
                    v2(f, u);
                  } finally {
                    var n2 = w2;
                    w2 = [];
                    t3.current = d2;
                  }
                  var p2 = l2.parse(k2);
                  return F(p2, n2, e3);
                }
                return H2(f, c2, b2, e3);
              } finally {
                A2 = null, I2(r3);
              }
            };
          },
          /* 29 */
          /***/
          function(module4, exports3, __webpack_require__) {
            var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;
            function _typeof7(obj) {
              "@babel/helpers - typeof";
              if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return typeof obj2;
                }, "_typeof");
              } else {
                _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
                }, "_typeof");
              }
              return _typeof7(obj);
            }
            __name(_typeof7, "_typeof");
            (function(root, factory) {
              "use strict";
              if (true) {
                !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(30)], __WEBPACK_AMD_DEFINE_FACTORY__ = factory, __WEBPACK_AMD_DEFINE_RESULT__ = typeof __WEBPACK_AMD_DEFINE_FACTORY__ === "function" ? __WEBPACK_AMD_DEFINE_FACTORY__.apply(exports3, __WEBPACK_AMD_DEFINE_ARRAY__) : __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__ !== void 0 && (module4.exports = __WEBPACK_AMD_DEFINE_RESULT__));
              } else {
              }
            })(this, /* @__PURE__ */ __name(function ErrorStackParser(StackFrame) {
              "use strict";
              var FIREFOX_SAFARI_STACK_REGEXP = /(^|@)\S+:\d+/;
              var CHROME_IE_STACK_REGEXP = /^\s*at .*(\S+:\d+|\(native\))/m;
              var SAFARI_NATIVE_CODE_REGEXP = /^(eval@)?(\[native code])?$/;
              return {
                /**
                 * Given an Error object, extract the most information from it.
                 *
                 * @param {Error} error object
                 * @return {Array} of StackFrames
                 */
                parse: /* @__PURE__ */ __name(function ErrorStackParser$$parse(error2) {
                  if (typeof error2.stacktrace !== "undefined" || typeof error2["opera#sourceloc"] !== "undefined") {
                    return this.parseOpera(error2);
                  } else if (error2.stack && error2.stack.match(CHROME_IE_STACK_REGEXP)) {
                    return this.parseV8OrIE(error2);
                  } else if (error2.stack) {
                    return this.parseFFOrSafari(error2);
                  } else {
                    throw new Error("Cannot parse given Error object");
                  }
                }, "ErrorStackParser$$parse"),
                // Separate line and column numbers from a string of the form: (URI:Line:Column)
                extractLocation: /* @__PURE__ */ __name(function ErrorStackParser$$extractLocation(urlLike) {
                  if (urlLike.indexOf(":") === -1) {
                    return [urlLike];
                  }
                  var regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
                  var parts = regExp.exec(urlLike.replace(/[()]/g, ""));
                  return [parts[1], parts[2] || void 0, parts[3] || void 0];
                }, "ErrorStackParser$$extractLocation"),
                parseV8OrIE: /* @__PURE__ */ __name(function ErrorStackParser$$parseV8OrIE(error2) {
                  var filtered = error2.stack.split("\n").filter(function(line) {
                    return !!line.match(CHROME_IE_STACK_REGEXP);
                  }, this);
                  return filtered.map(function(line) {
                    if (line.indexOf("(eval ") > -1) {
                      line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(\),.*$)/g, "");
                    }
                    var sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(");
                    var location = sanitizedLine.match(/ (\((.+):(\d+):(\d+)\)$)/);
                    sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
                    var tokens = sanitizedLine.split(/\s+/).slice(1);
                    var locationParts = this.extractLocation(location ? location[1] : tokens.pop());
                    var functionName = tokens.join(" ") || void 0;
                    var fileName = ["eval", "<anonymous>"].indexOf(locationParts[0]) > -1 ? void 0 : locationParts[0];
                    return new StackFrame({
                      functionName,
                      fileName,
                      lineNumber: locationParts[1],
                      columnNumber: locationParts[2],
                      source: line
                    });
                  }, this);
                }, "ErrorStackParser$$parseV8OrIE"),
                parseFFOrSafari: /* @__PURE__ */ __name(function ErrorStackParser$$parseFFOrSafari(error2) {
                  var filtered = error2.stack.split("\n").filter(function(line) {
                    return !line.match(SAFARI_NATIVE_CODE_REGEXP);
                  }, this);
                  return filtered.map(function(line) {
                    if (line.indexOf(" > eval") > -1) {
                      line = line.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ":$1");
                    }
                    if (line.indexOf("@") === -1 && line.indexOf(":") === -1) {
                      return new StackFrame({
                        functionName: line
                      });
                    } else {
                      var functionNameRegex = /((.*".+"[^@]*)?[^@]*)(?:@)/;
                      var matches = line.match(functionNameRegex);
                      var functionName = matches && matches[1] ? matches[1] : void 0;
                      var locationParts = this.extractLocation(line.replace(functionNameRegex, ""));
                      return new StackFrame({
                        functionName,
                        fileName: locationParts[0],
                        lineNumber: locationParts[1],
                        columnNumber: locationParts[2],
                        source: line
                      });
                    }
                  }, this);
                }, "ErrorStackParser$$parseFFOrSafari"),
                parseOpera: /* @__PURE__ */ __name(function ErrorStackParser$$parseOpera(e3) {
                  if (!e3.stacktrace || e3.message.indexOf("\n") > -1 && e3.message.split("\n").length > e3.stacktrace.split("\n").length) {
                    return this.parseOpera9(e3);
                  } else if (!e3.stack) {
                    return this.parseOpera10(e3);
                  } else {
                    return this.parseOpera11(e3);
                  }
                }, "ErrorStackParser$$parseOpera"),
                parseOpera9: /* @__PURE__ */ __name(function ErrorStackParser$$parseOpera9(e3) {
                  var lineRE = /Line (\d+).*script (?:in )?(\S+)/i;
                  var lines = e3.message.split("\n");
                  var result = [];
                  for (var i = 2, len = lines.length; i < len; i += 2) {
                    var match = lineRE.exec(lines[i]);
                    if (match) {
                      result.push(new StackFrame({
                        fileName: match[2],
                        lineNumber: match[1],
                        source: lines[i]
                      }));
                    }
                  }
                  return result;
                }, "ErrorStackParser$$parseOpera9"),
                parseOpera10: /* @__PURE__ */ __name(function ErrorStackParser$$parseOpera10(e3) {
                  var lineRE = /Line (\d+).*script (?:in )?(\S+)(?:: In function (\S+))?$/i;
                  var lines = e3.stacktrace.split("\n");
                  var result = [];
                  for (var i = 0, len = lines.length; i < len; i += 2) {
                    var match = lineRE.exec(lines[i]);
                    if (match) {
                      result.push(new StackFrame({
                        functionName: match[3] || void 0,
                        fileName: match[2],
                        lineNumber: match[1],
                        source: lines[i]
                      }));
                    }
                  }
                  return result;
                }, "ErrorStackParser$$parseOpera10"),
                // Opera 10.65+ Error.stack very similar to FF/Safari
                parseOpera11: /* @__PURE__ */ __name(function ErrorStackParser$$parseOpera11(error2) {
                  var filtered = error2.stack.split("\n").filter(function(line) {
                    return !!line.match(FIREFOX_SAFARI_STACK_REGEXP) && !line.match(/^Error created at/);
                  }, this);
                  return filtered.map(function(line) {
                    var tokens = line.split("@");
                    var locationParts = this.extractLocation(tokens.pop());
                    var functionCall = tokens.shift() || "";
                    var functionName = functionCall.replace(/<anonymous function(: (\w+))?>/, "$2").replace(/\([^)]*\)/g, "") || void 0;
                    var argsRaw;
                    if (functionCall.match(/\(([^)]*)\)/)) {
                      argsRaw = functionCall.replace(/^[^(]+\(([^)]*)\)$/, "$1");
                    }
                    var args = argsRaw === void 0 || argsRaw === "[arguments not available]" ? void 0 : argsRaw.split(",");
                    return new StackFrame({
                      functionName,
                      args,
                      fileName: locationParts[0],
                      lineNumber: locationParts[1],
                      columnNumber: locationParts[2],
                      source: line
                    });
                  }, this);
                }, "ErrorStackParser$$parseOpera11")
              };
            }, "ErrorStackParser"));
          },
          /* 30 */
          /***/
          function(module4, exports3, __webpack_require__) {
            var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;
            function _typeof7(obj) {
              "@babel/helpers - typeof";
              if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return typeof obj2;
                }, "_typeof");
              } else {
                _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
                }, "_typeof");
              }
              return _typeof7(obj);
            }
            __name(_typeof7, "_typeof");
            (function(root, factory) {
              "use strict";
              if (true) {
                !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = factory, __WEBPACK_AMD_DEFINE_RESULT__ = typeof __WEBPACK_AMD_DEFINE_FACTORY__ === "function" ? __WEBPACK_AMD_DEFINE_FACTORY__.apply(exports3, __WEBPACK_AMD_DEFINE_ARRAY__) : __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__ !== void 0 && (module4.exports = __WEBPACK_AMD_DEFINE_RESULT__));
              } else {
              }
            })(this, function() {
              "use strict";
              function _isNumber(n2) {
                return !isNaN(parseFloat(n2)) && isFinite(n2);
              }
              __name(_isNumber, "_isNumber");
              function _capitalize(str) {
                return str.charAt(0).toUpperCase() + str.substring(1);
              }
              __name(_capitalize, "_capitalize");
              function _getter(p2) {
                return function() {
                  return this[p2];
                };
              }
              __name(_getter, "_getter");
              var booleanProps = ["isConstructor", "isEval", "isNative", "isToplevel"];
              var numericProps = ["columnNumber", "lineNumber"];
              var stringProps = ["fileName", "functionName", "source"];
              var arrayProps = ["args"];
              var props = booleanProps.concat(numericProps, stringProps, arrayProps);
              function StackFrame(obj) {
                if (!obj)
                  return;
                for (var i2 = 0; i2 < props.length; i2++) {
                  if (obj[props[i2]] !== void 0) {
                    this["set" + _capitalize(props[i2])](obj[props[i2]]);
                  }
                }
              }
              __name(StackFrame, "StackFrame");
              StackFrame.prototype = {
                getArgs: /* @__PURE__ */ __name(function getArgs() {
                  return this.args;
                }, "getArgs"),
                setArgs: /* @__PURE__ */ __name(function setArgs(v2) {
                  if (Object.prototype.toString.call(v2) !== "[object Array]") {
                    throw new TypeError("Args must be an Array");
                  }
                  this.args = v2;
                }, "setArgs"),
                getEvalOrigin: /* @__PURE__ */ __name(function getEvalOrigin() {
                  return this.evalOrigin;
                }, "getEvalOrigin"),
                setEvalOrigin: /* @__PURE__ */ __name(function setEvalOrigin(v2) {
                  if (v2 instanceof StackFrame) {
                    this.evalOrigin = v2;
                  } else if (v2 instanceof Object) {
                    this.evalOrigin = new StackFrame(v2);
                  } else {
                    throw new TypeError("Eval Origin must be an Object or StackFrame");
                  }
                }, "setEvalOrigin"),
                toString: /* @__PURE__ */ __name(function toString2() {
                  var fileName = this.getFileName() || "";
                  var lineNumber = this.getLineNumber() || "";
                  var columnNumber = this.getColumnNumber() || "";
                  var functionName = this.getFunctionName() || "";
                  if (this.getIsEval()) {
                    if (fileName) {
                      return "[eval] (" + fileName + ":" + lineNumber + ":" + columnNumber + ")";
                    }
                    return "[eval]:" + lineNumber + ":" + columnNumber;
                  }
                  if (functionName) {
                    return functionName + " (" + fileName + ":" + lineNumber + ":" + columnNumber + ")";
                  }
                  return fileName + ":" + lineNumber + ":" + columnNumber;
                }, "toString")
              };
              StackFrame.fromString = /* @__PURE__ */ __name(function StackFrame$$fromString(str) {
                var argsStartIndex = str.indexOf("(");
                var argsEndIndex = str.lastIndexOf(")");
                var functionName = str.substring(0, argsStartIndex);
                var args = str.substring(argsStartIndex + 1, argsEndIndex).split(",");
                var locationString = str.substring(argsEndIndex + 1);
                if (locationString.indexOf("@") === 0) {
                  var parts = /@(.+?)(?::(\d+))?(?::(\d+))?$/.exec(locationString, "");
                  var fileName = parts[1];
                  var lineNumber = parts[2];
                  var columnNumber = parts[3];
                }
                return new StackFrame({
                  functionName,
                  args: args || void 0,
                  fileName,
                  lineNumber: lineNumber || void 0,
                  columnNumber: columnNumber || void 0
                });
              }, "StackFrame$$fromString");
              for (var i = 0; i < booleanProps.length; i++) {
                StackFrame.prototype["get" + _capitalize(booleanProps[i])] = _getter(booleanProps[i]);
                StackFrame.prototype["set" + _capitalize(booleanProps[i])] = function(p2) {
                  return function(v2) {
                    this[p2] = Boolean(v2);
                  };
                }(booleanProps[i]);
              }
              for (var j2 = 0; j2 < numericProps.length; j2++) {
                StackFrame.prototype["get" + _capitalize(numericProps[j2])] = _getter(numericProps[j2]);
                StackFrame.prototype["set" + _capitalize(numericProps[j2])] = function(p2) {
                  return function(v2) {
                    if (!_isNumber(v2)) {
                      throw new TypeError(p2 + " must be a Number");
                    }
                    this[p2] = Number(v2);
                  };
                }(numericProps[j2]);
              }
              for (var k2 = 0; k2 < stringProps.length; k2++) {
                StackFrame.prototype["get" + _capitalize(stringProps[k2])] = _getter(stringProps[k2]);
                StackFrame.prototype["set" + _capitalize(stringProps[k2])] = function(p2) {
                  return function(v2) {
                    this[p2] = String(v2);
                  };
                }(stringProps[k2]);
              }
              return StackFrame;
            });
          },
          /* 31 */
          /***/
          function(module4, exports3, __webpack_require__) {
            "use strict";
            if (true) {
              module4.exports = __webpack_require__(32);
            } else {
            }
          },
          /* 32 */
          /***/
          function(module4, exports3, __webpack_require__) {
            "use strict";
            function _typeof7(obj) {
              "@babel/helpers - typeof";
              if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return typeof obj2;
                }, "_typeof");
              } else {
                _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
                }, "_typeof");
              }
              return _typeof7(obj);
            }
            __name(_typeof7, "_typeof");
            var l2 = __webpack_require__(8), m2 = 60103, p2 = 60106;
            exports3.Fragment = 60107;
            exports3.StrictMode = 60108;
            exports3.Profiler = 60114;
            var q2 = 60109, r3 = 60110, t3 = 60112;
            exports3.Suspense = 60113;
            exports3.SuspenseList = 60120;
            var u = 60115, v2 = 60116;
            exports3.unstable_DebugTracingMode = 60129;
            exports3.unstable_Offscreen = 60130;
            exports3.unstable_LegacyHidden = 60131;
            exports3.unstable_Cache = 60132;
            if ("function" === typeof Symbol && Symbol.for) {
              var w2 = Symbol.for;
              m2 = w2("react.element");
              p2 = w2("react.portal");
              exports3.Fragment = w2("react.fragment");
              exports3.StrictMode = w2("react.strict_mode");
              exports3.Profiler = w2("react.profiler");
              q2 = w2("react.provider");
              r3 = w2("react.context");
              t3 = w2("react.forward_ref");
              exports3.Suspense = w2("react.suspense");
              exports3.SuspenseList = w2("react.suspense_list");
              u = w2("react.memo");
              v2 = w2("react.lazy");
              exports3.unstable_DebugTracingMode = w2("react.debug_trace_mode");
              exports3.unstable_Offscreen = w2("react.offscreen");
              exports3.unstable_LegacyHidden = w2("react.legacy_hidden");
              exports3.unstable_Cache = w2("react.cache");
            }
            var x2 = "function" === typeof Symbol && Symbol.iterator;
            function y2(a) {
              if (null === a || "object" !== _typeof7(a))
                return null;
              a = x2 && a[x2] || a["@@iterator"];
              return "function" === typeof a ? a : null;
            }
            __name(y2, "y");
            var z2 = {
              isMounted: /* @__PURE__ */ __name(function isMounted() {
                return false;
              }, "isMounted"),
              enqueueForceUpdate: /* @__PURE__ */ __name(function enqueueForceUpdate() {
              }, "enqueueForceUpdate"),
              enqueueReplaceState: /* @__PURE__ */ __name(function enqueueReplaceState() {
              }, "enqueueReplaceState"),
              enqueueSetState: /* @__PURE__ */ __name(function enqueueSetState() {
              }, "enqueueSetState")
            }, A2 = {};
            function B2(a, b2, e3) {
              this.props = a;
              this.context = b2;
              this.refs = A2;
              this.updater = e3 || z2;
            }
            __name(B2, "B");
            B2.prototype.isReactComponent = {};
            B2.prototype.setState = function(a, b2) {
              if ("object" !== _typeof7(a) && "function" !== typeof a && null != a)
                throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
              this.updater.enqueueSetState(this, a, b2, "setState");
            };
            B2.prototype.forceUpdate = function(a) {
              this.updater.enqueueForceUpdate(this, a, "forceUpdate");
            };
            function C2() {
            }
            __name(C2, "C");
            C2.prototype = B2.prototype;
            function D(a, b2, e3) {
              this.props = a;
              this.context = b2;
              this.refs = A2;
              this.updater = e3 || z2;
            }
            __name(D, "D");
            var E2 = D.prototype = new C2();
            E2.constructor = D;
            l2(E2, B2.prototype);
            E2.isPureReactComponent = true;
            var F = Array.isArray, G2 = Object.prototype.hasOwnProperty, H2 = {
              current: null
            }, I2 = {
              key: true,
              ref: true,
              __self: true,
              __source: true
            };
            function J2(a, b2, e3) {
              var d2, c2 = {}, k2 = null, h2 = null;
              if (null != b2)
                for (d2 in void 0 !== b2.ref && (h2 = b2.ref), void 0 !== b2.key && (k2 = "" + b2.key), b2) {
                  G2.call(b2, d2) && !I2.hasOwnProperty(d2) && (c2[d2] = b2[d2]);
                }
              var g2 = arguments.length - 2;
              if (1 === g2)
                c2.children = e3;
              else if (1 < g2) {
                for (var f = Array(g2), n2 = 0; n2 < g2; n2++) {
                  f[n2] = arguments[n2 + 2];
                }
                c2.children = f;
              }
              if (a && a.defaultProps)
                for (d2 in g2 = a.defaultProps, g2) {
                  void 0 === c2[d2] && (c2[d2] = g2[d2]);
                }
              return {
                $$typeof: m2,
                type: a,
                key: k2,
                ref: h2,
                props: c2,
                _owner: H2.current
              };
            }
            __name(J2, "J");
            function K2(a, b2) {
              return {
                $$typeof: m2,
                type: a.type,
                key: b2,
                ref: a.ref,
                props: a.props,
                _owner: a._owner
              };
            }
            __name(K2, "K");
            function L2(a) {
              return "object" === _typeof7(a) && null !== a && a.$$typeof === m2;
            }
            __name(L2, "L");
            function escape2(a) {
              var b2 = {
                "=": "=0",
                ":": "=2"
              };
              return "$" + a.replace(/[=:]/g, function(a2) {
                return b2[a2];
              });
            }
            __name(escape2, "escape");
            var M2 = /\/+/g;
            function N2(a, b2) {
              return "object" === _typeof7(a) && null !== a && null != a.key ? escape2("" + a.key) : b2.toString(36);
            }
            __name(N2, "N");
            function O2(a, b2, e3, d2, c2) {
              var k2 = _typeof7(a);
              if ("undefined" === k2 || "boolean" === k2)
                a = null;
              var h2 = false;
              if (null === a)
                h2 = true;
              else
                switch (k2) {
                  case "string":
                  case "number":
                    h2 = true;
                    break;
                  case "object":
                    switch (a.$$typeof) {
                      case m2:
                      case p2:
                        h2 = true;
                    }
                }
              if (h2)
                return h2 = a, c2 = c2(h2), a = "" === d2 ? "." + N2(h2, 0) : d2, F(c2) ? (e3 = "", null != a && (e3 = a.replace(M2, "$&/") + "/"), O2(c2, b2, e3, "", function(a2) {
                  return a2;
                })) : null != c2 && (L2(c2) && (c2 = K2(c2, e3 + (!c2.key || h2 && h2.key === c2.key ? "" : ("" + c2.key).replace(M2, "$&/") + "/") + a)), b2.push(c2)), 1;
              h2 = 0;
              d2 = "" === d2 ? "." : d2 + ":";
              if (F(a))
                for (var g2 = 0; g2 < a.length; g2++) {
                  k2 = a[g2];
                  var f = d2 + N2(k2, g2);
                  h2 += O2(k2, b2, e3, f, c2);
                }
              else if (f = y2(a), "function" === typeof f)
                for (a = f.call(a), g2 = 0; !(k2 = a.next()).done; ) {
                  k2 = k2.value, f = d2 + N2(k2, g2++), h2 += O2(k2, b2, e3, f, c2);
                }
              else if ("object" === k2)
                throw b2 = String(a), Error("Objects are not valid as a React child (found: " + ("[object Object]" === b2 ? "object with keys {" + Object.keys(a).join(", ") + "}" : b2) + "). If you meant to render a collection of children, use an array instead.");
              return h2;
            }
            __name(O2, "O");
            function P2(a, b2, e3) {
              if (null == a)
                return a;
              var d2 = [], c2 = 0;
              O2(a, d2, "", "", function(a2) {
                return b2.call(e3, a2, c2++);
              });
              return d2;
            }
            __name(P2, "P");
            function Q3(a) {
              if (-1 === a._status) {
                var b2 = a._result;
                b2 = b2();
                b2.then(function(b3) {
                  if (0 === a._status || -1 === a._status)
                    a._status = 1, a._result = b3;
                }, function(b3) {
                  if (0 === a._status || -1 === a._status)
                    a._status = 2, a._result = b3;
                });
                -1 === a._status && (a._status = 0, a._result = b2);
              }
              if (1 === a._status)
                return a._result.default;
              throw a._result;
            }
            __name(Q3, "Q");
            var R2 = {
              current: null
            }, S2 = {
              transition: 0
            }, T2 = {
              ReactCurrentDispatcher: R2,
              ReactCurrentBatchConfig: S2,
              ReactCurrentOwner: H2,
              assign: l2
            };
            exports3.Children = {
              map: P2,
              forEach: /* @__PURE__ */ __name(function forEach(a, b2, e3) {
                P2(a, function() {
                  b2.apply(this, arguments);
                }, e3);
              }, "forEach"),
              count: /* @__PURE__ */ __name(function count(a) {
                var b2 = 0;
                P2(a, function() {
                  b2++;
                });
                return b2;
              }, "count"),
              toArray: /* @__PURE__ */ __name(function toArray(a) {
                return P2(a, function(a2) {
                  return a2;
                }) || [];
              }, "toArray"),
              only: /* @__PURE__ */ __name(function only(a) {
                if (!L2(a))
                  throw Error("React.Children.only expected to receive a single React element child.");
                return a;
              }, "only")
            };
            exports3.Component = B2;
            exports3.PureComponent = D;
            exports3.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = T2;
            exports3.cloneElement = function(a, b2, e3) {
              if (null === a || void 0 === a)
                throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + a + ".");
              var d2 = l2({}, a.props), c2 = a.key, k2 = a.ref, h2 = a._owner;
              if (null != b2) {
                void 0 !== b2.ref && (k2 = b2.ref, h2 = H2.current);
                void 0 !== b2.key && (c2 = "" + b2.key);
                if (a.type && a.type.defaultProps)
                  var g2 = a.type.defaultProps;
                for (f in b2) {
                  G2.call(b2, f) && !I2.hasOwnProperty(f) && (d2[f] = void 0 === b2[f] && void 0 !== g2 ? g2[f] : b2[f]);
                }
              }
              var f = arguments.length - 2;
              if (1 === f)
                d2.children = e3;
              else if (1 < f) {
                g2 = Array(f);
                for (var n2 = 0; n2 < f; n2++) {
                  g2[n2] = arguments[n2 + 2];
                }
                d2.children = g2;
              }
              return {
                $$typeof: m2,
                type: a.type,
                key: c2,
                ref: k2,
                props: d2,
                _owner: h2
              };
            };
            exports3.createContext = function(a) {
              a = {
                $$typeof: r3,
                _currentValue: a,
                _currentValue2: a,
                _threadCount: 0,
                Provider: null,
                Consumer: null
              };
              a.Provider = {
                $$typeof: q2,
                _context: a
              };
              return a.Consumer = a;
            };
            exports3.createElement = J2;
            exports3.createFactory = function(a) {
              var b2 = J2.bind(null, a);
              b2.type = a;
              return b2;
            };
            exports3.createRef = function() {
              return {
                current: null
              };
            };
            exports3.forwardRef = function(a) {
              return {
                $$typeof: t3,
                render: a
              };
            };
            exports3.isValidElement = L2;
            exports3.lazy = function(a) {
              return {
                $$typeof: v2,
                _payload: {
                  _status: -1,
                  _result: a
                },
                _init: Q3
              };
            };
            exports3.memo = function(a, b2) {
              return {
                $$typeof: u,
                type: a,
                compare: void 0 === b2 ? null : b2
              };
            };
            exports3.startTransition = function(a) {
              var b2 = S2.transition;
              S2.transition = 1;
              try {
                a();
              } finally {
                S2.transition = b2;
              }
            };
            exports3.unstable_act = function() {
              throw Error("act(...) is not supported in production builds of React.");
            };
            exports3.unstable_createMutableSource = function(a, b2) {
              return {
                _getVersion: b2,
                _source: a,
                _workInProgressVersionPrimary: null,
                _workInProgressVersionSecondary: null
              };
            };
            exports3.unstable_getCacheForType = function(a) {
              return R2.current.getCacheForType(a);
            };
            exports3.unstable_getCacheSignal = function() {
              return R2.current.getCacheSignal();
            };
            exports3.unstable_useCacheRefresh = function() {
              return R2.current.useCacheRefresh();
            };
            exports3.useCallback = function(a, b2) {
              return R2.current.useCallback(a, b2);
            };
            exports3.useContext = function(a) {
              return R2.current.useContext(a);
            };
            exports3.useDebugValue = function() {
            };
            exports3.useDeferredValue = function(a) {
              return R2.current.useDeferredValue(a);
            };
            exports3.useEffect = function(a, b2) {
              return R2.current.useEffect(a, b2);
            };
            exports3.useId = function() {
              return R2.current.useId();
            };
            exports3.useImperativeHandle = function(a, b2, e3) {
              return R2.current.useImperativeHandle(a, b2, e3);
            };
            exports3.useInsertionEffect = function(a, b2) {
              return R2.current.useInsertionEffect(a, b2);
            };
            exports3.useLayoutEffect = function(a, b2) {
              return R2.current.useLayoutEffect(a, b2);
            };
            exports3.useMemo = function(a, b2) {
              return R2.current.useMemo(a, b2);
            };
            exports3.useReducer = function(a, b2, e3) {
              return R2.current.useReducer(a, b2, e3);
            };
            exports3.useRef = function(a) {
              return R2.current.useRef(a);
            };
            exports3.useState = function(a) {
              return R2.current.useState(a);
            };
            exports3.useSyncExternalStore = function(a, b2, e3) {
              return R2.current.useSyncExternalStore(a, b2, e3);
            };
            exports3.useTransition = function() {
              return R2.current.useTransition();
            };
            exports3.version = "18.0.0-rc.0-experimental-13036bfbc-20220121";
          },
          /* 33 */
          /***/
          function(module4, __webpack_exports__, __webpack_require__) {
            "use strict";
            __webpack_require__.r(__webpack_exports__);
            __webpack_require__.d(__webpack_exports__, "connectToDevTools", function() {
              return (
                /* binding */
                connectToDevTools
              );
            });
            function _classCallCheck5(instance, Constructor) {
              if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
              }
            }
            __name(_classCallCheck5, "_classCallCheck");
            function _defineProperties5(target, props) {
              for (var i = 0; i < props.length; i++) {
                var descriptor2 = props[i];
                descriptor2.enumerable = descriptor2.enumerable || false;
                descriptor2.configurable = true;
                if ("value" in descriptor2)
                  descriptor2.writable = true;
                Object.defineProperty(target, descriptor2.key, descriptor2);
              }
            }
            __name(_defineProperties5, "_defineProperties");
            function _createClass5(Constructor, protoProps, staticProps) {
              if (protoProps)
                _defineProperties5(Constructor.prototype, protoProps);
              if (staticProps)
                _defineProperties5(Constructor, staticProps);
              return Constructor;
            }
            __name(_createClass5, "_createClass");
            function _defineProperty11(obj, key, value) {
              if (key in obj) {
                Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
              } else {
                obj[key] = value;
              }
              return obj;
            }
            __name(_defineProperty11, "_defineProperty");
            var EventEmitter7 = /* @__PURE__ */ function() {
              function EventEmitter8() {
                _classCallCheck5(this, EventEmitter8);
                _defineProperty11(this, "listenersMap", /* @__PURE__ */ new Map());
              }
              __name(EventEmitter8, "EventEmitter");
              _createClass5(EventEmitter8, [{
                key: "addListener",
                value: /* @__PURE__ */ __name(function addListener(event, listener) {
                  var listeners = this.listenersMap.get(event);
                  if (listeners === void 0) {
                    this.listenersMap.set(event, [listener]);
                  } else {
                    var index = listeners.indexOf(listener);
                    if (index < 0) {
                      listeners.push(listener);
                    }
                  }
                }, "addListener")
              }, {
                key: "emit",
                value: /* @__PURE__ */ __name(function emit(event) {
                  var listeners = this.listenersMap.get(event);
                  if (listeners !== void 0) {
                    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                      args[_key - 1] = arguments[_key];
                    }
                    if (listeners.length === 1) {
                      var listener = listeners[0];
                      listener.apply(null, args);
                    } else {
                      var didThrow = false;
                      var caughtError = null;
                      var clonedListeners = Array.from(listeners);
                      for (var i = 0; i < clonedListeners.length; i++) {
                        var _listener = clonedListeners[i];
                        try {
                          _listener.apply(null, args);
                        } catch (error2) {
                          if (caughtError === null) {
                            didThrow = true;
                            caughtError = error2;
                          }
                        }
                      }
                      if (didThrow) {
                        throw caughtError;
                      }
                    }
                  }
                }, "emit")
              }, {
                key: "removeAllListeners",
                value: /* @__PURE__ */ __name(function removeAllListeners() {
                  this.listenersMap.clear();
                }, "removeAllListeners")
              }, {
                key: "removeListener",
                value: /* @__PURE__ */ __name(function removeListener(event, listener) {
                  var listeners = this.listenersMap.get(event);
                  if (listeners !== void 0) {
                    var index = listeners.indexOf(listener);
                    if (index >= 0) {
                      listeners.splice(index, 1);
                    }
                  }
                }, "removeListener")
              }]);
              return EventEmitter8;
            }();
            var lodash_throttle = __webpack_require__(15);
            var lodash_throttle_default = /* @__PURE__ */ __webpack_require__.n(lodash_throttle);
            var constants3 = __webpack_require__(1);
            var storage = __webpack_require__(5);
            var simpleIsEqual = /* @__PURE__ */ __name(function simpleIsEqual2(a, b2) {
              return a === b2;
            }, "simpleIsEqual");
            var esm = /* @__PURE__ */ __name(function(resultFn) {
              var isEqual = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : simpleIsEqual;
              var lastThis = void 0;
              var lastArgs = [];
              var lastResult = void 0;
              var calledOnce = false;
              var isNewArgEqualToLast = /* @__PURE__ */ __name(function isNewArgEqualToLast2(newArg, index) {
                return isEqual(newArg, lastArgs[index]);
              }, "isNewArgEqualToLast");
              var result = /* @__PURE__ */ __name(function result2() {
                for (var _len = arguments.length, newArgs = Array(_len), _key = 0; _key < _len; _key++) {
                  newArgs[_key] = arguments[_key];
                }
                if (calledOnce && lastThis === this && newArgs.length === lastArgs.length && newArgs.every(isNewArgEqualToLast)) {
                  return lastResult;
                }
                calledOnce = true;
                lastThis = this;
                lastArgs = newArgs;
                lastResult = resultFn.apply(this, newArgs);
                return lastResult;
              }, "result");
              return result;
            }, "esm");
            var object_assign = __webpack_require__(8);
            var object_assign_default = /* @__PURE__ */ __webpack_require__.n(object_assign);
            function getOwnerWindow(node2) {
              if (!node2.ownerDocument) {
                return null;
              }
              return node2.ownerDocument.defaultView;
            }
            __name(getOwnerWindow, "getOwnerWindow");
            function getOwnerIframe(node2) {
              var nodeWindow = getOwnerWindow(node2);
              if (nodeWindow) {
                return nodeWindow.frameElement;
              }
              return null;
            }
            __name(getOwnerIframe, "getOwnerIframe");
            function getBoundingClientRectWithBorderOffset(node2) {
              var dimensions = getElementDimensions(node2);
              return mergeRectOffsets([node2.getBoundingClientRect(), {
                top: dimensions.borderTop,
                left: dimensions.borderLeft,
                bottom: dimensions.borderBottom,
                right: dimensions.borderRight,
                // This width and height won't get used by mergeRectOffsets (since this
                // is not the first rect in the array), but we set them so that this
                // object type checks as a ClientRect.
                width: 0,
                height: 0
              }]);
            }
            __name(getBoundingClientRectWithBorderOffset, "getBoundingClientRectWithBorderOffset");
            function mergeRectOffsets(rects) {
              return rects.reduce(function(previousRect, rect) {
                if (previousRect == null) {
                  return rect;
                }
                return {
                  top: previousRect.top + rect.top,
                  left: previousRect.left + rect.left,
                  width: previousRect.width,
                  height: previousRect.height,
                  bottom: previousRect.bottom + rect.bottom,
                  right: previousRect.right + rect.right
                };
              });
            }
            __name(mergeRectOffsets, "mergeRectOffsets");
            function getNestedBoundingClientRect(node2, boundaryWindow) {
              var ownerIframe = getOwnerIframe(node2);
              if (ownerIframe && ownerIframe !== boundaryWindow) {
                var rects = [node2.getBoundingClientRect()];
                var currentIframe = ownerIframe;
                var onlyOneMore = false;
                while (currentIframe) {
                  var rect = getBoundingClientRectWithBorderOffset(currentIframe);
                  rects.push(rect);
                  currentIframe = getOwnerIframe(currentIframe);
                  if (onlyOneMore) {
                    break;
                  }
                  if (currentIframe && getOwnerWindow(currentIframe) === boundaryWindow) {
                    onlyOneMore = true;
                  }
                }
                return mergeRectOffsets(rects);
              } else {
                return node2.getBoundingClientRect();
              }
            }
            __name(getNestedBoundingClientRect, "getNestedBoundingClientRect");
            function getElementDimensions(domElement) {
              var calculatedStyle = window.getComputedStyle(domElement);
              return {
                borderLeft: parseInt(calculatedStyle.borderLeftWidth, 10),
                borderRight: parseInt(calculatedStyle.borderRightWidth, 10),
                borderTop: parseInt(calculatedStyle.borderTopWidth, 10),
                borderBottom: parseInt(calculatedStyle.borderBottomWidth, 10),
                marginLeft: parseInt(calculatedStyle.marginLeft, 10),
                marginRight: parseInt(calculatedStyle.marginRight, 10),
                marginTop: parseInt(calculatedStyle.marginTop, 10),
                marginBottom: parseInt(calculatedStyle.marginBottom, 10),
                paddingLeft: parseInt(calculatedStyle.paddingLeft, 10),
                paddingRight: parseInt(calculatedStyle.paddingRight, 10),
                paddingTop: parseInt(calculatedStyle.paddingTop, 10),
                paddingBottom: parseInt(calculatedStyle.paddingBottom, 10)
              };
            }
            __name(getElementDimensions, "getElementDimensions");
            function _createForOfIteratorHelper(o2, allowArrayLike) {
              var it2;
              if (typeof Symbol === "undefined" || o2[Symbol.iterator] == null) {
                if (Array.isArray(o2) || (it2 = _unsupportedIterableToArray4(o2)) || allowArrayLike && o2 && typeof o2.length === "number") {
                  if (it2)
                    o2 = it2;
                  var i = 0;
                  var F = /* @__PURE__ */ __name(function F2() {
                  }, "F");
                  return { s: F, n: /* @__PURE__ */ __name(function n2() {
                    if (i >= o2.length)
                      return { done: true };
                    return { done: false, value: o2[i++] };
                  }, "n"), e: /* @__PURE__ */ __name(function e3(_e) {
                    throw _e;
                  }, "e"), f: F };
                }
                throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
              }
              var normalCompletion = true, didErr = false, err;
              return { s: /* @__PURE__ */ __name(function s() {
                it2 = o2[Symbol.iterator]();
              }, "s"), n: /* @__PURE__ */ __name(function n2() {
                var step = it2.next();
                normalCompletion = step.done;
                return step;
              }, "n"), e: /* @__PURE__ */ __name(function e3(_e2) {
                didErr = true;
                err = _e2;
              }, "e"), f: /* @__PURE__ */ __name(function f() {
                try {
                  if (!normalCompletion && it2.return != null)
                    it2.return();
                } finally {
                  if (didErr)
                    throw err;
                }
              }, "f") };
            }
            __name(_createForOfIteratorHelper, "_createForOfIteratorHelper");
            function _unsupportedIterableToArray4(o2, minLen) {
              if (!o2)
                return;
              if (typeof o2 === "string")
                return _arrayLikeToArray4(o2, minLen);
              var n2 = Object.prototype.toString.call(o2).slice(8, -1);
              if (n2 === "Object" && o2.constructor)
                n2 = o2.constructor.name;
              if (n2 === "Map" || n2 === "Set")
                return Array.from(o2);
              if (n2 === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n2))
                return _arrayLikeToArray4(o2, minLen);
            }
            __name(_unsupportedIterableToArray4, "_unsupportedIterableToArray");
            function _arrayLikeToArray4(arr, len) {
              if (len == null || len > arr.length)
                len = arr.length;
              for (var i = 0, arr2 = new Array(len); i < len; i++) {
                arr2[i] = arr[i];
              }
              return arr2;
            }
            __name(_arrayLikeToArray4, "_arrayLikeToArray");
            function Overlay_classCallCheck(instance, Constructor) {
              if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
              }
            }
            __name(Overlay_classCallCheck, "Overlay_classCallCheck");
            function Overlay_defineProperties(target, props) {
              for (var i = 0; i < props.length; i++) {
                var descriptor2 = props[i];
                descriptor2.enumerable = descriptor2.enumerable || false;
                descriptor2.configurable = true;
                if ("value" in descriptor2)
                  descriptor2.writable = true;
                Object.defineProperty(target, descriptor2.key, descriptor2);
              }
            }
            __name(Overlay_defineProperties, "Overlay_defineProperties");
            function Overlay_createClass(Constructor, protoProps, staticProps) {
              if (protoProps)
                Overlay_defineProperties(Constructor.prototype, protoProps);
              if (staticProps)
                Overlay_defineProperties(Constructor, staticProps);
              return Constructor;
            }
            __name(Overlay_createClass, "Overlay_createClass");
            var Overlay_OverlayRect = /* @__PURE__ */ function() {
              function OverlayRect(doc, container) {
                Overlay_classCallCheck(this, OverlayRect);
                this.node = doc.createElement("div");
                this.border = doc.createElement("div");
                this.padding = doc.createElement("div");
                this.content = doc.createElement("div");
                this.border.style.borderColor = overlayStyles.border;
                this.padding.style.borderColor = overlayStyles.padding;
                this.content.style.backgroundColor = overlayStyles.background;
                object_assign_default()(this.node.style, {
                  borderColor: overlayStyles.margin,
                  pointerEvents: "none",
                  position: "fixed"
                });
                this.node.style.zIndex = "10000000";
                this.node.appendChild(this.border);
                this.border.appendChild(this.padding);
                this.padding.appendChild(this.content);
                container.appendChild(this.node);
              }
              __name(OverlayRect, "OverlayRect");
              Overlay_createClass(OverlayRect, [{
                key: "remove",
                value: /* @__PURE__ */ __name(function remove() {
                  if (this.node.parentNode) {
                    this.node.parentNode.removeChild(this.node);
                  }
                }, "remove")
              }, {
                key: "update",
                value: /* @__PURE__ */ __name(function update(box, dims) {
                  boxWrap(dims, "margin", this.node);
                  boxWrap(dims, "border", this.border);
                  boxWrap(dims, "padding", this.padding);
                  object_assign_default()(this.content.style, {
                    height: box.height - dims.borderTop - dims.borderBottom - dims.paddingTop - dims.paddingBottom + "px",
                    width: box.width - dims.borderLeft - dims.borderRight - dims.paddingLeft - dims.paddingRight + "px"
                  });
                  object_assign_default()(this.node.style, {
                    top: box.top - dims.marginTop + "px",
                    left: box.left - dims.marginLeft + "px"
                  });
                }, "update")
              }]);
              return OverlayRect;
            }();
            var Overlay_OverlayTip = /* @__PURE__ */ function() {
              function OverlayTip(doc, container) {
                Overlay_classCallCheck(this, OverlayTip);
                this.tip = doc.createElement("div");
                object_assign_default()(this.tip.style, {
                  display: "flex",
                  flexFlow: "row nowrap",
                  backgroundColor: "#333740",
                  borderRadius: "2px",
                  fontFamily: '"SFMono-Regular", Consolas, "Liberation Mono", Menlo, Courier, monospace',
                  fontWeight: "bold",
                  padding: "3px 5px",
                  pointerEvents: "none",
                  position: "fixed",
                  fontSize: "12px",
                  whiteSpace: "nowrap"
                });
                this.nameSpan = doc.createElement("span");
                this.tip.appendChild(this.nameSpan);
                object_assign_default()(this.nameSpan.style, {
                  color: "#ee78e6",
                  borderRight: "1px solid #aaaaaa",
                  paddingRight: "0.5rem",
                  marginRight: "0.5rem"
                });
                this.dimSpan = doc.createElement("span");
                this.tip.appendChild(this.dimSpan);
                object_assign_default()(this.dimSpan.style, {
                  color: "#d7d7d7"
                });
                this.tip.style.zIndex = "10000000";
                container.appendChild(this.tip);
              }
              __name(OverlayTip, "OverlayTip");
              Overlay_createClass(OverlayTip, [{
                key: "remove",
                value: /* @__PURE__ */ __name(function remove() {
                  if (this.tip.parentNode) {
                    this.tip.parentNode.removeChild(this.tip);
                  }
                }, "remove")
              }, {
                key: "updateText",
                value: /* @__PURE__ */ __name(function updateText(name, width, height) {
                  this.nameSpan.textContent = name;
                  this.dimSpan.textContent = Math.round(width) + "px \xD7 " + Math.round(height) + "px";
                }, "updateText")
              }, {
                key: "updatePosition",
                value: /* @__PURE__ */ __name(function updatePosition(dims, bounds) {
                  var tipRect = this.tip.getBoundingClientRect();
                  var tipPos = findTipPos(dims, bounds, {
                    width: tipRect.width,
                    height: tipRect.height
                  });
                  object_assign_default()(this.tip.style, tipPos.style);
                }, "updatePosition")
              }]);
              return OverlayTip;
            }();
            var Overlay_Overlay = /* @__PURE__ */ function() {
              function Overlay() {
                Overlay_classCallCheck(this, Overlay);
                var currentWindow = window.__REACT_DEVTOOLS_TARGET_WINDOW__ || window;
                this.window = currentWindow;
                var tipBoundsWindow = window.__REACT_DEVTOOLS_TARGET_WINDOW__ || window;
                this.tipBoundsWindow = tipBoundsWindow;
                var doc = currentWindow.document;
                this.container = doc.createElement("div");
                this.container.style.zIndex = "10000000";
                this.tip = new Overlay_OverlayTip(doc, this.container);
                this.rects = [];
                doc.body.appendChild(this.container);
              }
              __name(Overlay, "Overlay");
              Overlay_createClass(Overlay, [{
                key: "remove",
                value: /* @__PURE__ */ __name(function remove() {
                  this.tip.remove();
                  this.rects.forEach(function(rect) {
                    rect.remove();
                  });
                  this.rects.length = 0;
                  if (this.container.parentNode) {
                    this.container.parentNode.removeChild(this.container);
                  }
                }, "remove")
              }, {
                key: "inspect",
                value: /* @__PURE__ */ __name(function inspect2(nodes, name) {
                  var _this = this;
                  var elements = nodes.filter(function(node3) {
                    return node3.nodeType === Node.ELEMENT_NODE;
                  });
                  while (this.rects.length > elements.length) {
                    var rect = this.rects.pop();
                    rect.remove();
                  }
                  if (elements.length === 0) {
                    return;
                  }
                  while (this.rects.length < elements.length) {
                    this.rects.push(new Overlay_OverlayRect(this.window.document, this.container));
                  }
                  var outerBox = {
                    top: Number.POSITIVE_INFINITY,
                    right: Number.NEGATIVE_INFINITY,
                    bottom: Number.NEGATIVE_INFINITY,
                    left: Number.POSITIVE_INFINITY
                  };
                  elements.forEach(function(element, index) {
                    var box = getNestedBoundingClientRect(element, _this.window);
                    var dims = getElementDimensions(element);
                    outerBox.top = Math.min(outerBox.top, box.top - dims.marginTop);
                    outerBox.right = Math.max(outerBox.right, box.left + box.width + dims.marginRight);
                    outerBox.bottom = Math.max(outerBox.bottom, box.top + box.height + dims.marginBottom);
                    outerBox.left = Math.min(outerBox.left, box.left - dims.marginLeft);
                    var rect2 = _this.rects[index];
                    rect2.update(box, dims);
                  });
                  if (!name) {
                    name = elements[0].nodeName.toLowerCase();
                    var node2 = elements[0];
                    var hook = node2.ownerDocument.defaultView.__REACT_DEVTOOLS_GLOBAL_HOOK__;
                    if (hook != null && hook.rendererInterfaces != null) {
                      var ownerName = null;
                      var _iterator = _createForOfIteratorHelper(hook.rendererInterfaces.values()), _step;
                      try {
                        for (_iterator.s(); !(_step = _iterator.n()).done; ) {
                          var rendererInterface = _step.value;
                          var id = rendererInterface.getFiberIDForNative(node2, true);
                          if (id !== null) {
                            ownerName = rendererInterface.getDisplayNameForFiberID(id, true);
                            break;
                          }
                        }
                      } catch (err) {
                        _iterator.e(err);
                      } finally {
                        _iterator.f();
                      }
                      if (ownerName) {
                        name += " (in " + ownerName + ")";
                      }
                    }
                  }
                  this.tip.updateText(name, outerBox.right - outerBox.left, outerBox.bottom - outerBox.top);
                  var tipBounds = getNestedBoundingClientRect(this.tipBoundsWindow.document.documentElement, this.window);
                  this.tip.updatePosition({
                    top: outerBox.top,
                    left: outerBox.left,
                    height: outerBox.bottom - outerBox.top,
                    width: outerBox.right - outerBox.left
                  }, {
                    top: tipBounds.top + this.tipBoundsWindow.scrollY,
                    left: tipBounds.left + this.tipBoundsWindow.scrollX,
                    height: this.tipBoundsWindow.innerHeight,
                    width: this.tipBoundsWindow.innerWidth
                  });
                }, "inspect")
              }]);
              return Overlay;
            }();
            function findTipPos(dims, bounds, tipSize) {
              var tipHeight = Math.max(tipSize.height, 20);
              var tipWidth = Math.max(tipSize.width, 60);
              var margin = 5;
              var top2;
              if (dims.top + dims.height + tipHeight <= bounds.top + bounds.height) {
                if (dims.top + dims.height < bounds.top + 0) {
                  top2 = bounds.top + margin;
                } else {
                  top2 = dims.top + dims.height + margin;
                }
              } else if (dims.top - tipHeight <= bounds.top + bounds.height) {
                if (dims.top - tipHeight - margin < bounds.top + margin) {
                  top2 = bounds.top + margin;
                } else {
                  top2 = dims.top - tipHeight - margin;
                }
              } else {
                top2 = bounds.top + bounds.height - tipHeight - margin;
              }
              var left2 = dims.left + margin;
              if (dims.left < bounds.left) {
                left2 = bounds.left + margin;
              }
              if (dims.left + tipWidth > bounds.left + bounds.width) {
                left2 = bounds.left + bounds.width - tipWidth - margin;
              }
              top2 += "px";
              left2 += "px";
              return {
                style: {
                  top: top2,
                  left: left2
                }
              };
            }
            __name(findTipPos, "findTipPos");
            function boxWrap(dims, what, node2) {
              object_assign_default()(node2.style, {
                borderTopWidth: dims[what + "Top"] + "px",
                borderLeftWidth: dims[what + "Left"] + "px",
                borderRightWidth: dims[what + "Right"] + "px",
                borderBottomWidth: dims[what + "Bottom"] + "px",
                borderStyle: "solid"
              });
            }
            __name(boxWrap, "boxWrap");
            var overlayStyles = {
              background: "rgba(120, 170, 210, 0.7)",
              padding: "rgba(77, 200, 0, 0.3)",
              margin: "rgba(255, 155, 0, 0.3)",
              border: "rgba(255, 200, 50, 0.3)"
            };
            var SHOW_DURATION = 2e3;
            var timeoutID = null;
            var overlay = null;
            function hideOverlay() {
              timeoutID = null;
              if (overlay !== null) {
                overlay.remove();
                overlay = null;
              }
            }
            __name(hideOverlay, "hideOverlay");
            function showOverlay(elements, componentName, hideAfterTimeout) {
              if (window.document == null) {
                return;
              }
              if (timeoutID !== null) {
                clearTimeout(timeoutID);
              }
              if (elements == null) {
                return;
              }
              if (overlay === null) {
                overlay = new Overlay_Overlay();
              }
              overlay.inspect(elements, componentName);
              if (hideAfterTimeout) {
                timeoutID = setTimeout(hideOverlay, SHOW_DURATION);
              }
            }
            __name(showOverlay, "showOverlay");
            var iframesListeningTo = /* @__PURE__ */ new Set();
            function setupHighlighter(bridge, agent) {
              bridge.addListener("clearNativeElementHighlight", clearNativeElementHighlight);
              bridge.addListener("highlightNativeElement", highlightNativeElement);
              bridge.addListener("shutdown", stopInspectingNative);
              bridge.addListener("startInspectingNative", startInspectingNative);
              bridge.addListener("stopInspectingNative", stopInspectingNative);
              function startInspectingNative() {
                registerListenersOnWindow(window);
              }
              __name(startInspectingNative, "startInspectingNative");
              function registerListenersOnWindow(window2) {
                if (window2 && typeof window2.addEventListener === "function") {
                  window2.addEventListener("click", onClick, true);
                  window2.addEventListener("mousedown", onMouseEvent, true);
                  window2.addEventListener("mouseover", onMouseEvent, true);
                  window2.addEventListener("mouseup", onMouseEvent, true);
                  window2.addEventListener("pointerdown", onPointerDown, true);
                  window2.addEventListener("pointerover", onPointerOver, true);
                  window2.addEventListener("pointerup", onPointerUp, true);
                }
              }
              __name(registerListenersOnWindow, "registerListenersOnWindow");
              function stopInspectingNative() {
                hideOverlay();
                removeListenersOnWindow(window);
                iframesListeningTo.forEach(function(frame) {
                  try {
                    removeListenersOnWindow(frame.contentWindow);
                  } catch (error2) {
                  }
                });
                iframesListeningTo = /* @__PURE__ */ new Set();
              }
              __name(stopInspectingNative, "stopInspectingNative");
              function removeListenersOnWindow(window2) {
                if (window2 && typeof window2.removeEventListener === "function") {
                  window2.removeEventListener("click", onClick, true);
                  window2.removeEventListener("mousedown", onMouseEvent, true);
                  window2.removeEventListener("mouseover", onMouseEvent, true);
                  window2.removeEventListener("mouseup", onMouseEvent, true);
                  window2.removeEventListener("pointerdown", onPointerDown, true);
                  window2.removeEventListener("pointerover", onPointerOver, true);
                  window2.removeEventListener("pointerup", onPointerUp, true);
                }
              }
              __name(removeListenersOnWindow, "removeListenersOnWindow");
              function clearNativeElementHighlight() {
                hideOverlay();
              }
              __name(clearNativeElementHighlight, "clearNativeElementHighlight");
              function highlightNativeElement(_ref) {
                var displayName = _ref.displayName, hideAfterTimeout = _ref.hideAfterTimeout, id = _ref.id, openNativeElementsPanel = _ref.openNativeElementsPanel, rendererID = _ref.rendererID, scrollIntoView = _ref.scrollIntoView;
                var renderer = agent.rendererInterfaces[rendererID];
                if (renderer == null) {
                  console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
                }
                var nodes = null;
                if (renderer != null) {
                  nodes = renderer.findNativeNodesForFiberID(id);
                }
                if (nodes != null && nodes[0] != null) {
                  var node2 = nodes[0];
                  if (scrollIntoView && typeof node2.scrollIntoView === "function") {
                    node2.scrollIntoView({
                      block: "nearest",
                      inline: "nearest"
                    });
                  }
                  showOverlay(nodes, displayName, hideAfterTimeout);
                  if (openNativeElementsPanel) {
                    window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$0 = node2;
                    bridge.send("syncSelectionToNativeElementsPanel");
                  }
                } else {
                  hideOverlay();
                }
              }
              __name(highlightNativeElement, "highlightNativeElement");
              function onClick(event) {
                event.preventDefault();
                event.stopPropagation();
                stopInspectingNative();
                bridge.send("stopInspectingNative", true);
              }
              __name(onClick, "onClick");
              function onMouseEvent(event) {
                event.preventDefault();
                event.stopPropagation();
              }
              __name(onMouseEvent, "onMouseEvent");
              function onPointerDown(event) {
                event.preventDefault();
                event.stopPropagation();
                selectFiberForNode(event.target);
              }
              __name(onPointerDown, "onPointerDown");
              function onPointerOver(event) {
                event.preventDefault();
                event.stopPropagation();
                var target = event.target;
                if (target.tagName === "IFRAME") {
                  var iframe = target;
                  try {
                    if (!iframesListeningTo.has(iframe)) {
                      var _window = iframe.contentWindow;
                      registerListenersOnWindow(_window);
                      iframesListeningTo.add(iframe);
                    }
                  } catch (error2) {
                  }
                }
                showOverlay([target], null, false);
                selectFiberForNode(target);
              }
              __name(onPointerOver, "onPointerOver");
              function onPointerUp(event) {
                event.preventDefault();
                event.stopPropagation();
              }
              __name(onPointerUp, "onPointerUp");
              var selectFiberForNode = lodash_throttle_default()(
                esm(function(node2) {
                  var id = agent.getIDForNode(node2);
                  if (id !== null) {
                    bridge.send("selectFiber", id);
                  }
                }),
                200,
                // Don't change the selection in the very first 200ms
                // because those are usually unintentional as you lift the cursor.
                {
                  leading: false
                }
              );
            }
            __name(setupHighlighter, "setupHighlighter");
            var OUTLINE_COLOR = "#f0f0f0";
            var COLORS = ["#37afa9", "#63b19e", "#80b393", "#97b488", "#abb67d", "#beb771", "#cfb965", "#dfba57", "#efbb49", "#febc38"];
            var canvas = null;
            function draw(nodeToData2) {
              if (canvas === null) {
                initialize();
              }
              var canvasFlow = canvas;
              canvasFlow.width = window.innerWidth;
              canvasFlow.height = window.innerHeight;
              var context2 = canvasFlow.getContext("2d");
              context2.clearRect(0, 0, canvasFlow.width, canvasFlow.height);
              nodeToData2.forEach(function(_ref) {
                var count = _ref.count, rect = _ref.rect;
                if (rect !== null) {
                  var colorIndex = Math.min(COLORS.length - 1, count - 1);
                  var color = COLORS[colorIndex];
                  drawBorder(context2, rect, color);
                }
              });
            }
            __name(draw, "draw");
            function drawBorder(context2, rect, color) {
              var height = rect.height, left2 = rect.left, top2 = rect.top, width = rect.width;
              context2.lineWidth = 1;
              context2.strokeStyle = OUTLINE_COLOR;
              context2.strokeRect(left2 - 1, top2 - 1, width + 2, height + 2);
              context2.lineWidth = 1;
              context2.strokeStyle = OUTLINE_COLOR;
              context2.strokeRect(left2 + 1, top2 + 1, width - 1, height - 1);
              context2.strokeStyle = color;
              context2.setLineDash([0]);
              context2.lineWidth = 1;
              context2.strokeRect(left2, top2, width - 1, height - 1);
              context2.setLineDash([0]);
            }
            __name(drawBorder, "drawBorder");
            function destroy() {
              if (canvas !== null) {
                if (canvas.parentNode != null) {
                  canvas.parentNode.removeChild(canvas);
                }
                canvas = null;
              }
            }
            __name(destroy, "destroy");
            function initialize() {
              canvas = window.document.createElement("canvas");
              canvas.style.cssText = "\n    xx-background-color: red;\n    xx-opacity: 0.5;\n    bottom: 0;\n    left: 0;\n    pointer-events: none;\n    position: fixed;\n    right: 0;\n    top: 0;\n    z-index: 1000000000;\n  ";
              var root = window.document.documentElement;
              root.insertBefore(canvas, root.firstChild);
            }
            __name(initialize, "initialize");
            function _typeof7(obj) {
              "@babel/helpers - typeof";
              if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return typeof obj2;
                }, "_typeof");
              } else {
                _typeof7 = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
                }, "_typeof");
              }
              return _typeof7(obj);
            }
            __name(_typeof7, "_typeof");
            var DISPLAY_DURATION = 250;
            var MAX_DISPLAY_DURATION = 3e3;
            var REMEASUREMENT_AFTER_DURATION = 250;
            var getCurrentTime = (typeof performance === "undefined" ? "undefined" : _typeof7(performance)) === "object" && typeof performance.now === "function" ? function() {
              return performance.now();
            } : function() {
              return Date.now();
            };
            var nodeToData = /* @__PURE__ */ new Map();
            var TraceUpdates_agent = null;
            var drawAnimationFrameID = null;
            var isEnabled = false;
            var redrawTimeoutID = null;
            function TraceUpdates_initialize(injectedAgent) {
              TraceUpdates_agent = injectedAgent;
              TraceUpdates_agent.addListener("traceUpdates", traceUpdates);
            }
            __name(TraceUpdates_initialize, "TraceUpdates_initialize");
            function toggleEnabled(value) {
              isEnabled = value;
              if (!isEnabled) {
                nodeToData.clear();
                if (drawAnimationFrameID !== null) {
                  cancelAnimationFrame(drawAnimationFrameID);
                  drawAnimationFrameID = null;
                }
                if (redrawTimeoutID !== null) {
                  clearTimeout(redrawTimeoutID);
                  redrawTimeoutID = null;
                }
                destroy();
              }
            }
            __name(toggleEnabled, "toggleEnabled");
            function traceUpdates(nodes) {
              if (!isEnabled) {
                return;
              }
              nodes.forEach(function(node2) {
                var data = nodeToData.get(node2);
                var now = getCurrentTime();
                var lastMeasuredAt = data != null ? data.lastMeasuredAt : 0;
                var rect = data != null ? data.rect : null;
                if (rect === null || lastMeasuredAt + REMEASUREMENT_AFTER_DURATION < now) {
                  lastMeasuredAt = now;
                  rect = measureNode(node2);
                }
                nodeToData.set(node2, {
                  count: data != null ? data.count + 1 : 1,
                  expirationTime: data != null ? Math.min(now + MAX_DISPLAY_DURATION, data.expirationTime + DISPLAY_DURATION) : now + DISPLAY_DURATION,
                  lastMeasuredAt,
                  rect
                });
              });
              if (redrawTimeoutID !== null) {
                clearTimeout(redrawTimeoutID);
                redrawTimeoutID = null;
              }
              if (drawAnimationFrameID === null) {
                drawAnimationFrameID = requestAnimationFrame(prepareToDraw);
              }
            }
            __name(traceUpdates, "traceUpdates");
            function prepareToDraw() {
              drawAnimationFrameID = null;
              redrawTimeoutID = null;
              var now = getCurrentTime();
              var earliestExpiration = Number.MAX_VALUE;
              nodeToData.forEach(function(data, node2) {
                if (data.expirationTime < now) {
                  nodeToData.delete(node2);
                } else {
                  earliestExpiration = Math.min(earliestExpiration, data.expirationTime);
                }
              });
              draw(nodeToData);
              if (earliestExpiration !== Number.MAX_VALUE) {
                redrawTimeoutID = setTimeout(prepareToDraw, earliestExpiration - now);
              }
            }
            __name(prepareToDraw, "prepareToDraw");
            function measureNode(node2) {
              if (!node2 || typeof node2.getBoundingClientRect !== "function") {
                return null;
              }
              var currentWindow = window.__REACT_DEVTOOLS_TARGET_WINDOW__ || window;
              return getNestedBoundingClientRect(node2, currentWindow);
            }
            __name(measureNode, "measureNode");
            var backend_console = __webpack_require__(10);
            function bridge_typeof(obj) {
              "@babel/helpers - typeof";
              if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                bridge_typeof = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return typeof obj2;
                }, "_typeof");
              } else {
                bridge_typeof = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
                }, "_typeof");
              }
              return bridge_typeof(obj);
            }
            __name(bridge_typeof, "bridge_typeof");
            function _toConsumableArray(arr) {
              return _arrayWithoutHoles(arr) || _iterableToArray(arr) || bridge_unsupportedIterableToArray(arr) || _nonIterableSpread();
            }
            __name(_toConsumableArray, "_toConsumableArray");
            function _nonIterableSpread() {
              throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
            }
            __name(_nonIterableSpread, "_nonIterableSpread");
            function bridge_unsupportedIterableToArray(o2, minLen) {
              if (!o2)
                return;
              if (typeof o2 === "string")
                return bridge_arrayLikeToArray(o2, minLen);
              var n2 = Object.prototype.toString.call(o2).slice(8, -1);
              if (n2 === "Object" && o2.constructor)
                n2 = o2.constructor.name;
              if (n2 === "Map" || n2 === "Set")
                return Array.from(o2);
              if (n2 === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n2))
                return bridge_arrayLikeToArray(o2, minLen);
            }
            __name(bridge_unsupportedIterableToArray, "bridge_unsupportedIterableToArray");
            function _iterableToArray(iter) {
              if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter))
                return Array.from(iter);
            }
            __name(_iterableToArray, "_iterableToArray");
            function _arrayWithoutHoles(arr) {
              if (Array.isArray(arr))
                return bridge_arrayLikeToArray(arr);
            }
            __name(_arrayWithoutHoles, "_arrayWithoutHoles");
            function bridge_arrayLikeToArray(arr, len) {
              if (len == null || len > arr.length)
                len = arr.length;
              for (var i = 0, arr2 = new Array(len); i < len; i++) {
                arr2[i] = arr[i];
              }
              return arr2;
            }
            __name(bridge_arrayLikeToArray, "bridge_arrayLikeToArray");
            function bridge_classCallCheck(instance, Constructor) {
              if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
              }
            }
            __name(bridge_classCallCheck, "bridge_classCallCheck");
            function bridge_defineProperties(target, props) {
              for (var i = 0; i < props.length; i++) {
                var descriptor2 = props[i];
                descriptor2.enumerable = descriptor2.enumerable || false;
                descriptor2.configurable = true;
                if ("value" in descriptor2)
                  descriptor2.writable = true;
                Object.defineProperty(target, descriptor2.key, descriptor2);
              }
            }
            __name(bridge_defineProperties, "bridge_defineProperties");
            function bridge_createClass(Constructor, protoProps, staticProps) {
              if (protoProps)
                bridge_defineProperties(Constructor.prototype, protoProps);
              if (staticProps)
                bridge_defineProperties(Constructor, staticProps);
              return Constructor;
            }
            __name(bridge_createClass, "bridge_createClass");
            function _inherits(subClass, superClass) {
              if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
              }
              subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
              if (superClass)
                _setPrototypeOf2(subClass, superClass);
            }
            __name(_inherits, "_inherits");
            function _setPrototypeOf2(o2, p2) {
              _setPrototypeOf2 = Object.setPrototypeOf || /* @__PURE__ */ __name(function _setPrototypeOf3(o3, p3) {
                o3.__proto__ = p3;
                return o3;
              }, "_setPrototypeOf");
              return _setPrototypeOf2(o2, p2);
            }
            __name(_setPrototypeOf2, "_setPrototypeOf");
            function _createSuper(Derived) {
              var hasNativeReflectConstruct = _isNativeReflectConstruct();
              return /* @__PURE__ */ __name(function _createSuperInternal() {
                var Super = _getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                  var NewTarget = _getPrototypeOf(this).constructor;
                  result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                  result = Super.apply(this, arguments);
                }
                return _possibleConstructorReturn(this, result);
              }, "_createSuperInternal");
            }
            __name(_createSuper, "_createSuper");
            function _possibleConstructorReturn(self2, call) {
              if (call && (bridge_typeof(call) === "object" || typeof call === "function")) {
                return call;
              }
              return _assertThisInitialized(self2);
            }
            __name(_possibleConstructorReturn, "_possibleConstructorReturn");
            function _assertThisInitialized(self2) {
              if (self2 === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
              }
              return self2;
            }
            __name(_assertThisInitialized, "_assertThisInitialized");
            function _isNativeReflectConstruct() {
              if (typeof Reflect === "undefined" || !Reflect.construct)
                return false;
              if (Reflect.construct.sham)
                return false;
              if (typeof Proxy === "function")
                return true;
              try {
                Date.prototype.toString.call(Reflect.construct(Date, [], function() {
                }));
                return true;
              } catch (e3) {
                return false;
              }
            }
            __name(_isNativeReflectConstruct, "_isNativeReflectConstruct");
            function _getPrototypeOf(o2) {
              _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : /* @__PURE__ */ __name(function _getPrototypeOf2(o3) {
                return o3.__proto__ || Object.getPrototypeOf(o3);
              }, "_getPrototypeOf");
              return _getPrototypeOf(o2);
            }
            __name(_getPrototypeOf, "_getPrototypeOf");
            function bridge_defineProperty(obj, key, value) {
              if (key in obj) {
                Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
              } else {
                obj[key] = value;
              }
              return obj;
            }
            __name(bridge_defineProperty, "bridge_defineProperty");
            var BATCH_DURATION = 100;
            var BRIDGE_PROTOCOL = [
              // This version technically never existed,
              // but a backwards breaking change was added in 4.11,
              // so the safest guess to downgrade the frontend would be to version 4.10.
              {
                version: 0,
                minNpmVersion: '"<4.11.0"',
                maxNpmVersion: '"<4.11.0"'
              },
              {
                version: 1,
                minNpmVersion: "4.13.0",
                maxNpmVersion: "4.21.0"
              },
              // Version 2 adds a StrictMode-enabled and supports-StrictMode bits to add-root operation.
              {
                version: 2,
                minNpmVersion: "4.22.0",
                maxNpmVersion: null
              }
            ];
            var currentBridgeProtocol = BRIDGE_PROTOCOL[BRIDGE_PROTOCOL.length - 1];
            var Bridge = /* @__PURE__ */ function(_EventEmitter) {
              _inherits(Bridge2, _EventEmitter);
              var _super = _createSuper(Bridge2);
              function Bridge2(wall) {
                var _this;
                bridge_classCallCheck(this, Bridge2);
                _this = _super.call(this);
                bridge_defineProperty(_assertThisInitialized(_this), "_isShutdown", false);
                bridge_defineProperty(_assertThisInitialized(_this), "_messageQueue", []);
                bridge_defineProperty(_assertThisInitialized(_this), "_timeoutID", null);
                bridge_defineProperty(_assertThisInitialized(_this), "_wallUnlisten", null);
                bridge_defineProperty(_assertThisInitialized(_this), "_flush", function() {
                  if (_this._timeoutID !== null) {
                    clearTimeout(_this._timeoutID);
                    _this._timeoutID = null;
                  }
                  if (_this._messageQueue.length) {
                    for (var i = 0; i < _this._messageQueue.length; i += 2) {
                      var _this$_wall;
                      (_this$_wall = _this._wall).send.apply(_this$_wall, [_this._messageQueue[i]].concat(_toConsumableArray(_this._messageQueue[i + 1])));
                    }
                    _this._messageQueue.length = 0;
                    _this._timeoutID = setTimeout(_this._flush, BATCH_DURATION);
                  }
                });
                bridge_defineProperty(_assertThisInitialized(_this), "overrideValueAtPath", function(_ref) {
                  var id = _ref.id, path67 = _ref.path, rendererID = _ref.rendererID, type = _ref.type, value = _ref.value;
                  switch (type) {
                    case "context":
                      _this.send("overrideContext", {
                        id,
                        path: path67,
                        rendererID,
                        wasForwarded: true,
                        value
                      });
                      break;
                    case "hooks":
                      _this.send("overrideHookState", {
                        id,
                        path: path67,
                        rendererID,
                        wasForwarded: true,
                        value
                      });
                      break;
                    case "props":
                      _this.send("overrideProps", {
                        id,
                        path: path67,
                        rendererID,
                        wasForwarded: true,
                        value
                      });
                      break;
                    case "state":
                      _this.send("overrideState", {
                        id,
                        path: path67,
                        rendererID,
                        wasForwarded: true,
                        value
                      });
                      break;
                  }
                });
                _this._wall = wall;
                _this._wallUnlisten = wall.listen(function(message) {
                  if (message && message.event) {
                    _assertThisInitialized(_this).emit(message.event, message.payload);
                  }
                }) || null;
                _this.addListener("overrideValueAtPath", _this.overrideValueAtPath);
                return _this;
              }
              __name(Bridge2, "Bridge");
              bridge_createClass(Bridge2, [{
                key: "send",
                value: /* @__PURE__ */ __name(function send(event) {
                  if (this._isShutdown) {
                    console.warn('Cannot send message "'.concat(event, '" through a Bridge that has been shutdown.'));
                    return;
                  }
                  for (var _len = arguments.length, payload = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                    payload[_key - 1] = arguments[_key];
                  }
                  this._messageQueue.push(event, payload);
                  if (!this._timeoutID) {
                    this._timeoutID = setTimeout(this._flush, 0);
                  }
                }, "send")
              }, {
                key: "shutdown",
                value: /* @__PURE__ */ __name(function shutdown() {
                  if (this._isShutdown) {
                    console.warn("Bridge was already shutdown.");
                    return;
                  }
                  this.send("shutdown");
                  this._isShutdown = true;
                  this.addListener = function() {
                  };
                  this.emit = function() {
                  };
                  this.removeAllListeners();
                  var wallUnlisten = this._wallUnlisten;
                  if (wallUnlisten) {
                    wallUnlisten();
                  }
                  do {
                    this._flush();
                  } while (this._messageQueue.length);
                  if (this._timeoutID !== null) {
                    clearTimeout(this._timeoutID);
                    this._timeoutID = null;
                  }
                }, "shutdown")
              }, {
                key: "wall",
                get: /* @__PURE__ */ __name(function get() {
                  return this._wall;
                }, "get")
              }]);
              return Bridge2;
            }(EventEmitter7);
            var src_bridge = Bridge;
            var utils = __webpack_require__(4);
            function agent_typeof(obj) {
              "@babel/helpers - typeof";
              if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                agent_typeof = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return typeof obj2;
                }, "_typeof");
              } else {
                agent_typeof = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
                }, "_typeof");
              }
              return agent_typeof(obj);
            }
            __name(agent_typeof, "agent_typeof");
            function agent_classCallCheck(instance, Constructor) {
              if (!(instance instanceof Constructor)) {
                throw new TypeError("Cannot call a class as a function");
              }
            }
            __name(agent_classCallCheck, "agent_classCallCheck");
            function agent_defineProperties(target, props) {
              for (var i = 0; i < props.length; i++) {
                var descriptor2 = props[i];
                descriptor2.enumerable = descriptor2.enumerable || false;
                descriptor2.configurable = true;
                if ("value" in descriptor2)
                  descriptor2.writable = true;
                Object.defineProperty(target, descriptor2.key, descriptor2);
              }
            }
            __name(agent_defineProperties, "agent_defineProperties");
            function agent_createClass(Constructor, protoProps, staticProps) {
              if (protoProps)
                agent_defineProperties(Constructor.prototype, protoProps);
              if (staticProps)
                agent_defineProperties(Constructor, staticProps);
              return Constructor;
            }
            __name(agent_createClass, "agent_createClass");
            function agent_inherits(subClass, superClass) {
              if (typeof superClass !== "function" && superClass !== null) {
                throw new TypeError("Super expression must either be null or a function");
              }
              subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
              if (superClass)
                agent_setPrototypeOf(subClass, superClass);
            }
            __name(agent_inherits, "agent_inherits");
            function agent_setPrototypeOf(o2, p2) {
              agent_setPrototypeOf = Object.setPrototypeOf || /* @__PURE__ */ __name(function _setPrototypeOf3(o3, p3) {
                o3.__proto__ = p3;
                return o3;
              }, "_setPrototypeOf");
              return agent_setPrototypeOf(o2, p2);
            }
            __name(agent_setPrototypeOf, "agent_setPrototypeOf");
            function agent_createSuper(Derived) {
              var hasNativeReflectConstruct = agent_isNativeReflectConstruct();
              return /* @__PURE__ */ __name(function _createSuperInternal() {
                var Super = agent_getPrototypeOf(Derived), result;
                if (hasNativeReflectConstruct) {
                  var NewTarget = agent_getPrototypeOf(this).constructor;
                  result = Reflect.construct(Super, arguments, NewTarget);
                } else {
                  result = Super.apply(this, arguments);
                }
                return agent_possibleConstructorReturn(this, result);
              }, "_createSuperInternal");
            }
            __name(agent_createSuper, "agent_createSuper");
            function agent_possibleConstructorReturn(self2, call) {
              if (call && (agent_typeof(call) === "object" || typeof call === "function")) {
                return call;
              }
              return agent_assertThisInitialized(self2);
            }
            __name(agent_possibleConstructorReturn, "agent_possibleConstructorReturn");
            function agent_assertThisInitialized(self2) {
              if (self2 === void 0) {
                throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
              }
              return self2;
            }
            __name(agent_assertThisInitialized, "agent_assertThisInitialized");
            function agent_isNativeReflectConstruct() {
              if (typeof Reflect === "undefined" || !Reflect.construct)
                return false;
              if (Reflect.construct.sham)
                return false;
              if (typeof Proxy === "function")
                return true;
              try {
                Date.prototype.toString.call(Reflect.construct(Date, [], function() {
                }));
                return true;
              } catch (e3) {
                return false;
              }
            }
            __name(agent_isNativeReflectConstruct, "agent_isNativeReflectConstruct");
            function agent_getPrototypeOf(o2) {
              agent_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : /* @__PURE__ */ __name(function _getPrototypeOf2(o3) {
                return o3.__proto__ || Object.getPrototypeOf(o3);
              }, "_getPrototypeOf");
              return agent_getPrototypeOf(o2);
            }
            __name(agent_getPrototypeOf, "agent_getPrototypeOf");
            function agent_defineProperty(obj, key, value) {
              if (key in obj) {
                Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
              } else {
                obj[key] = value;
              }
              return obj;
            }
            __name(agent_defineProperty, "agent_defineProperty");
            var agent_debug = /* @__PURE__ */ __name(function debug(methodName) {
              if (constants3[
                "q"
                /* __DEBUG__ */
              ]) {
                var _console;
                for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                  args[_key - 1] = arguments[_key];
                }
                (_console = console).log.apply(_console, ["%cAgent %c".concat(methodName), "color: purple; font-weight: bold;", "font-weight: bold;"].concat(args));
              }
            }, "debug");
            var agent_Agent = /* @__PURE__ */ function(_EventEmitter) {
              agent_inherits(Agent, _EventEmitter);
              var _super = agent_createSuper(Agent);
              function Agent(bridge) {
                var _this;
                agent_classCallCheck(this, Agent);
                _this = _super.call(this);
                agent_defineProperty(agent_assertThisInitialized(_this), "_isProfiling", false);
                agent_defineProperty(agent_assertThisInitialized(_this), "_recordChangeDescriptions", false);
                agent_defineProperty(agent_assertThisInitialized(_this), "_rendererInterfaces", {});
                agent_defineProperty(agent_assertThisInitialized(_this), "_persistedSelection", null);
                agent_defineProperty(agent_assertThisInitialized(_this), "_persistedSelectionMatch", null);
                agent_defineProperty(agent_assertThisInitialized(_this), "_traceUpdatesEnabled", false);
                agent_defineProperty(agent_assertThisInitialized(_this), "clearErrorsAndWarnings", function(_ref) {
                  var rendererID = _ref.rendererID;
                  var renderer = _this._rendererInterfaces[rendererID];
                  if (renderer == null) {
                    console.warn('Invalid renderer id "'.concat(rendererID, '"'));
                  } else {
                    renderer.clearErrorsAndWarnings();
                  }
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "clearErrorsForFiberID", function(_ref2) {
                  var id = _ref2.id, rendererID = _ref2.rendererID;
                  var renderer = _this._rendererInterfaces[rendererID];
                  if (renderer == null) {
                    console.warn('Invalid renderer id "'.concat(rendererID, '"'));
                  } else {
                    renderer.clearErrorsForFiberID(id);
                  }
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "clearWarningsForFiberID", function(_ref3) {
                  var id = _ref3.id, rendererID = _ref3.rendererID;
                  var renderer = _this._rendererInterfaces[rendererID];
                  if (renderer == null) {
                    console.warn('Invalid renderer id "'.concat(rendererID, '"'));
                  } else {
                    renderer.clearWarningsForFiberID(id);
                  }
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "copyElementPath", function(_ref4) {
                  var id = _ref4.id, path67 = _ref4.path, rendererID = _ref4.rendererID;
                  var renderer = _this._rendererInterfaces[rendererID];
                  if (renderer == null) {
                    console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
                  } else {
                    renderer.copyElementPath(id, path67);
                  }
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "deletePath", function(_ref5) {
                  var hookID = _ref5.hookID, id = _ref5.id, path67 = _ref5.path, rendererID = _ref5.rendererID, type = _ref5.type;
                  var renderer = _this._rendererInterfaces[rendererID];
                  if (renderer == null) {
                    console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
                  } else {
                    renderer.deletePath(type, id, hookID, path67);
                  }
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "getBridgeProtocol", function() {
                  _this._bridge.send("bridgeProtocol", currentBridgeProtocol);
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "getProfilingData", function(_ref6) {
                  var rendererID = _ref6.rendererID;
                  var renderer = _this._rendererInterfaces[rendererID];
                  if (renderer == null) {
                    console.warn('Invalid renderer id "'.concat(rendererID, '"'));
                  }
                  _this._bridge.send("profilingData", renderer.getProfilingData());
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "getProfilingStatus", function() {
                  _this._bridge.send("profilingStatus", _this._isProfiling);
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "getOwnersList", function(_ref7) {
                  var id = _ref7.id, rendererID = _ref7.rendererID;
                  var renderer = _this._rendererInterfaces[rendererID];
                  if (renderer == null) {
                    console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
                  } else {
                    var owners = renderer.getOwnersList(id);
                    _this._bridge.send("ownersList", {
                      id,
                      owners
                    });
                  }
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "inspectElement", function(_ref8) {
                  var forceFullData = _ref8.forceFullData, id = _ref8.id, path67 = _ref8.path, rendererID = _ref8.rendererID, requestID = _ref8.requestID;
                  var renderer = _this._rendererInterfaces[rendererID];
                  if (renderer == null) {
                    console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
                  } else {
                    _this._bridge.send("inspectedElement", renderer.inspectElement(requestID, id, path67, forceFullData));
                    if (_this._persistedSelectionMatch === null || _this._persistedSelectionMatch.id !== id) {
                      _this._persistedSelection = null;
                      _this._persistedSelectionMatch = null;
                      renderer.setTrackedPath(null);
                      _this._throttledPersistSelection(rendererID, id);
                    }
                  }
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "logElementToConsole", function(_ref9) {
                  var id = _ref9.id, rendererID = _ref9.rendererID;
                  var renderer = _this._rendererInterfaces[rendererID];
                  if (renderer == null) {
                    console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
                  } else {
                    renderer.logElementToConsole(id);
                  }
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "overrideError", function(_ref10) {
                  var id = _ref10.id, rendererID = _ref10.rendererID, forceError = _ref10.forceError;
                  var renderer = _this._rendererInterfaces[rendererID];
                  if (renderer == null) {
                    console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
                  } else {
                    renderer.overrideError(id, forceError);
                  }
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "overrideSuspense", function(_ref11) {
                  var id = _ref11.id, rendererID = _ref11.rendererID, forceFallback = _ref11.forceFallback;
                  var renderer = _this._rendererInterfaces[rendererID];
                  if (renderer == null) {
                    console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
                  } else {
                    renderer.overrideSuspense(id, forceFallback);
                  }
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "overrideValueAtPath", function(_ref12) {
                  var hookID = _ref12.hookID, id = _ref12.id, path67 = _ref12.path, rendererID = _ref12.rendererID, type = _ref12.type, value = _ref12.value;
                  var renderer = _this._rendererInterfaces[rendererID];
                  if (renderer == null) {
                    console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
                  } else {
                    renderer.overrideValueAtPath(type, id, hookID, path67, value);
                  }
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "overrideContext", function(_ref13) {
                  var id = _ref13.id, path67 = _ref13.path, rendererID = _ref13.rendererID, wasForwarded = _ref13.wasForwarded, value = _ref13.value;
                  if (!wasForwarded) {
                    _this.overrideValueAtPath({
                      id,
                      path: path67,
                      rendererID,
                      type: "context",
                      value
                    });
                  }
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "overrideHookState", function(_ref14) {
                  var id = _ref14.id, hookID = _ref14.hookID, path67 = _ref14.path, rendererID = _ref14.rendererID, wasForwarded = _ref14.wasForwarded, value = _ref14.value;
                  if (!wasForwarded) {
                    _this.overrideValueAtPath({
                      id,
                      path: path67,
                      rendererID,
                      type: "hooks",
                      value
                    });
                  }
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "overrideProps", function(_ref15) {
                  var id = _ref15.id, path67 = _ref15.path, rendererID = _ref15.rendererID, wasForwarded = _ref15.wasForwarded, value = _ref15.value;
                  if (!wasForwarded) {
                    _this.overrideValueAtPath({
                      id,
                      path: path67,
                      rendererID,
                      type: "props",
                      value
                    });
                  }
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "overrideState", function(_ref16) {
                  var id = _ref16.id, path67 = _ref16.path, rendererID = _ref16.rendererID, wasForwarded = _ref16.wasForwarded, value = _ref16.value;
                  if (!wasForwarded) {
                    _this.overrideValueAtPath({
                      id,
                      path: path67,
                      rendererID,
                      type: "state",
                      value
                    });
                  }
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "reloadAndProfile", function(recordChangeDescriptions) {
                  Object(storage[
                    "e"
                    /* sessionStorageSetItem */
                  ])(constants3[
                    "i"
                    /* SESSION_STORAGE_RELOAD_AND_PROFILE_KEY */
                  ], "true");
                  Object(storage[
                    "e"
                    /* sessionStorageSetItem */
                  ])(constants3[
                    "h"
                    /* SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY */
                  ], recordChangeDescriptions ? "true" : "false");
                  _this._bridge.send("reloadAppForProfiling");
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "renamePath", function(_ref17) {
                  var hookID = _ref17.hookID, id = _ref17.id, newPath = _ref17.newPath, oldPath = _ref17.oldPath, rendererID = _ref17.rendererID, type = _ref17.type;
                  var renderer = _this._rendererInterfaces[rendererID];
                  if (renderer == null) {
                    console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
                  } else {
                    renderer.renamePath(type, id, hookID, oldPath, newPath);
                  }
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "setTraceUpdatesEnabled", function(traceUpdatesEnabled) {
                  _this._traceUpdatesEnabled = traceUpdatesEnabled;
                  toggleEnabled(traceUpdatesEnabled);
                  for (var rendererID in _this._rendererInterfaces) {
                    var renderer = _this._rendererInterfaces[rendererID];
                    renderer.setTraceUpdatesEnabled(traceUpdatesEnabled);
                  }
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "syncSelectionFromNativeElementsPanel", function() {
                  var target = window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$0;
                  if (target == null) {
                    return;
                  }
                  _this.selectNode(target);
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "shutdown", function() {
                  _this.emit("shutdown");
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "startProfiling", function(recordChangeDescriptions) {
                  _this._recordChangeDescriptions = recordChangeDescriptions;
                  _this._isProfiling = true;
                  for (var rendererID in _this._rendererInterfaces) {
                    var renderer = _this._rendererInterfaces[rendererID];
                    renderer.startProfiling(recordChangeDescriptions);
                  }
                  _this._bridge.send("profilingStatus", _this._isProfiling);
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "stopProfiling", function() {
                  _this._isProfiling = false;
                  _this._recordChangeDescriptions = false;
                  for (var rendererID in _this._rendererInterfaces) {
                    var renderer = _this._rendererInterfaces[rendererID];
                    renderer.stopProfiling();
                  }
                  _this._bridge.send("profilingStatus", _this._isProfiling);
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "storeAsGlobal", function(_ref18) {
                  var count = _ref18.count, id = _ref18.id, path67 = _ref18.path, rendererID = _ref18.rendererID;
                  var renderer = _this._rendererInterfaces[rendererID];
                  if (renderer == null) {
                    console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
                  } else {
                    renderer.storeAsGlobal(id, path67, count);
                  }
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "updateConsolePatchSettings", function(_ref19) {
                  var appendComponentStack = _ref19.appendComponentStack, breakOnConsoleErrors = _ref19.breakOnConsoleErrors, showInlineWarningsAndErrors = _ref19.showInlineWarningsAndErrors, hideConsoleLogsInStrictMode = _ref19.hideConsoleLogsInStrictMode, browserTheme = _ref19.browserTheme;
                  Object(backend_console[
                    "a"
                    /* patch */
                  ])({
                    appendComponentStack,
                    breakOnConsoleErrors,
                    showInlineWarningsAndErrors,
                    hideConsoleLogsInStrictMode,
                    browserTheme
                  });
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "updateComponentFilters", function(componentFilters) {
                  for (var rendererID in _this._rendererInterfaces) {
                    var renderer = _this._rendererInterfaces[rendererID];
                    renderer.updateComponentFilters(componentFilters);
                  }
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "viewAttributeSource", function(_ref20) {
                  var id = _ref20.id, path67 = _ref20.path, rendererID = _ref20.rendererID;
                  var renderer = _this._rendererInterfaces[rendererID];
                  if (renderer == null) {
                    console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
                  } else {
                    renderer.prepareViewAttributeSource(id, path67);
                  }
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "viewElementSource", function(_ref21) {
                  var id = _ref21.id, rendererID = _ref21.rendererID;
                  var renderer = _this._rendererInterfaces[rendererID];
                  if (renderer == null) {
                    console.warn('Invalid renderer id "'.concat(rendererID, '" for element "').concat(id, '"'));
                  } else {
                    renderer.prepareViewElementSource(id);
                  }
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "onTraceUpdates", function(nodes) {
                  _this.emit("traceUpdates", nodes);
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "onFastRefreshScheduled", function() {
                  if (constants3[
                    "q"
                    /* __DEBUG__ */
                  ]) {
                    agent_debug("onFastRefreshScheduled");
                  }
                  _this._bridge.send("fastRefreshScheduled");
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "onHookOperations", function(operations) {
                  if (constants3[
                    "q"
                    /* __DEBUG__ */
                  ]) {
                    agent_debug("onHookOperations", "(".concat(operations.length, ") [").concat(operations.join(", "), "]"));
                  }
                  _this._bridge.send("operations", operations);
                  if (_this._persistedSelection !== null) {
                    var rendererID = operations[0];
                    if (_this._persistedSelection.rendererID === rendererID) {
                      var renderer = _this._rendererInterfaces[rendererID];
                      if (renderer == null) {
                        console.warn('Invalid renderer id "'.concat(rendererID, '"'));
                      } else {
                        var prevMatch = _this._persistedSelectionMatch;
                        var nextMatch = renderer.getBestMatchForTrackedPath();
                        _this._persistedSelectionMatch = nextMatch;
                        var prevMatchID = prevMatch !== null ? prevMatch.id : null;
                        var nextMatchID = nextMatch !== null ? nextMatch.id : null;
                        if (prevMatchID !== nextMatchID) {
                          if (nextMatchID !== null) {
                            _this._bridge.send("selectFiber", nextMatchID);
                          }
                        }
                        if (nextMatch !== null && nextMatch.isFullMatch) {
                          _this._persistedSelection = null;
                          _this._persistedSelectionMatch = null;
                          renderer.setTrackedPath(null);
                        }
                      }
                    }
                  }
                });
                agent_defineProperty(agent_assertThisInitialized(_this), "_throttledPersistSelection", lodash_throttle_default()(function(rendererID, id) {
                  var renderer = _this._rendererInterfaces[rendererID];
                  var path67 = renderer != null ? renderer.getPathForElement(id) : null;
                  if (path67 !== null) {
                    Object(storage[
                      "e"
                      /* sessionStorageSetItem */
                    ])(constants3[
                      "g"
                      /* SESSION_STORAGE_LAST_SELECTION_KEY */
                    ], JSON.stringify({
                      rendererID,
                      path: path67
                    }));
                  } else {
                    Object(storage[
                      "d"
                      /* sessionStorageRemoveItem */
                    ])(constants3[
                      "g"
                      /* SESSION_STORAGE_LAST_SELECTION_KEY */
                    ]);
                  }
                }, 1e3));
                if (Object(storage[
                  "c"
                  /* sessionStorageGetItem */
                ])(constants3[
                  "i"
                  /* SESSION_STORAGE_RELOAD_AND_PROFILE_KEY */
                ]) === "true") {
                  _this._recordChangeDescriptions = Object(storage[
                    "c"
                    /* sessionStorageGetItem */
                  ])(constants3[
                    "h"
                    /* SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY */
                  ]) === "true";
                  _this._isProfiling = true;
                  Object(storage[
                    "d"
                    /* sessionStorageRemoveItem */
                  ])(constants3[
                    "h"
                    /* SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY */
                  ]);
                  Object(storage[
                    "d"
                    /* sessionStorageRemoveItem */
                  ])(constants3[
                    "i"
                    /* SESSION_STORAGE_RELOAD_AND_PROFILE_KEY */
                  ]);
                }
                var persistedSelectionString = Object(storage[
                  "c"
                  /* sessionStorageGetItem */
                ])(constants3[
                  "g"
                  /* SESSION_STORAGE_LAST_SELECTION_KEY */
                ]);
                if (persistedSelectionString != null) {
                  _this._persistedSelection = JSON.parse(persistedSelectionString);
                }
                _this._bridge = bridge;
                bridge.addListener("clearErrorsAndWarnings", _this.clearErrorsAndWarnings);
                bridge.addListener("clearErrorsForFiberID", _this.clearErrorsForFiberID);
                bridge.addListener("clearWarningsForFiberID", _this.clearWarningsForFiberID);
                bridge.addListener("copyElementPath", _this.copyElementPath);
                bridge.addListener("deletePath", _this.deletePath);
                bridge.addListener("getBridgeProtocol", _this.getBridgeProtocol);
                bridge.addListener("getProfilingData", _this.getProfilingData);
                bridge.addListener("getProfilingStatus", _this.getProfilingStatus);
                bridge.addListener("getOwnersList", _this.getOwnersList);
                bridge.addListener("inspectElement", _this.inspectElement);
                bridge.addListener("logElementToConsole", _this.logElementToConsole);
                bridge.addListener("overrideError", _this.overrideError);
                bridge.addListener("overrideSuspense", _this.overrideSuspense);
                bridge.addListener("overrideValueAtPath", _this.overrideValueAtPath);
                bridge.addListener("reloadAndProfile", _this.reloadAndProfile);
                bridge.addListener("renamePath", _this.renamePath);
                bridge.addListener("setTraceUpdatesEnabled", _this.setTraceUpdatesEnabled);
                bridge.addListener("startProfiling", _this.startProfiling);
                bridge.addListener("stopProfiling", _this.stopProfiling);
                bridge.addListener("storeAsGlobal", _this.storeAsGlobal);
                bridge.addListener("syncSelectionFromNativeElementsPanel", _this.syncSelectionFromNativeElementsPanel);
                bridge.addListener("shutdown", _this.shutdown);
                bridge.addListener("updateConsolePatchSettings", _this.updateConsolePatchSettings);
                bridge.addListener("updateComponentFilters", _this.updateComponentFilters);
                bridge.addListener("viewAttributeSource", _this.viewAttributeSource);
                bridge.addListener("viewElementSource", _this.viewElementSource);
                bridge.addListener("overrideContext", _this.overrideContext);
                bridge.addListener("overrideHookState", _this.overrideHookState);
                bridge.addListener("overrideProps", _this.overrideProps);
                bridge.addListener("overrideState", _this.overrideState);
                if (_this._isProfiling) {
                  bridge.send("profilingStatus", true);
                }
                _this._bridge.send("bridgeProtocol", currentBridgeProtocol);
                var isBackendStorageAPISupported = false;
                try {
                  localStorage.getItem("test");
                  isBackendStorageAPISupported = true;
                } catch (error2) {
                }
                bridge.send("isBackendStorageAPISupported", isBackendStorageAPISupported);
                bridge.send("isSynchronousXHRSupported", Object(utils[
                  "h"
                  /* isSynchronousXHRSupported */
                ])());
                setupHighlighter(bridge, agent_assertThisInitialized(_this));
                TraceUpdates_initialize(agent_assertThisInitialized(_this));
                return _this;
              }
              __name(Agent, "Agent");
              agent_createClass(Agent, [{
                key: "getInstanceAndStyle",
                value: /* @__PURE__ */ __name(function getInstanceAndStyle(_ref22) {
                  var id = _ref22.id, rendererID = _ref22.rendererID;
                  var renderer = this._rendererInterfaces[rendererID];
                  if (renderer == null) {
                    console.warn('Invalid renderer id "'.concat(rendererID, '"'));
                    return null;
                  }
                  return renderer.getInstanceAndStyle(id);
                }, "getInstanceAndStyle")
              }, {
                key: "getIDForNode",
                value: /* @__PURE__ */ __name(function getIDForNode(node2) {
                  for (var rendererID in this._rendererInterfaces) {
                    var renderer = this._rendererInterfaces[rendererID];
                    try {
                      var id = renderer.getFiberIDForNative(node2, true);
                      if (id !== null) {
                        return id;
                      }
                    } catch (error2) {
                    }
                  }
                  return null;
                }, "getIDForNode")
              }, {
                key: "selectNode",
                value: /* @__PURE__ */ __name(function selectNode(target) {
                  var id = this.getIDForNode(target);
                  if (id !== null) {
                    this._bridge.send("selectFiber", id);
                  }
                }, "selectNode")
              }, {
                key: "setRendererInterface",
                value: /* @__PURE__ */ __name(function setRendererInterface(rendererID, rendererInterface) {
                  this._rendererInterfaces[rendererID] = rendererInterface;
                  if (this._isProfiling) {
                    rendererInterface.startProfiling(this._recordChangeDescriptions);
                  }
                  rendererInterface.setTraceUpdatesEnabled(this._traceUpdatesEnabled);
                  var selection = this._persistedSelection;
                  if (selection !== null && selection.rendererID === rendererID) {
                    rendererInterface.setTrackedPath(selection.path);
                  }
                }, "setRendererInterface")
              }, {
                key: "onUnsupportedRenderer",
                value: /* @__PURE__ */ __name(function onUnsupportedRenderer(rendererID) {
                  this._bridge.send("unsupportedRendererVersion", rendererID);
                }, "onUnsupportedRenderer")
              }, {
                key: "rendererInterfaces",
                get: /* @__PURE__ */ __name(function get() {
                  return this._rendererInterfaces;
                }, "get")
              }]);
              return Agent;
            }(EventEmitter7);
            function installHook(target) {
              if (target.hasOwnProperty("__REACT_DEVTOOLS_GLOBAL_HOOK__")) {
                return null;
              }
              var targetConsole = console;
              var targetConsoleMethods = {};
              for (var method in console) {
                targetConsoleMethods[method] = console[method];
              }
              function dangerous_setTargetConsoleForTesting(targetConsoleForTesting) {
                targetConsole = targetConsoleForTesting;
                targetConsoleMethods = {};
                for (var _method in targetConsole) {
                  targetConsoleMethods[_method] = console[_method];
                }
              }
              __name(dangerous_setTargetConsoleForTesting, "dangerous_setTargetConsoleForTesting");
              function detectReactBuildType(renderer) {
                try {
                  if (typeof renderer.version === "string") {
                    if (renderer.bundleType > 0) {
                      return "development";
                    }
                    return "production";
                  }
                  var _toString = Function.prototype.toString;
                  if (renderer.Mount && renderer.Mount._renderNewRootComponent) {
                    var renderRootCode = _toString.call(renderer.Mount._renderNewRootComponent);
                    if (renderRootCode.indexOf("function") !== 0) {
                      return "production";
                    }
                    if (renderRootCode.indexOf("storedMeasure") !== -1) {
                      return "development";
                    }
                    if (renderRootCode.indexOf("should be a pure function") !== -1) {
                      if (renderRootCode.indexOf("NODE_ENV") !== -1) {
                        return "development";
                      }
                      if (renderRootCode.indexOf("development") !== -1) {
                        return "development";
                      }
                      if (renderRootCode.indexOf("true") !== -1) {
                        return "development";
                      }
                      if (
                        // 0.13 to 15
                        renderRootCode.indexOf("nextElement") !== -1 || // 0.12
                        renderRootCode.indexOf("nextComponent") !== -1
                      ) {
                        return "unminified";
                      } else {
                        return "development";
                      }
                    }
                    if (
                      // 0.13 to 15
                      renderRootCode.indexOf("nextElement") !== -1 || // 0.12
                      renderRootCode.indexOf("nextComponent") !== -1
                    ) {
                      return "unminified";
                    }
                    return "outdated";
                  }
                } catch (err) {
                }
                return "production";
              }
              __name(detectReactBuildType, "detectReactBuildType");
              function checkDCE(fn2) {
                try {
                  var _toString2 = Function.prototype.toString;
                  var code = _toString2.call(fn2);
                  if (code.indexOf("^_^") > -1) {
                    hasDetectedBadDCE = true;
                    setTimeout(function() {
                      throw new Error("React is running in production mode, but dead code elimination has not been applied. Read how to correctly configure React for production: https://reactjs.org/link/perf-use-production-build");
                    });
                  }
                } catch (err) {
                }
              }
              __name(checkDCE, "checkDCE");
              function format10(maybeMessage) {
                for (var _len = arguments.length, inputArgs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                  inputArgs[_key - 1] = arguments[_key];
                }
                var args = inputArgs.slice();
                var formatted = String(maybeMessage);
                if (typeof maybeMessage === "string") {
                  if (args.length) {
                    var REGEXP = /(%?)(%([jds]))/g;
                    formatted = formatted.replace(REGEXP, function(match, escaped, ptn, flag) {
                      var arg = args.shift();
                      switch (flag) {
                        case "s":
                          arg += "";
                          break;
                        case "d":
                        case "i":
                          arg = parseInt(arg, 10).toString();
                          break;
                        case "f":
                          arg = parseFloat(arg).toString();
                          break;
                      }
                      if (!escaped) {
                        return arg;
                      }
                      args.unshift(arg);
                      return match;
                    });
                  }
                }
                if (args.length) {
                  for (var i = 0; i < args.length; i++) {
                    formatted += " " + String(args[i]);
                  }
                }
                formatted = formatted.replace(/%{2,2}/g, "%");
                return String(formatted);
              }
              __name(format10, "format");
              var unpatchFn = null;
              function patchConsoleForInitialRenderInStrictMode(_ref) {
                var hideConsoleLogsInStrictMode = _ref.hideConsoleLogsInStrictMode, browserTheme = _ref.browserTheme;
                var overrideConsoleMethods = ["error", "trace", "warn", "log"];
                if (unpatchFn !== null) {
                  return;
                }
                var originalConsoleMethods2 = {};
                unpatchFn = /* @__PURE__ */ __name(function unpatchFn2() {
                  for (var _method2 in originalConsoleMethods2) {
                    try {
                      targetConsole[_method2] = originalConsoleMethods2[_method2];
                    } catch (error2) {
                    }
                  }
                }, "unpatchFn");
                overrideConsoleMethods.forEach(function(method2) {
                  try {
                    var originalMethod = originalConsoleMethods2[method2] = targetConsole[method2].__REACT_DEVTOOLS_STRICT_MODE_ORIGINAL_METHOD__ ? targetConsole[method2].__REACT_DEVTOOLS_STRICT_MODE_ORIGINAL_METHOD__ : targetConsole[method2];
                    var overrideMethod = /* @__PURE__ */ __name(function overrideMethod2() {
                      if (!hideConsoleLogsInStrictMode) {
                        var color;
                        switch (method2) {
                          case "warn":
                            color = browserTheme === "light" ? "rgba(250, 180, 50, 0.75)" : "rgba(250, 180, 50, 0.5)";
                            break;
                          case "error":
                            color = browserTheme === "light" ? "rgba(250, 123, 130, 0.75)" : "rgba(250, 123, 130, 0.5)";
                            break;
                          case "log":
                          default:
                            color = browserTheme === "light" ? "rgba(125, 125, 125, 0.75)" : "rgba(125, 125, 125, 0.5)";
                            break;
                        }
                        if (color) {
                          originalMethod("%c".concat(format10.apply(void 0, arguments)), "color: ".concat(color));
                        } else {
                          throw Error("Console color is not defined");
                        }
                      }
                    }, "overrideMethod");
                    overrideMethod.__REACT_DEVTOOLS_STRICT_MODE_ORIGINAL_METHOD__ = originalMethod;
                    originalMethod.__REACT_DEVTOOLS_STRICT_MODE_OVERRIDE_METHOD__ = overrideMethod;
                    targetConsole[method2] = overrideMethod;
                  } catch (error2) {
                  }
                });
              }
              __name(patchConsoleForInitialRenderInStrictMode, "patchConsoleForInitialRenderInStrictMode");
              function unpatchConsoleForInitialRenderInStrictMode() {
                if (unpatchFn !== null) {
                  unpatchFn();
                  unpatchFn = null;
                }
              }
              __name(unpatchConsoleForInitialRenderInStrictMode, "unpatchConsoleForInitialRenderInStrictMode");
              var uidCounter = 0;
              function inject(renderer) {
                var id = ++uidCounter;
                renderers.set(id, renderer);
                var reactBuildType = hasDetectedBadDCE ? "deadcode" : detectReactBuildType(renderer);
                if (true) {
                  try {
                    var appendComponentStack = window.__REACT_DEVTOOLS_APPEND_COMPONENT_STACK__ !== false;
                    var breakOnConsoleErrors = window.__REACT_DEVTOOLS_BREAK_ON_CONSOLE_ERRORS__ === true;
                    var showInlineWarningsAndErrors = window.__REACT_DEVTOOLS_SHOW_INLINE_WARNINGS_AND_ERRORS__ !== false;
                    var hideConsoleLogsInStrictMode = window.__REACT_DEVTOOLS_HIDE_CONSOLE_LOGS_IN_STRICT_MODE__ === true;
                    var browserTheme = window.__REACT_DEVTOOLS_BROWSER_THEME__;
                    Object(backend_console[
                      "c"
                      /* registerRenderer */
                    ])(renderer);
                    Object(backend_console[
                      "a"
                      /* patch */
                    ])({
                      appendComponentStack,
                      breakOnConsoleErrors,
                      showInlineWarningsAndErrors,
                      hideConsoleLogsInStrictMode,
                      browserTheme
                    });
                  } catch (error2) {
                  }
                }
                var attach = target.__REACT_DEVTOOLS_ATTACH__;
                if (typeof attach === "function") {
                  var rendererInterface = attach(hook, id, renderer, target);
                  hook.rendererInterfaces.set(id, rendererInterface);
                }
                hook.emit("renderer", {
                  id,
                  renderer,
                  reactBuildType
                });
                return id;
              }
              __name(inject, "inject");
              var hasDetectedBadDCE = false;
              function sub(event, fn2) {
                hook.on(event, fn2);
                return function() {
                  return hook.off(event, fn2);
                };
              }
              __name(sub, "sub");
              function on(event, fn2) {
                if (!listeners[event]) {
                  listeners[event] = [];
                }
                listeners[event].push(fn2);
              }
              __name(on, "on");
              function off(event, fn2) {
                if (!listeners[event]) {
                  return;
                }
                var index = listeners[event].indexOf(fn2);
                if (index !== -1) {
                  listeners[event].splice(index, 1);
                }
                if (!listeners[event].length) {
                  delete listeners[event];
                }
              }
              __name(off, "off");
              function emit(event, data) {
                if (listeners[event]) {
                  listeners[event].map(function(fn2) {
                    return fn2(data);
                  });
                }
              }
              __name(emit, "emit");
              function getFiberRoots(rendererID) {
                var roots = fiberRoots;
                if (!roots[rendererID]) {
                  roots[rendererID] = /* @__PURE__ */ new Set();
                }
                return roots[rendererID];
              }
              __name(getFiberRoots, "getFiberRoots");
              function onCommitFiberUnmount(rendererID, fiber) {
                var rendererInterface = rendererInterfaces.get(rendererID);
                if (rendererInterface != null) {
                  rendererInterface.handleCommitFiberUnmount(fiber);
                }
              }
              __name(onCommitFiberUnmount, "onCommitFiberUnmount");
              function onCommitFiberRoot(rendererID, root, priorityLevel) {
                var mountedRoots = hook.getFiberRoots(rendererID);
                var current = root.current;
                var isKnownRoot = mountedRoots.has(root);
                var isUnmounting = current.memoizedState == null || current.memoizedState.element == null;
                if (!isKnownRoot && !isUnmounting) {
                  mountedRoots.add(root);
                } else if (isKnownRoot && isUnmounting) {
                  mountedRoots.delete(root);
                }
                var rendererInterface = rendererInterfaces.get(rendererID);
                if (rendererInterface != null) {
                  rendererInterface.handleCommitFiberRoot(root, priorityLevel);
                }
              }
              __name(onCommitFiberRoot, "onCommitFiberRoot");
              function onPostCommitFiberRoot(rendererID, root) {
                var rendererInterface = rendererInterfaces.get(rendererID);
                if (rendererInterface != null) {
                  rendererInterface.handlePostCommitFiberRoot(root);
                }
              }
              __name(onPostCommitFiberRoot, "onPostCommitFiberRoot");
              function setStrictMode(rendererID, isStrictMode) {
                var rendererInterface = rendererInterfaces.get(rendererID);
                if (rendererInterface != null) {
                  if (isStrictMode) {
                    rendererInterface.patchConsoleForStrictMode();
                  } else {
                    rendererInterface.unpatchConsoleForStrictMode();
                  }
                } else {
                  if (isStrictMode) {
                    var hideConsoleLogsInStrictMode = window.__REACT_DEVTOOLS_HIDE_CONSOLE_LOGS_IN_STRICT_MODE__ === true;
                    var browserTheme = window.__REACT_DEVTOOLS_BROWSER_THEME__;
                    patchConsoleForInitialRenderInStrictMode({
                      hideConsoleLogsInStrictMode,
                      browserTheme
                    });
                  } else {
                    unpatchConsoleForInitialRenderInStrictMode();
                  }
                }
              }
              __name(setStrictMode, "setStrictMode");
              var openModuleRangesStack = [];
              var moduleRanges = [];
              function getTopStackFrameString(error2) {
                var frames = error2.stack.split("\n");
                var frame = frames.length > 1 ? frames[1] : null;
                return frame;
              }
              __name(getTopStackFrameString, "getTopStackFrameString");
              function getInternalModuleRanges() {
                return moduleRanges;
              }
              __name(getInternalModuleRanges, "getInternalModuleRanges");
              function registerInternalModuleStart(error2) {
                var startStackFrame = getTopStackFrameString(error2);
                if (startStackFrame !== null) {
                  openModuleRangesStack.push(startStackFrame);
                }
              }
              __name(registerInternalModuleStart, "registerInternalModuleStart");
              function registerInternalModuleStop(error2) {
                if (openModuleRangesStack.length > 0) {
                  var startStackFrame = openModuleRangesStack.pop();
                  var stopStackFrame = getTopStackFrameString(error2);
                  if (stopStackFrame !== null) {
                    moduleRanges.push([startStackFrame, stopStackFrame]);
                  }
                }
              }
              __name(registerInternalModuleStop, "registerInternalModuleStop");
              var fiberRoots = {};
              var rendererInterfaces = /* @__PURE__ */ new Map();
              var listeners = {};
              var renderers = /* @__PURE__ */ new Map();
              var hook = {
                rendererInterfaces,
                listeners,
                // Fast Refresh for web relies on this.
                renderers,
                emit,
                getFiberRoots,
                inject,
                on,
                off,
                sub,
                // This is a legacy flag.
                // React v16 checks the hook for this to ensure DevTools is new enough.
                supportsFiber: true,
                // React calls these methods.
                checkDCE,
                onCommitFiberUnmount,
                onCommitFiberRoot,
                onPostCommitFiberRoot,
                setStrictMode,
                // Schedule Profiler runtime helpers.
                // These internal React modules to report their own boundaries
                // which in turn enables the profiler to dim or filter internal frames.
                getInternalModuleRanges,
                registerInternalModuleStart,
                registerInternalModuleStop
              };
              if (false) {
              }
              Object.defineProperty(target, "__REACT_DEVTOOLS_GLOBAL_HOOK__", {
                // This property needs to be configurable for the test environment,
                // else we won't be able to delete and recreate it between tests.
                configurable: false,
                enumerable: false,
                get: /* @__PURE__ */ __name(function get() {
                  return hook;
                }, "get")
              });
              return hook;
            }
            __name(installHook, "installHook");
            var backend_renderer = __webpack_require__(16);
            var types = __webpack_require__(0);
            var src_utils = __webpack_require__(2);
            function decorate(object, attr, fn2) {
              var old = object[attr];
              object[attr] = function(instance) {
                return fn2.call(this, old, arguments);
              };
              return old;
            }
            __name(decorate, "decorate");
            function decorateMany(source, fns) {
              var olds = {};
              for (var name in fns) {
                olds[name] = decorate(source, name, fns[name]);
              }
              return olds;
            }
            __name(decorateMany, "decorateMany");
            function restoreMany(source, olds) {
              for (var name in olds) {
                source[name] = olds[name];
              }
            }
            __name(restoreMany, "restoreMany");
            function forceUpdate(instance) {
              if (typeof instance.forceUpdate === "function") {
                instance.forceUpdate();
              } else if (instance.updater != null && typeof instance.updater.enqueueForceUpdate === "function") {
                instance.updater.enqueueForceUpdate(this, function() {
                }, "forceUpdate");
              }
            }
            __name(forceUpdate, "forceUpdate");
            function ownKeys11(object, enumerableOnly) {
              var keys = Object.keys(object);
              if (Object.getOwnPropertySymbols) {
                var symbols = Object.getOwnPropertySymbols(object);
                if (enumerableOnly)
                  symbols = symbols.filter(function(sym) {
                    return Object.getOwnPropertyDescriptor(object, sym).enumerable;
                  });
                keys.push.apply(keys, symbols);
              }
              return keys;
            }
            __name(ownKeys11, "ownKeys");
            function _objectSpread11(target) {
              for (var i = 1; i < arguments.length; i++) {
                var source = arguments[i] != null ? arguments[i] : {};
                if (i % 2) {
                  ownKeys11(Object(source), true).forEach(function(key) {
                    renderer_defineProperty(target, key, source[key]);
                  });
                } else if (Object.getOwnPropertyDescriptors) {
                  Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
                } else {
                  ownKeys11(Object(source)).forEach(function(key) {
                    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
                  });
                }
              }
              return target;
            }
            __name(_objectSpread11, "_objectSpread");
            function renderer_defineProperty(obj, key, value) {
              if (key in obj) {
                Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
              } else {
                obj[key] = value;
              }
              return obj;
            }
            __name(renderer_defineProperty, "renderer_defineProperty");
            function renderer_typeof(obj) {
              "@babel/helpers - typeof";
              if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                renderer_typeof = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return typeof obj2;
                }, "_typeof");
              } else {
                renderer_typeof = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
                }, "_typeof");
              }
              return renderer_typeof(obj);
            }
            __name(renderer_typeof, "renderer_typeof");
            function getData(internalInstance) {
              var displayName = null;
              var key = null;
              if (internalInstance._currentElement != null) {
                if (internalInstance._currentElement.key) {
                  key = String(internalInstance._currentElement.key);
                }
                var elementType = internalInstance._currentElement.type;
                if (typeof elementType === "string") {
                  displayName = elementType;
                } else if (typeof elementType === "function") {
                  displayName = Object(src_utils[
                    "f"
                    /* getDisplayName */
                  ])(elementType);
                }
              }
              return {
                displayName,
                key
              };
            }
            __name(getData, "getData");
            function getElementType(internalInstance) {
              if (internalInstance._currentElement != null) {
                var elementType = internalInstance._currentElement.type;
                if (typeof elementType === "function") {
                  var publicInstance = internalInstance.getPublicInstance();
                  if (publicInstance !== null) {
                    return types[
                      "e"
                      /* ElementTypeClass */
                    ];
                  } else {
                    return types[
                      "h"
                      /* ElementTypeFunction */
                    ];
                  }
                } else if (typeof elementType === "string") {
                  return types[
                    "i"
                    /* ElementTypeHostComponent */
                  ];
                }
              }
              return types[
                "k"
                /* ElementTypeOtherOrUnknown */
              ];
            }
            __name(getElementType, "getElementType");
            function getChildren(internalInstance) {
              var children = [];
              if (renderer_typeof(internalInstance) !== "object") {
              } else if (internalInstance._currentElement === null || internalInstance._currentElement === false) {
              } else if (internalInstance._renderedComponent) {
                var child = internalInstance._renderedComponent;
                if (getElementType(child) !== types[
                  "k"
                  /* ElementTypeOtherOrUnknown */
                ]) {
                  children.push(child);
                }
              } else if (internalInstance._renderedChildren) {
                var renderedChildren = internalInstance._renderedChildren;
                for (var name in renderedChildren) {
                  var _child = renderedChildren[name];
                  if (getElementType(_child) !== types[
                    "k"
                    /* ElementTypeOtherOrUnknown */
                  ]) {
                    children.push(_child);
                  }
                }
              }
              return children;
            }
            __name(getChildren, "getChildren");
            function renderer_attach(hook, rendererID, renderer, global2) {
              var idToInternalInstanceMap = /* @__PURE__ */ new Map();
              var internalInstanceToIDMap = /* @__PURE__ */ new WeakMap();
              var internalInstanceToRootIDMap = /* @__PURE__ */ new WeakMap();
              var getInternalIDForNative = null;
              var findNativeNodeForInternalID;
              if (renderer.ComponentTree) {
                getInternalIDForNative = /* @__PURE__ */ __name(function getInternalIDForNative2(node2, findNearestUnfilteredAncestor) {
                  var internalInstance = renderer.ComponentTree.getClosestInstanceFromNode(node2);
                  return internalInstanceToIDMap.get(internalInstance) || null;
                }, "getInternalIDForNative");
                findNativeNodeForInternalID = /* @__PURE__ */ __name(function findNativeNodeForInternalID2(id) {
                  var internalInstance = idToInternalInstanceMap.get(id);
                  return renderer.ComponentTree.getNodeFromInstance(internalInstance);
                }, "findNativeNodeForInternalID");
              } else if (renderer.Mount.getID && renderer.Mount.getNode) {
                getInternalIDForNative = /* @__PURE__ */ __name(function getInternalIDForNative2(node2, findNearestUnfilteredAncestor) {
                  return null;
                }, "getInternalIDForNative");
                findNativeNodeForInternalID = /* @__PURE__ */ __name(function findNativeNodeForInternalID2(id) {
                  return null;
                }, "findNativeNodeForInternalID");
              }
              function getDisplayNameForFiberID(id) {
                var internalInstance = idToInternalInstanceMap.get(id);
                return internalInstance ? getData(internalInstance).displayName : null;
              }
              __name(getDisplayNameForFiberID, "getDisplayNameForFiberID");
              function getID(internalInstance) {
                if (renderer_typeof(internalInstance) !== "object" || internalInstance === null) {
                  throw new Error("Invalid internal instance: " + internalInstance);
                }
                if (!internalInstanceToIDMap.has(internalInstance)) {
                  var _id = Object(src_utils[
                    "i"
                    /* getUID */
                  ])();
                  internalInstanceToIDMap.set(internalInstance, _id);
                  idToInternalInstanceMap.set(_id, internalInstance);
                }
                return internalInstanceToIDMap.get(internalInstance);
              }
              __name(getID, "getID");
              function areEqualArrays(a, b2) {
                if (a.length !== b2.length) {
                  return false;
                }
                for (var i = 0; i < a.length; i++) {
                  if (a[i] !== b2[i]) {
                    return false;
                  }
                }
                return true;
              }
              __name(areEqualArrays, "areEqualArrays");
              var parentIDStack = [];
              var oldReconcilerMethods = null;
              if (renderer.Reconciler) {
                oldReconcilerMethods = decorateMany(renderer.Reconciler, {
                  mountComponent: /* @__PURE__ */ __name(function mountComponent(fn2, args) {
                    var internalInstance = args[0];
                    var hostContainerInfo = args[3];
                    if (getElementType(internalInstance) === types[
                      "k"
                      /* ElementTypeOtherOrUnknown */
                    ]) {
                      return fn2.apply(this, args);
                    }
                    if (hostContainerInfo._topLevelWrapper === void 0) {
                      return fn2.apply(this, args);
                    }
                    var id = getID(internalInstance);
                    var parentID = parentIDStack.length > 0 ? parentIDStack[parentIDStack.length - 1] : 0;
                    recordMount(internalInstance, id, parentID);
                    parentIDStack.push(id);
                    internalInstanceToRootIDMap.set(internalInstance, getID(hostContainerInfo._topLevelWrapper));
                    try {
                      var result = fn2.apply(this, args);
                      parentIDStack.pop();
                      return result;
                    } catch (err) {
                      parentIDStack = [];
                      throw err;
                    } finally {
                      if (parentIDStack.length === 0) {
                        var rootID = internalInstanceToRootIDMap.get(internalInstance);
                        if (rootID === void 0) {
                          throw new Error("Expected to find root ID.");
                        }
                        flushPendingEvents(rootID);
                      }
                    }
                  }, "mountComponent"),
                  performUpdateIfNecessary: /* @__PURE__ */ __name(function performUpdateIfNecessary(fn2, args) {
                    var internalInstance = args[0];
                    if (getElementType(internalInstance) === types[
                      "k"
                      /* ElementTypeOtherOrUnknown */
                    ]) {
                      return fn2.apply(this, args);
                    }
                    var id = getID(internalInstance);
                    parentIDStack.push(id);
                    var prevChildren = getChildren(internalInstance);
                    try {
                      var result = fn2.apply(this, args);
                      var nextChildren = getChildren(internalInstance);
                      if (!areEqualArrays(prevChildren, nextChildren)) {
                        recordReorder(internalInstance, id, nextChildren);
                      }
                      parentIDStack.pop();
                      return result;
                    } catch (err) {
                      parentIDStack = [];
                      throw err;
                    } finally {
                      if (parentIDStack.length === 0) {
                        var rootID = internalInstanceToRootIDMap.get(internalInstance);
                        if (rootID === void 0) {
                          throw new Error("Expected to find root ID.");
                        }
                        flushPendingEvents(rootID);
                      }
                    }
                  }, "performUpdateIfNecessary"),
                  receiveComponent: /* @__PURE__ */ __name(function receiveComponent(fn2, args) {
                    var internalInstance = args[0];
                    if (getElementType(internalInstance) === types[
                      "k"
                      /* ElementTypeOtherOrUnknown */
                    ]) {
                      return fn2.apply(this, args);
                    }
                    var id = getID(internalInstance);
                    parentIDStack.push(id);
                    var prevChildren = getChildren(internalInstance);
                    try {
                      var result = fn2.apply(this, args);
                      var nextChildren = getChildren(internalInstance);
                      if (!areEqualArrays(prevChildren, nextChildren)) {
                        recordReorder(internalInstance, id, nextChildren);
                      }
                      parentIDStack.pop();
                      return result;
                    } catch (err) {
                      parentIDStack = [];
                      throw err;
                    } finally {
                      if (parentIDStack.length === 0) {
                        var rootID = internalInstanceToRootIDMap.get(internalInstance);
                        if (rootID === void 0) {
                          throw new Error("Expected to find root ID.");
                        }
                        flushPendingEvents(rootID);
                      }
                    }
                  }, "receiveComponent"),
                  unmountComponent: /* @__PURE__ */ __name(function unmountComponent(fn2, args) {
                    var internalInstance = args[0];
                    if (getElementType(internalInstance) === types[
                      "k"
                      /* ElementTypeOtherOrUnknown */
                    ]) {
                      return fn2.apply(this, args);
                    }
                    var id = getID(internalInstance);
                    parentIDStack.push(id);
                    try {
                      var result = fn2.apply(this, args);
                      parentIDStack.pop();
                      recordUnmount(internalInstance, id);
                      return result;
                    } catch (err) {
                      parentIDStack = [];
                      throw err;
                    } finally {
                      if (parentIDStack.length === 0) {
                        var rootID = internalInstanceToRootIDMap.get(internalInstance);
                        if (rootID === void 0) {
                          throw new Error("Expected to find root ID.");
                        }
                        flushPendingEvents(rootID);
                      }
                    }
                  }, "unmountComponent")
                });
              }
              function cleanup() {
                if (oldReconcilerMethods !== null) {
                  if (renderer.Component) {
                    restoreMany(renderer.Component.Mixin, oldReconcilerMethods);
                  } else {
                    restoreMany(renderer.Reconciler, oldReconcilerMethods);
                  }
                }
                oldReconcilerMethods = null;
              }
              __name(cleanup, "cleanup");
              function recordMount(internalInstance, id, parentID) {
                var isRoot = parentID === 0;
                if (constants3[
                  "q"
                  /* __DEBUG__ */
                ]) {
                  console.log("%crecordMount()", "color: green; font-weight: bold;", id, getData(internalInstance).displayName);
                }
                if (isRoot) {
                  var hasOwnerMetadata = internalInstance._currentElement != null && internalInstance._currentElement._owner != null;
                  pushOperation(constants3[
                    "j"
                    /* TREE_OPERATION_ADD */
                  ]);
                  pushOperation(id);
                  pushOperation(types[
                    "m"
                    /* ElementTypeRoot */
                  ]);
                  pushOperation(0);
                  pushOperation(0);
                  pushOperation(0);
                  pushOperation(hasOwnerMetadata ? 1 : 0);
                } else {
                  var type = getElementType(internalInstance);
                  var _getData = getData(internalInstance), displayName = _getData.displayName, key = _getData.key;
                  var ownerID = internalInstance._currentElement != null && internalInstance._currentElement._owner != null ? getID(internalInstance._currentElement._owner) : 0;
                  var displayNameStringID = getStringID(displayName);
                  var keyStringID = getStringID(key);
                  pushOperation(constants3[
                    "j"
                    /* TREE_OPERATION_ADD */
                  ]);
                  pushOperation(id);
                  pushOperation(type);
                  pushOperation(parentID);
                  pushOperation(ownerID);
                  pushOperation(displayNameStringID);
                  pushOperation(keyStringID);
                }
              }
              __name(recordMount, "recordMount");
              function recordReorder(internalInstance, id, nextChildren) {
                pushOperation(constants3[
                  "m"
                  /* TREE_OPERATION_REORDER_CHILDREN */
                ]);
                pushOperation(id);
                var nextChildIDs = nextChildren.map(getID);
                pushOperation(nextChildIDs.length);
                for (var i = 0; i < nextChildIDs.length; i++) {
                  pushOperation(nextChildIDs[i]);
                }
              }
              __name(recordReorder, "recordReorder");
              function recordUnmount(internalInstance, id) {
                pendingUnmountedIDs.push(id);
                idToInternalInstanceMap.delete(id);
              }
              __name(recordUnmount, "recordUnmount");
              function crawlAndRecordInitialMounts(id, parentID, rootID) {
                if (constants3[
                  "q"
                  /* __DEBUG__ */
                ]) {
                  console.group("crawlAndRecordInitialMounts() id:", id);
                }
                var internalInstance = idToInternalInstanceMap.get(id);
                if (internalInstance != null) {
                  internalInstanceToRootIDMap.set(internalInstance, rootID);
                  recordMount(internalInstance, id, parentID);
                  getChildren(internalInstance).forEach(function(child) {
                    return crawlAndRecordInitialMounts(getID(child), id, rootID);
                  });
                }
                if (constants3[
                  "q"
                  /* __DEBUG__ */
                ]) {
                  console.groupEnd();
                }
              }
              __name(crawlAndRecordInitialMounts, "crawlAndRecordInitialMounts");
              function flushInitialOperations() {
                var roots = renderer.Mount._instancesByReactRootID || renderer.Mount._instancesByContainerID;
                for (var key in roots) {
                  var internalInstance = roots[key];
                  var _id2 = getID(internalInstance);
                  crawlAndRecordInitialMounts(_id2, 0, _id2);
                  flushPendingEvents(_id2);
                }
              }
              __name(flushInitialOperations, "flushInitialOperations");
              var pendingOperations = [];
              var pendingStringTable = /* @__PURE__ */ new Map();
              var pendingUnmountedIDs = [];
              var pendingStringTableLength = 0;
              var pendingUnmountedRootID = null;
              function flushPendingEvents(rootID) {
                if (pendingOperations.length === 0 && pendingUnmountedIDs.length === 0 && pendingUnmountedRootID === null) {
                  return;
                }
                var numUnmountIDs = pendingUnmountedIDs.length + (pendingUnmountedRootID === null ? 0 : 1);
                var operations = new Array(
                  // Identify which renderer this update is coming from.
                  2 + // [rendererID, rootFiberID]
                  // How big is the string table?
                  1 + // [stringTableLength]
                  // Then goes the actual string table.
                  pendingStringTableLength + // All unmounts are batched in a single message.
                  // [TREE_OPERATION_REMOVE, removedIDLength, ...ids]
                  (numUnmountIDs > 0 ? 2 + numUnmountIDs : 0) + // Mount operations
                  pendingOperations.length
                );
                var i = 0;
                operations[i++] = rendererID;
                operations[i++] = rootID;
                operations[i++] = pendingStringTableLength;
                pendingStringTable.forEach(function(value, key) {
                  operations[i++] = key.length;
                  var encodedKey = Object(src_utils[
                    "m"
                    /* utfEncodeString */
                  ])(key);
                  for (var j3 = 0; j3 < encodedKey.length; j3++) {
                    operations[i + j3] = encodedKey[j3];
                  }
                  i += key.length;
                });
                if (numUnmountIDs > 0) {
                  operations[i++] = constants3[
                    "k"
                    /* TREE_OPERATION_REMOVE */
                  ];
                  operations[i++] = numUnmountIDs;
                  for (var j2 = 0; j2 < pendingUnmountedIDs.length; j2++) {
                    operations[i++] = pendingUnmountedIDs[j2];
                  }
                  if (pendingUnmountedRootID !== null) {
                    operations[i] = pendingUnmountedRootID;
                    i++;
                  }
                }
                for (var _j = 0; _j < pendingOperations.length; _j++) {
                  operations[i + _j] = pendingOperations[_j];
                }
                i += pendingOperations.length;
                if (constants3[
                  "q"
                  /* __DEBUG__ */
                ]) {
                  Object(src_utils[
                    "j"
                    /* printOperationsArray */
                  ])(operations);
                }
                hook.emit("operations", operations);
                pendingOperations.length = 0;
                pendingUnmountedIDs = [];
                pendingUnmountedRootID = null;
                pendingStringTable.clear();
                pendingStringTableLength = 0;
              }
              __name(flushPendingEvents, "flushPendingEvents");
              function pushOperation(op) {
                if (false) {
                }
                pendingOperations.push(op);
              }
              __name(pushOperation, "pushOperation");
              function getStringID(str) {
                if (str === null) {
                  return 0;
                }
                var existingID = pendingStringTable.get(str);
                if (existingID !== void 0) {
                  return existingID;
                }
                var stringID = pendingStringTable.size + 1;
                pendingStringTable.set(str, stringID);
                pendingStringTableLength += str.length + 1;
                return stringID;
              }
              __name(getStringID, "getStringID");
              var currentlyInspectedElementID = null;
              var currentlyInspectedPaths = {};
              function mergeInspectedPaths(path67) {
                var current = currentlyInspectedPaths;
                path67.forEach(function(key) {
                  if (!current[key]) {
                    current[key] = {};
                  }
                  current = current[key];
                });
              }
              __name(mergeInspectedPaths, "mergeInspectedPaths");
              function createIsPathAllowed(key) {
                return /* @__PURE__ */ __name(function isPathAllowed(path67) {
                  var current = currentlyInspectedPaths[key];
                  if (!current) {
                    return false;
                  }
                  for (var i = 0; i < path67.length; i++) {
                    current = current[path67[i]];
                    if (!current) {
                      return false;
                    }
                  }
                  return true;
                }, "isPathAllowed");
              }
              __name(createIsPathAllowed, "createIsPathAllowed");
              function getInstanceAndStyle(id) {
                var instance = null;
                var style = null;
                var internalInstance = idToInternalInstanceMap.get(id);
                if (internalInstance != null) {
                  instance = internalInstance._instance || null;
                  var element = internalInstance._currentElement;
                  if (element != null && element.props != null) {
                    style = element.props.style || null;
                  }
                }
                return {
                  instance,
                  style
                };
              }
              __name(getInstanceAndStyle, "getInstanceAndStyle");
              function updateSelectedElement(id) {
                var internalInstance = idToInternalInstanceMap.get(id);
                if (internalInstance == null) {
                  console.warn('Could not find instance with id "'.concat(id, '"'));
                  return;
                }
                switch (getElementType(internalInstance)) {
                  case types[
                    "e"
                    /* ElementTypeClass */
                  ]:
                    global2.$r = internalInstance._instance;
                    break;
                  case types[
                    "h"
                    /* ElementTypeFunction */
                  ]:
                    var element = internalInstance._currentElement;
                    if (element == null) {
                      console.warn('Could not find element with id "'.concat(id, '"'));
                      return;
                    }
                    global2.$r = {
                      props: element.props,
                      type: element.type
                    };
                    break;
                  default:
                    global2.$r = null;
                    break;
                }
              }
              __name(updateSelectedElement, "updateSelectedElement");
              function storeAsGlobal(id, path67, count) {
                var inspectedElement = inspectElementRaw(id);
                if (inspectedElement !== null) {
                  var value = Object(src_utils[
                    "h"
                    /* getInObject */
                  ])(inspectedElement, path67);
                  var key = "$reactTemp".concat(count);
                  window[key] = value;
                  console.log(key);
                  console.log(value);
                }
              }
              __name(storeAsGlobal, "storeAsGlobal");
              function copyElementPath(id, path67) {
                var inspectedElement = inspectElementRaw(id);
                if (inspectedElement !== null) {
                  Object(utils[
                    "b"
                    /* copyToClipboard */
                  ])(Object(src_utils[
                    "h"
                    /* getInObject */
                  ])(inspectedElement, path67));
                }
              }
              __name(copyElementPath, "copyElementPath");
              function inspectElement(requestID, id, path67, forceFullData) {
                if (forceFullData || currentlyInspectedElementID !== id) {
                  currentlyInspectedElementID = id;
                  currentlyInspectedPaths = {};
                }
                var inspectedElement = inspectElementRaw(id);
                if (inspectedElement === null) {
                  return {
                    id,
                    responseID: requestID,
                    type: "not-found"
                  };
                }
                if (path67 !== null) {
                  mergeInspectedPaths(path67);
                }
                updateSelectedElement(id);
                inspectedElement.context = Object(utils[
                  "a"
                  /* cleanForBridge */
                ])(inspectedElement.context, createIsPathAllowed("context"));
                inspectedElement.props = Object(utils[
                  "a"
                  /* cleanForBridge */
                ])(inspectedElement.props, createIsPathAllowed("props"));
                inspectedElement.state = Object(utils[
                  "a"
                  /* cleanForBridge */
                ])(inspectedElement.state, createIsPathAllowed("state"));
                return {
                  id,
                  responseID: requestID,
                  type: "full-data",
                  value: inspectedElement
                };
              }
              __name(inspectElement, "inspectElement");
              function inspectElementRaw(id) {
                var internalInstance = idToInternalInstanceMap.get(id);
                if (internalInstance == null) {
                  return null;
                }
                var _getData2 = getData(internalInstance), displayName = _getData2.displayName, key = _getData2.key;
                var type = getElementType(internalInstance);
                var context2 = null;
                var owners = null;
                var props = null;
                var state = null;
                var source = null;
                var element = internalInstance._currentElement;
                if (element !== null) {
                  props = element.props;
                  source = element._source != null ? element._source : null;
                  var owner = element._owner;
                  if (owner) {
                    owners = [];
                    while (owner != null) {
                      owners.push({
                        displayName: getData(owner).displayName || "Unknown",
                        id: getID(owner),
                        key: element.key,
                        type: getElementType(owner)
                      });
                      if (owner._currentElement) {
                        owner = owner._currentElement._owner;
                      }
                    }
                  }
                }
                var publicInstance = internalInstance._instance;
                if (publicInstance != null) {
                  context2 = publicInstance.context || null;
                  state = publicInstance.state || null;
                }
                var errors = [];
                var warnings = [];
                return {
                  id,
                  // Does the current renderer support editable hooks and function props?
                  canEditHooks: false,
                  canEditFunctionProps: false,
                  // Does the current renderer support advanced editing interface?
                  canEditHooksAndDeletePaths: false,
                  canEditHooksAndRenamePaths: false,
                  canEditFunctionPropsDeletePaths: false,
                  canEditFunctionPropsRenamePaths: false,
                  // Toggle error boundary did not exist in legacy versions
                  canToggleError: false,
                  isErrored: false,
                  targetErrorBoundaryID: null,
                  // Suspense did not exist in legacy versions
                  canToggleSuspense: false,
                  // Can view component source location.
                  canViewSource: type === types[
                    "e"
                    /* ElementTypeClass */
                  ] || type === types[
                    "h"
                    /* ElementTypeFunction */
                  ],
                  // Only legacy context exists in legacy versions.
                  hasLegacyContext: true,
                  displayName,
                  type,
                  key: key != null ? key : null,
                  // Inspectable properties.
                  context: context2,
                  hooks: null,
                  props,
                  state,
                  errors,
                  warnings,
                  // List of owners
                  owners,
                  // Location of component in source code.
                  source,
                  rootType: null,
                  rendererPackageName: null,
                  rendererVersion: null,
                  plugins: {
                    stylex: null
                  }
                };
              }
              __name(inspectElementRaw, "inspectElementRaw");
              function logElementToConsole(id) {
                var result = inspectElementRaw(id);
                if (result === null) {
                  console.warn('Could not find element with id "'.concat(id, '"'));
                  return;
                }
                var supportsGroup = typeof console.groupCollapsed === "function";
                if (supportsGroup) {
                  console.groupCollapsed(
                    "[Click to expand] %c<".concat(result.displayName || "Component", " />"),
                    // --dom-tag-name-color is the CSS variable Chrome styles HTML elements with in the console.
                    "color: var(--dom-tag-name-color); font-weight: normal;"
                  );
                }
                if (result.props !== null) {
                  console.log("Props:", result.props);
                }
                if (result.state !== null) {
                  console.log("State:", result.state);
                }
                if (result.context !== null) {
                  console.log("Context:", result.context);
                }
                var nativeNode = findNativeNodeForInternalID(id);
                if (nativeNode !== null) {
                  console.log("Node:", nativeNode);
                }
                if (window.chrome || /firefox/i.test(navigator.userAgent)) {
                  console.log("Right-click any value to save it as a global variable for further inspection.");
                }
                if (supportsGroup) {
                  console.groupEnd();
                }
              }
              __name(logElementToConsole, "logElementToConsole");
              function prepareViewAttributeSource(id, path67) {
                var inspectedElement = inspectElementRaw(id);
                if (inspectedElement !== null) {
                  window.$attribute = Object(src_utils[
                    "h"
                    /* getInObject */
                  ])(inspectedElement, path67);
                }
              }
              __name(prepareViewAttributeSource, "prepareViewAttributeSource");
              function prepareViewElementSource(id) {
                var internalInstance = idToInternalInstanceMap.get(id);
                if (internalInstance == null) {
                  console.warn('Could not find instance with id "'.concat(id, '"'));
                  return;
                }
                var element = internalInstance._currentElement;
                if (element == null) {
                  console.warn('Could not find element with id "'.concat(id, '"'));
                  return;
                }
                global2.$type = element.type;
              }
              __name(prepareViewElementSource, "prepareViewElementSource");
              function deletePath(type, id, hookID, path67) {
                var internalInstance = idToInternalInstanceMap.get(id);
                if (internalInstance != null) {
                  var publicInstance = internalInstance._instance;
                  if (publicInstance != null) {
                    switch (type) {
                      case "context":
                        Object(src_utils[
                          "a"
                          /* deletePathInObject */
                        ])(publicInstance.context, path67);
                        forceUpdate(publicInstance);
                        break;
                      case "hooks":
                        throw new Error("Hooks not supported by this renderer");
                      case "props":
                        var element = internalInstance._currentElement;
                        internalInstance._currentElement = _objectSpread11(_objectSpread11({}, element), {}, {
                          props: Object(utils[
                            "c"
                            /* copyWithDelete */
                          ])(element.props, path67)
                        });
                        forceUpdate(publicInstance);
                        break;
                      case "state":
                        Object(src_utils[
                          "a"
                          /* deletePathInObject */
                        ])(publicInstance.state, path67);
                        forceUpdate(publicInstance);
                        break;
                    }
                  }
                }
              }
              __name(deletePath, "deletePath");
              function renamePath(type, id, hookID, oldPath, newPath) {
                var internalInstance = idToInternalInstanceMap.get(id);
                if (internalInstance != null) {
                  var publicInstance = internalInstance._instance;
                  if (publicInstance != null) {
                    switch (type) {
                      case "context":
                        Object(src_utils[
                          "k"
                          /* renamePathInObject */
                        ])(publicInstance.context, oldPath, newPath);
                        forceUpdate(publicInstance);
                        break;
                      case "hooks":
                        throw new Error("Hooks not supported by this renderer");
                      case "props":
                        var element = internalInstance._currentElement;
                        internalInstance._currentElement = _objectSpread11(_objectSpread11({}, element), {}, {
                          props: Object(utils[
                            "d"
                            /* copyWithRename */
                          ])(element.props, oldPath, newPath)
                        });
                        forceUpdate(publicInstance);
                        break;
                      case "state":
                        Object(src_utils[
                          "k"
                          /* renamePathInObject */
                        ])(publicInstance.state, oldPath, newPath);
                        forceUpdate(publicInstance);
                        break;
                    }
                  }
                }
              }
              __name(renamePath, "renamePath");
              function overrideValueAtPath(type, id, hookID, path67, value) {
                var internalInstance = idToInternalInstanceMap.get(id);
                if (internalInstance != null) {
                  var publicInstance = internalInstance._instance;
                  if (publicInstance != null) {
                    switch (type) {
                      case "context":
                        Object(src_utils[
                          "l"
                          /* setInObject */
                        ])(publicInstance.context, path67, value);
                        forceUpdate(publicInstance);
                        break;
                      case "hooks":
                        throw new Error("Hooks not supported by this renderer");
                      case "props":
                        var element = internalInstance._currentElement;
                        internalInstance._currentElement = _objectSpread11(_objectSpread11({}, element), {}, {
                          props: Object(utils[
                            "e"
                            /* copyWithSet */
                          ])(element.props, path67, value)
                        });
                        forceUpdate(publicInstance);
                        break;
                      case "state":
                        Object(src_utils[
                          "l"
                          /* setInObject */
                        ])(publicInstance.state, path67, value);
                        forceUpdate(publicInstance);
                        break;
                    }
                  }
                }
              }
              __name(overrideValueAtPath, "overrideValueAtPath");
              var getProfilingData = /* @__PURE__ */ __name(function getProfilingData2() {
                throw new Error("getProfilingData not supported by this renderer");
              }, "getProfilingData");
              var handleCommitFiberRoot = /* @__PURE__ */ __name(function handleCommitFiberRoot2() {
                throw new Error("handleCommitFiberRoot not supported by this renderer");
              }, "handleCommitFiberRoot");
              var handleCommitFiberUnmount = /* @__PURE__ */ __name(function handleCommitFiberUnmount2() {
                throw new Error("handleCommitFiberUnmount not supported by this renderer");
              }, "handleCommitFiberUnmount");
              var handlePostCommitFiberRoot = /* @__PURE__ */ __name(function handlePostCommitFiberRoot2() {
                throw new Error("handlePostCommitFiberRoot not supported by this renderer");
              }, "handlePostCommitFiberRoot");
              var overrideError = /* @__PURE__ */ __name(function overrideError2() {
                throw new Error("overrideError not supported by this renderer");
              }, "overrideError");
              var overrideSuspense = /* @__PURE__ */ __name(function overrideSuspense2() {
                throw new Error("overrideSuspense not supported by this renderer");
              }, "overrideSuspense");
              var startProfiling = /* @__PURE__ */ __name(function startProfiling2() {
              }, "startProfiling");
              var stopProfiling = /* @__PURE__ */ __name(function stopProfiling2() {
              }, "stopProfiling");
              function getBestMatchForTrackedPath() {
                return null;
              }
              __name(getBestMatchForTrackedPath, "getBestMatchForTrackedPath");
              function getPathForElement(id) {
                return null;
              }
              __name(getPathForElement, "getPathForElement");
              function updateComponentFilters(componentFilters) {
              }
              __name(updateComponentFilters, "updateComponentFilters");
              function setTraceUpdatesEnabled(enabled) {
              }
              __name(setTraceUpdatesEnabled, "setTraceUpdatesEnabled");
              function setTrackedPath(path67) {
              }
              __name(setTrackedPath, "setTrackedPath");
              function getOwnersList(id) {
                return null;
              }
              __name(getOwnersList, "getOwnersList");
              function clearErrorsAndWarnings() {
              }
              __name(clearErrorsAndWarnings, "clearErrorsAndWarnings");
              function clearErrorsForFiberID(id) {
              }
              __name(clearErrorsForFiberID, "clearErrorsForFiberID");
              function clearWarningsForFiberID(id) {
              }
              __name(clearWarningsForFiberID, "clearWarningsForFiberID");
              function patchConsoleForStrictMode() {
              }
              __name(patchConsoleForStrictMode, "patchConsoleForStrictMode");
              function unpatchConsoleForStrictMode() {
              }
              __name(unpatchConsoleForStrictMode, "unpatchConsoleForStrictMode");
              return {
                clearErrorsAndWarnings,
                clearErrorsForFiberID,
                clearWarningsForFiberID,
                cleanup,
                copyElementPath,
                deletePath,
                flushInitialOperations,
                getBestMatchForTrackedPath,
                getDisplayNameForFiberID,
                getFiberIDForNative: getInternalIDForNative,
                getInstanceAndStyle,
                findNativeNodesForFiberID: /* @__PURE__ */ __name(function findNativeNodesForFiberID(id) {
                  var nativeNode = findNativeNodeForInternalID(id);
                  return nativeNode == null ? null : [nativeNode];
                }, "findNativeNodesForFiberID"),
                getOwnersList,
                getPathForElement,
                getProfilingData,
                handleCommitFiberRoot,
                handleCommitFiberUnmount,
                handlePostCommitFiberRoot,
                inspectElement,
                logElementToConsole,
                overrideError,
                overrideSuspense,
                overrideValueAtPath,
                renamePath,
                patchConsoleForStrictMode,
                prepareViewAttributeSource,
                prepareViewElementSource,
                renderer,
                setTraceUpdatesEnabled,
                setTrackedPath,
                startProfiling,
                stopProfiling,
                storeAsGlobal,
                unpatchConsoleForStrictMode,
                updateComponentFilters
              };
            }
            __name(renderer_attach, "renderer_attach");
            function initBackend(hook, agent, global2) {
              if (hook == null) {
                return function() {
                };
              }
              var subs = [
                hook.sub("renderer-attached", function(_ref) {
                  var id = _ref.id, renderer = _ref.renderer, rendererInterface = _ref.rendererInterface;
                  agent.setRendererInterface(id, rendererInterface);
                  rendererInterface.flushInitialOperations();
                }),
                hook.sub("unsupported-renderer-version", function(id) {
                  agent.onUnsupportedRenderer(id);
                }),
                hook.sub("fastRefreshScheduled", agent.onFastRefreshScheduled),
                hook.sub("operations", agent.onHookOperations),
                hook.sub("traceUpdates", agent.onTraceUpdates)
                // TODO Add additional subscriptions required for profiling mode
              ];
              var attachRenderer = /* @__PURE__ */ __name(function attachRenderer2(id, renderer) {
                var rendererInterface = hook.rendererInterfaces.get(id);
                if (rendererInterface == null) {
                  if (typeof renderer.findFiberByHostInstance === "function") {
                    rendererInterface = Object(backend_renderer[
                      "a"
                      /* attach */
                    ])(hook, id, renderer, global2);
                  } else if (renderer.ComponentTree) {
                    rendererInterface = renderer_attach(hook, id, renderer, global2);
                  } else {
                  }
                  if (rendererInterface != null) {
                    hook.rendererInterfaces.set(id, rendererInterface);
                  }
                }
                if (rendererInterface != null) {
                  hook.emit("renderer-attached", {
                    id,
                    renderer,
                    rendererInterface
                  });
                } else {
                  hook.emit("unsupported-renderer-version", id);
                }
              }, "attachRenderer");
              hook.renderers.forEach(function(renderer, id) {
                attachRenderer(id, renderer);
              });
              subs.push(hook.sub("renderer", function(_ref2) {
                var id = _ref2.id, renderer = _ref2.renderer;
                attachRenderer(id, renderer);
              }));
              hook.emit("react-devtools", agent);
              hook.reactDevtoolsAgent = agent;
              var onAgentShutdown = /* @__PURE__ */ __name(function onAgentShutdown2() {
                subs.forEach(function(fn2) {
                  return fn2();
                });
                hook.rendererInterfaces.forEach(function(rendererInterface) {
                  rendererInterface.cleanup();
                });
                hook.reactDevtoolsAgent = null;
              }, "onAgentShutdown");
              agent.addListener("shutdown", onAgentShutdown);
              subs.push(function() {
                agent.removeListener("shutdown", onAgentShutdown);
              });
              return function() {
                subs.forEach(function(fn2) {
                  return fn2();
                });
              };
            }
            __name(initBackend, "initBackend");
            function resolveBoxStyle(prefix, style) {
              var hasParts = false;
              var result = {
                bottom: 0,
                left: 0,
                right: 0,
                top: 0
              };
              var styleForAll = style[prefix];
              if (styleForAll != null) {
                for (var _i = 0, _Object$keys = Object.keys(result); _i < _Object$keys.length; _i++) {
                  var key = _Object$keys[_i];
                  result[key] = styleForAll;
                }
                hasParts = true;
              }
              var styleForHorizontal = style[prefix + "Horizontal"];
              if (styleForHorizontal != null) {
                result.left = styleForHorizontal;
                result.right = styleForHorizontal;
                hasParts = true;
              } else {
                var styleForLeft = style[prefix + "Left"];
                if (styleForLeft != null) {
                  result.left = styleForLeft;
                  hasParts = true;
                }
                var styleForRight = style[prefix + "Right"];
                if (styleForRight != null) {
                  result.right = styleForRight;
                  hasParts = true;
                }
                var styleForEnd = style[prefix + "End"];
                if (styleForEnd != null) {
                  result.right = styleForEnd;
                  hasParts = true;
                }
                var styleForStart = style[prefix + "Start"];
                if (styleForStart != null) {
                  result.left = styleForStart;
                  hasParts = true;
                }
              }
              var styleForVertical = style[prefix + "Vertical"];
              if (styleForVertical != null) {
                result.bottom = styleForVertical;
                result.top = styleForVertical;
                hasParts = true;
              } else {
                var styleForBottom = style[prefix + "Bottom"];
                if (styleForBottom != null) {
                  result.bottom = styleForBottom;
                  hasParts = true;
                }
                var styleForTop = style[prefix + "Top"];
                if (styleForTop != null) {
                  result.top = styleForTop;
                  hasParts = true;
                }
              }
              return hasParts ? result : null;
            }
            __name(resolveBoxStyle, "resolveBoxStyle");
            var isArray = __webpack_require__(6);
            function setupNativeStyleEditor_typeof(obj) {
              "@babel/helpers - typeof";
              if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
                setupNativeStyleEditor_typeof = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return typeof obj2;
                }, "_typeof");
              } else {
                setupNativeStyleEditor_typeof = /* @__PURE__ */ __name(function _typeof8(obj2) {
                  return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
                }, "_typeof");
              }
              return setupNativeStyleEditor_typeof(obj);
            }
            __name(setupNativeStyleEditor_typeof, "setupNativeStyleEditor_typeof");
            function setupNativeStyleEditor_defineProperty(obj, key, value) {
              if (key in obj) {
                Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
              } else {
                obj[key] = value;
              }
              return obj;
            }
            __name(setupNativeStyleEditor_defineProperty, "setupNativeStyleEditor_defineProperty");
            function setupNativeStyleEditor(bridge, agent, resolveNativeStyle, validAttributes) {
              bridge.addListener("NativeStyleEditor_measure", function(_ref) {
                var id = _ref.id, rendererID = _ref.rendererID;
                measureStyle(agent, bridge, resolveNativeStyle, id, rendererID);
              });
              bridge.addListener("NativeStyleEditor_renameAttribute", function(_ref2) {
                var id = _ref2.id, rendererID = _ref2.rendererID, oldName = _ref2.oldName, newName = _ref2.newName, value = _ref2.value;
                renameStyle(agent, id, rendererID, oldName, newName, value);
                setTimeout(function() {
                  return measureStyle(agent, bridge, resolveNativeStyle, id, rendererID);
                });
              });
              bridge.addListener("NativeStyleEditor_setValue", function(_ref3) {
                var id = _ref3.id, rendererID = _ref3.rendererID, name = _ref3.name, value = _ref3.value;
                setStyle(agent, id, rendererID, name, value);
                setTimeout(function() {
                  return measureStyle(agent, bridge, resolveNativeStyle, id, rendererID);
                });
              });
              bridge.send("isNativeStyleEditorSupported", {
                isSupported: true,
                validAttributes
              });
            }
            __name(setupNativeStyleEditor, "setupNativeStyleEditor");
            var EMPTY_BOX_STYLE = {
              top: 0,
              left: 0,
              right: 0,
              bottom: 0
            };
            var componentIDToStyleOverrides = /* @__PURE__ */ new Map();
            function measureStyle(agent, bridge, resolveNativeStyle, id, rendererID) {
              var data = agent.getInstanceAndStyle({
                id,
                rendererID
              });
              if (!data || !data.style) {
                bridge.send("NativeStyleEditor_styleAndLayout", {
                  id,
                  layout: null,
                  style: null
                });
                return;
              }
              var instance = data.instance, style = data.style;
              var resolvedStyle = resolveNativeStyle(style);
              var styleOverrides = componentIDToStyleOverrides.get(id);
              if (styleOverrides != null) {
                resolvedStyle = Object.assign({}, resolvedStyle, styleOverrides);
              }
              if (!instance || typeof instance.measure !== "function") {
                bridge.send("NativeStyleEditor_styleAndLayout", {
                  id,
                  layout: null,
                  style: resolvedStyle || null
                });
                return;
              }
              instance.measure(function(x2, y2, width, height, left2, top2) {
                if (typeof x2 !== "number") {
                  bridge.send("NativeStyleEditor_styleAndLayout", {
                    id,
                    layout: null,
                    style: resolvedStyle || null
                  });
                  return;
                }
                var margin = resolvedStyle != null && resolveBoxStyle("margin", resolvedStyle) || EMPTY_BOX_STYLE;
                var padding = resolvedStyle != null && resolveBoxStyle("padding", resolvedStyle) || EMPTY_BOX_STYLE;
                bridge.send("NativeStyleEditor_styleAndLayout", {
                  id,
                  layout: {
                    x: x2,
                    y: y2,
                    width,
                    height,
                    left: left2,
                    top: top2,
                    margin,
                    padding
                  },
                  style: resolvedStyle || null
                });
              });
            }
            __name(measureStyle, "measureStyle");
            function shallowClone(object) {
              var cloned = {};
              for (var n2 in object) {
                cloned[n2] = object[n2];
              }
              return cloned;
            }
            __name(shallowClone, "shallowClone");
            function renameStyle(agent, id, rendererID, oldName, newName, value) {
              var _ref4;
              var data = agent.getInstanceAndStyle({
                id,
                rendererID
              });
              if (!data || !data.style) {
                return;
              }
              var instance = data.instance, style = data.style;
              var newStyle = newName ? (_ref4 = {}, setupNativeStyleEditor_defineProperty(_ref4, oldName, void 0), setupNativeStyleEditor_defineProperty(_ref4, newName, value), _ref4) : setupNativeStyleEditor_defineProperty({}, oldName, void 0);
              var customStyle;
              if (instance !== null && typeof instance.setNativeProps === "function") {
                var styleOverrides = componentIDToStyleOverrides.get(id);
                if (!styleOverrides) {
                  componentIDToStyleOverrides.set(id, newStyle);
                } else {
                  Object.assign(styleOverrides, newStyle);
                }
                instance.setNativeProps({
                  style: newStyle
                });
              } else if (Object(isArray[
                "a"
                /* default */
              ])(style)) {
                var lastIndex = style.length - 1;
                if (setupNativeStyleEditor_typeof(style[lastIndex]) === "object" && !Object(isArray[
                  "a"
                  /* default */
                ])(style[lastIndex])) {
                  customStyle = shallowClone(style[lastIndex]);
                  delete customStyle[oldName];
                  if (newName) {
                    customStyle[newName] = value;
                  } else {
                    customStyle[oldName] = void 0;
                  }
                  agent.overrideValueAtPath({
                    type: "props",
                    id,
                    rendererID,
                    path: ["style", lastIndex],
                    value: customStyle
                  });
                } else {
                  agent.overrideValueAtPath({
                    type: "props",
                    id,
                    rendererID,
                    path: ["style"],
                    value: style.concat([newStyle])
                  });
                }
              } else if (setupNativeStyleEditor_typeof(style) === "object") {
                customStyle = shallowClone(style);
                delete customStyle[oldName];
                if (newName) {
                  customStyle[newName] = value;
                } else {
                  customStyle[oldName] = void 0;
                }
                agent.overrideValueAtPath({
                  type: "props",
                  id,
                  rendererID,
                  path: ["style"],
                  value: customStyle
                });
              } else {
                agent.overrideValueAtPath({
                  type: "props",
                  id,
                  rendererID,
                  path: ["style"],
                  value: [style, newStyle]
                });
              }
              agent.emit("hideNativeHighlight");
            }
            __name(renameStyle, "renameStyle");
            function setStyle(agent, id, rendererID, name, value) {
              var data = agent.getInstanceAndStyle({
                id,
                rendererID
              });
              if (!data || !data.style) {
                return;
              }
              var instance = data.instance, style = data.style;
              var newStyle = setupNativeStyleEditor_defineProperty({}, name, value);
              if (instance !== null && typeof instance.setNativeProps === "function") {
                var styleOverrides = componentIDToStyleOverrides.get(id);
                if (!styleOverrides) {
                  componentIDToStyleOverrides.set(id, newStyle);
                } else {
                  Object.assign(styleOverrides, newStyle);
                }
                instance.setNativeProps({
                  style: newStyle
                });
              } else if (Object(isArray[
                "a"
                /* default */
              ])(style)) {
                var lastLength = style.length - 1;
                if (setupNativeStyleEditor_typeof(style[lastLength]) === "object" && !Object(isArray[
                  "a"
                  /* default */
                ])(style[lastLength])) {
                  agent.overrideValueAtPath({
                    type: "props",
                    id,
                    rendererID,
                    path: ["style", lastLength, name],
                    value
                  });
                } else {
                  agent.overrideValueAtPath({
                    type: "props",
                    id,
                    rendererID,
                    path: ["style"],
                    value: style.concat([newStyle])
                  });
                }
              } else {
                agent.overrideValueAtPath({
                  type: "props",
                  id,
                  rendererID,
                  path: ["style"],
                  value: [style, newStyle]
                });
              }
              agent.emit("hideNativeHighlight");
            }
            __name(setStyle, "setStyle");
            installHook(window);
            var backend_hook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
            var savedComponentFilters = Object(src_utils[
              "e"
              /* getDefaultComponentFilters */
            ])();
            function backend_debug(methodName) {
              if (constants3[
                "q"
                /* __DEBUG__ */
              ]) {
                var _console;
                for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                  args[_key - 1] = arguments[_key];
                }
                (_console = console).log.apply(_console, ["%c[core/backend] %c".concat(methodName), "color: teal; font-weight: bold;", "font-weight: bold;"].concat(args));
              }
            }
            __name(backend_debug, "backend_debug");
            function connectToDevTools(options29) {
              if (backend_hook == null) {
                return;
              }
              var _ref = options29 || {}, _ref$host = _ref.host, host = _ref$host === void 0 ? "localhost" : _ref$host, nativeStyleEditorValidAttributes = _ref.nativeStyleEditorValidAttributes, _ref$useHttps = _ref.useHttps, useHttps = _ref$useHttps === void 0 ? false : _ref$useHttps, _ref$port = _ref.port, port2 = _ref$port === void 0 ? 8097 : _ref$port, websocket = _ref.websocket, _ref$resolveRNStyle = _ref.resolveRNStyle, resolveRNStyle = _ref$resolveRNStyle === void 0 ? null : _ref$resolveRNStyle, _ref$retryConnectionD = _ref.retryConnectionDelay, retryConnectionDelay = _ref$retryConnectionD === void 0 ? 2e3 : _ref$retryConnectionD, _ref$isAppActive = _ref.isAppActive, isAppActive = _ref$isAppActive === void 0 ? function() {
                return true;
              } : _ref$isAppActive;
              var protocol = useHttps ? "wss" : "ws";
              var retryTimeoutID = null;
              function scheduleRetry() {
                if (retryTimeoutID === null) {
                  retryTimeoutID = setTimeout(function() {
                    return connectToDevTools(options29);
                  }, retryConnectionDelay);
                }
              }
              __name(scheduleRetry, "scheduleRetry");
              if (!isAppActive()) {
                scheduleRetry();
                return;
              }
              var bridge = null;
              var messageListeners = [];
              var uri = protocol + "://" + host + ":" + port2;
              var ws = websocket ? websocket : new window.WebSocket(uri);
              ws.onclose = handleClose;
              ws.onerror = handleFailed;
              ws.onmessage = handleMessage;
              ws.onopen = function() {
                bridge = new src_bridge({
                  listen: /* @__PURE__ */ __name(function listen(fn2) {
                    messageListeners.push(fn2);
                    return function() {
                      var index = messageListeners.indexOf(fn2);
                      if (index >= 0) {
                        messageListeners.splice(index, 1);
                      }
                    };
                  }, "listen"),
                  send: /* @__PURE__ */ __name(function send(event, payload, transferable) {
                    if (ws.readyState === ws.OPEN) {
                      if (constants3[
                        "q"
                        /* __DEBUG__ */
                      ]) {
                        backend_debug("wall.send()", event, payload);
                      }
                      ws.send(JSON.stringify({
                        event,
                        payload
                      }));
                    } else {
                      if (constants3[
                        "q"
                        /* __DEBUG__ */
                      ]) {
                        backend_debug("wall.send()", "Shutting down bridge because of closed WebSocket connection");
                      }
                      if (bridge !== null) {
                        bridge.shutdown();
                      }
                      scheduleRetry();
                    }
                  }, "send")
                });
                bridge.addListener("inspectElement", function(_ref2) {
                  var id = _ref2.id, rendererID = _ref2.rendererID;
                  var renderer = agent.rendererInterfaces[rendererID];
                  if (renderer != null) {
                    var nodes = renderer.findNativeNodesForFiberID(id);
                    if (nodes != null && nodes[0] != null) {
                      agent.emit("showNativeHighlight", nodes[0]);
                    }
                  }
                });
                bridge.addListener("updateComponentFilters", function(componentFilters) {
                  savedComponentFilters = componentFilters;
                });
                if (window.__REACT_DEVTOOLS_COMPONENT_FILTERS__ == null) {
                  bridge.send("overrideComponentFilters", savedComponentFilters);
                }
                var agent = new agent_Agent(bridge);
                agent.addListener("shutdown", function() {
                  backend_hook.emit("shutdown");
                });
                initBackend(backend_hook, agent, window);
                if (resolveRNStyle != null || backend_hook.resolveRNStyle != null) {
                  setupNativeStyleEditor(bridge, agent, resolveRNStyle || backend_hook.resolveRNStyle, nativeStyleEditorValidAttributes || backend_hook.nativeStyleEditorValidAttributes || null);
                } else {
                  var lazyResolveRNStyle;
                  var lazyNativeStyleEditorValidAttributes;
                  var initAfterTick = /* @__PURE__ */ __name(function initAfterTick2() {
                    if (bridge !== null) {
                      setupNativeStyleEditor(bridge, agent, lazyResolveRNStyle, lazyNativeStyleEditorValidAttributes);
                    }
                  }, "initAfterTick");
                  if (!backend_hook.hasOwnProperty("resolveRNStyle")) {
                    Object.defineProperty(backend_hook, "resolveRNStyle", {
                      enumerable: false,
                      get: /* @__PURE__ */ __name(function get() {
                        return lazyResolveRNStyle;
                      }, "get"),
                      set: /* @__PURE__ */ __name(function set(value) {
                        lazyResolveRNStyle = value;
                        initAfterTick();
                      }, "set")
                    });
                  }
                  if (!backend_hook.hasOwnProperty("nativeStyleEditorValidAttributes")) {
                    Object.defineProperty(backend_hook, "nativeStyleEditorValidAttributes", {
                      enumerable: false,
                      get: /* @__PURE__ */ __name(function get() {
                        return lazyNativeStyleEditorValidAttributes;
                      }, "get"),
                      set: /* @__PURE__ */ __name(function set(value) {
                        lazyNativeStyleEditorValidAttributes = value;
                        initAfterTick();
                      }, "set")
                    });
                  }
                }
              };
              function handleClose() {
                if (constants3[
                  "q"
                  /* __DEBUG__ */
                ]) {
                  backend_debug("WebSocket.onclose");
                }
                if (bridge !== null) {
                  bridge.emit("shutdown");
                }
                scheduleRetry();
              }
              __name(handleClose, "handleClose");
              function handleFailed() {
                if (constants3[
                  "q"
                  /* __DEBUG__ */
                ]) {
                  backend_debug("WebSocket.onerror");
                }
                scheduleRetry();
              }
              __name(handleFailed, "handleFailed");
              function handleMessage(event) {
                var data;
                try {
                  if (typeof event.data === "string") {
                    data = JSON.parse(event.data);
                    if (constants3[
                      "q"
                      /* __DEBUG__ */
                    ]) {
                      backend_debug("WebSocket.onmessage", data);
                    }
                  } else {
                    throw Error();
                  }
                } catch (e3) {
                  console.error("[React DevTools] Failed to parse JSON: " + event.data);
                  return;
                }
                messageListeners.forEach(function(fn2) {
                  try {
                    fn2(data);
                  } catch (error2) {
                    console.log("[React DevTools] Error calling listener", data);
                    console.log("error:", error2);
                    throw error2;
                  }
                });
              }
              __name(handleMessage, "handleMessage");
            }
            __name(connectToDevTools, "connectToDevTools");
          }
          /******/
        ])
      );
    });
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/devtools.js
var require_devtools = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/devtools.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    require_devtools_window_polyfill();
    var react_devtools_core_1 = require_backend();
    react_devtools_core_1.connectToDevTools();
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/reconciler.js
var require_reconciler = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/reconciler.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var scheduler_1 = require_scheduler();
    var react_reconciler_1 = __importDefault(require_react_reconciler());
    var yoga_layout_prebuilt_1 = __importDefault(require_wasm_sync2());
    var dom_1 = require_dom();
    if (process.env.DEV === "true") {
      require_devtools();
    }
    var cleanupYogaNode = /* @__PURE__ */ __name((node2) => {
      node2 === null || node2 === void 0 ? void 0 : node2.unsetMeasureFunc();
      node2 === null || node2 === void 0 ? void 0 : node2.freeRecursive();
    }, "cleanupYogaNode");
    exports2.default = react_reconciler_1.default({
      // @ts-ignore
      schedulePassiveEffects: scheduler_1.unstable_scheduleCallback,
      cancelPassiveEffects: scheduler_1.unstable_cancelCallback,
      now: Date.now,
      getRootHostContext: () => ({
        isInsideText: false
      }),
      prepareForCommit: () => null,
      preparePortalMount: () => null,
      clearContainer: () => false,
      shouldDeprioritizeSubtree: () => false,
      resetAfterCommit: (rootNode) => {
        if (rootNode.isStaticDirty) {
          rootNode.isStaticDirty = false;
          if (typeof rootNode.onImmediateRender === "function") {
            rootNode.onImmediateRender();
          }
          return;
        }
        if (typeof rootNode.onRender === "function") {
          rootNode.onRender();
        }
      },
      getChildHostContext: (parentHostContext, type) => {
        const previousIsInsideText = parentHostContext.isInsideText;
        const isInsideText = type === "ink-text" || type === "ink-virtual-text";
        if (previousIsInsideText === isInsideText) {
          return parentHostContext;
        }
        return { isInsideText };
      },
      shouldSetTextContent: () => false,
      createInstance: (originalType, newProps, _root, hostContext) => {
        if (hostContext.isInsideText && originalType === "ink-box") {
          throw new Error(`<Box> can\u2019t be nested inside <Text> component`);
        }
        const type = originalType === "ink-text" && hostContext.isInsideText ? "ink-virtual-text" : originalType;
        const node2 = dom_1.createNode(type);
        for (const [key, value] of Object.entries(newProps)) {
          if (key === "children") {
            continue;
          } else if (key === "style") {
            dom_1.setStyle(node2, value);
          } else if (key === "internal_transform") {
            node2.internal_transform = value;
          } else if (key === "internal_static") {
            node2.internal_static = true;
          } else {
            dom_1.setAttribute(node2, key, value);
          }
        }
        return node2;
      },
      createTextInstance: (text, _root, hostContext) => {
        if (!hostContext.isInsideText) {
          throw new Error(`Text string "${text}" must be rendered inside <Text> component`);
        }
        return dom_1.createTextNode(text);
      },
      resetTextContent: () => {
      },
      hideTextInstance: (node2) => {
        dom_1.setTextNodeValue(node2, "");
      },
      unhideTextInstance: (node2, text) => {
        dom_1.setTextNodeValue(node2, text);
      },
      getPublicInstance: (instance) => instance,
      hideInstance: (node2) => {
        var _a2;
        (_a2 = node2.yogaNode) === null || _a2 === void 0 ? void 0 : _a2.setDisplay(yoga_layout_prebuilt_1.default.DISPLAY_NONE);
      },
      unhideInstance: (node2) => {
        var _a2;
        (_a2 = node2.yogaNode) === null || _a2 === void 0 ? void 0 : _a2.setDisplay(yoga_layout_prebuilt_1.default.DISPLAY_FLEX);
      },
      appendInitialChild: dom_1.appendChildNode,
      appendChild: dom_1.appendChildNode,
      insertBefore: dom_1.insertBeforeNode,
      finalizeInitialChildren: (node2, _type2, _props, rootNode) => {
        if (node2.internal_static) {
          rootNode.isStaticDirty = true;
          rootNode.staticNode = node2;
        }
        return false;
      },
      supportsMutation: true,
      appendChildToContainer: dom_1.appendChildNode,
      insertInContainerBefore: dom_1.insertBeforeNode,
      removeChildFromContainer: (node2, removeNode) => {
        dom_1.removeChildNode(node2, removeNode);
        cleanupYogaNode(removeNode.yogaNode);
      },
      prepareUpdate: (node2, _type2, oldProps, newProps, rootNode) => {
        if (node2.internal_static) {
          rootNode.isStaticDirty = true;
        }
        const updatePayload = {};
        const keys = Object.keys(newProps);
        for (const key of keys) {
          if (newProps[key] !== oldProps[key]) {
            const isStyle2 = key === "style" && typeof newProps.style === "object" && typeof oldProps.style === "object";
            if (isStyle2) {
              const newStyle = newProps.style;
              const oldStyle = oldProps.style;
              const styleKeys = Object.keys(newStyle);
              for (const styleKey of styleKeys) {
                if (styleKey === "borderStyle" || styleKey === "borderColor") {
                  if (typeof updatePayload.style !== "object") {
                    const style = {};
                    updatePayload.style = style;
                  }
                  updatePayload.style.borderStyle = newStyle.borderStyle;
                  updatePayload.style.borderColor = newStyle.borderColor;
                }
                if (newStyle[styleKey] !== oldStyle[styleKey]) {
                  if (typeof updatePayload.style !== "object") {
                    const style = {};
                    updatePayload.style = style;
                  }
                  updatePayload.style[styleKey] = newStyle[styleKey];
                }
              }
              continue;
            }
            updatePayload[key] = newProps[key];
          }
        }
        return updatePayload;
      },
      commitUpdate: (node2, updatePayload) => {
        for (const [key, value] of Object.entries(updatePayload)) {
          if (key === "children") {
            continue;
          } else if (key === "style") {
            dom_1.setStyle(node2, value);
          } else if (key === "internal_transform") {
            node2.internal_transform = value;
          } else if (key === "internal_static") {
            node2.internal_static = true;
          } else {
            dom_1.setAttribute(node2, key, value);
          }
        }
      },
      commitTextUpdate: (node2, _oldText, newText) => {
        dom_1.setTextNodeValue(node2, newText);
      },
      removeChild: (node2, removeNode) => {
        dom_1.removeChildNode(node2, removeNode);
        cleanupYogaNode(removeNode.yogaNode);
      }
    });
  }
});

// ../../node_modules/.pnpm/indent-string@4.0.0/node_modules/indent-string/index.js
var require_indent_string = __commonJS({
  "../../node_modules/.pnpm/indent-string@4.0.0/node_modules/indent-string/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = (string, count = 1, options29) => {
      options29 = {
        indent: " ",
        includeEmptyLines: false,
        ...options29
      };
      if (typeof string !== "string") {
        throw new TypeError(
          `Expected \`input\` to be a \`string\`, got \`${typeof string}\``
        );
      }
      if (typeof count !== "number") {
        throw new TypeError(
          `Expected \`count\` to be a \`number\`, got \`${typeof count}\``
        );
      }
      if (typeof options29.indent !== "string") {
        throw new TypeError(
          `Expected \`options.indent\` to be a \`string\`, got \`${typeof options29.indent}\``
        );
      }
      if (count === 0) {
        return string;
      }
      const regex2 = options29.includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
      return string.replace(regex2, options29.indent.repeat(count));
    };
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/get-max-width.js
var require_get_max_width = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/get-max-width.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var yoga_layout_prebuilt_1 = __importDefault(require_wasm_sync2());
    exports2.default = (yogaNode) => {
      return yogaNode.getComputedWidth() - yogaNode.getComputedPadding(yoga_layout_prebuilt_1.default.EDGE_LEFT) - yogaNode.getComputedPadding(yoga_layout_prebuilt_1.default.EDGE_RIGHT) - yogaNode.getComputedBorder(yoga_layout_prebuilt_1.default.EDGE_LEFT) - yogaNode.getComputedBorder(yoga_layout_prebuilt_1.default.EDGE_RIGHT);
    };
  }
});

// ../../node_modules/.pnpm/cli-boxes@2.2.1/node_modules/cli-boxes/boxes.json
var require_boxes = __commonJS({
  "../../node_modules/.pnpm/cli-boxes@2.2.1/node_modules/cli-boxes/boxes.json"(exports2, module3) {
    module3.exports = {
      single: {
        topLeft: "\u250C",
        topRight: "\u2510",
        bottomRight: "\u2518",
        bottomLeft: "\u2514",
        vertical: "\u2502",
        horizontal: "\u2500"
      },
      double: {
        topLeft: "\u2554",
        topRight: "\u2557",
        bottomRight: "\u255D",
        bottomLeft: "\u255A",
        vertical: "\u2551",
        horizontal: "\u2550"
      },
      round: {
        topLeft: "\u256D",
        topRight: "\u256E",
        bottomRight: "\u256F",
        bottomLeft: "\u2570",
        vertical: "\u2502",
        horizontal: "\u2500"
      },
      bold: {
        topLeft: "\u250F",
        topRight: "\u2513",
        bottomRight: "\u251B",
        bottomLeft: "\u2517",
        vertical: "\u2503",
        horizontal: "\u2501"
      },
      singleDouble: {
        topLeft: "\u2553",
        topRight: "\u2556",
        bottomRight: "\u255C",
        bottomLeft: "\u2559",
        vertical: "\u2551",
        horizontal: "\u2500"
      },
      doubleSingle: {
        topLeft: "\u2552",
        topRight: "\u2555",
        bottomRight: "\u255B",
        bottomLeft: "\u2558",
        vertical: "\u2502",
        horizontal: "\u2550"
      },
      classic: {
        topLeft: "+",
        topRight: "+",
        bottomRight: "+",
        bottomLeft: "+",
        vertical: "|",
        horizontal: "-"
      }
    };
  }
});

// ../../node_modules/.pnpm/cli-boxes@2.2.1/node_modules/cli-boxes/index.js
var require_cli_boxes = __commonJS({
  "../../node_modules/.pnpm/cli-boxes@2.2.1/node_modules/cli-boxes/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var cliBoxes = require_boxes();
    module3.exports = cliBoxes;
    module3.exports.default = cliBoxes;
  }
});

// ../../node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js
var require_has_flag = __commonJS({
  "../../node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = (flag, argv = process.argv) => {
      const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
      const position = argv.indexOf(prefix + flag);
      const terminatorPosition = argv.indexOf("--");
      return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
    };
  }
});

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

// ../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/util.js
var require_util8 = __commonJS({
  "../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/util.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var stringReplaceAll = /* @__PURE__ */ __name((string, substring, replacer2) => {
      let index = string.indexOf(substring);
      if (index === -1) {
        return string;
      }
      const substringLength = substring.length;
      let endIndex = 0;
      let returnValue = "";
      do {
        returnValue += string.substr(endIndex, index - endIndex) + substring + replacer2;
        endIndex = index + substringLength;
        index = string.indexOf(substring, endIndex);
      } while (index !== -1);
      returnValue += string.substr(endIndex);
      return returnValue;
    }, "stringReplaceAll");
    var stringEncaseCRLFWithFirstIndex = /* @__PURE__ */ __name((string, prefix, postfix, index) => {
      let endIndex = 0;
      let returnValue = "";
      do {
        const gotCR = string[index - 1] === "\r";
        returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
        endIndex = index + 1;
        index = string.indexOf("\n", endIndex);
      } while (index !== -1);
      returnValue += string.substr(endIndex);
      return returnValue;
    }, "stringEncaseCRLFWithFirstIndex");
    module3.exports = {
      stringReplaceAll,
      stringEncaseCRLFWithFirstIndex
    };
  }
});

// ../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/templates.js
var require_templates = __commonJS({
  "../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/templates.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var TEMPLATE_REGEX2 = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
    var STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
    var STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
    var ESCAPE_REGEX = /\\(u(?:[a-f\d]{4}|{[a-f\d]{1,6}})|x[a-f\d]{2}|.)|([^\\])/gi;
    var ESCAPES3 = /* @__PURE__ */ new Map([
      ["n", "\n"],
      ["r", "\r"],
      ["t", "	"],
      ["b", "\b"],
      ["f", "\f"],
      ["v", "\v"],
      ["0", "\0"],
      ["\\", "\\"],
      ["e", "\x1B"],
      ["a", "\x07"]
    ]);
    function unescape2(c2) {
      const u = c2[0] === "u";
      const bracket = c2[1] === "{";
      if (u && !bracket && c2.length === 5 || c2[0] === "x" && c2.length === 3) {
        return String.fromCharCode(parseInt(c2.slice(1), 16));
      }
      if (u && bracket) {
        return String.fromCodePoint(parseInt(c2.slice(2, -1), 16));
      }
      return ESCAPES3.get(c2) || c2;
    }
    __name(unescape2, "unescape");
    function parseArguments(name, arguments_) {
      const results = [];
      const chunks = arguments_.trim().split(/\s*,\s*/g);
      let matches;
      for (const chunk of chunks) {
        const number = Number(chunk);
        if (!Number.isNaN(number)) {
          results.push(number);
        } else if (matches = chunk.match(STRING_REGEX)) {
          results.push(matches[2].replace(ESCAPE_REGEX, (m2, escape2, character) => escape2 ? unescape2(escape2) : character));
        } else {
          throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
        }
      }
      return results;
    }
    __name(parseArguments, "parseArguments");
    function parseStyle(style) {
      STYLE_REGEX.lastIndex = 0;
      const results = [];
      let matches;
      while ((matches = STYLE_REGEX.exec(style)) !== null) {
        const name = matches[1];
        if (matches[2]) {
          const args = parseArguments(name, matches[2]);
          results.push([name].concat(args));
        } else {
          results.push([name]);
        }
      }
      return results;
    }
    __name(parseStyle, "parseStyle");
    function buildStyle(chalk21, styles2) {
      const enabled = {};
      for (const layer of styles2) {
        for (const style of layer.styles) {
          enabled[style[0]] = layer.inverse ? null : style.slice(1);
        }
      }
      let current = chalk21;
      for (const [styleName, styles3] of Object.entries(enabled)) {
        if (!Array.isArray(styles3)) {
          continue;
        }
        if (!(styleName in current)) {
          throw new Error(`Unknown Chalk style: ${styleName}`);
        }
        current = styles3.length > 0 ? current[styleName](...styles3) : current[styleName];
      }
      return current;
    }
    __name(buildStyle, "buildStyle");
    module3.exports = (chalk21, temporary) => {
      const styles2 = [];
      const chunks = [];
      let chunk = [];
      temporary.replace(TEMPLATE_REGEX2, (m2, escapeCharacter, inverse, style, close2, character) => {
        if (escapeCharacter) {
          chunk.push(unescape2(escapeCharacter));
        } else if (style) {
          const string = chunk.join("");
          chunk = [];
          chunks.push(styles2.length === 0 ? string : buildStyle(chalk21, styles2)(string));
          styles2.push({ inverse, styles: parseStyle(style) });
        } else if (close2) {
          if (styles2.length === 0) {
            throw new Error("Found extraneous } in Chalk template literal");
          }
          chunks.push(buildStyle(chalk21, styles2)(chunk.join("")));
          chunk = [];
          styles2.pop();
        } else {
          chunk.push(character);
        }
      });
      chunks.push(chunk.join(""));
      if (styles2.length > 0) {
        const errMessage = `Chalk template literal is missing ${styles2.length} closing bracket${styles2.length === 1 ? "" : "s"} (\`}\`)`;
        throw new Error(errMessage);
      }
      return chunks.join("");
    };
  }
});

// ../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/index.js
var require_source = __commonJS({
  "../../node_modules/.pnpm/chalk@4.1.2/node_modules/chalk/source/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var ansiStyles2 = require_ansi_styles();
    var { stdout: stdoutColor, stderr: stderrColor } = require_supports_color();
    var {
      stringReplaceAll,
      stringEncaseCRLFWithFirstIndex
    } = require_util8();
    var { isArray } = Array;
    var levelMapping = [
      "ansi",
      "ansi",
      "ansi256",
      "ansi16m"
    ];
    var styles2 = /* @__PURE__ */ Object.create(null);
    var applyOptions = /* @__PURE__ */ __name((object, options29 = {}) => {
      if (options29.level && !(Number.isInteger(options29.level) && options29.level >= 0 && options29.level <= 3)) {
        throw new Error("The `level` option should be an integer from 0 to 3");
      }
      const colorLevel = stdoutColor ? stdoutColor.level : 0;
      object.level = options29.level === void 0 ? colorLevel : options29.level;
    }, "applyOptions");
    var ChalkClass = class {
      constructor(options29) {
        return chalkFactory(options29);
      }
    };
    __name(ChalkClass, "ChalkClass");
    var chalkFactory = /* @__PURE__ */ __name((options29) => {
      const chalk22 = {};
      applyOptions(chalk22, options29);
      chalk22.template = (...arguments_) => chalkTag(chalk22.template, ...arguments_);
      Object.setPrototypeOf(chalk22, Chalk.prototype);
      Object.setPrototypeOf(chalk22.template, chalk22);
      chalk22.template.constructor = () => {
        throw new Error("`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.");
      };
      chalk22.template.Instance = ChalkClass;
      return chalk22.template;
    }, "chalkFactory");
    function Chalk(options29) {
      return chalkFactory(options29);
    }
    __name(Chalk, "Chalk");
    for (const [styleName, style] of Object.entries(ansiStyles2)) {
      styles2[styleName] = {
        get() {
          const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);
          Object.defineProperty(this, styleName, { value: builder });
          return builder;
        }
      };
    }
    styles2.visible = {
      get() {
        const builder = createBuilder(this, this._styler, true);
        Object.defineProperty(this, "visible", { value: builder });
        return builder;
      }
    };
    var usedModels = ["rgb", "hex", "keyword", "hsl", "hsv", "hwb", "ansi", "ansi256"];
    for (const model of usedModels) {
      styles2[model] = {
        get() {
          const { level } = this;
          return function(...arguments_) {
            const styler = createStyler(ansiStyles2.color[levelMapping[level]][model](...arguments_), ansiStyles2.color.close, this._styler);
            return createBuilder(this, styler, this._isEmpty);
          };
        }
      };
    }
    for (const model of usedModels) {
      const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
      styles2[bgModel] = {
        get() {
          const { level } = this;
          return function(...arguments_) {
            const styler = createStyler(ansiStyles2.bgColor[levelMapping[level]][model](...arguments_), ansiStyles2.bgColor.close, this._styler);
            return createBuilder(this, styler, this._isEmpty);
          };
        }
      };
    }
    var proto = Object.defineProperties(() => {
    }, {
      ...styles2,
      level: {
        enumerable: true,
        get() {
          return this._generator.level;
        },
        set(level) {
          this._generator.level = level;
        }
      }
    });
    var createStyler = /* @__PURE__ */ __name((open3, close2, parent) => {
      let openAll;
      let closeAll;
      if (parent === void 0) {
        openAll = open3;
        closeAll = close2;
      } else {
        openAll = parent.openAll + open3;
        closeAll = close2 + parent.closeAll;
      }
      return {
        open: open3,
        close: close2,
        openAll,
        closeAll,
        parent
      };
    }, "createStyler");
    var createBuilder = /* @__PURE__ */ __name((self2, _styler, _isEmpty) => {
      const builder = /* @__PURE__ */ __name((...arguments_) => {
        if (isArray(arguments_[0]) && isArray(arguments_[0].raw)) {
          return applyStyle(builder, chalkTag(builder, ...arguments_));
        }
        return applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
      }, "builder");
      Object.setPrototypeOf(builder, proto);
      builder._generator = self2;
      builder._styler = _styler;
      builder._isEmpty = _isEmpty;
      return builder;
    }, "createBuilder");
    var applyStyle = /* @__PURE__ */ __name((self2, string) => {
      if (self2.level <= 0 || !string) {
        return self2._isEmpty ? "" : string;
      }
      let styler = self2._styler;
      if (styler === void 0) {
        return string;
      }
      const { openAll, closeAll } = styler;
      if (string.indexOf("\x1B") !== -1) {
        while (styler !== void 0) {
          string = stringReplaceAll(string, styler.close, styler.open);
          styler = styler.parent;
        }
      }
      const lfIndex = string.indexOf("\n");
      if (lfIndex !== -1) {
        string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
      }
      return openAll + string + closeAll;
    }, "applyStyle");
    var template;
    var chalkTag = /* @__PURE__ */ __name((chalk22, ...strings) => {
      const [firstString] = strings;
      if (!isArray(firstString) || !isArray(firstString.raw)) {
        return strings.join(" ");
      }
      const arguments_ = strings.slice(1);
      const parts = [firstString.raw[0]];
      for (let i = 1; i < firstString.length; i++) {
        parts.push(
          String(arguments_[i - 1]).replace(/[{}\\]/g, "\\$&"),
          String(firstString.raw[i])
        );
      }
      if (template === void 0) {
        template = require_templates();
      }
      return template(chalk22, parts.join(""));
    }, "chalkTag");
    Object.defineProperties(Chalk.prototype, styles2);
    var chalk21 = Chalk();
    chalk21.supportsColor = stdoutColor;
    chalk21.stderr = Chalk({ level: stderrColor ? stderrColor.level : 0 });
    chalk21.stderr.supportsColor = stderrColor;
    module3.exports = chalk21;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/colorize.js
var require_colorize = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/colorize.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var chalk_1 = __importDefault(require_source());
    var RGB_LIKE_REGEX = /^(rgb|hsl|hsv|hwb)\(\s?(\d+),\s?(\d+),\s?(\d+)\s?\)$/;
    var ANSI_REGEX = /^(ansi|ansi256)\(\s?(\d+)\s?\)$/;
    var getMethod = /* @__PURE__ */ __name((name, type) => {
      if (type === "foreground") {
        return name;
      }
      return "bg" + name[0].toUpperCase() + name.slice(1);
    }, "getMethod");
    exports2.default = (str, color, type) => {
      if (!color) {
        return str;
      }
      if (color in chalk_1.default) {
        const method = getMethod(color, type);
        return chalk_1.default[method](str);
      }
      if (color.startsWith("#")) {
        const method = getMethod("hex", type);
        return chalk_1.default[method](color)(str);
      }
      if (color.startsWith("ansi")) {
        const matches = ANSI_REGEX.exec(color);
        if (!matches) {
          return str;
        }
        const method = getMethod(matches[1], type);
        const value = Number(matches[2]);
        return chalk_1.default[method](value)(str);
      }
      const isRgbLike = color.startsWith("rgb") || color.startsWith("hsl") || color.startsWith("hsv") || color.startsWith("hwb");
      if (isRgbLike) {
        const matches = RGB_LIKE_REGEX.exec(color);
        if (!matches) {
          return str;
        }
        const method = getMethod(matches[1], type);
        const firstValue = Number(matches[2]);
        const secondValue = Number(matches[3]);
        const thirdValue = Number(matches[4]);
        return chalk_1.default[method](firstValue, secondValue, thirdValue)(str);
      }
      return str;
    };
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/render-border.js
var require_render_border = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/render-border.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var cli_boxes_1 = __importDefault(require_cli_boxes());
    var colorize_1 = __importDefault(require_colorize());
    exports2.default = (x2, y2, node2, output) => {
      if (typeof node2.style.borderStyle === "string") {
        const width = node2.yogaNode.getComputedWidth();
        const height = node2.yogaNode.getComputedHeight();
        const color = node2.style.borderColor;
        const box = cli_boxes_1.default[node2.style.borderStyle];
        const topBorder = colorize_1.default(box.topLeft + box.horizontal.repeat(width - 2) + box.topRight, color, "foreground");
        const verticalBorder = (colorize_1.default(box.vertical, color, "foreground") + "\n").repeat(height - 2);
        const bottomBorder = colorize_1.default(box.bottomLeft + box.horizontal.repeat(width - 2) + box.bottomRight, color, "foreground");
        output.write(x2, y2, topBorder, { transformers: [] });
        output.write(x2, y2 + 1, verticalBorder, { transformers: [] });
        output.write(x2 + width - 1, y2 + 1, verticalBorder, { transformers: [] });
        output.write(x2, y2 + height - 1, bottomBorder, { transformers: [] });
      }
    };
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/render-node-to-output.js
var require_render_node_to_output = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/render-node-to-output.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var yoga_layout_prebuilt_1 = __importDefault(require_wasm_sync2());
    var widest_line_1 = __importDefault(require_widest_line());
    var indent_string_1 = __importDefault(require_indent_string());
    var wrap_text_1 = __importDefault(require_wrap_text());
    var get_max_width_1 = __importDefault(require_get_max_width());
    var squash_text_nodes_1 = __importDefault(require_squash_text_nodes());
    var render_border_1 = __importDefault(require_render_border());
    var applyPaddingToText = /* @__PURE__ */ __name((node2, text) => {
      var _a2;
      const yogaNode = (_a2 = node2.childNodes[0]) === null || _a2 === void 0 ? void 0 : _a2.yogaNode;
      if (yogaNode) {
        const offsetX = yogaNode.getComputedLeft();
        const offsetY = yogaNode.getComputedTop();
        text = "\n".repeat(offsetY) + indent_string_1.default(text, offsetX);
      }
      return text;
    }, "applyPaddingToText");
    var renderNodeToOutput = /* @__PURE__ */ __name((node2, output, options29) => {
      var _a2;
      const { offsetX = 0, offsetY = 0, transformers = [], skipStaticElements } = options29;
      if (skipStaticElements && node2.internal_static) {
        return;
      }
      const { yogaNode } = node2;
      if (yogaNode) {
        if (yogaNode.getDisplay() === yoga_layout_prebuilt_1.default.DISPLAY_NONE) {
          return;
        }
        const x2 = offsetX + yogaNode.getComputedLeft();
        const y2 = offsetY + yogaNode.getComputedTop();
        let newTransformers = transformers;
        if (typeof node2.internal_transform === "function") {
          newTransformers = [node2.internal_transform, ...transformers];
        }
        if (node2.nodeName === "ink-text") {
          let text = squash_text_nodes_1.default(node2);
          if (text.length > 0) {
            const currentWidth = widest_line_1.default(text);
            const maxWidth = get_max_width_1.default(yogaNode);
            if (currentWidth > maxWidth) {
              const textWrap = (_a2 = node2.style.textWrap) !== null && _a2 !== void 0 ? _a2 : "wrap";
              text = wrap_text_1.default(text, maxWidth, textWrap);
            }
            text = applyPaddingToText(node2, text);
            output.write(x2, y2, text, { transformers: newTransformers });
          }
          return;
        }
        if (node2.nodeName === "ink-box") {
          render_border_1.default(x2, y2, node2, output);
        }
        if (node2.nodeName === "ink-root" || node2.nodeName === "ink-box") {
          for (const childNode of node2.childNodes) {
            renderNodeToOutput(childNode, output, {
              offsetX: x2,
              offsetY: y2,
              transformers: newTransformers,
              skipStaticElements
            });
          }
        }
      }
    }, "renderNodeToOutput");
    exports2.default = renderNodeToOutput;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/output.js
var require_output = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/output.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var slice_ansi_1 = __importDefault(require_slice_ansi());
    var string_width_1 = __importDefault(require_string_width());
    var Output = class {
      constructor(options29) {
        this.writes = [];
        const { width, height } = options29;
        this.width = width;
        this.height = height;
      }
      write(x2, y2, text, options29) {
        const { transformers } = options29;
        if (!text) {
          return;
        }
        this.writes.push({ x: x2, y: y2, text, transformers });
      }
      get() {
        const output = [];
        for (let y2 = 0; y2 < this.height; y2++) {
          output.push(" ".repeat(this.width));
        }
        for (const write of this.writes) {
          const { x: x2, y: y2, text, transformers } = write;
          const lines = text.split("\n");
          let offsetY = 0;
          for (let line of lines) {
            const currentLine = output[y2 + offsetY];
            if (!currentLine) {
              continue;
            }
            const width = string_width_1.default(line);
            for (const transformer of transformers) {
              line = transformer(line);
            }
            output[y2 + offsetY] = slice_ansi_1.default(currentLine, 0, x2) + line + slice_ansi_1.default(currentLine, x2 + width);
            offsetY++;
          }
        }
        const generatedOutput = output.map((line) => line.trimRight()).join("\n");
        return {
          output: generatedOutput,
          height: output.length
        };
      }
    };
    __name(Output, "Output");
    exports2.default = Output;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/renderer.js
var require_renderer = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/renderer.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var yoga_layout_prebuilt_1 = __importDefault(require_wasm_sync2());
    var render_node_to_output_1 = __importDefault(require_render_node_to_output());
    var output_1 = __importDefault(require_output());
    exports2.default = (node2, terminalWidth) => {
      var _a2;
      node2.yogaNode.setWidth(terminalWidth);
      if (node2.yogaNode) {
        node2.yogaNode.calculateLayout(void 0, void 0, yoga_layout_prebuilt_1.default.DIRECTION_LTR);
        const output = new output_1.default({
          width: node2.yogaNode.getComputedWidth(),
          height: node2.yogaNode.getComputedHeight()
        });
        render_node_to_output_1.default(node2, output, { skipStaticElements: true });
        let staticOutput;
        if ((_a2 = node2.staticNode) === null || _a2 === void 0 ? void 0 : _a2.yogaNode) {
          staticOutput = new output_1.default({
            width: node2.staticNode.yogaNode.getComputedWidth(),
            height: node2.staticNode.yogaNode.getComputedHeight()
          });
          render_node_to_output_1.default(node2.staticNode, staticOutput, {
            skipStaticElements: false
          });
        }
        const { output: generatedOutput, height: outputHeight } = output.get();
        return {
          output: generatedOutput,
          outputHeight,
          // Newline at the end is needed, because static output doesn't have one, so
          // interactive output will override last line of static output
          staticOutput: staticOutput ? `${staticOutput.get().output}
` : ""
        };
      }
      return {
        output: "",
        outputHeight: 0,
        staticOutput: ""
      };
    };
  }
});

// ../../node_modules/.pnpm/patch-console@1.0.0/node_modules/patch-console/build/index.js
var require_build = __commonJS({
  "../../node_modules/.pnpm/patch-console@1.0.0/node_modules/patch-console/build/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var stream_1 = require("stream");
    var CONSOLE_METHODS = [
      "assert",
      "count",
      "countReset",
      "debug",
      "dir",
      "dirxml",
      "error",
      "group",
      "groupCollapsed",
      "groupEnd",
      "info",
      "log",
      "table",
      "time",
      "timeEnd",
      "timeLog",
      "trace",
      "warn"
    ];
    var originalMethods = {};
    var patchConsole = /* @__PURE__ */ __name((callback) => {
      const stdout2 = new stream_1.PassThrough();
      const stderr2 = new stream_1.PassThrough();
      stdout2.write = (data) => callback("stdout", data);
      stderr2.write = (data) => callback("stderr", data);
      const internalConsole = new console.Console(stdout2, stderr2);
      for (const method of CONSOLE_METHODS) {
        originalMethods[method] = console[method];
        console[method] = internalConsole[method];
      }
      return () => {
        for (const method of CONSOLE_METHODS) {
          console[method] = originalMethods[method];
        }
        originalMethods = {};
      };
    }, "patchConsole");
    module3.exports = patchConsole;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/instances.js
var require_instances = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/instances.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = /* @__PURE__ */ new WeakMap();
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/AppContext.js
var require_AppContext = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/AppContext.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    var react_1 = require_react();
    var AppContext = react_1.createContext({
      exit: () => {
      }
    });
    AppContext.displayName = "InternalAppContext";
    exports2.default = AppContext;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/StdinContext.js
var require_StdinContext = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/StdinContext.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    var react_1 = require_react();
    var StdinContext = react_1.createContext({
      stdin: void 0,
      setRawMode: () => {
      },
      isRawModeSupported: false,
      internal_exitOnCtrlC: true
    });
    StdinContext.displayName = "InternalStdinContext";
    exports2.default = StdinContext;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/StdoutContext.js
var require_StdoutContext = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/StdoutContext.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    var react_1 = require_react();
    var StdoutContext = react_1.createContext({
      stdout: void 0,
      write: () => {
      }
    });
    StdoutContext.displayName = "InternalStdoutContext";
    exports2.default = StdoutContext;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/StderrContext.js
var require_StderrContext = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/StderrContext.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    var react_1 = require_react();
    var StderrContext = react_1.createContext({
      stderr: void 0,
      write: () => {
      }
    });
    StderrContext.displayName = "InternalStderrContext";
    exports2.default = StderrContext;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/FocusContext.js
var require_FocusContext = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/FocusContext.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    var react_1 = require_react();
    var FocusContext = react_1.createContext({
      activeId: void 0,
      add: () => {
      },
      remove: () => {
      },
      activate: () => {
      },
      deactivate: () => {
      },
      enableFocus: () => {
      },
      disableFocus: () => {
      },
      focusNext: () => {
      },
      focusPrevious: () => {
      },
      focus: () => {
      }
    });
    FocusContext.displayName = "InternalFocusContext";
    exports2.default = FocusContext;
  }
});

// ../../node_modules/.pnpm/escape-string-regexp@2.0.0/node_modules/escape-string-regexp/index.js
var require_escape_string_regexp = __commonJS({
  "../../node_modules/.pnpm/escape-string-regexp@2.0.0/node_modules/escape-string-regexp/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var matchOperatorsRegex = /[|\\{}()[\]^$+*?.-]/g;
    module3.exports = (string) => {
      if (typeof string !== "string") {
        throw new TypeError("Expected a string");
      }
      return string.replace(matchOperatorsRegex, "\\$&");
    };
  }
});

// ../../node_modules/.pnpm/stack-utils@2.0.5/node_modules/stack-utils/index.js
var require_stack_utils = __commonJS({
  "../../node_modules/.pnpm/stack-utils@2.0.5/node_modules/stack-utils/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var escapeStringRegexp = require_escape_string_regexp();
    var cwd2 = typeof process === "object" && process && typeof process.cwd === "function" ? process.cwd() : ".";
    var natives = [].concat(
      require("module").builtinModules,
      "bootstrap_node",
      "node"
    ).map((n2) => new RegExp(`(?:\\((?:node:)?${n2}(?:\\.js)?:\\d+:\\d+\\)$|^\\s*at (?:node:)?${n2}(?:\\.js)?:\\d+:\\d+$)`));
    natives.push(
      /\((?:node:)?internal\/[^:]+:\d+:\d+\)$/,
      /\s*at (?:node:)?internal\/[^:]+:\d+:\d+$/,
      /\/\.node-spawn-wrap-\w+-\w+\/node:\d+:\d+\)?$/
    );
    var StackUtils = class {
      constructor(opts) {
        opts = {
          ignoredPackages: [],
          ...opts
        };
        if ("internals" in opts === false) {
          opts.internals = StackUtils.nodeInternals();
        }
        if ("cwd" in opts === false) {
          opts.cwd = cwd2;
        }
        this._cwd = opts.cwd.replace(/\\/g, "/");
        this._internals = [].concat(
          opts.internals,
          ignoredPackagesRegExp(opts.ignoredPackages)
        );
        this._wrapCallSite = opts.wrapCallSite || false;
      }
      static nodeInternals() {
        return [...natives];
      }
      clean(stack, indent = 0) {
        indent = " ".repeat(indent);
        if (!Array.isArray(stack)) {
          stack = stack.split("\n");
        }
        if (!/^\s*at /.test(stack[0]) && /^\s*at /.test(stack[1])) {
          stack = stack.slice(1);
        }
        let outdent = false;
        let lastNonAtLine = null;
        const result = [];
        stack.forEach((st) => {
          st = st.replace(/\\/g, "/");
          if (this._internals.some((internal) => internal.test(st))) {
            return;
          }
          const isAtLine = /^\s*at /.test(st);
          if (outdent) {
            st = st.trimEnd().replace(/^(\s+)at /, "$1");
          } else {
            st = st.trim();
            if (isAtLine) {
              st = st.slice(3);
            }
          }
          st = st.replace(`${this._cwd}/`, "");
          if (st) {
            if (isAtLine) {
              if (lastNonAtLine) {
                result.push(lastNonAtLine);
                lastNonAtLine = null;
              }
              result.push(st);
            } else {
              outdent = true;
              lastNonAtLine = st;
            }
          }
        });
        return result.map((line) => `${indent}${line}
`).join("");
      }
      captureString(limit, fn2 = this.captureString) {
        if (typeof limit === "function") {
          fn2 = limit;
          limit = Infinity;
        }
        const { stackTraceLimit } = Error;
        if (limit) {
          Error.stackTraceLimit = limit;
        }
        const obj = {};
        Error.captureStackTrace(obj, fn2);
        const { stack } = obj;
        Error.stackTraceLimit = stackTraceLimit;
        return this.clean(stack);
      }
      capture(limit, fn2 = this.capture) {
        if (typeof limit === "function") {
          fn2 = limit;
          limit = Infinity;
        }
        const { prepareStackTrace, stackTraceLimit } = Error;
        Error.prepareStackTrace = (obj2, site) => {
          if (this._wrapCallSite) {
            return site.map(this._wrapCallSite);
          }
          return site;
        };
        if (limit) {
          Error.stackTraceLimit = limit;
        }
        const obj = {};
        Error.captureStackTrace(obj, fn2);
        const { stack } = obj;
        Object.assign(Error, { prepareStackTrace, stackTraceLimit });
        return stack;
      }
      at(fn2 = this.at) {
        const [site] = this.capture(1, fn2);
        if (!site) {
          return {};
        }
        const res = {
          line: site.getLineNumber(),
          column: site.getColumnNumber()
        };
        setFile(res, site.getFileName(), this._cwd);
        if (site.isConstructor()) {
          res.constructor = true;
        }
        if (site.isEval()) {
          res.evalOrigin = site.getEvalOrigin();
        }
        if (site.isNative()) {
          res.native = true;
        }
        let typename;
        try {
          typename = site.getTypeName();
        } catch (_3) {
        }
        if (typename && typename !== "Object" && typename !== "[object Object]") {
          res.type = typename;
        }
        const fname = site.getFunctionName();
        if (fname) {
          res.function = fname;
        }
        const meth = site.getMethodName();
        if (meth && fname !== meth) {
          res.method = meth;
        }
        return res;
      }
      parseLine(line) {
        const match = line && line.match(re);
        if (!match) {
          return null;
        }
        const ctor = match[1] === "new";
        let fname = match[2];
        const evalOrigin = match[3];
        const evalFile = match[4];
        const evalLine = Number(match[5]);
        const evalCol = Number(match[6]);
        let file = match[7];
        const lnum = match[8];
        const col = match[9];
        const native = match[10] === "native";
        const closeParen = match[11] === ")";
        let method;
        const res = {};
        if (lnum) {
          res.line = Number(lnum);
        }
        if (col) {
          res.column = Number(col);
        }
        if (closeParen && file) {
          let closes = 0;
          for (let i = file.length - 1; i > 0; i--) {
            if (file.charAt(i) === ")") {
              closes++;
            } else if (file.charAt(i) === "(" && file.charAt(i - 1) === " ") {
              closes--;
              if (closes === -1 && file.charAt(i - 1) === " ") {
                const before = file.slice(0, i - 1);
                const after = file.slice(i + 1);
                file = after;
                fname += ` (${before}`;
                break;
              }
            }
          }
        }
        if (fname) {
          const methodMatch = fname.match(methodRe);
          if (methodMatch) {
            fname = methodMatch[1];
            method = methodMatch[2];
          }
        }
        setFile(res, file, this._cwd);
        if (ctor) {
          res.constructor = true;
        }
        if (evalOrigin) {
          res.evalOrigin = evalOrigin;
          res.evalLine = evalLine;
          res.evalColumn = evalCol;
          res.evalFile = evalFile && evalFile.replace(/\\/g, "/");
        }
        if (native) {
          res.native = true;
        }
        if (fname) {
          res.function = fname;
        }
        if (method && fname !== method) {
          res.method = method;
        }
        return res;
      }
    };
    __name(StackUtils, "StackUtils");
    function setFile(result, filename, cwd3) {
      if (filename) {
        filename = filename.replace(/\\/g, "/");
        if (filename.startsWith(`${cwd3}/`)) {
          filename = filename.slice(cwd3.length + 1);
        }
        result.file = filename;
      }
    }
    __name(setFile, "setFile");
    function ignoredPackagesRegExp(ignoredPackages) {
      if (ignoredPackages.length === 0) {
        return [];
      }
      const packages = ignoredPackages.map((mod) => escapeStringRegexp(mod));
      return new RegExp(`[/\\\\]node_modules[/\\\\](?:${packages.join("|")})[/\\\\][^:]+:\\d+:\\d+`);
    }
    __name(ignoredPackagesRegExp, "ignoredPackagesRegExp");
    var re = new RegExp(
      "^(?:\\s*at )?(?:(new) )?(?:(.*?) \\()?(?:eval at ([^ ]+) \\((.+?):(\\d+):(\\d+)\\), )?(?:(.+?):(\\d+):(\\d+)|(native))(\\)?)$"
    );
    var methodRe = /^(.*?) \[as (.*?)\]$/;
    module3.exports = StackUtils;
  }
});

// ../../node_modules/.pnpm/convert-to-spaces@1.0.2/node_modules/convert-to-spaces/index.js
var require_convert_to_spaces = __commonJS({
  "../../node_modules/.pnpm/convert-to-spaces@1.0.2/node_modules/convert-to-spaces/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = (str, spaces) => {
      return str.replace(/^\t+/gm, ($1) => " ".repeat($1.length * (spaces || 2)));
    };
  }
});

// ../../node_modules/.pnpm/code-excerpt@3.0.0/node_modules/code-excerpt/index.js
var require_code_excerpt = __commonJS({
  "../../node_modules/.pnpm/code-excerpt@3.0.0/node_modules/code-excerpt/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var tabsToSpaces = require_convert_to_spaces();
    var generateLineNumbers = /* @__PURE__ */ __name((line, around) => {
      const lineNumbers = [];
      const min = line - around;
      const max = line + around;
      for (let lineNumber = min; lineNumber <= max; lineNumber++) {
        lineNumbers.push(lineNumber);
      }
      return lineNumbers;
    }, "generateLineNumbers");
    module3.exports = (source, line, options29) => {
      if (typeof source !== "string") {
        throw new TypeError("Source code is missing.");
      }
      if (!line || line < 1) {
        throw new TypeError("Line number must start from `1`.");
      }
      source = tabsToSpaces(source).split(/\r?\n/);
      if (line > source.length) {
        return;
      }
      options29 = {
        around: 3,
        ...options29
      };
      return generateLineNumbers(line, options29.around).filter((line2) => source[line2 - 1] !== void 0).map((line2) => ({ line: line2, value: source[line2 - 1] }));
    };
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/Box.js
var require_Box = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/Box.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o2, m2, k2, k22) {
      if (k22 === void 0)
        k22 = k2;
      Object.defineProperty(o2, k22, { enumerable: true, get: function() {
        return m2[k2];
      } });
    } : function(o2, m2, k2, k22) {
      if (k22 === void 0)
        k22 = k2;
      o2[k22] = m2[k2];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o2, v2) {
      Object.defineProperty(o2, "default", { enumerable: true, value: v2 });
    } : function(o2, v2) {
      o2["default"] = v2;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule)
        return mod;
      var result = {};
      if (mod != null) {
        for (var k2 in mod)
          if (k2 !== "default" && Object.hasOwnProperty.call(mod, k2))
            __createBinding(result, mod, k2);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    var __rest = exports2 && exports2.__rest || function(s, e3) {
      var t3 = {};
      for (var p2 in s)
        if (Object.prototype.hasOwnProperty.call(s, p2) && e3.indexOf(p2) < 0)
          t3[p2] = s[p2];
      if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p2 = Object.getOwnPropertySymbols(s); i < p2.length; i++) {
          if (e3.indexOf(p2[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p2[i]))
            t3[p2[i]] = s[p2[i]];
        }
      return t3;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var react_1 = __importStar(require_react());
    var Box7 = react_1.forwardRef((_a2, ref) => {
      var { children } = _a2, style = __rest(_a2, ["children"]);
      const transformedStyle = Object.assign(Object.assign({}, style), { marginLeft: style.marginLeft || style.marginX || style.margin || 0, marginRight: style.marginRight || style.marginX || style.margin || 0, marginTop: style.marginTop || style.marginY || style.margin || 0, marginBottom: style.marginBottom || style.marginY || style.margin || 0, paddingLeft: style.paddingLeft || style.paddingX || style.padding || 0, paddingRight: style.paddingRight || style.paddingX || style.padding || 0, paddingTop: style.paddingTop || style.paddingY || style.padding || 0, paddingBottom: style.paddingBottom || style.paddingY || style.padding || 0 });
      return react_1.default.createElement("ink-box", { ref, style: transformedStyle }, children);
    });
    Box7.displayName = "Box";
    Box7.defaultProps = {
      flexDirection: "row",
      flexGrow: 0,
      flexShrink: 1
    };
    exports2.default = Box7;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/Text.js
var require_Text = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/Text.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var react_1 = __importDefault(require_react());
    var chalk_1 = __importDefault(require_source());
    var colorize_1 = __importDefault(require_colorize());
    var Text12 = /* @__PURE__ */ __name(({ color, backgroundColor, dimColor, bold: bold2, italic, underline, strikethrough, inverse, wrap: wrap4, children }) => {
      if (children === void 0 || children === null) {
        return null;
      }
      const transform = /* @__PURE__ */ __name((children2) => {
        if (dimColor) {
          children2 = chalk_1.default.dim(children2);
        }
        if (color) {
          children2 = colorize_1.default(children2, color, "foreground");
        }
        if (backgroundColor) {
          children2 = colorize_1.default(children2, backgroundColor, "background");
        }
        if (bold2) {
          children2 = chalk_1.default.bold(children2);
        }
        if (italic) {
          children2 = chalk_1.default.italic(children2);
        }
        if (underline) {
          children2 = chalk_1.default.underline(children2);
        }
        if (strikethrough) {
          children2 = chalk_1.default.strikethrough(children2);
        }
        if (inverse) {
          children2 = chalk_1.default.inverse(children2);
        }
        return children2;
      }, "transform");
      return react_1.default.createElement("ink-text", { style: { flexGrow: 0, flexShrink: 1, flexDirection: "row", textWrap: wrap4 }, internal_transform: transform }, children);
    }, "Text");
    Text12.displayName = "Text";
    Text12.defaultProps = {
      dimColor: false,
      bold: false,
      italic: false,
      underline: false,
      strikethrough: false,
      wrap: "wrap"
    };
    exports2.default = Text12;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/ErrorOverview.js
var require_ErrorOverview = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/ErrorOverview.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o2, m2, k2, k22) {
      if (k22 === void 0)
        k22 = k2;
      Object.defineProperty(o2, k22, { enumerable: true, get: function() {
        return m2[k2];
      } });
    } : function(o2, m2, k2, k22) {
      if (k22 === void 0)
        k22 = k2;
      o2[k22] = m2[k2];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o2, v2) {
      Object.defineProperty(o2, "default", { enumerable: true, value: v2 });
    } : function(o2, v2) {
      o2["default"] = v2;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule)
        return mod;
      var result = {};
      if (mod != null) {
        for (var k2 in mod)
          if (k2 !== "default" && Object.hasOwnProperty.call(mod, k2))
            __createBinding(result, mod, k2);
      }
      __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 });
    var fs26 = __importStar(require("fs"));
    var react_1 = __importDefault(require_react());
    var stack_utils_1 = __importDefault(require_stack_utils());
    var code_excerpt_1 = __importDefault(require_code_excerpt());
    var Box_1 = __importDefault(require_Box());
    var Text_1 = __importDefault(require_Text());
    var stackUtils = new stack_utils_1.default({
      cwd: process.cwd(),
      internals: stack_utils_1.default.nodeInternals()
    });
    var ErrorOverview = /* @__PURE__ */ __name(({ error: error2 }) => {
      const stack = error2.stack ? error2.stack.split("\n").slice(1) : void 0;
      const origin = stack ? stackUtils.parseLine(stack[0]) : void 0;
      let excerpt;
      let lineWidth = 0;
      if ((origin === null || origin === void 0 ? void 0 : origin.file) && (origin === null || origin === void 0 ? void 0 : origin.line) && fs26.existsSync(origin.file)) {
        const sourceCode = fs26.readFileSync(origin.file, "utf8");
        excerpt = code_excerpt_1.default(sourceCode, origin.line);
        if (excerpt) {
          for (const { line } of excerpt) {
            lineWidth = Math.max(lineWidth, String(line).length);
          }
        }
      }
      return react_1.default.createElement(
        Box_1.default,
        { flexDirection: "column", padding: 1 },
        react_1.default.createElement(
          Box_1.default,
          null,
          react_1.default.createElement(
            Text_1.default,
            { backgroundColor: "red", color: "white" },
            " ",
            "ERROR",
            " "
          ),
          react_1.default.createElement(
            Text_1.default,
            null,
            " ",
            error2.message
          )
        ),
        origin && react_1.default.createElement(
          Box_1.default,
          { marginTop: 1 },
          react_1.default.createElement(
            Text_1.default,
            { dimColor: true },
            origin.file,
            ":",
            origin.line,
            ":",
            origin.column
          )
        ),
        origin && excerpt && react_1.default.createElement(Box_1.default, { marginTop: 1, flexDirection: "column" }, excerpt.map(({ line, value }) => react_1.default.createElement(
          Box_1.default,
          { key: line },
          react_1.default.createElement(
            Box_1.default,
            { width: lineWidth + 1 },
            react_1.default.createElement(
              Text_1.default,
              { dimColor: line !== origin.line, backgroundColor: line === origin.line ? "red" : void 0, color: line === origin.line ? "white" : void 0 },
              String(line).padStart(lineWidth, " "),
              ":"
            )
          ),
          react_1.default.createElement(Text_1.default, { key: line, backgroundColor: line === origin.line ? "red" : void 0, color: line === origin.line ? "white" : void 0 }, " " + value)
        ))),
        error2.stack && react_1.default.createElement(Box_1.default, { marginTop: 1, flexDirection: "column" }, error2.stack.split("\n").slice(1).map((line) => {
          const parsedLine = stackUtils.parseLine(line);
          if (!parsedLine) {
            return react_1.default.createElement(
              Box_1.default,
              { key: line },
              react_1.default.createElement(Text_1.default, { dimColor: true }, "- "),
              react_1.default.createElement(Text_1.default, { dimColor: true, bold: true }, line)
            );
          }
          return react_1.default.createElement(
            Box_1.default,
            { key: line },
            react_1.default.createElement(Text_1.default, { dimColor: true }, "- "),
            react_1.default.createElement(Text_1.default, { dimColor: true, bold: true }, parsedLine.function),
            react_1.default.createElement(
              Text_1.default,
              { dimColor: true, color: "gray" },
              " ",
              "(",
              parsedLine.file,
              ":",
              parsedLine.line,
              ":",
              parsedLine.column,
              ")"
            )
          );
        }))
      );
    }, "ErrorOverview");
    exports2.default = ErrorOverview;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/App.js
var require_App = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/App.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o2, m2, k2, k22) {
      if (k22 === void 0)
        k22 = k2;
      Object.defineProperty(o2, k22, { enumerable: true, get: function() {
        return m2[k2];
      } });
    } : function(o2, m2, k2, k22) {
      if (k22 === void 0)
        k22 = k2;
      o2[k22] = m2[k2];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o2, v2) {
      Object.defineProperty(o2, "default", { enumerable: true, value: v2 });
    } : function(o2, v2) {
      o2["default"] = v2;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule)
        return mod;
      var result = {};
      if (mod != null) {
        for (var k2 in mod)
          if (k2 !== "default" && Object.hasOwnProperty.call(mod, k2))
            __createBinding(result, mod, k2);
      }
      __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 });
    var react_1 = __importStar(require_react());
    var cli_cursor_1 = __importDefault(require_cli_cursor());
    var AppContext_1 = __importDefault(require_AppContext());
    var StdinContext_1 = __importDefault(require_StdinContext());
    var StdoutContext_1 = __importDefault(require_StdoutContext());
    var StderrContext_1 = __importDefault(require_StderrContext());
    var FocusContext_1 = __importDefault(require_FocusContext());
    var ErrorOverview_1 = __importDefault(require_ErrorOverview());
    var TAB = "	";
    var SHIFT_TAB = "\x1B[Z";
    var ESC2 = "\x1B";
    var App = class extends react_1.PureComponent {
      constructor() {
        super(...arguments);
        this.state = {
          isFocusEnabled: true,
          activeFocusId: void 0,
          focusables: [],
          error: void 0
        };
        this.rawModeEnabledCount = 0;
        this.handleSetRawMode = (isEnabled) => {
          const { stdin } = this.props;
          if (!this.isRawModeSupported()) {
            if (stdin === process.stdin) {
              throw new Error("Raw mode is not supported on the current process.stdin, which Ink uses as input stream by default.\nRead about how to prevent this error on https://github.com/vadimdemedes/ink/#israwmodesupported");
            } else {
              throw new Error("Raw mode is not supported on the stdin provided to Ink.\nRead about how to prevent this error on https://github.com/vadimdemedes/ink/#israwmodesupported");
            }
          }
          stdin.setEncoding("utf8");
          if (isEnabled) {
            if (this.rawModeEnabledCount === 0) {
              stdin.addListener("data", this.handleInput);
              stdin.resume();
              stdin.setRawMode(true);
            }
            this.rawModeEnabledCount++;
            return;
          }
          if (--this.rawModeEnabledCount === 0) {
            stdin.setRawMode(false);
            stdin.removeListener("data", this.handleInput);
            stdin.pause();
          }
        };
        this.handleInput = (input) => {
          if (input === "" && this.props.exitOnCtrlC) {
            this.handleExit();
          }
          if (input === ESC2 && this.state.activeFocusId) {
            this.setState({
              activeFocusId: void 0
            });
          }
          if (this.state.isFocusEnabled && this.state.focusables.length > 0) {
            if (input === TAB) {
              this.focusNext();
            }
            if (input === SHIFT_TAB) {
              this.focusPrevious();
            }
          }
        };
        this.handleExit = (error2) => {
          if (this.isRawModeSupported()) {
            this.handleSetRawMode(false);
          }
          this.props.onExit(error2);
        };
        this.enableFocus = () => {
          this.setState({
            isFocusEnabled: true
          });
        };
        this.disableFocus = () => {
          this.setState({
            isFocusEnabled: false
          });
        };
        this.focus = (id) => {
          this.setState((previousState) => {
            const hasFocusableId = previousState.focusables.some((focusable) => (focusable === null || focusable === void 0 ? void 0 : focusable.id) === id);
            if (!hasFocusableId) {
              return previousState;
            }
            return { activeFocusId: id };
          });
        };
        this.focusNext = () => {
          this.setState((previousState) => {
            var _a2;
            const firstFocusableId = (_a2 = previousState.focusables[0]) === null || _a2 === void 0 ? void 0 : _a2.id;
            const nextFocusableId = this.findNextFocusable(previousState);
            return {
              activeFocusId: nextFocusableId || firstFocusableId
            };
          });
        };
        this.focusPrevious = () => {
          this.setState((previousState) => {
            var _a2;
            const lastFocusableId = (_a2 = previousState.focusables[previousState.focusables.length - 1]) === null || _a2 === void 0 ? void 0 : _a2.id;
            const previousFocusableId = this.findPreviousFocusable(previousState);
            return {
              activeFocusId: previousFocusableId || lastFocusableId
            };
          });
        };
        this.addFocusable = (id, { autoFocus }) => {
          this.setState((previousState) => {
            let nextFocusId = previousState.activeFocusId;
            if (!nextFocusId && autoFocus) {
              nextFocusId = id;
            }
            return {
              activeFocusId: nextFocusId,
              focusables: [
                ...previousState.focusables,
                {
                  id,
                  isActive: true
                }
              ]
            };
          });
        };
        this.removeFocusable = (id) => {
          this.setState((previousState) => ({
            activeFocusId: previousState.activeFocusId === id ? void 0 : previousState.activeFocusId,
            focusables: previousState.focusables.filter((focusable) => {
              return focusable.id !== id;
            })
          }));
        };
        this.activateFocusable = (id) => {
          this.setState((previousState) => ({
            focusables: previousState.focusables.map((focusable) => {
              if (focusable.id !== id) {
                return focusable;
              }
              return {
                id,
                isActive: true
              };
            })
          }));
        };
        this.deactivateFocusable = (id) => {
          this.setState((previousState) => ({
            activeFocusId: previousState.activeFocusId === id ? void 0 : previousState.activeFocusId,
            focusables: previousState.focusables.map((focusable) => {
              if (focusable.id !== id) {
                return focusable;
              }
              return {
                id,
                isActive: false
              };
            })
          }));
        };
        this.findNextFocusable = (state) => {
          var _a2;
          const activeIndex = state.focusables.findIndex((focusable) => {
            return focusable.id === state.activeFocusId;
          });
          for (let index = activeIndex + 1; index < state.focusables.length; index++) {
            if ((_a2 = state.focusables[index]) === null || _a2 === void 0 ? void 0 : _a2.isActive) {
              return state.focusables[index].id;
            }
          }
          return void 0;
        };
        this.findPreviousFocusable = (state) => {
          var _a2;
          const activeIndex = state.focusables.findIndex((focusable) => {
            return focusable.id === state.activeFocusId;
          });
          for (let index = activeIndex - 1; index >= 0; index--) {
            if ((_a2 = state.focusables[index]) === null || _a2 === void 0 ? void 0 : _a2.isActive) {
              return state.focusables[index].id;
            }
          }
          return void 0;
        };
      }
      static getDerivedStateFromError(error2) {
        return { error: error2 };
      }
      // Determines if TTY is supported on the provided stdin
      isRawModeSupported() {
        return this.props.stdin.isTTY;
      }
      render() {
        return react_1.default.createElement(
          AppContext_1.default.Provider,
          { value: {
            exit: this.handleExit
          } },
          react_1.default.createElement(
            StdinContext_1.default.Provider,
            { value: {
              stdin: this.props.stdin,
              setRawMode: this.handleSetRawMode,
              isRawModeSupported: this.isRawModeSupported(),
              internal_exitOnCtrlC: this.props.exitOnCtrlC
            } },
            react_1.default.createElement(
              StdoutContext_1.default.Provider,
              { value: {
                stdout: this.props.stdout,
                write: this.props.writeToStdout
              } },
              react_1.default.createElement(
                StderrContext_1.default.Provider,
                { value: {
                  stderr: this.props.stderr,
                  write: this.props.writeToStderr
                } },
                react_1.default.createElement(FocusContext_1.default.Provider, { value: {
                  activeId: this.state.activeFocusId,
                  add: this.addFocusable,
                  remove: this.removeFocusable,
                  activate: this.activateFocusable,
                  deactivate: this.deactivateFocusable,
                  enableFocus: this.enableFocus,
                  disableFocus: this.disableFocus,
                  focusNext: this.focusNext,
                  focusPrevious: this.focusPrevious,
                  focus: this.focus
                } }, this.state.error ? react_1.default.createElement(ErrorOverview_1.default, { error: this.state.error }) : this.props.children)
              )
            )
          )
        );
      }
      componentDidMount() {
        cli_cursor_1.default.hide(this.props.stdout);
      }
      componentWillUnmount() {
        cli_cursor_1.default.show(this.props.stdout);
        if (this.isRawModeSupported()) {
          this.handleSetRawMode(false);
        }
      }
      componentDidCatch(error2) {
        this.handleExit(error2);
      }
    };
    __name(App, "App");
    exports2.default = App;
    App.displayName = "InternalApp";
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/ink.js
var require_ink = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/ink.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o2, m2, k2, k22) {
      if (k22 === void 0)
        k22 = k2;
      Object.defineProperty(o2, k22, { enumerable: true, get: function() {
        return m2[k2];
      } });
    } : function(o2, m2, k2, k22) {
      if (k22 === void 0)
        k22 = k2;
      o2[k22] = m2[k2];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o2, v2) {
      Object.defineProperty(o2, "default", { enumerable: true, value: v2 });
    } : function(o2, v2) {
      o2["default"] = v2;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule)
        return mod;
      var result = {};
      if (mod != null) {
        for (var k2 in mod)
          if (k2 !== "default" && Object.hasOwnProperty.call(mod, k2))
            __createBinding(result, mod, k2);
      }
      __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 });
    var react_1 = __importDefault(require_react());
    var lodash_1 = require_lodash();
    var log_update_1 = __importDefault(require_log_update());
    var ansi_escapes_1 = __importDefault(require_ansi_escapes());
    var is_ci_1 = __importDefault(require_is_ci());
    var auto_bind_1 = __importDefault(require_auto_bind());
    var reconciler_1 = __importDefault(require_reconciler());
    var renderer_1 = __importDefault(require_renderer());
    var signal_exit_1 = __importDefault(require_signal_exit());
    var patch_console_1 = __importDefault(require_build());
    var dom = __importStar(require_dom());
    var instances_1 = __importDefault(require_instances());
    var App_1 = __importDefault(require_App());
    var isCI2 = process.env.CI === "false" ? false : is_ci_1.default;
    var noop = /* @__PURE__ */ __name(() => {
    }, "noop");
    var Ink = class {
      constructor(options29) {
        this.resolveExitPromise = () => {
        };
        this.rejectExitPromise = () => {
        };
        this.unsubscribeExit = () => {
        };
        this.onRender = () => {
          if (this.isUnmounted) {
            return;
          }
          const { output, outputHeight, staticOutput } = renderer_1.default(
            this.rootNode,
            // The 'columns' property can be undefined or 0 when not using a TTY.
            // In that case we fall back to 80.
            this.options.stdout.columns || 80
          );
          const hasStaticOutput = staticOutput && staticOutput !== "\n";
          if (this.options.debug) {
            if (hasStaticOutput) {
              this.fullStaticOutput += staticOutput;
            }
            this.options.stdout.write(this.fullStaticOutput + output);
            return;
          }
          if (isCI2) {
            if (hasStaticOutput) {
              this.options.stdout.write(staticOutput);
            }
            this.lastOutput = output;
            return;
          }
          if (hasStaticOutput) {
            this.fullStaticOutput += staticOutput;
          }
          if (outputHeight >= this.options.stdout.rows) {
            this.options.stdout.write(ansi_escapes_1.default.clearTerminal + this.fullStaticOutput + output);
            this.lastOutput = output;
            return;
          }
          if (hasStaticOutput) {
            this.log.clear();
            this.options.stdout.write(staticOutput);
            this.log(output);
          }
          if (!hasStaticOutput && output !== this.lastOutput) {
            this.throttledLog(output);
          }
          this.lastOutput = output;
        };
        auto_bind_1.default(this);
        this.options = options29;
        this.rootNode = dom.createNode("ink-root");
        this.rootNode.onRender = options29.debug ? this.onRender : lodash_1.throttle(this.onRender, 32, {
          leading: true,
          trailing: true
        });
        this.rootNode.onImmediateRender = this.onRender;
        this.log = log_update_1.default.create(options29.stdout);
        this.throttledLog = options29.debug ? this.log : lodash_1.throttle(this.log, void 0, {
          leading: true,
          trailing: true
        });
        this.isUnmounted = false;
        this.lastOutput = "";
        this.fullStaticOutput = "";
        this.container = reconciler_1.default.createContainer(
          this.rootNode,
          // Legacy mode
          0,
          false,
          null
        );
        this.unsubscribeExit = signal_exit_1.default(this.unmount, { alwaysLast: false });
        if (process.env.DEV === "true") {
          reconciler_1.default.injectIntoDevTools({
            bundleType: 0,
            // Reporting React DOM's version, not Ink's
            // See https://github.com/facebook/react/issues/16666#issuecomment-532639905
            version: "16.13.1",
            rendererPackageName: "ink"
          });
        }
        if (options29.patchConsole) {
          this.patchConsole();
        }
        if (!isCI2) {
          options29.stdout.on("resize", this.onRender);
          this.unsubscribeResize = () => {
            options29.stdout.off("resize", this.onRender);
          };
        }
      }
      render(node2) {
        const tree = react_1.default.createElement(App_1.default, { stdin: this.options.stdin, stdout: this.options.stdout, stderr: this.options.stderr, writeToStdout: this.writeToStdout, writeToStderr: this.writeToStderr, exitOnCtrlC: this.options.exitOnCtrlC, onExit: this.unmount }, node2);
        reconciler_1.default.updateContainer(tree, this.container, null, noop);
      }
      writeToStdout(data) {
        if (this.isUnmounted) {
          return;
        }
        if (this.options.debug) {
          this.options.stdout.write(data + this.fullStaticOutput + this.lastOutput);
          return;
        }
        if (isCI2) {
          this.options.stdout.write(data);
          return;
        }
        this.log.clear();
        this.options.stdout.write(data);
        this.log(this.lastOutput);
      }
      writeToStderr(data) {
        if (this.isUnmounted) {
          return;
        }
        if (this.options.debug) {
          this.options.stderr.write(data);
          this.options.stdout.write(this.fullStaticOutput + this.lastOutput);
          return;
        }
        if (isCI2) {
          this.options.stderr.write(data);
          return;
        }
        this.log.clear();
        this.options.stderr.write(data);
        this.log(this.lastOutput);
      }
      unmount(error2) {
        if (this.isUnmounted) {
          return;
        }
        this.onRender();
        this.unsubscribeExit();
        if (typeof this.restoreConsole === "function") {
          this.restoreConsole();
        }
        if (typeof this.unsubscribeResize === "function") {
          this.unsubscribeResize();
        }
        if (isCI2) {
          this.options.stdout.write(this.lastOutput + "\n");
        } else if (!this.options.debug) {
          this.log.done();
        }
        this.isUnmounted = true;
        reconciler_1.default.updateContainer(null, this.container, null, noop);
        instances_1.default.delete(this.options.stdout);
        if (error2 instanceof Error) {
          this.rejectExitPromise(error2);
        } else {
          this.resolveExitPromise();
        }
      }
      waitUntilExit() {
        if (!this.exitPromise) {
          this.exitPromise = new Promise((resolve19, reject) => {
            this.resolveExitPromise = resolve19;
            this.rejectExitPromise = reject;
          });
        }
        return this.exitPromise;
      }
      clear() {
        if (!isCI2 && !this.options.debug) {
          this.log.clear();
        }
      }
      patchConsole() {
        if (this.options.debug) {
          return;
        }
        this.restoreConsole = patch_console_1.default((stream2, data) => {
          if (stream2 === "stdout") {
            this.writeToStdout(data);
          }
          if (stream2 === "stderr") {
            const isReactMessage = data.startsWith("The above error occurred");
            if (!isReactMessage) {
              this.writeToStderr(data);
            }
          }
        });
      }
    };
    __name(Ink, "Ink");
    exports2.default = Ink;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/render.js
var require_render = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/render.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var ink_1 = __importDefault(require_ink());
    var instances_1 = __importDefault(require_instances());
    var stream_1 = require("stream");
    var render7 = /* @__PURE__ */ __name((node2, options29) => {
      const inkOptions = Object.assign({ stdout: process.stdout, stdin: process.stdin, stderr: process.stderr, debug: false, exitOnCtrlC: true, patchConsole: true }, getOptions(options29));
      const instance = getInstance(inkOptions.stdout, () => new ink_1.default(inkOptions));
      instance.render(node2);
      return {
        rerender: instance.render,
        unmount: () => instance.unmount(),
        waitUntilExit: instance.waitUntilExit,
        cleanup: () => instances_1.default.delete(inkOptions.stdout),
        clear: instance.clear
      };
    }, "render");
    exports2.default = render7;
    var getOptions = /* @__PURE__ */ __name((stdout2 = {}) => {
      if (stdout2 instanceof stream_1.Stream) {
        return {
          stdout: stdout2,
          stdin: process.stdin
        };
      }
      return stdout2;
    }, "getOptions");
    var getInstance = /* @__PURE__ */ __name((stdout2, createInstance) => {
      let instance;
      if (instances_1.default.has(stdout2)) {
        instance = instances_1.default.get(stdout2);
      } else {
        instance = createInstance();
        instances_1.default.set(stdout2, instance);
      }
      return instance;
    }, "getInstance");
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/Static.js
var require_Static = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/Static.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o2, m2, k2, k22) {
      if (k22 === void 0)
        k22 = k2;
      Object.defineProperty(o2, k22, { enumerable: true, get: function() {
        return m2[k2];
      } });
    } : function(o2, m2, k2, k22) {
      if (k22 === void 0)
        k22 = k2;
      o2[k22] = m2[k2];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o2, v2) {
      Object.defineProperty(o2, "default", { enumerable: true, value: v2 });
    } : function(o2, v2) {
      o2["default"] = v2;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule)
        return mod;
      var result = {};
      if (mod != null) {
        for (var k2 in mod)
          if (k2 !== "default" && Object.hasOwnProperty.call(mod, k2))
            __createBinding(result, mod, k2);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var react_1 = __importStar(require_react());
    var Static2 = /* @__PURE__ */ __name((props) => {
      const { items, children: render7, style: customStyle } = props;
      const [index, setIndex] = react_1.useState(0);
      const itemsToRender = react_1.useMemo(() => {
        return items.slice(index);
      }, [items, index]);
      react_1.useLayoutEffect(() => {
        setIndex(items.length);
      }, [items.length]);
      const children = itemsToRender.map((item, itemIndex) => {
        return render7(item, index + itemIndex);
      });
      const style = react_1.useMemo(() => Object.assign({ position: "absolute", flexDirection: "column" }, customStyle), [customStyle]);
      return react_1.default.createElement("ink-box", {
        // @ts-ignore
        internal_static: true,
        style
      }, children);
    }, "Static");
    Static2.displayName = "Static";
    exports2.default = Static2;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/Transform.js
var require_Transform = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/Transform.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var react_1 = __importDefault(require_react());
    var Transform = /* @__PURE__ */ __name(({ children, transform }) => {
      if (children === void 0 || children === null) {
        return null;
      }
      return react_1.default.createElement("ink-text", { style: { flexGrow: 0, flexShrink: 1, flexDirection: "row" }, internal_transform: transform }, children);
    }, "Transform");
    Transform.displayName = "Transform";
    exports2.default = Transform;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/Newline.js
var require_Newline = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/Newline.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var react_1 = __importDefault(require_react());
    var Newline = /* @__PURE__ */ __name(({ count = 1 }) => react_1.default.createElement("ink-text", null, "\n".repeat(count)), "Newline");
    Newline.displayName = "Newline";
    exports2.default = Newline;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/Spacer.js
var require_Spacer = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/components/Spacer.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var react_1 = __importDefault(require_react());
    var Box_1 = __importDefault(require_Box());
    var Spacer = /* @__PURE__ */ __name(() => react_1.default.createElement(Box_1.default, { flexGrow: 1 }), "Spacer");
    Spacer.displayName = "Spacer";
    exports2.default = Spacer;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-stdin.js
var require_use_stdin = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-stdin.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var react_1 = require_react();
    var StdinContext_1 = __importDefault(require_StdinContext());
    var useStdin2 = /* @__PURE__ */ __name(() => react_1.useContext(StdinContext_1.default), "useStdin");
    exports2.default = useStdin2;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-input.js
var require_use_input = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-input.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var react_1 = require_react();
    var use_stdin_1 = __importDefault(require_use_stdin());
    var useInput2 = /* @__PURE__ */ __name((inputHandler, options29 = {}) => {
      const { stdin, setRawMode, internal_exitOnCtrlC } = use_stdin_1.default();
      react_1.useEffect(() => {
        if (options29.isActive === false) {
          return;
        }
        setRawMode(true);
        return () => {
          setRawMode(false);
        };
      }, [options29.isActive, setRawMode]);
      react_1.useEffect(() => {
        if (options29.isActive === false) {
          return;
        }
        const handleData = /* @__PURE__ */ __name((data) => {
          let input = String(data);
          const key = {
            upArrow: input === "\x1B[A",
            downArrow: input === "\x1B[B",
            leftArrow: input === "\x1B[D",
            rightArrow: input === "\x1B[C",
            pageDown: input === "\x1B[6~",
            pageUp: input === "\x1B[5~",
            return: input === "\r",
            escape: input === "\x1B",
            ctrl: false,
            shift: false,
            tab: input === "	" || input === "\x1B[Z",
            backspace: input === "\b",
            delete: input === "\x7F" || input === "\x1B[3~",
            meta: false
          };
          if (input <= "" && !key.return) {
            input = String.fromCharCode(input.charCodeAt(0) + "a".charCodeAt(0) - 1);
            key.ctrl = true;
          }
          if (input.startsWith("\x1B")) {
            input = input.slice(1);
            key.meta = true;
          }
          const isLatinUppercase = input >= "A" && input <= "Z";
          const isCyrillicUppercase = input >= "\u0410" && input <= "\u042F";
          if (input.length === 1 && (isLatinUppercase || isCyrillicUppercase)) {
            key.shift = true;
          }
          if (key.tab && input === "[Z") {
            key.shift = true;
          }
          if (key.tab || key.backspace || key.delete) {
            input = "";
          }
          if (!(input === "c" && key.ctrl) || !internal_exitOnCtrlC) {
            inputHandler(input, key);
          }
        }, "handleData");
        stdin === null || stdin === void 0 ? void 0 : stdin.on("data", handleData);
        return () => {
          stdin === null || stdin === void 0 ? void 0 : stdin.off("data", handleData);
        };
      }, [options29.isActive, stdin, internal_exitOnCtrlC, inputHandler]);
    }, "useInput");
    exports2.default = useInput2;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-app.js
var require_use_app = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-app.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var react_1 = require_react();
    var AppContext_1 = __importDefault(require_AppContext());
    var useApp3 = /* @__PURE__ */ __name(() => react_1.useContext(AppContext_1.default), "useApp");
    exports2.default = useApp3;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-stdout.js
var require_use_stdout = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-stdout.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var react_1 = require_react();
    var StdoutContext_1 = __importDefault(require_StdoutContext());
    var useStdout = /* @__PURE__ */ __name(() => react_1.useContext(StdoutContext_1.default), "useStdout");
    exports2.default = useStdout;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-stderr.js
var require_use_stderr = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-stderr.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var react_1 = require_react();
    var StderrContext_1 = __importDefault(require_StderrContext());
    var useStderr = /* @__PURE__ */ __name(() => react_1.useContext(StderrContext_1.default), "useStderr");
    exports2.default = useStderr;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-focus.js
var require_use_focus = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-focus.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var react_1 = require_react();
    var FocusContext_1 = __importDefault(require_FocusContext());
    var use_stdin_1 = __importDefault(require_use_stdin());
    var useFocus = /* @__PURE__ */ __name(({ isActive = true, autoFocus = false, id: customId } = {}) => {
      const { isRawModeSupported, setRawMode } = use_stdin_1.default();
      const { activeId, add, remove, activate, deactivate, focus } = react_1.useContext(FocusContext_1.default);
      const id = react_1.useMemo(() => {
        return customId !== null && customId !== void 0 ? customId : Math.random().toString().slice(2, 7);
      }, [customId]);
      react_1.useEffect(() => {
        add(id, { autoFocus });
        return () => {
          remove(id);
        };
      }, [id, autoFocus]);
      react_1.useEffect(() => {
        if (isActive) {
          activate(id);
        } else {
          deactivate(id);
        }
      }, [isActive, id]);
      react_1.useEffect(() => {
        if (!isRawModeSupported || !isActive) {
          return;
        }
        setRawMode(true);
        return () => {
          setRawMode(false);
        };
      }, [isActive]);
      return {
        isFocused: Boolean(id) && activeId === id,
        focus
      };
    }, "useFocus");
    exports2.default = useFocus;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-focus-manager.js
var require_use_focus_manager = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/hooks/use-focus-manager.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var react_1 = require_react();
    var FocusContext_1 = __importDefault(require_FocusContext());
    var useFocusManager = /* @__PURE__ */ __name(() => {
      const focusContext = react_1.useContext(FocusContext_1.default);
      return {
        enableFocus: focusContext.enableFocus,
        disableFocus: focusContext.disableFocus,
        focusNext: focusContext.focusNext,
        focusPrevious: focusContext.focusPrevious,
        focus: focusContext.focus
      };
    }, "useFocusManager");
    exports2.default = useFocusManager;
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/measure-element.js
var require_measure_element = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/measure-element.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.default = (node2) => {
      var _a2, _b2, _c2, _d;
      return {
        width: (_b2 = (_a2 = node2.yogaNode) === null || _a2 === void 0 ? void 0 : _a2.getComputedWidth()) !== null && _b2 !== void 0 ? _b2 : 0,
        height: (_d = (_c2 = node2.yogaNode) === null || _c2 === void 0 ? void 0 : _c2.getComputedHeight()) !== null && _d !== void 0 ? _d : 0
      };
    };
  }
});

// ../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/index.js
var require_build2 = __commonJS({
  "../../node_modules/.pnpm/ink@3.2.0_patch_hash=iiwbcf44d6ccmi6a27ljqs7qce_@types+react@17.0.52_react@17.0.2/node_modules/ink/build/index.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    var render_1 = require_render();
    Object.defineProperty(exports2, "render", { enumerable: true, get: function() {
      return render_1.default;
    } });
    var Box_1 = require_Box();
    Object.defineProperty(exports2, "Box", { enumerable: true, get: function() {
      return Box_1.default;
    } });
    var Text_1 = require_Text();
    Object.defineProperty(exports2, "Text", { enumerable: true, get: function() {
      return Text_1.default;
    } });
    var Static_1 = require_Static();
    Object.defineProperty(exports2, "Static", { enumerable: true, get: function() {
      return Static_1.default;
    } });
    var Transform_1 = require_Transform();
    Object.defineProperty(exports2, "Transform", { enumerable: true, get: function() {
      return Transform_1.default;
    } });
    var Newline_1 = require_Newline();
    Object.defineProperty(exports2, "Newline", { enumerable: true, get: function() {
      return Newline_1.default;
    } });
    var Spacer_1 = require_Spacer();
    Object.defineProperty(exports2, "Spacer", { enumerable: true, get: function() {
      return Spacer_1.default;
    } });
    var use_input_1 = require_use_input();
    Object.defineProperty(exports2, "useInput", { enumerable: true, get: function() {
      return use_input_1.default;
    } });
    var use_app_1 = require_use_app();
    Object.defineProperty(exports2, "useApp", { enumerable: true, get: function() {
      return use_app_1.default;
    } });
    var use_stdin_1 = require_use_stdin();
    Object.defineProperty(exports2, "useStdin", { enumerable: true, get: function() {
      return use_stdin_1.default;
    } });
    var use_stdout_1 = require_use_stdout();
    Object.defineProperty(exports2, "useStdout", { enumerable: true, get: function() {
      return use_stdout_1.default;
    } });
    var use_stderr_1 = require_use_stderr();
    Object.defineProperty(exports2, "useStderr", { enumerable: true, get: function() {
      return use_stderr_1.default;
    } });
    var use_focus_1 = require_use_focus();
    Object.defineProperty(exports2, "useFocus", { enumerable: true, get: function() {
      return use_focus_1.default;
    } });
    var use_focus_manager_1 = require_use_focus_manager();
    Object.defineProperty(exports2, "useFocusManager", { enumerable: true, get: function() {
      return use_focus_manager_1.default;
    } });
    var measure_element_1 = require_measure_element();
    Object.defineProperty(exports2, "measureElement", { enumerable: true, get: function() {
      return measure_element_1.default;
    } });
  }
});

// ../../node_modules/.pnpm/dotenv@16.0.0/node_modules/dotenv/lib/main.js
var require_main2 = __commonJS({
  "../../node_modules/.pnpm/dotenv@16.0.0/node_modules/dotenv/lib/main.js"(exports2, module3) {
    init_import_meta_url();
    var fs26 = require("fs");
    var path67 = require("path");
    var os11 = require("os");
    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
    function parse7(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;
    }
    __name(parse7, "parse");
    function _log(message) {
      console.log(`[dotenv][DEBUG] ${message}`);
    }
    __name(_log, "_log");
    function _resolveHome(envPath) {
      return envPath[0] === "~" ? path67.join(os11.homedir(), envPath.slice(1)) : envPath;
    }
    __name(_resolveHome, "_resolveHome");
    function config(options29) {
      let dotenvPath = path67.resolve(process.cwd(), ".env");
      let encoding = "utf8";
      const debug = Boolean(options29 && options29.debug);
      const override = Boolean(options29 && options29.override);
      if (options29) {
        if (options29.path != null) {
          dotenvPath = _resolveHome(options29.path);
        }
        if (options29.encoding != null) {
          encoding = options29.encoding;
        }
      }
      try {
        const parsed = DotenvModule.parse(fs26.readFileSync(dotenvPath, { encoding }));
        Object.keys(parsed).forEach(function(key) {
          if (!Object.prototype.hasOwnProperty.call(process.env, key)) {
            process.env[key] = parsed[key];
          } else {
            if (override === true) {
              process.env[key] = parsed[key];
            }
            if (debug) {
              if (override === true) {
                _log(`"${key}" is already defined in \`process.env\` and WAS overwritten`);
              } else {
                _log(`"${key}" is already defined in \`process.env\` and was NOT overwritten`);
              }
            }
          }
        });
        return { parsed };
      } catch (e3) {
        if (debug) {
          _log(`Failed to load ${dotenvPath} ${e3.message}`);
        }
        return { error: e3 };
      }
    }
    __name(config, "config");
    var DotenvModule = {
      config,
      parse: parse7
    };
    module3.exports.config = DotenvModule.config;
    module3.exports.parse = DotenvModule.parse;
    module3.exports = DotenvModule;
  }
});

// ../../node_modules/.pnpm/escape-string-regexp@1.0.5/node_modules/escape-string-regexp/index.js
var require_escape_string_regexp2 = __commonJS({
  "../../node_modules/.pnpm/escape-string-regexp@1.0.5/node_modules/escape-string-regexp/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
    module3.exports = function(str) {
      if (typeof str !== "string") {
        throw new TypeError("Expected a string");
      }
      return str.replace(matchOperatorsRe, "\\$&");
    };
  }
});

// ../../node_modules/.pnpm/color-name@1.1.3/node_modules/color-name/index.js
var require_color_name2 = __commonJS({
  "../../node_modules/.pnpm/color-name@1.1.3/node_modules/color-name/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = {
      "aliceblue": [240, 248, 255],
      "antiquewhite": [250, 235, 215],
      "aqua": [0, 255, 255],
      "aquamarine": [127, 255, 212],
      "azure": [240, 255, 255],
      "beige": [245, 245, 220],
      "bisque": [255, 228, 196],
      "black": [0, 0, 0],
      "blanchedalmond": [255, 235, 205],
      "blue": [0, 0, 255],
      "blueviolet": [138, 43, 226],
      "brown": [165, 42, 42],
      "burlywood": [222, 184, 135],
      "cadetblue": [95, 158, 160],
      "chartreuse": [127, 255, 0],
      "chocolate": [210, 105, 30],
      "coral": [255, 127, 80],
      "cornflowerblue": [100, 149, 237],
      "cornsilk": [255, 248, 220],
      "crimson": [220, 20, 60],
      "cyan": [0, 255, 255],
      "darkblue": [0, 0, 139],
      "darkcyan": [0, 139, 139],
      "darkgoldenrod": [184, 134, 11],
      "darkgray": [169, 169, 169],
      "darkgreen": [0, 100, 0],
      "darkgrey": [169, 169, 169],
      "darkkhaki": [189, 183, 107],
      "darkmagenta": [139, 0, 139],
      "darkolivegreen": [85, 107, 47],
      "darkorange": [255, 140, 0],
      "darkorchid": [153, 50, 204],
      "darkred": [139, 0, 0],
      "darksalmon": [233, 150, 122],
      "darkseagreen": [143, 188, 143],
      "darkslateblue": [72, 61, 139],
      "darkslategray": [47, 79, 79],
      "darkslategrey": [47, 79, 79],
      "darkturquoise": [0, 206, 209],
      "darkviolet": [148, 0, 211],
      "deeppink": [255, 20, 147],
      "deepskyblue": [0, 191, 255],
      "dimgray": [105, 105, 105],
      "dimgrey": [105, 105, 105],
      "dodgerblue": [30, 144, 255],
      "firebrick": [178, 34, 34],
      "floralwhite": [255, 250, 240],
      "forestgreen": [34, 139, 34],
      "fuchsia": [255, 0, 255],
      "gainsboro": [220, 220, 220],
      "ghostwhite": [248, 248, 255],
      "gold": [255, 215, 0],
      "goldenrod": [218, 165, 32],
      "gray": [128, 128, 128],
      "green": [0, 128, 0],
      "greenyellow": [173, 255, 47],
      "grey": [128, 128, 128],
      "honeydew": [240, 255, 240],
      "hotpink": [255, 105, 180],
      "indianred": [205, 92, 92],
      "indigo": [75, 0, 130],
      "ivory": [255, 255, 240],
      "khaki": [240, 230, 140],
      "lavender": [230, 230, 250],
      "lavenderblush": [255, 240, 245],
      "lawngreen": [124, 252, 0],
      "lemonchiffon": [255, 250, 205],
      "lightblue": [173, 216, 230],
      "lightcoral": [240, 128, 128],
      "lightcyan": [224, 255, 255],
      "lightgoldenrodyellow": [250, 250, 210],
      "lightgray": [211, 211, 211],
      "lightgreen": [144, 238, 144],
      "lightgrey": [211, 211, 211],
      "lightpink": [255, 182, 193],
      "lightsalmon": [255, 160, 122],
      "lightseagreen": [32, 178, 170],
      "lightskyblue": [135, 206, 250],
      "lightslategray": [119, 136, 153],
      "lightslategrey": [119, 136, 153],
      "lightsteelblue": [176, 196, 222],
      "lightyellow": [255, 255, 224],
      "lime": [0, 255, 0],
      "limegreen": [50, 205, 50],
      "linen": [250, 240, 230],
      "magenta": [255, 0, 255],
      "maroon": [128, 0, 0],
      "mediumaquamarine": [102, 205, 170],
      "mediumblue": [0, 0, 205],
      "mediumorchid": [186, 85, 211],
      "mediumpurple": [147, 112, 219],
      "mediumseagreen": [60, 179, 113],
      "mediumslateblue": [123, 104, 238],
      "mediumspringgreen": [0, 250, 154],
      "mediumturquoise": [72, 209, 204],
      "mediumvioletred": [199, 21, 133],
      "midnightblue": [25, 25, 112],
      "mintcream": [245, 255, 250],
      "mistyrose": [255, 228, 225],
      "moccasin": [255, 228, 181],
      "navajowhite": [255, 222, 173],
      "navy": [0, 0, 128],
      "oldlace": [253, 245, 230],
      "olive": [128, 128, 0],
      "olivedrab": [107, 142, 35],
      "orange": [255, 165, 0],
      "orangered": [255, 69, 0],
      "orchid": [218, 112, 214],
      "palegoldenrod": [238, 232, 170],
      "palegreen": [152, 251, 152],
      "paleturquoise": [175, 238, 238],
      "palevioletred": [219, 112, 147],
      "papayawhip": [255, 239, 213],
      "peachpuff": [255, 218, 185],
      "peru": [205, 133, 63],
      "pink": [255, 192, 203],
      "plum": [221, 160, 221],
      "powderblue": [176, 224, 230],
      "purple": [128, 0, 128],
      "rebeccapurple": [102, 51, 153],
      "red": [255, 0, 0],
      "rosybrown": [188, 143, 143],
      "royalblue": [65, 105, 225],
      "saddlebrown": [139, 69, 19],
      "salmon": [250, 128, 114],
      "sandybrown": [244, 164, 96],
      "seagreen": [46, 139, 87],
      "seashell": [255, 245, 238],
      "sienna": [160, 82, 45],
      "silver": [192, 192, 192],
      "skyblue": [135, 206, 235],
      "slateblue": [106, 90, 205],
      "slategray": [112, 128, 144],
      "slategrey": [112, 128, 144],
      "snow": [255, 250, 250],
      "springgreen": [0, 255, 127],
      "steelblue": [70, 130, 180],
      "tan": [210, 180, 140],
      "teal": [0, 128, 128],
      "thistle": [216, 191, 216],
      "tomato": [255, 99, 71],
      "turquoise": [64, 224, 208],
      "violet": [238, 130, 238],
      "wheat": [245, 222, 179],
      "white": [255, 255, 255],
      "whitesmoke": [245, 245, 245],
      "yellow": [255, 255, 0],
      "yellowgreen": [154, 205, 50]
    };
  }
});

// ../../node_modules/.pnpm/color-convert@1.9.3/node_modules/color-convert/conversions.js
var require_conversions2 = __commonJS({
  "../../node_modules/.pnpm/color-convert@1.9.3/node_modules/color-convert/conversions.js"(exports2, module3) {
    init_import_meta_url();
    var cssKeywords = require_color_name2();
    var reverseKeywords = {};
    for (key in cssKeywords) {
      if (cssKeywords.hasOwnProperty(key)) {
        reverseKeywords[cssKeywords[key]] = key;
      }
    }
    var key;
    var convert = module3.exports = {
      rgb: { channels: 3, labels: "rgb" },
      hsl: { channels: 3, labels: "hsl" },
      hsv: { channels: 3, labels: "hsv" },
      hwb: { channels: 3, labels: "hwb" },
      cmyk: { channels: 4, labels: "cmyk" },
      xyz: { channels: 3, labels: "xyz" },
      lab: { channels: 3, labels: "lab" },
      lch: { channels: 3, labels: "lch" },
      hex: { channels: 1, labels: ["hex"] },
      keyword: { channels: 1, labels: ["keyword"] },
      ansi16: { channels: 1, labels: ["ansi16"] },
      ansi256: { channels: 1, labels: ["ansi256"] },
      hcg: { channels: 3, labels: ["h", "c", "g"] },
      apple: { channels: 3, labels: ["r16", "g16", "b16"] },
      gray: { channels: 1, labels: ["gray"] }
    };
    for (model in convert) {
      if (convert.hasOwnProperty(model)) {
        if (!("channels" in convert[model])) {
          throw new Error("missing channels property: " + model);
        }
        if (!("labels" in convert[model])) {
          throw new Error("missing channel labels property: " + model);
        }
        if (convert[model].labels.length !== convert[model].channels) {
          throw new Error("channel and label counts mismatch: " + model);
        }
        channels = convert[model].channels;
        labels = convert[model].labels;
        delete convert[model].channels;
        delete convert[model].labels;
        Object.defineProperty(convert[model], "channels", { value: channels });
        Object.defineProperty(convert[model], "labels", { value: labels });
      }
    }
    var channels;
    var labels;
    var model;
    convert.rgb.hsl = function(rgb) {
      var r3 = rgb[0] / 255;
      var g2 = rgb[1] / 255;
      var b2 = rgb[2] / 255;
      var min = Math.min(r3, g2, b2);
      var max = Math.max(r3, g2, b2);
      var delta = max - min;
      var h2;
      var s;
      var l2;
      if (max === min) {
        h2 = 0;
      } else if (r3 === max) {
        h2 = (g2 - b2) / delta;
      } else if (g2 === max) {
        h2 = 2 + (b2 - r3) / delta;
      } else if (b2 === max) {
        h2 = 4 + (r3 - g2) / delta;
      }
      h2 = Math.min(h2 * 60, 360);
      if (h2 < 0) {
        h2 += 360;
      }
      l2 = (min + max) / 2;
      if (max === min) {
        s = 0;
      } else if (l2 <= 0.5) {
        s = delta / (max + min);
      } else {
        s = delta / (2 - max - min);
      }
      return [h2, s * 100, l2 * 100];
    };
    convert.rgb.hsv = function(rgb) {
      var rdif;
      var gdif;
      var bdif;
      var h2;
      var s;
      var r3 = rgb[0] / 255;
      var g2 = rgb[1] / 255;
      var b2 = rgb[2] / 255;
      var v2 = Math.max(r3, g2, b2);
      var diff = v2 - Math.min(r3, g2, b2);
      var diffc = /* @__PURE__ */ __name(function(c2) {
        return (v2 - c2) / 6 / diff + 1 / 2;
      }, "diffc");
      if (diff === 0) {
        h2 = s = 0;
      } else {
        s = diff / v2;
        rdif = diffc(r3);
        gdif = diffc(g2);
        bdif = diffc(b2);
        if (r3 === v2) {
          h2 = bdif - gdif;
        } else if (g2 === v2) {
          h2 = 1 / 3 + rdif - bdif;
        } else if (b2 === v2) {
          h2 = 2 / 3 + gdif - rdif;
        }
        if (h2 < 0) {
          h2 += 1;
        } else if (h2 > 1) {
          h2 -= 1;
        }
      }
      return [
        h2 * 360,
        s * 100,
        v2 * 100
      ];
    };
    convert.rgb.hwb = function(rgb) {
      var r3 = rgb[0];
      var g2 = rgb[1];
      var b2 = rgb[2];
      var h2 = convert.rgb.hsl(rgb)[0];
      var w2 = 1 / 255 * Math.min(r3, Math.min(g2, b2));
      b2 = 1 - 1 / 255 * Math.max(r3, Math.max(g2, b2));
      return [h2, w2 * 100, b2 * 100];
    };
    convert.rgb.cmyk = function(rgb) {
      var r3 = rgb[0] / 255;
      var g2 = rgb[1] / 255;
      var b2 = rgb[2] / 255;
      var c2;
      var m2;
      var y2;
      var k2;
      k2 = Math.min(1 - r3, 1 - g2, 1 - b2);
      c2 = (1 - r3 - k2) / (1 - k2) || 0;
      m2 = (1 - g2 - k2) / (1 - k2) || 0;
      y2 = (1 - b2 - k2) / (1 - k2) || 0;
      return [c2 * 100, m2 * 100, y2 * 100, k2 * 100];
    };
    function comparativeDistance(x2, y2) {
      return Math.pow(x2[0] - y2[0], 2) + Math.pow(x2[1] - y2[1], 2) + Math.pow(x2[2] - y2[2], 2);
    }
    __name(comparativeDistance, "comparativeDistance");
    convert.rgb.keyword = function(rgb) {
      var reversed = reverseKeywords[rgb];
      if (reversed) {
        return reversed;
      }
      var currentClosestDistance = Infinity;
      var currentClosestKeyword;
      for (var keyword in cssKeywords) {
        if (cssKeywords.hasOwnProperty(keyword)) {
          var value = cssKeywords[keyword];
          var distance = comparativeDistance(rgb, value);
          if (distance < currentClosestDistance) {
            currentClosestDistance = distance;
            currentClosestKeyword = keyword;
          }
        }
      }
      return currentClosestKeyword;
    };
    convert.keyword.rgb = function(keyword) {
      return cssKeywords[keyword];
    };
    convert.rgb.xyz = function(rgb) {
      var r3 = rgb[0] / 255;
      var g2 = rgb[1] / 255;
      var b2 = rgb[2] / 255;
      r3 = r3 > 0.04045 ? Math.pow((r3 + 0.055) / 1.055, 2.4) : r3 / 12.92;
      g2 = g2 > 0.04045 ? Math.pow((g2 + 0.055) / 1.055, 2.4) : g2 / 12.92;
      b2 = b2 > 0.04045 ? Math.pow((b2 + 0.055) / 1.055, 2.4) : b2 / 12.92;
      var x2 = r3 * 0.4124 + g2 * 0.3576 + b2 * 0.1805;
      var y2 = r3 * 0.2126 + g2 * 0.7152 + b2 * 0.0722;
      var z2 = r3 * 0.0193 + g2 * 0.1192 + b2 * 0.9505;
      return [x2 * 100, y2 * 100, z2 * 100];
    };
    convert.rgb.lab = function(rgb) {
      var xyz = convert.rgb.xyz(rgb);
      var x2 = xyz[0];
      var y2 = xyz[1];
      var z2 = xyz[2];
      var l2;
      var a;
      var b2;
      x2 /= 95.047;
      y2 /= 100;
      z2 /= 108.883;
      x2 = x2 > 8856e-6 ? Math.pow(x2, 1 / 3) : 7.787 * x2 + 16 / 116;
      y2 = y2 > 8856e-6 ? Math.pow(y2, 1 / 3) : 7.787 * y2 + 16 / 116;
      z2 = z2 > 8856e-6 ? Math.pow(z2, 1 / 3) : 7.787 * z2 + 16 / 116;
      l2 = 116 * y2 - 16;
      a = 500 * (x2 - y2);
      b2 = 200 * (y2 - z2);
      return [l2, a, b2];
    };
    convert.hsl.rgb = function(hsl) {
      var h2 = hsl[0] / 360;
      var s = hsl[1] / 100;
      var l2 = hsl[2] / 100;
      var t1;
      var t22;
      var t3;
      var rgb;
      var val;
      if (s === 0) {
        val = l2 * 255;
        return [val, val, val];
      }
      if (l2 < 0.5) {
        t22 = l2 * (1 + s);
      } else {
        t22 = l2 + s - l2 * s;
      }
      t1 = 2 * l2 - t22;
      rgb = [0, 0, 0];
      for (var i = 0; i < 3; i++) {
        t3 = h2 + 1 / 3 * -(i - 1);
        if (t3 < 0) {
          t3++;
        }
        if (t3 > 1) {
          t3--;
        }
        if (6 * t3 < 1) {
          val = t1 + (t22 - t1) * 6 * t3;
        } else if (2 * t3 < 1) {
          val = t22;
        } else if (3 * t3 < 2) {
          val = t1 + (t22 - t1) * (2 / 3 - t3) * 6;
        } else {
          val = t1;
        }
        rgb[i] = val * 255;
      }
      return rgb;
    };
    convert.hsl.hsv = function(hsl) {
      var h2 = hsl[0];
      var s = hsl[1] / 100;
      var l2 = hsl[2] / 100;
      var smin = s;
      var lmin = Math.max(l2, 0.01);
      var sv;
      var v2;
      l2 *= 2;
      s *= l2 <= 1 ? l2 : 2 - l2;
      smin *= lmin <= 1 ? lmin : 2 - lmin;
      v2 = (l2 + s) / 2;
      sv = l2 === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l2 + s);
      return [h2, sv * 100, v2 * 100];
    };
    convert.hsv.rgb = function(hsv) {
      var h2 = hsv[0] / 60;
      var s = hsv[1] / 100;
      var v2 = hsv[2] / 100;
      var hi = Math.floor(h2) % 6;
      var f = h2 - Math.floor(h2);
      var p2 = 255 * v2 * (1 - s);
      var q2 = 255 * v2 * (1 - s * f);
      var t3 = 255 * v2 * (1 - s * (1 - f));
      v2 *= 255;
      switch (hi) {
        case 0:
          return [v2, t3, p2];
        case 1:
          return [q2, v2, p2];
        case 2:
          return [p2, v2, t3];
        case 3:
          return [p2, q2, v2];
        case 4:
          return [t3, p2, v2];
        case 5:
          return [v2, p2, q2];
      }
    };
    convert.hsv.hsl = function(hsv) {
      var h2 = hsv[0];
      var s = hsv[1] / 100;
      var v2 = hsv[2] / 100;
      var vmin = Math.max(v2, 0.01);
      var lmin;
      var sl2;
      var l2;
      l2 = (2 - s) * v2;
      lmin = (2 - s) * vmin;
      sl2 = s * vmin;
      sl2 /= lmin <= 1 ? lmin : 2 - lmin;
      sl2 = sl2 || 0;
      l2 /= 2;
      return [h2, sl2 * 100, l2 * 100];
    };
    convert.hwb.rgb = function(hwb) {
      var h2 = hwb[0] / 360;
      var wh = hwb[1] / 100;
      var bl = hwb[2] / 100;
      var ratio = wh + bl;
      var i;
      var v2;
      var f;
      var n2;
      if (ratio > 1) {
        wh /= ratio;
        bl /= ratio;
      }
      i = Math.floor(6 * h2);
      v2 = 1 - bl;
      f = 6 * h2 - i;
      if ((i & 1) !== 0) {
        f = 1 - f;
      }
      n2 = wh + f * (v2 - wh);
      var r3;
      var g2;
      var b2;
      switch (i) {
        default:
        case 6:
        case 0:
          r3 = v2;
          g2 = n2;
          b2 = wh;
          break;
        case 1:
          r3 = n2;
          g2 = v2;
          b2 = wh;
          break;
        case 2:
          r3 = wh;
          g2 = v2;
          b2 = n2;
          break;
        case 3:
          r3 = wh;
          g2 = n2;
          b2 = v2;
          break;
        case 4:
          r3 = n2;
          g2 = wh;
          b2 = v2;
          break;
        case 5:
          r3 = v2;
          g2 = wh;
          b2 = n2;
          break;
      }
      return [r3 * 255, g2 * 255, b2 * 255];
    };
    convert.cmyk.rgb = function(cmyk) {
      var c2 = cmyk[0] / 100;
      var m2 = cmyk[1] / 100;
      var y2 = cmyk[2] / 100;
      var k2 = cmyk[3] / 100;
      var r3;
      var g2;
      var b2;
      r3 = 1 - Math.min(1, c2 * (1 - k2) + k2);
      g2 = 1 - Math.min(1, m2 * (1 - k2) + k2);
      b2 = 1 - Math.min(1, y2 * (1 - k2) + k2);
      return [r3 * 255, g2 * 255, b2 * 255];
    };
    convert.xyz.rgb = function(xyz) {
      var x2 = xyz[0] / 100;
      var y2 = xyz[1] / 100;
      var z2 = xyz[2] / 100;
      var r3;
      var g2;
      var b2;
      r3 = x2 * 3.2406 + y2 * -1.5372 + z2 * -0.4986;
      g2 = x2 * -0.9689 + y2 * 1.8758 + z2 * 0.0415;
      b2 = x2 * 0.0557 + y2 * -0.204 + z2 * 1.057;
      r3 = r3 > 31308e-7 ? 1.055 * Math.pow(r3, 1 / 2.4) - 0.055 : r3 * 12.92;
      g2 = g2 > 31308e-7 ? 1.055 * Math.pow(g2, 1 / 2.4) - 0.055 : g2 * 12.92;
      b2 = b2 > 31308e-7 ? 1.055 * Math.pow(b2, 1 / 2.4) - 0.055 : b2 * 12.92;
      r3 = Math.min(Math.max(0, r3), 1);
      g2 = Math.min(Math.max(0, g2), 1);
      b2 = Math.min(Math.max(0, b2), 1);
      return [r3 * 255, g2 * 255, b2 * 255];
    };
    convert.xyz.lab = function(xyz) {
      var x2 = xyz[0];
      var y2 = xyz[1];
      var z2 = xyz[2];
      var l2;
      var a;
      var b2;
      x2 /= 95.047;
      y2 /= 100;
      z2 /= 108.883;
      x2 = x2 > 8856e-6 ? Math.pow(x2, 1 / 3) : 7.787 * x2 + 16 / 116;
      y2 = y2 > 8856e-6 ? Math.pow(y2, 1 / 3) : 7.787 * y2 + 16 / 116;
      z2 = z2 > 8856e-6 ? Math.pow(z2, 1 / 3) : 7.787 * z2 + 16 / 116;
      l2 = 116 * y2 - 16;
      a = 500 * (x2 - y2);
      b2 = 200 * (y2 - z2);
      return [l2, a, b2];
    };
    convert.lab.xyz = function(lab) {
      var l2 = lab[0];
      var a = lab[1];
      var b2 = lab[2];
      var x2;
      var y2;
      var z2;
      y2 = (l2 + 16) / 116;
      x2 = a / 500 + y2;
      z2 = y2 - b2 / 200;
      var y22 = Math.pow(y2, 3);
      var x22 = Math.pow(x2, 3);
      var z22 = Math.pow(z2, 3);
      y2 = y22 > 8856e-6 ? y22 : (y2 - 16 / 116) / 7.787;
      x2 = x22 > 8856e-6 ? x22 : (x2 - 16 / 116) / 7.787;
      z2 = z22 > 8856e-6 ? z22 : (z2 - 16 / 116) / 7.787;
      x2 *= 95.047;
      y2 *= 100;
      z2 *= 108.883;
      return [x2, y2, z2];
    };
    convert.lab.lch = function(lab) {
      var l2 = lab[0];
      var a = lab[1];
      var b2 = lab[2];
      var hr;
      var h2;
      var c2;
      hr = Math.atan2(b2, a);
      h2 = hr * 360 / 2 / Math.PI;
      if (h2 < 0) {
        h2 += 360;
      }
      c2 = Math.sqrt(a * a + b2 * b2);
      return [l2, c2, h2];
    };
    convert.lch.lab = function(lch) {
      var l2 = lch[0];
      var c2 = lch[1];
      var h2 = lch[2];
      var a;
      var b2;
      var hr;
      hr = h2 / 360 * 2 * Math.PI;
      a = c2 * Math.cos(hr);
      b2 = c2 * Math.sin(hr);
      return [l2, a, b2];
    };
    convert.rgb.ansi16 = function(args) {
      var r3 = args[0];
      var g2 = args[1];
      var b2 = args[2];
      var value = 1 in arguments ? arguments[1] : convert.rgb.hsv(args)[2];
      value = Math.round(value / 50);
      if (value === 0) {
        return 30;
      }
      var ansi2 = 30 + (Math.round(b2 / 255) << 2 | Math.round(g2 / 255) << 1 | Math.round(r3 / 255));
      if (value === 2) {
        ansi2 += 60;
      }
      return ansi2;
    };
    convert.hsv.ansi16 = function(args) {
      return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
    };
    convert.rgb.ansi256 = function(args) {
      var r3 = args[0];
      var g2 = args[1];
      var b2 = args[2];
      if (r3 === g2 && g2 === b2) {
        if (r3 < 8) {
          return 16;
        }
        if (r3 > 248) {
          return 231;
        }
        return Math.round((r3 - 8) / 247 * 24) + 232;
      }
      var ansi2 = 16 + 36 * Math.round(r3 / 255 * 5) + 6 * Math.round(g2 / 255 * 5) + Math.round(b2 / 255 * 5);
      return ansi2;
    };
    convert.ansi16.rgb = function(args) {
      var color = args % 10;
      if (color === 0 || color === 7) {
        if (args > 50) {
          color += 3.5;
        }
        color = color / 10.5 * 255;
        return [color, color, color];
      }
      var mult = (~~(args > 50) + 1) * 0.5;
      var r3 = (color & 1) * mult * 255;
      var g2 = (color >> 1 & 1) * mult * 255;
      var b2 = (color >> 2 & 1) * mult * 255;
      return [r3, g2, b2];
    };
    convert.ansi256.rgb = function(args) {
      if (args >= 232) {
        var c2 = (args - 232) * 10 + 8;
        return [c2, c2, c2];
      }
      args -= 16;
      var rem;
      var r3 = Math.floor(args / 36) / 5 * 255;
      var g2 = Math.floor((rem = args % 36) / 6) / 5 * 255;
      var b2 = rem % 6 / 5 * 255;
      return [r3, g2, b2];
    };
    convert.rgb.hex = function(args) {
      var integer = ((Math.round(args[0]) & 255) << 16) + ((Math.round(args[1]) & 255) << 8) + (Math.round(args[2]) & 255);
      var string = integer.toString(16).toUpperCase();
      return "000000".substring(string.length) + string;
    };
    convert.hex.rgb = function(args) {
      var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
      if (!match) {
        return [0, 0, 0];
      }
      var colorString = match[0];
      if (match[0].length === 3) {
        colorString = colorString.split("").map(function(char) {
          return char + char;
        }).join("");
      }
      var integer = parseInt(colorString, 16);
      var r3 = integer >> 16 & 255;
      var g2 = integer >> 8 & 255;
      var b2 = integer & 255;
      return [r3, g2, b2];
    };
    convert.rgb.hcg = function(rgb) {
      var r3 = rgb[0] / 255;
      var g2 = rgb[1] / 255;
      var b2 = rgb[2] / 255;
      var max = Math.max(Math.max(r3, g2), b2);
      var min = Math.min(Math.min(r3, g2), b2);
      var chroma = max - min;
      var grayscale;
      var hue;
      if (chroma < 1) {
        grayscale = min / (1 - chroma);
      } else {
        grayscale = 0;
      }
      if (chroma <= 0) {
        hue = 0;
      } else if (max === r3) {
        hue = (g2 - b2) / chroma % 6;
      } else if (max === g2) {
        hue = 2 + (b2 - r3) / chroma;
      } else {
        hue = 4 + (r3 - g2) / chroma + 4;
      }
      hue /= 6;
      hue %= 1;
      return [hue * 360, chroma * 100, grayscale * 100];
    };
    convert.hsl.hcg = function(hsl) {
      var s = hsl[1] / 100;
      var l2 = hsl[2] / 100;
      var c2 = 1;
      var f = 0;
      if (l2 < 0.5) {
        c2 = 2 * s * l2;
      } else {
        c2 = 2 * s * (1 - l2);
      }
      if (c2 < 1) {
        f = (l2 - 0.5 * c2) / (1 - c2);
      }
      return [hsl[0], c2 * 100, f * 100];
    };
    convert.hsv.hcg = function(hsv) {
      var s = hsv[1] / 100;
      var v2 = hsv[2] / 100;
      var c2 = s * v2;
      var f = 0;
      if (c2 < 1) {
        f = (v2 - c2) / (1 - c2);
      }
      return [hsv[0], c2 * 100, f * 100];
    };
    convert.hcg.rgb = function(hcg) {
      var h2 = hcg[0] / 360;
      var c2 = hcg[1] / 100;
      var g2 = hcg[2] / 100;
      if (c2 === 0) {
        return [g2 * 255, g2 * 255, g2 * 255];
      }
      var pure = [0, 0, 0];
      var hi = h2 % 1 * 6;
      var v2 = hi % 1;
      var w2 = 1 - v2;
      var mg = 0;
      switch (Math.floor(hi)) {
        case 0:
          pure[0] = 1;
          pure[1] = v2;
          pure[2] = 0;
          break;
        case 1:
          pure[0] = w2;
          pure[1] = 1;
          pure[2] = 0;
          break;
        case 2:
          pure[0] = 0;
          pure[1] = 1;
          pure[2] = v2;
          break;
        case 3:
          pure[0] = 0;
          pure[1] = w2;
          pure[2] = 1;
          break;
        case 4:
          pure[0] = v2;
          pure[1] = 0;
          pure[2] = 1;
          break;
        default:
          pure[0] = 1;
          pure[1] = 0;
          pure[2] = w2;
      }
      mg = (1 - c2) * g2;
      return [
        (c2 * pure[0] + mg) * 255,
        (c2 * pure[1] + mg) * 255,
        (c2 * pure[2] + mg) * 255
      ];
    };
    convert.hcg.hsv = function(hcg) {
      var c2 = hcg[1] / 100;
      var g2 = hcg[2] / 100;
      var v2 = c2 + g2 * (1 - c2);
      var f = 0;
      if (v2 > 0) {
        f = c2 / v2;
      }
      return [hcg[0], f * 100, v2 * 100];
    };
    convert.hcg.hsl = function(hcg) {
      var c2 = hcg[1] / 100;
      var g2 = hcg[2] / 100;
      var l2 = g2 * (1 - c2) + 0.5 * c2;
      var s = 0;
      if (l2 > 0 && l2 < 0.5) {
        s = c2 / (2 * l2);
      } else if (l2 >= 0.5 && l2 < 1) {
        s = c2 / (2 * (1 - l2));
      }
      return [hcg[0], s * 100, l2 * 100];
    };
    convert.hcg.hwb = function(hcg) {
      var c2 = hcg[1] / 100;
      var g2 = hcg[2] / 100;
      var v2 = c2 + g2 * (1 - c2);
      return [hcg[0], (v2 - c2) * 100, (1 - v2) * 100];
    };
    convert.hwb.hcg = function(hwb) {
      var w2 = hwb[1] / 100;
      var b2 = hwb[2] / 100;
      var v2 = 1 - b2;
      var c2 = v2 - w2;
      var g2 = 0;
      if (c2 < 1) {
        g2 = (v2 - c2) / (1 - c2);
      }
      return [hwb[0], c2 * 100, g2 * 100];
    };
    convert.apple.rgb = function(apple) {
      return [apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255];
    };
    convert.rgb.apple = function(rgb) {
      return [rgb[0] / 255 * 65535, rgb[1] / 255 * 65535, rgb[2] / 255 * 65535];
    };
    convert.gray.rgb = function(args) {
      return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
    };
    convert.gray.hsl = convert.gray.hsv = function(args) {
      return [0, 0, args[0]];
    };
    convert.gray.hwb = function(gray2) {
      return [0, 100, gray2[0]];
    };
    convert.gray.cmyk = function(gray2) {
      return [0, 0, 0, gray2[0]];
    };
    convert.gray.lab = function(gray2) {
      return [gray2[0], 0, 0];
    };
    convert.gray.hex = function(gray2) {
      var val = Math.round(gray2[0] / 100 * 255) & 255;
      var integer = (val << 16) + (val << 8) + val;
      var string = integer.toString(16).toUpperCase();
      return "000000".substring(string.length) + string;
    };
    convert.rgb.gray = function(rgb) {
      var val = (rgb[0] + rgb[1] + rgb[2]) / 3;
      return [val / 255 * 100];
    };
  }
});

// ../../node_modules/.pnpm/color-convert@1.9.3/node_modules/color-convert/route.js
var require_route2 = __commonJS({
  "../../node_modules/.pnpm/color-convert@1.9.3/node_modules/color-convert/route.js"(exports2, module3) {
    init_import_meta_url();
    var conversions = require_conversions2();
    function buildGraph() {
      var graph = {};
      var models = Object.keys(conversions);
      for (var len = models.length, i = 0; i < len; i++) {
        graph[models[i]] = {
          // http://jsperf.com/1-vs-infinity
          // micro-opt, but this is simple.
          distance: -1,
          parent: null
        };
      }
      return graph;
    }
    __name(buildGraph, "buildGraph");
    function deriveBFS(fromModel) {
      var graph = buildGraph();
      var queue = [fromModel];
      graph[fromModel].distance = 0;
      while (queue.length) {
        var current = queue.pop();
        var adjacents = Object.keys(conversions[current]);
        for (var len = adjacents.length, i = 0; i < len; i++) {
          var adjacent = adjacents[i];
          var node2 = graph[adjacent];
          if (node2.distance === -1) {
            node2.distance = graph[current].distance + 1;
            node2.parent = current;
            queue.unshift(adjacent);
          }
        }
      }
      return graph;
    }
    __name(deriveBFS, "deriveBFS");
    function link(from, to) {
      return function(args) {
        return to(from(args));
      };
    }
    __name(link, "link");
    function wrapConversion(toModel, graph) {
      var path67 = [graph[toModel].parent, toModel];
      var fn2 = conversions[graph[toModel].parent][toModel];
      var cur = graph[toModel].parent;
      while (graph[cur].parent) {
        path67.unshift(graph[cur].parent);
        fn2 = link(conversions[graph[cur].parent][cur], fn2);
        cur = graph[cur].parent;
      }
      fn2.conversion = path67;
      return fn2;
    }
    __name(wrapConversion, "wrapConversion");
    module3.exports = function(fromModel) {
      var graph = deriveBFS(fromModel);
      var conversion = {};
      var models = Object.keys(graph);
      for (var len = models.length, i = 0; i < len; i++) {
        var toModel = models[i];
        var node2 = graph[toModel];
        if (node2.parent === null) {
          continue;
        }
        conversion[toModel] = wrapConversion(toModel, graph);
      }
      return conversion;
    };
  }
});

// ../../node_modules/.pnpm/color-convert@1.9.3/node_modules/color-convert/index.js
var require_color_convert2 = __commonJS({
  "../../node_modules/.pnpm/color-convert@1.9.3/node_modules/color-convert/index.js"(exports2, module3) {
    init_import_meta_url();
    var conversions = require_conversions2();
    var route2 = require_route2();
    var convert = {};
    var models = Object.keys(conversions);
    function wrapRaw(fn2) {
      var wrappedFn = /* @__PURE__ */ __name(function(args) {
        if (args === void 0 || args === null) {
          return args;
        }
        if (arguments.length > 1) {
          args = Array.prototype.slice.call(arguments);
        }
        return fn2(args);
      }, "wrappedFn");
      if ("conversion" in fn2) {
        wrappedFn.conversion = fn2.conversion;
      }
      return wrappedFn;
    }
    __name(wrapRaw, "wrapRaw");
    function wrapRounded(fn2) {
      var wrappedFn = /* @__PURE__ */ __name(function(args) {
        if (args === void 0 || args === null) {
          return args;
        }
        if (arguments.length > 1) {
          args = Array.prototype.slice.call(arguments);
        }
        var result = fn2(args);
        if (typeof result === "object") {
          for (var len = result.length, i = 0; i < len; i++) {
            result[i] = Math.round(result[i]);
          }
        }
        return result;
      }, "wrappedFn");
      if ("conversion" in fn2) {
        wrappedFn.conversion = fn2.conversion;
      }
      return wrappedFn;
    }
    __name(wrapRounded, "wrapRounded");
    models.forEach(function(fromModel) {
      convert[fromModel] = {};
      Object.defineProperty(convert[fromModel], "channels", { value: conversions[fromModel].channels });
      Object.defineProperty(convert[fromModel], "labels", { value: conversions[fromModel].labels });
      var routes = route2(fromModel);
      var routeModels = Object.keys(routes);
      routeModels.forEach(function(toModel) {
        var fn2 = routes[toModel];
        convert[fromModel][toModel] = wrapRounded(fn2);
        convert[fromModel][toModel].raw = wrapRaw(fn2);
      });
    });
    module3.exports = convert;
  }
});

// ../../node_modules/.pnpm/ansi-styles@3.2.1/node_modules/ansi-styles/index.js
var require_ansi_styles2 = __commonJS({
  "../../node_modules/.pnpm/ansi-styles@3.2.1/node_modules/ansi-styles/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var colorConvert = require_color_convert2();
    var wrapAnsi162 = /* @__PURE__ */ __name((fn2, offset) => function() {
      const code = fn2.apply(colorConvert, arguments);
      return `\x1B[${code + offset}m`;
    }, "wrapAnsi16");
    var wrapAnsi2562 = /* @__PURE__ */ __name((fn2, offset) => function() {
      const code = fn2.apply(colorConvert, arguments);
      return `\x1B[${38 + offset};5;${code}m`;
    }, "wrapAnsi256");
    var wrapAnsi16m2 = /* @__PURE__ */ __name((fn2, offset) => function() {
      const rgb = fn2.apply(colorConvert, arguments);
      return `\x1B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
    }, "wrapAnsi16m");
    function assembleStyles2() {
      const codes = /* @__PURE__ */ new Map();
      const styles2 = {
        modifier: {
          reset: [0, 0],
          // 21 isn't widely supported and 22 does the same thing
          bold: [1, 22],
          dim: [2, 22],
          italic: [3, 23],
          underline: [4, 24],
          inverse: [7, 27],
          hidden: [8, 28],
          strikethrough: [9, 29]
        },
        color: {
          black: [30, 39],
          red: [31, 39],
          green: [32, 39],
          yellow: [33, 39],
          blue: [34, 39],
          magenta: [35, 39],
          cyan: [36, 39],
          white: [37, 39],
          gray: [90, 39],
          // Bright color
          redBright: [91, 39],
          greenBright: [92, 39],
          yellowBright: [93, 39],
          blueBright: [94, 39],
          magentaBright: [95, 39],
          cyanBright: [96, 39],
          whiteBright: [97, 39]
        },
        bgColor: {
          bgBlack: [40, 49],
          bgRed: [41, 49],
          bgGreen: [42, 49],
          bgYellow: [43, 49],
          bgBlue: [44, 49],
          bgMagenta: [45, 49],
          bgCyan: [46, 49],
          bgWhite: [47, 49],
          // Bright color
          bgBlackBright: [100, 49],
          bgRedBright: [101, 49],
          bgGreenBright: [102, 49],
          bgYellowBright: [103, 49],
          bgBlueBright: [104, 49],
          bgMagentaBright: [105, 49],
          bgCyanBright: [106, 49],
          bgWhiteBright: [107, 49]
        }
      };
      styles2.color.grey = styles2.color.gray;
      for (const groupName of Object.keys(styles2)) {
        const group = styles2[groupName];
        for (const styleName of Object.keys(group)) {
          const style = group[styleName];
          styles2[styleName] = {
            open: `\x1B[${style[0]}m`,
            close: `\x1B[${style[1]}m`
          };
          group[styleName] = styles2[styleName];
          codes.set(style[0], style[1]);
        }
        Object.defineProperty(styles2, groupName, {
          value: group,
          enumerable: false
        });
        Object.defineProperty(styles2, "codes", {
          value: codes,
          enumerable: false
        });
      }
      const ansi2ansi = /* @__PURE__ */ __name((n2) => n2, "ansi2ansi");
      const rgb2rgb = /* @__PURE__ */ __name((r3, g2, b2) => [r3, g2, b2], "rgb2rgb");
      styles2.color.close = "\x1B[39m";
      styles2.bgColor.close = "\x1B[49m";
      styles2.color.ansi = {
        ansi: wrapAnsi162(ansi2ansi, 0)
      };
      styles2.color.ansi256 = {
        ansi256: wrapAnsi2562(ansi2ansi, 0)
      };
      styles2.color.ansi16m = {
        rgb: wrapAnsi16m2(rgb2rgb, 0)
      };
      styles2.bgColor.ansi = {
        ansi: wrapAnsi162(ansi2ansi, 10)
      };
      styles2.bgColor.ansi256 = {
        ansi256: wrapAnsi2562(ansi2ansi, 10)
      };
      styles2.bgColor.ansi16m = {
        rgb: wrapAnsi16m2(rgb2rgb, 10)
      };
      for (let key of Object.keys(colorConvert)) {
        if (typeof colorConvert[key] !== "object") {
          continue;
        }
        const suite = colorConvert[key];
        if (key === "ansi16") {
          key = "ansi";
        }
        if ("ansi16" in suite) {
          styles2.color.ansi[key] = wrapAnsi162(suite.ansi16, 0);
          styles2.bgColor.ansi[key] = wrapAnsi162(suite.ansi16, 10);
        }
        if ("ansi256" in suite) {
          styles2.color.ansi256[key] = wrapAnsi2562(suite.ansi256, 0);
          styles2.bgColor.ansi256[key] = wrapAnsi2562(suite.ansi256, 10);
        }
        if ("rgb" in suite) {
          styles2.color.ansi16m[key] = wrapAnsi16m2(suite.rgb, 0);
          styles2.bgColor.ansi16m[key] = wrapAnsi16m2(suite.rgb, 10);
        }
      }
      return styles2;
    }
    __name(assembleStyles2, "assembleStyles");
    Object.defineProperty(module3, "exports", {
      enumerable: true,
      get: assembleStyles2
    });
  }
});

// ../../node_modules/.pnpm/has-flag@3.0.0/node_modules/has-flag/index.js
var require_has_flag2 = __commonJS({
  "../../node_modules/.pnpm/has-flag@3.0.0/node_modules/has-flag/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.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/.pnpm/supports-color@5.5.0/node_modules/supports-color/index.js
var require_supports_color2 = __commonJS({
  "../../node_modules/.pnpm/supports-color@5.5.0/node_modules/supports-color/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var os11 = require("os");
    var hasFlag2 = require_has_flag2();
    var env5 = process.env;
    var forceColor;
    if (hasFlag2("no-color") || hasFlag2("no-colors") || hasFlag2("color=false")) {
      forceColor = false;
    } else if (hasFlag2("color") || hasFlag2("colors") || hasFlag2("color=true") || hasFlag2("color=always")) {
      forceColor = true;
    }
    if ("FORCE_COLOR" in env5) {
      forceColor = env5.FORCE_COLOR.length === 0 || parseInt(env5.FORCE_COLOR, 10) !== 0;
    }
    function translateLevel2(level) {
      if (level === 0) {
        return false;
      }
      return {
        level,
        hasBasic: true,
        has256: level >= 2,
        has16m: level >= 3
      };
    }
    __name(translateLevel2, "translateLevel");
    function supportsColor2(stream2) {
      if (forceColor === false) {
        return 0;
      }
      if (hasFlag2("color=16m") || hasFlag2("color=full") || hasFlag2("color=truecolor")) {
        return 3;
      }
      if (hasFlag2("color=256")) {
        return 2;
      }
      if (stream2 && !stream2.isTTY && forceColor !== true) {
        return 0;
      }
      const min = forceColor ? 1 : 0;
      if (process.platform === "win32") {
        const osRelease = os11.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 env5) {
        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI"].some((sign) => sign in env5) || env5.CI_NAME === "codeship") {
          return 1;
        }
        return min;
      }
      if ("TEAMCITY_VERSION" in env5) {
        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env5.TEAMCITY_VERSION) ? 1 : 0;
      }
      if (env5.COLORTERM === "truecolor") {
        return 3;
      }
      if ("TERM_PROGRAM" in env5) {
        const version3 = parseInt((env5.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
        switch (env5.TERM_PROGRAM) {
          case "iTerm.app":
            return version3 >= 3 ? 3 : 2;
          case "Apple_Terminal":
            return 2;
        }
      }
      if (/-256(color)?$/i.test(env5.TERM)) {
        return 2;
      }
      if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env5.TERM)) {
        return 1;
      }
      if ("COLORTERM" in env5) {
        return 1;
      }
      if (env5.TERM === "dumb") {
        return min;
      }
      return min;
    }
    __name(supportsColor2, "supportsColor");
    function getSupportLevel(stream2) {
      const level = supportsColor2(stream2);
      return translateLevel2(level);
    }
    __name(getSupportLevel, "getSupportLevel");
    module3.exports = {
      supportsColor: getSupportLevel,
      stdout: getSupportLevel(process.stdout),
      stderr: getSupportLevel(process.stderr)
    };
  }
});

// ../../node_modules/.pnpm/chalk@2.4.2/node_modules/chalk/templates.js
var require_templates2 = __commonJS({
  "../../node_modules/.pnpm/chalk@2.4.2/node_modules/chalk/templates.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var TEMPLATE_REGEX2 = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
    var STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
    var STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
    var ESCAPE_REGEX = /\\(u[a-f\d]{4}|x[a-f\d]{2}|.)|([^\\])/gi;
    var ESCAPES3 = /* @__PURE__ */ new Map([
      ["n", "\n"],
      ["r", "\r"],
      ["t", "	"],
      ["b", "\b"],
      ["f", "\f"],
      ["v", "\v"],
      ["0", "\0"],
      ["\\", "\\"],
      ["e", "\x1B"],
      ["a", "\x07"]
    ]);
    function unescape2(c2) {
      if (c2[0] === "u" && c2.length === 5 || c2[0] === "x" && c2.length === 3) {
        return String.fromCharCode(parseInt(c2.slice(1), 16));
      }
      return ESCAPES3.get(c2) || c2;
    }
    __name(unescape2, "unescape");
    function parseArguments(name, args) {
      const results = [];
      const chunks = args.trim().split(/\s*,\s*/g);
      let matches;
      for (const chunk of chunks) {
        if (!isNaN(chunk)) {
          results.push(Number(chunk));
        } else if (matches = chunk.match(STRING_REGEX)) {
          results.push(matches[2].replace(ESCAPE_REGEX, (m2, escape2, chr) => escape2 ? unescape2(escape2) : chr));
        } else {
          throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
        }
      }
      return results;
    }
    __name(parseArguments, "parseArguments");
    function parseStyle(style) {
      STYLE_REGEX.lastIndex = 0;
      const results = [];
      let matches;
      while ((matches = STYLE_REGEX.exec(style)) !== null) {
        const name = matches[1];
        if (matches[2]) {
          const args = parseArguments(name, matches[2]);
          results.push([name].concat(args));
        } else {
          results.push([name]);
        }
      }
      return results;
    }
    __name(parseStyle, "parseStyle");
    function buildStyle(chalk21, styles2) {
      const enabled = {};
      for (const layer of styles2) {
        for (const style of layer.styles) {
          enabled[style[0]] = layer.inverse ? null : style.slice(1);
        }
      }
      let current = chalk21;
      for (const styleName of Object.keys(enabled)) {
        if (Array.isArray(enabled[styleName])) {
          if (!(styleName in current)) {
            throw new Error(`Unknown Chalk style: ${styleName}`);
          }
          if (enabled[styleName].length > 0) {
            current = current[styleName].apply(current, enabled[styleName]);
          } else {
            current = current[styleName];
          }
        }
      }
      return current;
    }
    __name(buildStyle, "buildStyle");
    module3.exports = (chalk21, tmp) => {
      const styles2 = [];
      const chunks = [];
      let chunk = [];
      tmp.replace(TEMPLATE_REGEX2, (m2, escapeChar, inverse, style, close2, chr) => {
        if (escapeChar) {
          chunk.push(unescape2(escapeChar));
        } else if (style) {
          const str = chunk.join("");
          chunk = [];
          chunks.push(styles2.length === 0 ? str : buildStyle(chalk21, styles2)(str));
          styles2.push({ inverse, styles: parseStyle(style) });
        } else if (close2) {
          if (styles2.length === 0) {
            throw new Error("Found extraneous } in Chalk template literal");
          }
          chunks.push(buildStyle(chalk21, styles2)(chunk.join("")));
          chunk = [];
          styles2.pop();
        } else {
          chunk.push(chr);
        }
      });
      chunks.push(chunk.join(""));
      if (styles2.length > 0) {
        const errMsg = `Chalk template literal is missing ${styles2.length} closing bracket${styles2.length === 1 ? "" : "s"} (\`}\`)`;
        throw new Error(errMsg);
      }
      return chunks.join("");
    };
  }
});

// ../../node_modules/.pnpm/chalk@2.4.2/node_modules/chalk/index.js
var require_chalk = __commonJS({
  "../../node_modules/.pnpm/chalk@2.4.2/node_modules/chalk/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var escapeStringRegexp = require_escape_string_regexp2();
    var ansiStyles2 = require_ansi_styles2();
    var stdoutColor = require_supports_color2().stdout;
    var template = require_templates2();
    var isSimpleWindowsTerm = process.platform === "win32" && !(process.env.TERM || "").toLowerCase().startsWith("xterm");
    var levelMapping = ["ansi", "ansi", "ansi256", "ansi16m"];
    var skipModels = /* @__PURE__ */ new Set(["gray"]);
    var styles2 = /* @__PURE__ */ Object.create(null);
    function applyOptions(obj, options29) {
      options29 = options29 || {};
      const scLevel = stdoutColor ? stdoutColor.level : 0;
      obj.level = options29.level === void 0 ? scLevel : options29.level;
      obj.enabled = "enabled" in options29 ? options29.enabled : obj.level > 0;
    }
    __name(applyOptions, "applyOptions");
    function Chalk(options29) {
      if (!this || !(this instanceof Chalk) || this.template) {
        const chalk21 = {};
        applyOptions(chalk21, options29);
        chalk21.template = function() {
          const args = [].slice.call(arguments);
          return chalkTag.apply(null, [chalk21.template].concat(args));
        };
        Object.setPrototypeOf(chalk21, Chalk.prototype);
        Object.setPrototypeOf(chalk21.template, chalk21);
        chalk21.template.constructor = Chalk;
        return chalk21.template;
      }
      applyOptions(this, options29);
    }
    __name(Chalk, "Chalk");
    if (isSimpleWindowsTerm) {
      ansiStyles2.blue.open = "\x1B[94m";
    }
    for (const key of Object.keys(ansiStyles2)) {
      ansiStyles2[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles2[key].close), "g");
      styles2[key] = {
        get() {
          const codes = ansiStyles2[key];
          return build5.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, key);
        }
      };
    }
    styles2.visible = {
      get() {
        return build5.call(this, this._styles || [], true, "visible");
      }
    };
    ansiStyles2.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles2.color.close), "g");
    for (const model of Object.keys(ansiStyles2.color.ansi)) {
      if (skipModels.has(model)) {
        continue;
      }
      styles2[model] = {
        get() {
          const level = this.level;
          return function() {
            const open3 = ansiStyles2.color[levelMapping[level]][model].apply(null, arguments);
            const codes = {
              open: open3,
              close: ansiStyles2.color.close,
              closeRe: ansiStyles2.color.closeRe
            };
            return build5.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
          };
        }
      };
    }
    ansiStyles2.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles2.bgColor.close), "g");
    for (const model of Object.keys(ansiStyles2.bgColor.ansi)) {
      if (skipModels.has(model)) {
        continue;
      }
      const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
      styles2[bgModel] = {
        get() {
          const level = this.level;
          return function() {
            const open3 = ansiStyles2.bgColor[levelMapping[level]][model].apply(null, arguments);
            const codes = {
              open: open3,
              close: ansiStyles2.bgColor.close,
              closeRe: ansiStyles2.bgColor.closeRe
            };
            return build5.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
          };
        }
      };
    }
    var proto = Object.defineProperties(() => {
    }, styles2);
    function build5(_styles, _empty, key) {
      const builder = /* @__PURE__ */ __name(function() {
        return applyStyle.apply(builder, arguments);
      }, "builder");
      builder._styles = _styles;
      builder._empty = _empty;
      const self2 = this;
      Object.defineProperty(builder, "level", {
        enumerable: true,
        get() {
          return self2.level;
        },
        set(level) {
          self2.level = level;
        }
      });
      Object.defineProperty(builder, "enabled", {
        enumerable: true,
        get() {
          return self2.enabled;
        },
        set(enabled) {
          self2.enabled = enabled;
        }
      });
      builder.hasGrey = this.hasGrey || key === "gray" || key === "grey";
      builder.__proto__ = proto;
      return builder;
    }
    __name(build5, "build");
    function applyStyle() {
      const args = arguments;
      const argsLen = args.length;
      let str = String(arguments[0]);
      if (argsLen === 0) {
        return "";
      }
      if (argsLen > 1) {
        for (let a = 1; a < argsLen; a++) {
          str += " " + args[a];
        }
      }
      if (!this.enabled || this.level <= 0 || !str) {
        return this._empty ? "" : str;
      }
      const originalDim = ansiStyles2.dim.open;
      if (isSimpleWindowsTerm && this.hasGrey) {
        ansiStyles2.dim.open = "";
      }
      for (const code of this._styles.slice().reverse()) {
        str = code.open + str.replace(code.closeRe, code.open) + code.close;
        str = str.replace(/\r?\n/g, `${code.close}$&${code.open}`);
      }
      ansiStyles2.dim.open = originalDim;
      return str;
    }
    __name(applyStyle, "applyStyle");
    function chalkTag(chalk21, strings) {
      if (!Array.isArray(strings)) {
        return [].slice.call(arguments, 1).join(" ");
      }
      const args = [].slice.call(arguments, 2);
      const parts = [strings.raw[0]];
      for (let i = 1; i < strings.length; i++) {
        parts.push(String(args[i - 1]).replace(/[{}\\]/g, "\\$&"));
        parts.push(String(strings.raw[i]));
      }
      return template(chalk21, parts.join(""));
    }
    __name(chalkTag, "chalkTag");
    Object.defineProperties(Chalk.prototype, styles2);
    module3.exports = Chalk();
    module3.exports.supportsColor = stdoutColor;
    module3.exports.default = module3.exports;
  }
});

// ../../node_modules/.pnpm/cli-table3@0.6.3/node_modules/cli-table3/src/debug.js
var require_debug = __commonJS({
  "../../node_modules/.pnpm/cli-table3@0.6.3/node_modules/cli-table3/src/debug.js"(exports2, module3) {
    init_import_meta_url();
    var messages = [];
    var level = 0;
    var debug = /* @__PURE__ */ __name((msg, min) => {
      if (level >= min) {
        messages.push(msg);
      }
    }, "debug");
    debug.WARN = 1;
    debug.INFO = 2;
    debug.DEBUG = 3;
    debug.reset = () => {
      messages = [];
    };
    debug.setDebugLevel = (v2) => {
      level = v2;
    };
    debug.warn = (msg) => debug(msg, debug.WARN);
    debug.info = (msg) => debug(msg, debug.INFO);
    debug.debug = (msg) => debug(msg, debug.DEBUG);
    debug.debugMessages = () => messages;
    module3.exports = debug;
  }
});

// ../../node_modules/.pnpm/cli-table3@0.6.3/node_modules/cli-table3/src/utils.js
var require_utils2 = __commonJS({
  "../../node_modules/.pnpm/cli-table3@0.6.3/node_modules/cli-table3/src/utils.js"(exports2, module3) {
    init_import_meta_url();
    var stringWidth2 = require_string_width();
    function codeRegex(capture) {
      return capture ? /\u001b\[((?:\d*;){0,5}\d*)m/g : /\u001b\[(?:\d*;){0,5}\d*m/g;
    }
    __name(codeRegex, "codeRegex");
    function strlen(str) {
      let code = codeRegex();
      let stripped = ("" + str).replace(code, "");
      let split = stripped.split("\n");
      return split.reduce(function(memo, s) {
        return stringWidth2(s) > memo ? stringWidth2(s) : memo;
      }, 0);
    }
    __name(strlen, "strlen");
    function repeat(str, times) {
      return Array(times + 1).join(str);
    }
    __name(repeat, "repeat");
    function pad2(str, len, pad3, dir) {
      let length = strlen(str);
      if (len + 1 >= length) {
        let padlen = len - length;
        switch (dir) {
          case "right": {
            str = repeat(pad3, padlen) + str;
            break;
          }
          case "center": {
            let right2 = Math.ceil(padlen / 2);
            let left2 = padlen - right2;
            str = repeat(pad3, left2) + str + repeat(pad3, right2);
            break;
          }
          default: {
            str = str + repeat(pad3, padlen);
            break;
          }
        }
      }
      return str;
    }
    __name(pad2, "pad");
    var codeCache = {};
    function addToCodeCache(name, on, off) {
      on = "\x1B[" + on + "m";
      off = "\x1B[" + off + "m";
      codeCache[on] = { set: name, to: true };
      codeCache[off] = { set: name, to: false };
      codeCache[name] = { on, off };
    }
    __name(addToCodeCache, "addToCodeCache");
    addToCodeCache("bold", 1, 22);
    addToCodeCache("italics", 3, 23);
    addToCodeCache("underline", 4, 24);
    addToCodeCache("inverse", 7, 27);
    addToCodeCache("strikethrough", 9, 29);
    function updateState(state, controlChars) {
      let controlCode = controlChars[1] ? parseInt(controlChars[1].split(";")[0]) : 0;
      if (controlCode >= 30 && controlCode <= 39 || controlCode >= 90 && controlCode <= 97) {
        state.lastForegroundAdded = controlChars[0];
        return;
      }
      if (controlCode >= 40 && controlCode <= 49 || controlCode >= 100 && controlCode <= 107) {
        state.lastBackgroundAdded = controlChars[0];
        return;
      }
      if (controlCode === 0) {
        for (let i in state) {
          if (Object.prototype.hasOwnProperty.call(state, i)) {
            delete state[i];
          }
        }
        return;
      }
      let info = codeCache[controlChars[0]];
      if (info) {
        state[info.set] = info.to;
      }
    }
    __name(updateState, "updateState");
    function readState(line) {
      let code = codeRegex(true);
      let controlChars = code.exec(line);
      let state = {};
      while (controlChars !== null) {
        updateState(state, controlChars);
        controlChars = code.exec(line);
      }
      return state;
    }
    __name(readState, "readState");
    function unwindState(state, ret) {
      let lastBackgroundAdded = state.lastBackgroundAdded;
      let lastForegroundAdded = state.lastForegroundAdded;
      delete state.lastBackgroundAdded;
      delete state.lastForegroundAdded;
      Object.keys(state).forEach(function(key) {
        if (state[key]) {
          ret += codeCache[key].off;
        }
      });
      if (lastBackgroundAdded && lastBackgroundAdded != "\x1B[49m") {
        ret += "\x1B[49m";
      }
      if (lastForegroundAdded && lastForegroundAdded != "\x1B[39m") {
        ret += "\x1B[39m";
      }
      return ret;
    }
    __name(unwindState, "unwindState");
    function rewindState(state, ret) {
      let lastBackgroundAdded = state.lastBackgroundAdded;
      let lastForegroundAdded = state.lastForegroundAdded;
      delete state.lastBackgroundAdded;
      delete state.lastForegroundAdded;
      Object.keys(state).forEach(function(key) {
        if (state[key]) {
          ret = codeCache[key].on + ret;
        }
      });
      if (lastBackgroundAdded && lastBackgroundAdded != "\x1B[49m") {
        ret = lastBackgroundAdded + ret;
      }
      if (lastForegroundAdded && lastForegroundAdded != "\x1B[39m") {
        ret = lastForegroundAdded + ret;
      }
      return ret;
    }
    __name(rewindState, "rewindState");
    function truncateWidth(str, desiredLength) {
      if (str.length === strlen(str)) {
        return str.substr(0, desiredLength);
      }
      while (strlen(str) > desiredLength) {
        str = str.slice(0, -1);
      }
      return str;
    }
    __name(truncateWidth, "truncateWidth");
    function truncateWidthWithAnsi(str, desiredLength) {
      let code = codeRegex(true);
      let split = str.split(codeRegex());
      let splitIndex = 0;
      let retLen = 0;
      let ret = "";
      let myArray;
      let state = {};
      while (retLen < desiredLength) {
        myArray = code.exec(str);
        let toAdd = split[splitIndex];
        splitIndex++;
        if (retLen + strlen(toAdd) > desiredLength) {
          toAdd = truncateWidth(toAdd, desiredLength - retLen);
        }
        ret += toAdd;
        retLen += strlen(toAdd);
        if (retLen < desiredLength) {
          if (!myArray) {
            break;
          }
          ret += myArray[0];
          updateState(state, myArray);
        }
      }
      return unwindState(state, ret);
    }
    __name(truncateWidthWithAnsi, "truncateWidthWithAnsi");
    function truncate4(str, desiredLength, truncateChar) {
      truncateChar = truncateChar || "\u2026";
      let lengthOfStr = strlen(str);
      if (lengthOfStr <= desiredLength) {
        return str;
      }
      desiredLength -= strlen(truncateChar);
      let ret = truncateWidthWithAnsi(str, desiredLength);
      return ret + truncateChar;
    }
    __name(truncate4, "truncate");
    function defaultOptions() {
      return {
        chars: {
          top: "\u2500",
          "top-mid": "\u252C",
          "top-left": "\u250C",
          "top-right": "\u2510",
          bottom: "\u2500",
          "bottom-mid": "\u2534",
          "bottom-left": "\u2514",
          "bottom-right": "\u2518",
          left: "\u2502",
          "left-mid": "\u251C",
          mid: "\u2500",
          "mid-mid": "\u253C",
          right: "\u2502",
          "right-mid": "\u2524",
          middle: "\u2502"
        },
        truncate: "\u2026",
        colWidths: [],
        rowHeights: [],
        colAligns: [],
        rowAligns: [],
        style: {
          "padding-left": 1,
          "padding-right": 1,
          head: ["red"],
          border: ["grey"],
          compact: false
        },
        head: []
      };
    }
    __name(defaultOptions, "defaultOptions");
    function mergeOptions(options29, defaults) {
      options29 = options29 || {};
      defaults = defaults || defaultOptions();
      let ret = Object.assign({}, defaults, options29);
      ret.chars = Object.assign({}, defaults.chars, options29.chars);
      ret.style = Object.assign({}, defaults.style, options29.style);
      return ret;
    }
    __name(mergeOptions, "mergeOptions");
    function wordWrap(maxLength, input) {
      let lines = [];
      let split = input.split(/(\s+)/g);
      let line = [];
      let lineLength = 0;
      let whitespace;
      for (let i = 0; i < split.length; i += 2) {
        let word = split[i];
        let newLength = lineLength + strlen(word);
        if (lineLength > 0 && whitespace) {
          newLength += whitespace.length;
        }
        if (newLength > maxLength) {
          if (lineLength !== 0) {
            lines.push(line.join(""));
          }
          line = [word];
          lineLength = strlen(word);
        } else {
          line.push(whitespace || "", word);
          lineLength = newLength;
        }
        whitespace = split[i + 1];
      }
      if (lineLength) {
        lines.push(line.join(""));
      }
      return lines;
    }
    __name(wordWrap, "wordWrap");
    function textWrap(maxLength, input) {
      let lines = [];
      let line = "";
      function pushLine(str, ws) {
        if (line.length && ws)
          line += ws;
        line += str;
        while (line.length > maxLength) {
          lines.push(line.slice(0, maxLength));
          line = line.slice(maxLength);
        }
      }
      __name(pushLine, "pushLine");
      let split = input.split(/(\s+)/g);
      for (let i = 0; i < split.length; i += 2) {
        pushLine(split[i], i && split[i - 1]);
      }
      if (line.length)
        lines.push(line);
      return lines;
    }
    __name(textWrap, "textWrap");
    function multiLineWordWrap(maxLength, input, wrapOnWordBoundary = true) {
      let output = [];
      input = input.split("\n");
      const handler30 = wrapOnWordBoundary ? wordWrap : textWrap;
      for (let i = 0; i < input.length; i++) {
        output.push.apply(output, handler30(maxLength, input[i]));
      }
      return output;
    }
    __name(multiLineWordWrap, "multiLineWordWrap");
    function colorizeLines(input) {
      let state = {};
      let output = [];
      for (let i = 0; i < input.length; i++) {
        let line = rewindState(state, input[i]);
        state = readState(line);
        let temp = Object.assign({}, state);
        output.push(unwindState(temp, line));
      }
      return output;
    }
    __name(colorizeLines, "colorizeLines");
    function hyperlink(url4, text) {
      const OSC2 = "\x1B]";
      const BEL2 = "\x07";
      const SEP2 = ";";
      return [OSC2, "8", SEP2, SEP2, url4 || text, BEL2, text, OSC2, "8", SEP2, SEP2, BEL2].join("");
    }
    __name(hyperlink, "hyperlink");
    module3.exports = {
      strlen,
      repeat,
      pad: pad2,
      truncate: truncate4,
      mergeOptions,
      wordWrap: multiLineWordWrap,
      colorizeLines,
      hyperlink
    };
  }
});

// ../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/styles.js
var require_styles2 = __commonJS({
  "../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/styles.js"(exports2, module3) {
    init_import_meta_url();
    var styles2 = {};
    module3["exports"] = styles2;
    var codes = {
      reset: [0, 0],
      bold: [1, 22],
      dim: [2, 22],
      italic: [3, 23],
      underline: [4, 24],
      inverse: [7, 27],
      hidden: [8, 28],
      strikethrough: [9, 29],
      black: [30, 39],
      red: [31, 39],
      green: [32, 39],
      yellow: [33, 39],
      blue: [34, 39],
      magenta: [35, 39],
      cyan: [36, 39],
      white: [37, 39],
      gray: [90, 39],
      grey: [90, 39],
      brightRed: [91, 39],
      brightGreen: [92, 39],
      brightYellow: [93, 39],
      brightBlue: [94, 39],
      brightMagenta: [95, 39],
      brightCyan: [96, 39],
      brightWhite: [97, 39],
      bgBlack: [40, 49],
      bgRed: [41, 49],
      bgGreen: [42, 49],
      bgYellow: [43, 49],
      bgBlue: [44, 49],
      bgMagenta: [45, 49],
      bgCyan: [46, 49],
      bgWhite: [47, 49],
      bgGray: [100, 49],
      bgGrey: [100, 49],
      bgBrightRed: [101, 49],
      bgBrightGreen: [102, 49],
      bgBrightYellow: [103, 49],
      bgBrightBlue: [104, 49],
      bgBrightMagenta: [105, 49],
      bgBrightCyan: [106, 49],
      bgBrightWhite: [107, 49],
      // legacy styles for colors pre v1.0.0
      blackBG: [40, 49],
      redBG: [41, 49],
      greenBG: [42, 49],
      yellowBG: [43, 49],
      blueBG: [44, 49],
      magentaBG: [45, 49],
      cyanBG: [46, 49],
      whiteBG: [47, 49]
    };
    Object.keys(codes).forEach(function(key) {
      var val = codes[key];
      var style = styles2[key] = [];
      style.open = "\x1B[" + val[0] + "m";
      style.close = "\x1B[" + val[1] + "m";
    });
  }
});

// ../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/system/has-flag.js
var require_has_flag3 = __commonJS({
  "../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/system/has-flag.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = function(flag, argv) {
      argv = argv || process.argv;
      var terminatorPos = argv.indexOf("--");
      var prefix = /^-{1,2}/.test(flag) ? "" : "--";
      var pos = argv.indexOf(prefix + flag);
      return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
    };
  }
});

// ../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/system/supports-colors.js
var require_supports_colors = __commonJS({
  "../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/system/supports-colors.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var os11 = require("os");
    var hasFlag2 = require_has_flag3();
    var env5 = process.env;
    var forceColor = void 0;
    if (hasFlag2("no-color") || hasFlag2("no-colors") || hasFlag2("color=false")) {
      forceColor = false;
    } else if (hasFlag2("color") || hasFlag2("colors") || hasFlag2("color=true") || hasFlag2("color=always")) {
      forceColor = true;
    }
    if ("FORCE_COLOR" in env5) {
      forceColor = env5.FORCE_COLOR.length === 0 || parseInt(env5.FORCE_COLOR, 10) !== 0;
    }
    function translateLevel2(level) {
      if (level === 0) {
        return false;
      }
      return {
        level,
        hasBasic: true,
        has256: level >= 2,
        has16m: level >= 3
      };
    }
    __name(translateLevel2, "translateLevel");
    function supportsColor2(stream2) {
      if (forceColor === false) {
        return 0;
      }
      if (hasFlag2("color=16m") || hasFlag2("color=full") || hasFlag2("color=truecolor")) {
        return 3;
      }
      if (hasFlag2("color=256")) {
        return 2;
      }
      if (stream2 && !stream2.isTTY && forceColor !== true) {
        return 0;
      }
      var min = forceColor ? 1 : 0;
      if (process.platform === "win32") {
        var osRelease = os11.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 env5) {
        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI"].some(function(sign) {
          return sign in env5;
        }) || env5.CI_NAME === "codeship") {
          return 1;
        }
        return min;
      }
      if ("TEAMCITY_VERSION" in env5) {
        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env5.TEAMCITY_VERSION) ? 1 : 0;
      }
      if ("TERM_PROGRAM" in env5) {
        var version3 = parseInt((env5.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
        switch (env5.TERM_PROGRAM) {
          case "iTerm.app":
            return version3 >= 3 ? 3 : 2;
          case "Hyper":
            return 3;
          case "Apple_Terminal":
            return 2;
        }
      }
      if (/-256(color)?$/i.test(env5.TERM)) {
        return 2;
      }
      if (/^screen|^xterm|^vt100|^rxvt|color|ansi|cygwin|linux/i.test(env5.TERM)) {
        return 1;
      }
      if ("COLORTERM" in env5) {
        return 1;
      }
      if (env5.TERM === "dumb") {
        return min;
      }
      return min;
    }
    __name(supportsColor2, "supportsColor");
    function getSupportLevel(stream2) {
      var level = supportsColor2(stream2);
      return translateLevel2(level);
    }
    __name(getSupportLevel, "getSupportLevel");
    module3.exports = {
      supportsColor: getSupportLevel,
      stdout: getSupportLevel(process.stdout),
      stderr: getSupportLevel(process.stderr)
    };
  }
});

// ../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/custom/trap.js
var require_trap = __commonJS({
  "../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/custom/trap.js"(exports2, module3) {
    init_import_meta_url();
    module3["exports"] = /* @__PURE__ */ __name(function runTheTrap(text, options29) {
      var result = "";
      text = text || "Run the trap, drop the bass";
      text = text.split("");
      var trap = {
        a: ["@", "\u0104", "\u023A", "\u0245", "\u0394", "\u039B", "\u0414"],
        b: ["\xDF", "\u0181", "\u0243", "\u026E", "\u03B2", "\u0E3F"],
        c: ["\xA9", "\u023B", "\u03FE"],
        d: ["\xD0", "\u018A", "\u0500", "\u0501", "\u0502", "\u0503"],
        e: [
          "\xCB",
          "\u0115",
          "\u018E",
          "\u0258",
          "\u03A3",
          "\u03BE",
          "\u04BC",
          "\u0A6C"
        ],
        f: ["\u04FA"],
        g: ["\u0262"],
        h: ["\u0126", "\u0195", "\u04A2", "\u04BA", "\u04C7", "\u050A"],
        i: ["\u0F0F"],
        j: ["\u0134"],
        k: ["\u0138", "\u04A0", "\u04C3", "\u051E"],
        l: ["\u0139"],
        m: ["\u028D", "\u04CD", "\u04CE", "\u0520", "\u0521", "\u0D69"],
        n: ["\xD1", "\u014B", "\u019D", "\u0376", "\u03A0", "\u048A"],
        o: [
          "\xD8",
          "\xF5",
          "\xF8",
          "\u01FE",
          "\u0298",
          "\u047A",
          "\u05DD",
          "\u06DD",
          "\u0E4F"
        ],
        p: ["\u01F7", "\u048E"],
        q: ["\u09CD"],
        r: ["\xAE", "\u01A6", "\u0210", "\u024C", "\u0280", "\u042F"],
        s: ["\xA7", "\u03DE", "\u03DF", "\u03E8"],
        t: ["\u0141", "\u0166", "\u0373"],
        u: ["\u01B1", "\u054D"],
        v: ["\u05D8"],
        w: ["\u0428", "\u0460", "\u047C", "\u0D70"],
        x: ["\u04B2", "\u04FE", "\u04FC", "\u04FD"],
        y: ["\xA5", "\u04B0", "\u04CB"],
        z: ["\u01B5", "\u0240"]
      };
      text.forEach(function(c2) {
        c2 = c2.toLowerCase();
        var chars = trap[c2] || [" "];
        var rand = Math.floor(Math.random() * chars.length);
        if (typeof trap[c2] !== "undefined") {
          result += trap[c2][rand];
        } else {
          result += c2;
        }
      });
      return result;
    }, "runTheTrap");
  }
});

// ../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/custom/zalgo.js
var require_zalgo = __commonJS({
  "../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/custom/zalgo.js"(exports2, module3) {
    init_import_meta_url();
    module3["exports"] = /* @__PURE__ */ __name(function zalgo(text, options29) {
      text = text || "   he is here   ";
      var soul = {
        "up": [
          "\u030D",
          "\u030E",
          "\u0304",
          "\u0305",
          "\u033F",
          "\u0311",
          "\u0306",
          "\u0310",
          "\u0352",
          "\u0357",
          "\u0351",
          "\u0307",
          "\u0308",
          "\u030A",
          "\u0342",
          "\u0313",
          "\u0308",
          "\u034A",
          "\u034B",
          "\u034C",
          "\u0303",
          "\u0302",
          "\u030C",
          "\u0350",
          "\u0300",
          "\u0301",
          "\u030B",
          "\u030F",
          "\u0312",
          "\u0313",
          "\u0314",
          "\u033D",
          "\u0309",
          "\u0363",
          "\u0364",
          "\u0365",
          "\u0366",
          "\u0367",
          "\u0368",
          "\u0369",
          "\u036A",
          "\u036B",
          "\u036C",
          "\u036D",
          "\u036E",
          "\u036F",
          "\u033E",
          "\u035B",
          "\u0346",
          "\u031A"
        ],
        "down": [
          "\u0316",
          "\u0317",
          "\u0318",
          "\u0319",
          "\u031C",
          "\u031D",
          "\u031E",
          "\u031F",
          "\u0320",
          "\u0324",
          "\u0325",
          "\u0326",
          "\u0329",
          "\u032A",
          "\u032B",
          "\u032C",
          "\u032D",
          "\u032E",
          "\u032F",
          "\u0330",
          "\u0331",
          "\u0332",
          "\u0333",
          "\u0339",
          "\u033A",
          "\u033B",
          "\u033C",
          "\u0345",
          "\u0347",
          "\u0348",
          "\u0349",
          "\u034D",
          "\u034E",
          "\u0353",
          "\u0354",
          "\u0355",
          "\u0356",
          "\u0359",
          "\u035A",
          "\u0323"
        ],
        "mid": [
          "\u0315",
          "\u031B",
          "\u0300",
          "\u0301",
          "\u0358",
          "\u0321",
          "\u0322",
          "\u0327",
          "\u0328",
          "\u0334",
          "\u0335",
          "\u0336",
          "\u035C",
          "\u035D",
          "\u035E",
          "\u035F",
          "\u0360",
          "\u0362",
          "\u0338",
          "\u0337",
          "\u0361",
          " \u0489"
        ]
      };
      var all2 = [].concat(soul.up, soul.down, soul.mid);
      function randomNumber(range) {
        var r3 = Math.floor(Math.random() * range);
        return r3;
      }
      __name(randomNumber, "randomNumber");
      function isChar(character) {
        var bool = false;
        all2.filter(function(i) {
          bool = i === character;
        });
        return bool;
      }
      __name(isChar, "isChar");
      function heComes(text2, options30) {
        var result = "";
        var counts;
        var l2;
        options30 = options30 || {};
        options30["up"] = typeof options30["up"] !== "undefined" ? options30["up"] : true;
        options30["mid"] = typeof options30["mid"] !== "undefined" ? options30["mid"] : true;
        options30["down"] = typeof options30["down"] !== "undefined" ? options30["down"] : true;
        options30["size"] = typeof options30["size"] !== "undefined" ? options30["size"] : "maxi";
        text2 = text2.split("");
        for (l2 in text2) {
          if (isChar(l2)) {
            continue;
          }
          result = result + text2[l2];
          counts = { "up": 0, "down": 0, "mid": 0 };
          switch (options30.size) {
            case "mini":
              counts.up = randomNumber(8);
              counts.mid = randomNumber(2);
              counts.down = randomNumber(8);
              break;
            case "maxi":
              counts.up = randomNumber(16) + 3;
              counts.mid = randomNumber(4) + 1;
              counts.down = randomNumber(64) + 3;
              break;
            default:
              counts.up = randomNumber(8) + 1;
              counts.mid = randomNumber(6) / 2;
              counts.down = randomNumber(8) + 1;
              break;
          }
          var arr = ["up", "mid", "down"];
          for (var d2 in arr) {
            var index = arr[d2];
            for (var i = 0; i <= counts[index]; i++) {
              if (options30[index]) {
                result = result + soul[index][randomNumber(soul[index].length)];
              }
            }
          }
        }
        return result;
      }
      __name(heComes, "heComes");
      return heComes(text, options29);
    }, "zalgo");
  }
});

// ../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/maps/america.js
var require_america = __commonJS({
  "../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/maps/america.js"(exports2, module3) {
    init_import_meta_url();
    module3["exports"] = function(colors) {
      return function(letter, i, exploded) {
        if (letter === " ")
          return letter;
        switch (i % 3) {
          case 0:
            return colors.red(letter);
          case 1:
            return colors.white(letter);
          case 2:
            return colors.blue(letter);
        }
      };
    };
  }
});

// ../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/maps/zebra.js
var require_zebra = __commonJS({
  "../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/maps/zebra.js"(exports2, module3) {
    init_import_meta_url();
    module3["exports"] = function(colors) {
      return function(letter, i, exploded) {
        return i % 2 === 0 ? letter : colors.inverse(letter);
      };
    };
  }
});

// ../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/maps/rainbow.js
var require_rainbow = __commonJS({
  "../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/maps/rainbow.js"(exports2, module3) {
    init_import_meta_url();
    module3["exports"] = function(colors) {
      var rainbowColors = ["red", "yellow", "green", "blue", "magenta"];
      return function(letter, i, exploded) {
        if (letter === " ") {
          return letter;
        } else {
          return colors[rainbowColors[i++ % rainbowColors.length]](letter);
        }
      };
    };
  }
});

// ../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/maps/random.js
var require_random = __commonJS({
  "../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/maps/random.js"(exports2, module3) {
    init_import_meta_url();
    module3["exports"] = function(colors) {
      var available = [
        "underline",
        "inverse",
        "grey",
        "yellow",
        "red",
        "green",
        "blue",
        "white",
        "cyan",
        "magenta",
        "brightYellow",
        "brightRed",
        "brightGreen",
        "brightBlue",
        "brightWhite",
        "brightCyan",
        "brightMagenta"
      ];
      return function(letter, i, exploded) {
        return letter === " " ? letter : colors[available[Math.round(Math.random() * (available.length - 2))]](letter);
      };
    };
  }
});

// ../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/colors.js
var require_colors = __commonJS({
  "../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/lib/colors.js"(exports2, module3) {
    init_import_meta_url();
    var colors = {};
    module3["exports"] = colors;
    colors.themes = {};
    var util4 = require("util");
    var ansiStyles2 = colors.styles = require_styles2();
    var defineProps = Object.defineProperties;
    var newLineRegex = new RegExp(/[\r\n]+/g);
    colors.supportsColor = require_supports_colors().supportsColor;
    if (typeof colors.enabled === "undefined") {
      colors.enabled = colors.supportsColor() !== false;
    }
    colors.enable = function() {
      colors.enabled = true;
    };
    colors.disable = function() {
      colors.enabled = false;
    };
    colors.stripColors = colors.strip = function(str) {
      return ("" + str).replace(/\x1B\[\d+m/g, "");
    };
    var stylize = colors.stylize = /* @__PURE__ */ __name(function stylize2(str, style) {
      if (!colors.enabled) {
        return str + "";
      }
      var styleMap = ansiStyles2[style];
      if (!styleMap && style in colors) {
        return colors[style](str);
      }
      return styleMap.open + str + styleMap.close;
    }, "stylize");
    var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
    var escapeStringRegexp = /* @__PURE__ */ __name(function(str) {
      if (typeof str !== "string") {
        throw new TypeError("Expected a string");
      }
      return str.replace(matchOperatorsRe, "\\$&");
    }, "escapeStringRegexp");
    function build5(_styles) {
      var builder = /* @__PURE__ */ __name(function builder2() {
        return applyStyle.apply(builder2, arguments);
      }, "builder");
      builder._styles = _styles;
      builder.__proto__ = proto;
      return builder;
    }
    __name(build5, "build");
    var styles2 = function() {
      var ret = {};
      ansiStyles2.grey = ansiStyles2.gray;
      Object.keys(ansiStyles2).forEach(function(key) {
        ansiStyles2[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles2[key].close), "g");
        ret[key] = {
          get: function() {
            return build5(this._styles.concat(key));
          }
        };
      });
      return ret;
    }();
    var proto = defineProps(/* @__PURE__ */ __name(function colors2() {
    }, "colors"), styles2);
    function applyStyle() {
      var args = Array.prototype.slice.call(arguments);
      var str = args.map(function(arg) {
        if (arg != null && arg.constructor === String) {
          return arg;
        } else {
          return util4.inspect(arg);
        }
      }).join(" ");
      if (!colors.enabled || !str) {
        return str;
      }
      var newLinesPresent = str.indexOf("\n") != -1;
      var nestedStyles = this._styles;
      var i = nestedStyles.length;
      while (i--) {
        var code = ansiStyles2[nestedStyles[i]];
        str = code.open + str.replace(code.closeRe, code.open) + code.close;
        if (newLinesPresent) {
          str = str.replace(newLineRegex, function(match) {
            return code.close + match + code.open;
          });
        }
      }
      return str;
    }
    __name(applyStyle, "applyStyle");
    colors.setTheme = function(theme) {
      if (typeof theme === "string") {
        console.log("colors.setTheme now only accepts an object, not a string.  If you are trying to set a theme from a file, it is now your (the caller's) responsibility to require the file.  The old syntax looked like colors.setTheme(__dirname + '/../themes/generic-logging.js'); The new syntax looks like colors.setTheme(require(__dirname + '/../themes/generic-logging.js'));");
        return;
      }
      for (var style in theme) {
        (function(style2) {
          colors[style2] = function(str) {
            if (typeof theme[style2] === "object") {
              var out = str;
              for (var i in theme[style2]) {
                out = colors[theme[style2][i]](out);
              }
              return out;
            }
            return colors[theme[style2]](str);
          };
        })(style);
      }
    };
    function init3() {
      var ret = {};
      Object.keys(styles2).forEach(function(name) {
        ret[name] = {
          get: function() {
            return build5([name]);
          }
        };
      });
      return ret;
    }
    __name(init3, "init");
    var sequencer = /* @__PURE__ */ __name(function sequencer2(map2, str) {
      var exploded = str.split("");
      exploded = exploded.map(map2);
      return exploded.join("");
    }, "sequencer");
    colors.trap = require_trap();
    colors.zalgo = require_zalgo();
    colors.maps = {};
    colors.maps.america = require_america()(colors);
    colors.maps.zebra = require_zebra()(colors);
    colors.maps.rainbow = require_rainbow()(colors);
    colors.maps.random = require_random()(colors);
    for (map in colors.maps) {
      (function(map2) {
        colors[map2] = function(str) {
          return sequencer(colors.maps[map2], str);
        };
      })(map);
    }
    var map;
    defineProps(colors, init3());
  }
});

// ../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/safe.js
var require_safe = __commonJS({
  "../../node_modules/.pnpm/@colors+colors@1.5.0/node_modules/@colors/colors/safe.js"(exports2, module3) {
    init_import_meta_url();
    var colors = require_colors();
    module3["exports"] = colors;
  }
});

// ../../node_modules/.pnpm/cli-table3@0.6.3/node_modules/cli-table3/src/cell.js
var require_cell = __commonJS({
  "../../node_modules/.pnpm/cli-table3@0.6.3/node_modules/cli-table3/src/cell.js"(exports2, module3) {
    init_import_meta_url();
    var { info, debug } = require_debug();
    var utils = require_utils2();
    var Cell = class {
      /**
       * A representation of a cell within the table.
       * Implementations must have `init` and `draw` methods,
       * as well as `colSpan`, `rowSpan`, `desiredHeight` and `desiredWidth` properties.
       * @param options
       * @constructor
       */
      constructor(options29) {
        this.setOptions(options29);
        this.x = null;
        this.y = null;
      }
      setOptions(options29) {
        if (["boolean", "number", "string"].indexOf(typeof options29) !== -1) {
          options29 = { content: "" + options29 };
        }
        options29 = options29 || {};
        this.options = options29;
        let content = options29.content;
        if (["boolean", "number", "string"].indexOf(typeof content) !== -1) {
          this.content = String(content);
        } else if (!content) {
          this.content = this.options.href || "";
        } else {
          throw new Error("Content needs to be a primitive, got: " + typeof content);
        }
        this.colSpan = options29.colSpan || 1;
        this.rowSpan = options29.rowSpan || 1;
        if (this.options.href) {
          Object.defineProperty(this, "href", {
            get() {
              return this.options.href;
            }
          });
        }
      }
      mergeTableOptions(tableOptions, cells) {
        this.cells = cells;
        let optionsChars = this.options.chars || {};
        let tableChars = tableOptions.chars;
        let chars = this.chars = {};
        CHAR_NAMES.forEach(function(name) {
          setOption(optionsChars, tableChars, name, chars);
        });
        this.truncate = this.options.truncate || tableOptions.truncate;
        let style = this.options.style = this.options.style || {};
        let tableStyle = tableOptions.style;
        setOption(style, tableStyle, "padding-left", this);
        setOption(style, tableStyle, "padding-right", this);
        this.head = style.head || tableStyle.head;
        this.border = style.border || tableStyle.border;
        this.fixedWidth = tableOptions.colWidths[this.x];
        this.lines = this.computeLines(tableOptions);
        this.desiredWidth = utils.strlen(this.content) + this.paddingLeft + this.paddingRight;
        this.desiredHeight = this.lines.length;
      }
      computeLines(tableOptions) {
        const tableWordWrap = tableOptions.wordWrap || tableOptions.textWrap;
        const { wordWrap = tableWordWrap } = this.options;
        if (this.fixedWidth && wordWrap) {
          this.fixedWidth -= this.paddingLeft + this.paddingRight;
          if (this.colSpan) {
            let i = 1;
            while (i < this.colSpan) {
              this.fixedWidth += tableOptions.colWidths[this.x + i];
              i++;
            }
          }
          const { wrapOnWordBoundary: tableWrapOnWordBoundary = true } = tableOptions;
          const { wrapOnWordBoundary = tableWrapOnWordBoundary } = this.options;
          return this.wrapLines(utils.wordWrap(this.fixedWidth, this.content, wrapOnWordBoundary));
        }
        return this.wrapLines(this.content.split("\n"));
      }
      wrapLines(computedLines) {
        const lines = utils.colorizeLines(computedLines);
        if (this.href) {
          return lines.map((line) => utils.hyperlink(this.href, line));
        }
        return lines;
      }
      /**
       * Initializes the Cells data structure.
       *
       * @param tableOptions - A fully populated set of tableOptions.
       * In addition to the standard default values, tableOptions must have fully populated the
       * `colWidths` and `rowWidths` arrays. Those arrays must have lengths equal to the number
       * of columns or rows (respectively) in this table, and each array item must be a Number.
       *
       */
      init(tableOptions) {
        let x2 = this.x;
        let y2 = this.y;
        this.widths = tableOptions.colWidths.slice(x2, x2 + this.colSpan);
        this.heights = tableOptions.rowHeights.slice(y2, y2 + this.rowSpan);
        this.width = this.widths.reduce(sumPlusOne, -1);
        this.height = this.heights.reduce(sumPlusOne, -1);
        this.hAlign = this.options.hAlign || tableOptions.colAligns[x2];
        this.vAlign = this.options.vAlign || tableOptions.rowAligns[y2];
        this.drawRight = x2 + this.colSpan == tableOptions.colWidths.length;
      }
      /**
       * Draws the given line of the cell.
       * This default implementation defers to methods `drawTop`, `drawBottom`, `drawLine` and `drawEmpty`.
       * @param lineNum - can be `top`, `bottom` or a numerical line number.
       * @param spanningCell - will be a number if being called from a RowSpanCell, and will represent how
       * many rows below it's being called from. Otherwise it's undefined.
       * @returns {String} The representation of this line.
       */
      draw(lineNum, spanningCell) {
        if (lineNum == "top")
          return this.drawTop(this.drawRight);
        if (lineNum == "bottom")
          return this.drawBottom(this.drawRight);
        let content = utils.truncate(this.content, 10, this.truncate);
        if (!lineNum) {
          info(`${this.y}-${this.x}: ${this.rowSpan - lineNum}x${this.colSpan} Cell ${content}`);
        } else {
        }
        let padLen = Math.max(this.height - this.lines.length, 0);
        let padTop;
        switch (this.vAlign) {
          case "center":
            padTop = Math.ceil(padLen / 2);
            break;
          case "bottom":
            padTop = padLen;
            break;
          default:
            padTop = 0;
        }
        if (lineNum < padTop || lineNum >= padTop + this.lines.length) {
          return this.drawEmpty(this.drawRight, spanningCell);
        }
        let forceTruncation = this.lines.length > this.height && lineNum + 1 >= this.height;
        return this.drawLine(lineNum - padTop, this.drawRight, forceTruncation, spanningCell);
      }
      /**
       * Renders the top line of the cell.
       * @param drawRight - true if this method should render the right edge of the cell.
       * @returns {String}
       */
      drawTop(drawRight) {
        let content = [];
        if (this.cells) {
          this.widths.forEach(function(width, index) {
            content.push(this._topLeftChar(index));
            content.push(utils.repeat(this.chars[this.y == 0 ? "top" : "mid"], width));
          }, this);
        } else {
          content.push(this._topLeftChar(0));
          content.push(utils.repeat(this.chars[this.y == 0 ? "top" : "mid"], this.width));
        }
        if (drawRight) {
          content.push(this.chars[this.y == 0 ? "topRight" : "rightMid"]);
        }
        return this.wrapWithStyleColors("border", content.join(""));
      }
      _topLeftChar(offset) {
        let x2 = this.x + offset;
        let leftChar;
        if (this.y == 0) {
          leftChar = x2 == 0 ? "topLeft" : offset == 0 ? "topMid" : "top";
        } else {
          if (x2 == 0) {
            leftChar = "leftMid";
          } else {
            leftChar = offset == 0 ? "midMid" : "bottomMid";
            if (this.cells) {
              let spanAbove = this.cells[this.y - 1][x2] instanceof Cell.ColSpanCell;
              if (spanAbove) {
                leftChar = offset == 0 ? "topMid" : "mid";
              }
              if (offset == 0) {
                let i = 1;
                while (this.cells[this.y][x2 - i] instanceof Cell.ColSpanCell) {
                  i++;
                }
                if (this.cells[this.y][x2 - i] instanceof Cell.RowSpanCell) {
                  leftChar = "leftMid";
                }
              }
            }
          }
        }
        return this.chars[leftChar];
      }
      wrapWithStyleColors(styleProperty, content) {
        if (this[styleProperty] && this[styleProperty].length) {
          try {
            let colors = require_safe();
            for (let i = this[styleProperty].length - 1; i >= 0; i--) {
              colors = colors[this[styleProperty][i]];
            }
            return colors(content);
          } catch (e3) {
            return content;
          }
        } else {
          return content;
        }
      }
      /**
       * Renders a line of text.
       * @param lineNum - Which line of text to render. This is not necessarily the line within the cell.
       * There may be top-padding above the first line of text.
       * @param drawRight - true if this method should render the right edge of the cell.
       * @param forceTruncationSymbol - `true` if the rendered text should end with the truncation symbol even
       * if the text fits. This is used when the cell is vertically truncated. If `false` the text should
       * only include the truncation symbol if the text will not fit horizontally within the cell width.
       * @param spanningCell - a number of if being called from a RowSpanCell. (how many rows below). otherwise undefined.
       * @returns {String}
       */
      drawLine(lineNum, drawRight, forceTruncationSymbol, spanningCell) {
        let left2 = this.chars[this.x == 0 ? "left" : "middle"];
        if (this.x && spanningCell && this.cells) {
          let cellLeft = this.cells[this.y + spanningCell][this.x - 1];
          while (cellLeft instanceof ColSpanCell) {
            cellLeft = this.cells[cellLeft.y][cellLeft.x - 1];
          }
          if (!(cellLeft instanceof RowSpanCell)) {
            left2 = this.chars["rightMid"];
          }
        }
        let leftPadding = utils.repeat(" ", this.paddingLeft);
        let right2 = drawRight ? this.chars["right"] : "";
        let rightPadding = utils.repeat(" ", this.paddingRight);
        let line = this.lines[lineNum];
        let len = this.width - (this.paddingLeft + this.paddingRight);
        if (forceTruncationSymbol)
          line += this.truncate || "\u2026";
        let content = utils.truncate(line, len, this.truncate);
        content = utils.pad(content, len, " ", this.hAlign);
        content = leftPadding + content + rightPadding;
        return this.stylizeLine(left2, content, right2);
      }
      stylizeLine(left2, content, right2) {
        left2 = this.wrapWithStyleColors("border", left2);
        right2 = this.wrapWithStyleColors("border", right2);
        if (this.y === 0) {
          content = this.wrapWithStyleColors("head", content);
        }
        return left2 + content + right2;
      }
      /**
       * Renders the bottom line of the cell.
       * @param drawRight - true if this method should render the right edge of the cell.
       * @returns {String}
       */
      drawBottom(drawRight) {
        let left2 = this.chars[this.x == 0 ? "bottomLeft" : "bottomMid"];
        let content = utils.repeat(this.chars.bottom, this.width);
        let right2 = drawRight ? this.chars["bottomRight"] : "";
        return this.wrapWithStyleColors("border", left2 + content + right2);
      }
      /**
       * Renders a blank line of text within the cell. Used for top and/or bottom padding.
       * @param drawRight - true if this method should render the right edge of the cell.
       * @param spanningCell - a number of if being called from a RowSpanCell. (how many rows below). otherwise undefined.
       * @returns {String}
       */
      drawEmpty(drawRight, spanningCell) {
        let left2 = this.chars[this.x == 0 ? "left" : "middle"];
        if (this.x && spanningCell && this.cells) {
          let cellLeft = this.cells[this.y + spanningCell][this.x - 1];
          while (cellLeft instanceof ColSpanCell) {
            cellLeft = this.cells[cellLeft.y][cellLeft.x - 1];
          }
          if (!(cellLeft instanceof RowSpanCell)) {
            left2 = this.chars["rightMid"];
          }
        }
        let right2 = drawRight ? this.chars["right"] : "";
        let content = utils.repeat(" ", this.width);
        return this.stylizeLine(left2, content, right2);
      }
    };
    __name(Cell, "Cell");
    var ColSpanCell = class {
      /**
       * A Cell that doesn't do anything. It just draws empty lines.
       * Used as a placeholder in column spanning.
       * @constructor
       */
      constructor() {
      }
      draw(lineNum) {
        if (typeof lineNum === "number") {
          debug(`${this.y}-${this.x}: 1x1 ColSpanCell`);
        }
        return "";
      }
      init() {
      }
      mergeTableOptions() {
      }
    };
    __name(ColSpanCell, "ColSpanCell");
    var RowSpanCell = class {
      /**
       * A placeholder Cell for a Cell that spans multiple rows.
       * It delegates rendering to the original cell, but adds the appropriate offset.
       * @param originalCell
       * @constructor
       */
      constructor(originalCell) {
        this.originalCell = originalCell;
      }
      init(tableOptions) {
        let y2 = this.y;
        let originalY = this.originalCell.y;
        this.cellOffset = y2 - originalY;
        this.offset = findDimension(tableOptions.rowHeights, originalY, this.cellOffset);
      }
      draw(lineNum) {
        if (lineNum == "top") {
          return this.originalCell.draw(this.offset, this.cellOffset);
        }
        if (lineNum == "bottom") {
          return this.originalCell.draw("bottom");
        }
        debug(`${this.y}-${this.x}: 1x${this.colSpan} RowSpanCell for ${this.originalCell.content}`);
        return this.originalCell.draw(this.offset + 1 + lineNum);
      }
      mergeTableOptions() {
      }
    };
    __name(RowSpanCell, "RowSpanCell");
    function firstDefined(...args) {
      return args.filter((v2) => v2 !== void 0 && v2 !== null).shift();
    }
    __name(firstDefined, "firstDefined");
    function setOption(objA, objB, nameB, targetObj) {
      let nameA = nameB.split("-");
      if (nameA.length > 1) {
        nameA[1] = nameA[1].charAt(0).toUpperCase() + nameA[1].substr(1);
        nameA = nameA.join("");
        targetObj[nameA] = firstDefined(objA[nameA], objA[nameB], objB[nameA], objB[nameB]);
      } else {
        targetObj[nameB] = firstDefined(objA[nameB], objB[nameB]);
      }
    }
    __name(setOption, "setOption");
    function findDimension(dimensionTable, startingIndex, span) {
      let ret = dimensionTable[startingIndex];
      for (let i = 1; i < span; i++) {
        ret += 1 + dimensionTable[startingIndex + i];
      }
      return ret;
    }
    __name(findDimension, "findDimension");
    function sumPlusOne(a, b2) {
      return a + b2 + 1;
    }
    __name(sumPlusOne, "sumPlusOne");
    var CHAR_NAMES = [
      "top",
      "top-mid",
      "top-left",
      "top-right",
      "bottom",
      "bottom-mid",
      "bottom-left",
      "bottom-right",
      "left",
      "left-mid",
      "mid",
      "mid-mid",
      "right",
      "right-mid",
      "middle"
    ];
    module3.exports = Cell;
    module3.exports.ColSpanCell = ColSpanCell;
    module3.exports.RowSpanCell = RowSpanCell;
  }
});

// ../../node_modules/.pnpm/cli-table3@0.6.3/node_modules/cli-table3/src/layout-manager.js
var require_layout_manager = __commonJS({
  "../../node_modules/.pnpm/cli-table3@0.6.3/node_modules/cli-table3/src/layout-manager.js"(exports2, module3) {
    init_import_meta_url();
    var { warn: warn2, debug } = require_debug();
    var Cell = require_cell();
    var { ColSpanCell, RowSpanCell } = Cell;
    (function() {
      function next(alloc, col) {
        if (alloc[col] > 0) {
          return next(alloc, col + 1);
        }
        return col;
      }
      __name(next, "next");
      function layoutTable(table) {
        let alloc = {};
        table.forEach(function(row, rowIndex) {
          let col = 0;
          row.forEach(function(cell) {
            cell.y = rowIndex;
            cell.x = rowIndex ? next(alloc, col) : col;
            const rowSpan = cell.rowSpan || 1;
            const colSpan = cell.colSpan || 1;
            if (rowSpan > 1) {
              for (let cs2 = 0; cs2 < colSpan; cs2++) {
                alloc[cell.x + cs2] = rowSpan;
              }
            }
            col = cell.x + colSpan;
          });
          Object.keys(alloc).forEach((idx) => {
            alloc[idx]--;
            if (alloc[idx] < 1)
              delete alloc[idx];
          });
        });
      }
      __name(layoutTable, "layoutTable");
      function maxWidth(table) {
        let mw = 0;
        table.forEach(function(row) {
          row.forEach(function(cell) {
            mw = Math.max(mw, cell.x + (cell.colSpan || 1));
          });
        });
        return mw;
      }
      __name(maxWidth, "maxWidth");
      function maxHeight(table) {
        return table.length;
      }
      __name(maxHeight, "maxHeight");
      function cellsConflict(cell1, cell2) {
        let yMin1 = cell1.y;
        let yMax1 = cell1.y - 1 + (cell1.rowSpan || 1);
        let yMin2 = cell2.y;
        let yMax2 = cell2.y - 1 + (cell2.rowSpan || 1);
        let yConflict = !(yMin1 > yMax2 || yMin2 > yMax1);
        let xMin1 = cell1.x;
        let xMax1 = cell1.x - 1 + (cell1.colSpan || 1);
        let xMin2 = cell2.x;
        let xMax2 = cell2.x - 1 + (cell2.colSpan || 1);
        let xConflict = !(xMin1 > xMax2 || xMin2 > xMax1);
        return yConflict && xConflict;
      }
      __name(cellsConflict, "cellsConflict");
      function conflictExists(rows, x2, y2) {
        let i_max = Math.min(rows.length - 1, y2);
        let cell = { x: x2, y: y2 };
        for (let i = 0; i <= i_max; i++) {
          let row = rows[i];
          for (let j2 = 0; j2 < row.length; j2++) {
            if (cellsConflict(cell, row[j2])) {
              return true;
            }
          }
        }
        return false;
      }
      __name(conflictExists, "conflictExists");
      function allBlank(rows, y2, xMin, xMax) {
        for (let x2 = xMin; x2 < xMax; x2++) {
          if (conflictExists(rows, x2, y2)) {
            return false;
          }
        }
        return true;
      }
      __name(allBlank, "allBlank");
      function addRowSpanCells(table) {
        table.forEach(function(row, rowIndex) {
          row.forEach(function(cell) {
            for (let i = 1; i < cell.rowSpan; i++) {
              let rowSpanCell = new RowSpanCell(cell);
              rowSpanCell.x = cell.x;
              rowSpanCell.y = cell.y + i;
              rowSpanCell.colSpan = cell.colSpan;
              insertCell(rowSpanCell, table[rowIndex + i]);
            }
          });
        });
      }
      __name(addRowSpanCells, "addRowSpanCells");
      function addColSpanCells(cellRows) {
        for (let rowIndex = cellRows.length - 1; rowIndex >= 0; rowIndex--) {
          let cellColumns = cellRows[rowIndex];
          for (let columnIndex = 0; columnIndex < cellColumns.length; columnIndex++) {
            let cell = cellColumns[columnIndex];
            for (let k2 = 1; k2 < cell.colSpan; k2++) {
              let colSpanCell = new ColSpanCell();
              colSpanCell.x = cell.x + k2;
              colSpanCell.y = cell.y;
              cellColumns.splice(columnIndex + 1, 0, colSpanCell);
            }
          }
        }
      }
      __name(addColSpanCells, "addColSpanCells");
      function insertCell(cell, row) {
        let x2 = 0;
        while (x2 < row.length && row[x2].x < cell.x) {
          x2++;
        }
        row.splice(x2, 0, cell);
      }
      __name(insertCell, "insertCell");
      function fillInTable(table) {
        let h_max = maxHeight(table);
        let w_max = maxWidth(table);
        debug(`Max rows: ${h_max}; Max cols: ${w_max}`);
        for (let y2 = 0; y2 < h_max; y2++) {
          for (let x2 = 0; x2 < w_max; x2++) {
            if (!conflictExists(table, x2, y2)) {
              let opts = { x: x2, y: y2, colSpan: 1, rowSpan: 1 };
              x2++;
              while (x2 < w_max && !conflictExists(table, x2, y2)) {
                opts.colSpan++;
                x2++;
              }
              let y22 = y2 + 1;
              while (y22 < h_max && allBlank(table, y22, opts.x, opts.x + opts.colSpan)) {
                opts.rowSpan++;
                y22++;
              }
              let cell = new Cell(opts);
              cell.x = opts.x;
              cell.y = opts.y;
              warn2(`Missing cell at ${cell.y}-${cell.x}.`);
              insertCell(cell, table[y2]);
            }
          }
        }
      }
      __name(fillInTable, "fillInTable");
      function generateCells(rows) {
        return rows.map(function(row) {
          if (!Array.isArray(row)) {
            let key = Object.keys(row)[0];
            row = row[key];
            if (Array.isArray(row)) {
              row = row.slice();
              row.unshift(key);
            } else {
              row = [key, row];
            }
          }
          return row.map(function(cell) {
            return new Cell(cell);
          });
        });
      }
      __name(generateCells, "generateCells");
      function makeTableLayout(rows) {
        let cellRows = generateCells(rows);
        layoutTable(cellRows);
        fillInTable(cellRows);
        addRowSpanCells(cellRows);
        addColSpanCells(cellRows);
        return cellRows;
      }
      __name(makeTableLayout, "makeTableLayout");
      module3.exports = {
        makeTableLayout,
        layoutTable,
        addRowSpanCells,
        maxWidth,
        fillInTable,
        computeWidths: makeComputeWidths("colSpan", "desiredWidth", "x", 1),
        computeHeights: makeComputeWidths("rowSpan", "desiredHeight", "y", 1)
      };
    })();
    function makeComputeWidths(colSpan, desiredWidth, x2, forcedMin) {
      return function(vals, table) {
        let result = [];
        let spanners = [];
        let auto = {};
        table.forEach(function(row) {
          row.forEach(function(cell) {
            if ((cell[colSpan] || 1) > 1) {
              spanners.push(cell);
            } else {
              result[cell[x2]] = Math.max(result[cell[x2]] || 0, cell[desiredWidth] || 0, forcedMin);
            }
          });
        });
        vals.forEach(function(val, index) {
          if (typeof val === "number") {
            result[index] = val;
          }
        });
        for (let k2 = spanners.length - 1; k2 >= 0; k2--) {
          let cell = spanners[k2];
          let span = cell[colSpan];
          let col = cell[x2];
          let existingWidth = result[col];
          let editableCols = typeof vals[col] === "number" ? 0 : 1;
          if (typeof existingWidth === "number") {
            for (let i = 1; i < span; i++) {
              existingWidth += 1 + result[col + i];
              if (typeof vals[col + i] !== "number") {
                editableCols++;
              }
            }
          } else {
            existingWidth = desiredWidth === "desiredWidth" ? cell.desiredWidth - 1 : 1;
            if (!auto[col] || auto[col] < existingWidth) {
              auto[col] = existingWidth;
            }
          }
          if (cell[desiredWidth] > existingWidth) {
            let i = 0;
            while (editableCols > 0 && cell[desiredWidth] > existingWidth) {
              if (typeof vals[col + i] !== "number") {
                let dif = Math.round((cell[desiredWidth] - existingWidth) / editableCols);
                existingWidth += dif;
                result[col + i] += dif;
                editableCols--;
              }
              i++;
            }
          }
        }
        Object.assign(vals, result, auto);
        for (let j2 = 0; j2 < vals.length; j2++) {
          vals[j2] = Math.max(forcedMin, vals[j2] || 0);
        }
      };
    }
    __name(makeComputeWidths, "makeComputeWidths");
  }
});

// ../../node_modules/.pnpm/cli-table3@0.6.3/node_modules/cli-table3/src/table.js
var require_table = __commonJS({
  "../../node_modules/.pnpm/cli-table3@0.6.3/node_modules/cli-table3/src/table.js"(exports2, module3) {
    init_import_meta_url();
    var debug = require_debug();
    var utils = require_utils2();
    var tableLayout = require_layout_manager();
    var Table10 = class extends Array {
      constructor(opts) {
        super();
        const options29 = utils.mergeOptions(opts);
        Object.defineProperty(this, "options", {
          value: options29,
          enumerable: options29.debug
        });
        if (options29.debug) {
          switch (typeof options29.debug) {
            case "boolean":
              debug.setDebugLevel(debug.WARN);
              break;
            case "number":
              debug.setDebugLevel(options29.debug);
              break;
            case "string":
              debug.setDebugLevel(parseInt(options29.debug, 10));
              break;
            default:
              debug.setDebugLevel(debug.WARN);
              debug.warn(`Debug option is expected to be boolean, number, or string. Received a ${typeof options29.debug}`);
          }
          Object.defineProperty(this, "messages", {
            get() {
              return debug.debugMessages();
            }
          });
        }
      }
      toString() {
        let array = this;
        let headersPresent = this.options.head && this.options.head.length;
        if (headersPresent) {
          array = [this.options.head];
          if (this.length) {
            array.push.apply(array, this);
          }
        } else {
          this.options.style.head = [];
        }
        let cells = tableLayout.makeTableLayout(array);
        cells.forEach(function(row) {
          row.forEach(function(cell) {
            cell.mergeTableOptions(this.options, cells);
          }, this);
        }, this);
        tableLayout.computeWidths(this.options.colWidths, cells);
        tableLayout.computeHeights(this.options.rowHeights, cells);
        cells.forEach(function(row) {
          row.forEach(function(cell) {
            cell.init(this.options);
          }, this);
        }, this);
        let result = [];
        for (let rowIndex = 0; rowIndex < cells.length; rowIndex++) {
          let row = cells[rowIndex];
          let heightOfRow = this.options.rowHeights[rowIndex];
          if (rowIndex === 0 || !this.options.style.compact || rowIndex == 1 && headersPresent) {
            doDraw(row, "top", result);
          }
          for (let lineNum = 0; lineNum < heightOfRow; lineNum++) {
            doDraw(row, lineNum, result);
          }
          if (rowIndex + 1 == cells.length) {
            doDraw(row, "bottom", result);
          }
        }
        return result.join("\n");
      }
      get width() {
        let str = this.toString().split("\n");
        return str[0].length;
      }
    };
    __name(Table10, "Table");
    Table10.reset = () => debug.reset();
    function doDraw(row, lineNum, result) {
      let line = [];
      row.forEach(function(cell) {
        line.push(cell.draw(lineNum));
      });
      let str = line.join("");
      if (str.length)
        result.push(str);
    }
    __name(doDraw, "doDraw");
    module3.exports = Table10;
  }
});

// ../../node_modules/.pnpm/cli-table3@0.6.3/node_modules/cli-table3/index.js
var require_cli_table3 = __commonJS({
  "../../node_modules/.pnpm/cli-table3@0.6.3/node_modules/cli-table3/index.js"(exports2, module3) {
    init_import_meta_url();
    module3.exports = require_table();
  }
});

// ../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/lib/XDGAppPaths.js
var require_XDGAppPaths = __commonJS({
  "../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/lib/XDGAppPaths.js"(exports2) {
    "use strict";
    init_import_meta_url();
    exports2.__esModule = true;
    exports2.Adapt = void 0;
    function isBoolean3(t3) {
      return typeOf(t3) === "boolean";
    }
    __name(isBoolean3, "isBoolean");
    function isObject2(t3) {
      return typeOf(t3) === "object";
    }
    __name(isObject2, "isObject");
    function isString4(t3) {
      return typeOf(t3) === "string";
    }
    __name(isString4, "isString");
    function typeOf(t3) {
      return typeof t3;
    }
    __name(typeOf, "typeOf");
    function Adapt(adapter_) {
      var meta = adapter_.meta, path67 = adapter_.path, xdg = adapter_.xdg;
      var XDGAppPaths_ = function() {
        function XDGAppPaths_2(options_) {
          if (options_ === void 0) {
            options_ = {};
          }
          var _a2, _b2, _c2;
          function XDGAppPaths(options30) {
            if (options30 === void 0) {
              options30 = {};
            }
            return new XDGAppPaths_2(options30);
          }
          __name(XDGAppPaths, "XDGAppPaths");
          var options29 = isObject2(options_) ? options_ : { name: options_ };
          var suffix = (_a2 = options29.suffix) !== null && _a2 !== void 0 ? _a2 : "";
          var isolated_ = (_b2 = options29.isolated) !== null && _b2 !== void 0 ? _b2 : true;
          var namePriorityList = [
            options29.name,
            meta.pkgMainFilename(),
            meta.mainFilename()
          ];
          var nameFallback = "$eval";
          var name = path67.parse(((_c2 = namePriorityList.find(function(e3) {
            return isString4(e3);
          })) !== null && _c2 !== void 0 ? _c2 : nameFallback) + suffix).name;
          XDGAppPaths.$name = /* @__PURE__ */ __name(function $name() {
            return name;
          }, "$name");
          XDGAppPaths.$isolated = /* @__PURE__ */ __name(function $isolated() {
            return isolated_;
          }, "$isolated");
          function isIsolated(dirOptions) {
            var _a3;
            dirOptions = dirOptions !== null && dirOptions !== void 0 ? dirOptions : { isolated: isolated_ };
            var isolated = isBoolean3(dirOptions) ? dirOptions : (_a3 = dirOptions.isolated) !== null && _a3 !== void 0 ? _a3 : isolated_;
            return isolated;
          }
          __name(isIsolated, "isIsolated");
          function finalPathSegment(dirOptions) {
            return isIsolated(dirOptions) ? name : "";
          }
          __name(finalPathSegment, "finalPathSegment");
          XDGAppPaths.cache = /* @__PURE__ */ __name(function cache2(dirOptions) {
            return path67.join(xdg.cache(), finalPathSegment(dirOptions));
          }, "cache");
          XDGAppPaths.config = /* @__PURE__ */ __name(function config(dirOptions) {
            return path67.join(xdg.config(), finalPathSegment(dirOptions));
          }, "config");
          XDGAppPaths.data = /* @__PURE__ */ __name(function data(dirOptions) {
            return path67.join(xdg.data(), finalPathSegment(dirOptions));
          }, "data");
          XDGAppPaths.runtime = /* @__PURE__ */ __name(function runtime(dirOptions) {
            return xdg.runtime() ? path67.join(xdg.runtime(), finalPathSegment(dirOptions)) : void 0;
          }, "runtime");
          XDGAppPaths.state = /* @__PURE__ */ __name(function state(dirOptions) {
            return path67.join(xdg.state(), finalPathSegment(dirOptions));
          }, "state");
          XDGAppPaths.configDirs = /* @__PURE__ */ __name(function configDirs(dirOptions) {
            return xdg.configDirs().map(function(s) {
              return path67.join(s, finalPathSegment(dirOptions));
            });
          }, "configDirs");
          XDGAppPaths.dataDirs = /* @__PURE__ */ __name(function dataDirs(dirOptions) {
            return xdg.dataDirs().map(function(s) {
              return path67.join(s, finalPathSegment(dirOptions));
            });
          }, "dataDirs");
          return XDGAppPaths;
        }
        __name(XDGAppPaths_2, "XDGAppPaths_");
        return XDGAppPaths_2;
      }();
      return { XDGAppPaths: new XDGAppPaths_() };
    }
    __name(Adapt, "Adapt");
    exports2.Adapt = Adapt;
  }
});

// ../../node_modules/.pnpm/xdg-portable@10.6.0/node_modules/xdg-portable/dist/cjs/lib/XDG.js
var require_XDG = __commonJS({
  "../../node_modules/.pnpm/xdg-portable@10.6.0/node_modules/xdg-portable/dist/cjs/lib/XDG.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __spreadArray = exports2 && exports2.__spreadArray || function(to, from) {
      for (var i = 0, il = from.length, j2 = to.length; i < il; i++, j2++)
        to[j2] = from[i];
      return to;
    };
    exports2.__esModule = true;
    exports2.Adapt = void 0;
    function Adapt(adapter_) {
      var env5 = adapter_.env, osPaths = adapter_.osPaths, path67 = adapter_.path;
      var isMacOS = /^darwin$/i.test(adapter_.process.platform);
      var isWinOS = /^win/i.test(adapter_.process.platform);
      function baseDir() {
        return osPaths.home() || osPaths.temp();
      }
      __name(baseDir, "baseDir");
      function valOrPath(val, pathSegments) {
        return val || path67.join.apply(path67, pathSegments);
      }
      __name(valOrPath, "valOrPath");
      var linux = /* @__PURE__ */ __name(function() {
        var cache2 = /* @__PURE__ */ __name(function() {
          return valOrPath(env5.get("XDG_CACHE_HOME"), [baseDir(), ".cache"]);
        }, "cache");
        var config = /* @__PURE__ */ __name(function() {
          return valOrPath(env5.get("XDG_CONFIG_HOME"), [baseDir(), ".config"]);
        }, "config");
        var data = /* @__PURE__ */ __name(function() {
          return valOrPath(env5.get("XDG_DATA_HOME"), [baseDir(), ".local", "share"]);
        }, "data");
        var runtime = /* @__PURE__ */ __name(function() {
          return env5.get("XDG_RUNTIME_DIR") || void 0;
        }, "runtime");
        var state = /* @__PURE__ */ __name(function() {
          return valOrPath(env5.get("XDG_STATE_HOME"), [baseDir(), ".local", "state"]);
        }, "state");
        return { cache: cache2, config, data, runtime, state };
      }, "linux");
      var macos = /* @__PURE__ */ __name(function() {
        var cache2 = /* @__PURE__ */ __name(function() {
          return valOrPath(env5.get("XDG_CACHE_HOME"), [baseDir(), "Library", "Caches"]);
        }, "cache");
        var config = /* @__PURE__ */ __name(function() {
          return valOrPath(env5.get("XDG_CONFIG_HOME"), [baseDir(), "Library", "Preferences"]);
        }, "config");
        var data = /* @__PURE__ */ __name(function() {
          return valOrPath(env5.get("XDG_DATA_HOME"), [baseDir(), "Library", "Application Support"]);
        }, "data");
        var runtime = /* @__PURE__ */ __name(function() {
          return env5.get("XDG_RUNTIME_DIR") || void 0;
        }, "runtime");
        var state = /* @__PURE__ */ __name(function() {
          return valOrPath(env5.get("XDG_STATE_HOME"), [baseDir(), "Library", "State"]);
        }, "state");
        return { cache: cache2, config, data, runtime, state };
      }, "macos");
      var windows = /* @__PURE__ */ __name(function() {
        function appData() {
          return valOrPath(env5.get("APPDATA"), [baseDir(), "AppData", "Roaming"]);
        }
        __name(appData, "appData");
        function localAppData() {
          return valOrPath(env5.get("LOCALAPPDATA"), [baseDir(), "AppData", "Local"]);
        }
        __name(localAppData, "localAppData");
        var cache2 = /* @__PURE__ */ __name(function() {
          return valOrPath(env5.get("XDG_CACHE_HOME"), [localAppData(), "xdg.cache"]);
        }, "cache");
        var config = /* @__PURE__ */ __name(function() {
          return valOrPath(env5.get("XDG_CONFIG_HOME"), [appData(), "xdg.config"]);
        }, "config");
        var data = /* @__PURE__ */ __name(function() {
          return valOrPath(env5.get("XDG_DATA_HOME"), [appData(), "xdg.data"]);
        }, "data");
        var runtime = /* @__PURE__ */ __name(function() {
          return env5.get("XDG_RUNTIME_DIR") || void 0;
        }, "runtime");
        var state = /* @__PURE__ */ __name(function() {
          return valOrPath(env5.get("XDG_STATE_HOME"), [localAppData(), "xdg.state"]);
        }, "state");
        return { cache: cache2, config, data, runtime, state };
      }, "windows");
      var XDG_ = function() {
        function XDG_2() {
          function XDG() {
            return new XDG_2();
          }
          __name(XDG, "XDG");
          var extension = isMacOS ? macos() : isWinOS ? windows() : linux();
          XDG.cache = extension.cache;
          XDG.config = extension.config;
          XDG.data = extension.data;
          XDG.runtime = extension.runtime;
          XDG.state = extension.state;
          XDG.configDirs = /* @__PURE__ */ __name(function configDirs() {
            var pathList = env5.get("XDG_CONFIG_DIRS");
            return __spreadArray([extension.config()], pathList ? pathList.split(path67.delimiter) : []);
          }, "configDirs");
          XDG.dataDirs = /* @__PURE__ */ __name(function dataDirs() {
            var pathList = env5.get("XDG_DATA_DIRS");
            return __spreadArray([extension.data()], pathList ? pathList.split(path67.delimiter) : []);
          }, "dataDirs");
          return XDG;
        }
        __name(XDG_2, "XDG_");
        return XDG_2;
      }();
      return { XDG: new XDG_() };
    }
    __name(Adapt, "Adapt");
    exports2.Adapt = Adapt;
  }
});

// ../../node_modules/.pnpm/os-paths@7.4.0/node_modules/os-paths/dist/cjs/lib/OSPaths.js
var require_OSPaths = __commonJS({
  "../../node_modules/.pnpm/os-paths@7.4.0/node_modules/os-paths/dist/cjs/lib/OSPaths.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __spreadArray = exports2 && exports2.__spreadArray || function(to, from) {
      for (var i = 0, il = from.length, j2 = to.length; i < il; i++, j2++)
        to[j2] = from[i];
      return to;
    };
    exports2.__esModule = true;
    exports2.Adapt = void 0;
    function isEmpty(s) {
      return !s;
    }
    __name(isEmpty, "isEmpty");
    function Adapt(adapter_) {
      var env5 = adapter_.env, os11 = adapter_.os, path67 = adapter_.path;
      var isWinOS = /^win/i.test(adapter_.process.platform);
      function normalizePath(path_) {
        return path_ ? adapter_.path.normalize(adapter_.path.join(path_, ".")) : void 0;
      }
      __name(normalizePath, "normalizePath");
      function home() {
        var posix2 = /* @__PURE__ */ __name(function() {
          return normalizePath((typeof os11.homedir === "function" ? os11.homedir() : void 0) || env5.get("HOME"));
        }, "posix");
        var windows = /* @__PURE__ */ __name(function() {
          var priorityList = [
            typeof os11.homedir === "function" ? os11.homedir() : void 0,
            env5.get("USERPROFILE"),
            env5.get("HOME"),
            env5.get("HOMEDRIVE") || env5.get("HOMEPATH") ? path67.join(env5.get("HOMEDRIVE") || "", env5.get("HOMEPATH") || "") : void 0
          ];
          return normalizePath(priorityList.find(function(v2) {
            return !isEmpty(v2);
          }));
        }, "windows");
        return isWinOS ? windows() : posix2();
      }
      __name(home, "home");
      function temp() {
        function joinPathToBase(base, segments) {
          return base ? path67.join.apply(path67, __spreadArray([base], segments)) : void 0;
        }
        __name(joinPathToBase, "joinPathToBase");
        function posix2() {
          var fallback = "/tmp";
          var priorityList = [
            typeof os11.tmpdir === "function" ? os11.tmpdir() : void 0,
            env5.get("TMPDIR"),
            env5.get("TEMP"),
            env5.get("TMP")
          ];
          return normalizePath(priorityList.find(function(v2) {
            return !isEmpty(v2);
          })) || fallback;
        }
        __name(posix2, "posix");
        function windows() {
          var fallback = "C:\\Temp";
          var priorityListLazy = [
            typeof os11.tmpdir === "function" ? os11.tmpdir : function() {
              return void 0;
            },
            function() {
              return env5.get("TEMP");
            },
            function() {
              return env5.get("TMP");
            },
            function() {
              return joinPathToBase(env5.get("LOCALAPPDATA"), ["Temp"]);
            },
            function() {
              return joinPathToBase(home(), ["AppData", "Local", "Temp"]);
            },
            function() {
              return joinPathToBase(env5.get("ALLUSERSPROFILE"), ["Temp"]);
            },
            function() {
              return joinPathToBase(env5.get("SystemRoot"), ["Temp"]);
            },
            function() {
              return joinPathToBase(env5.get("windir"), ["Temp"]);
            },
            function() {
              return joinPathToBase(env5.get("SystemDrive"), ["\\", "Temp"]);
            }
          ];
          var v2 = priorityListLazy.find(function(v3) {
            return v3 && !isEmpty(v3());
          });
          return v2 && normalizePath(v2()) || fallback;
        }
        __name(windows, "windows");
        return isWinOS ? windows() : posix2();
      }
      __name(temp, "temp");
      var OSPaths_ = function() {
        function OSPaths_2() {
          function OSPaths() {
            return new OSPaths_2();
          }
          __name(OSPaths, "OSPaths");
          OSPaths.home = home;
          OSPaths.temp = temp;
          return OSPaths;
        }
        __name(OSPaths_2, "OSPaths_");
        return OSPaths_2;
      }();
      return { OSPaths: new OSPaths_() };
    }
    __name(Adapt, "Adapt");
    exports2.Adapt = Adapt;
  }
});

// ../../node_modules/.pnpm/os-paths@7.4.0/node_modules/os-paths/dist/cjs/platform-adapters/node.js
var require_node = __commonJS({
  "../../node_modules/.pnpm/os-paths@7.4.0/node_modules/os-paths/dist/cjs/platform-adapters/node.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o2, m2, k2, k22) {
      if (k22 === void 0)
        k22 = k2;
      Object.defineProperty(o2, k22, { enumerable: true, get: function() {
        return m2[k2];
      } });
    } : function(o2, m2, k2, k22) {
      if (k22 === void 0)
        k22 = k2;
      o2[k22] = m2[k2];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o2, v2) {
      Object.defineProperty(o2, "default", { enumerable: true, value: v2 });
    } : function(o2, v2) {
      o2["default"] = v2;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule)
        return mod;
      var result = {};
      if (mod != null) {
        for (var k2 in mod)
          if (k2 !== "default" && Object.prototype.hasOwnProperty.call(mod, k2))
            __createBinding(result, mod, k2);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    exports2.__esModule = true;
    exports2.adapter = void 0;
    var os11 = __importStar(require("os"));
    var path67 = __importStar(require("path"));
    exports2.adapter = {
      atImportPermissions: { env: true },
      env: {
        get: function(s) {
          return process.env[s];
        }
      },
      os: os11,
      path: path67,
      process
    };
  }
});

// ../../node_modules/.pnpm/os-paths@7.4.0/node_modules/os-paths/dist/cjs/mod.cjs.js
var require_mod_cjs = __commonJS({
  "../../node_modules/.pnpm/os-paths@7.4.0/node_modules/os-paths/dist/cjs/mod.cjs.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var OSPaths_js_1 = require_OSPaths();
    var node_js_1 = require_node();
    module3.exports = OSPaths_js_1.Adapt(node_js_1.adapter).OSPaths;
  }
});

// ../../node_modules/.pnpm/xdg-portable@10.6.0/node_modules/xdg-portable/dist/cjs/platform-adapters/node.js
var require_node2 = __commonJS({
  "../../node_modules/.pnpm/xdg-portable@10.6.0/node_modules/xdg-portable/dist/cjs/platform-adapters/node.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o2, m2, k2, k22) {
      if (k22 === void 0)
        k22 = k2;
      Object.defineProperty(o2, k22, { enumerable: true, get: function() {
        return m2[k2];
      } });
    } : function(o2, m2, k2, k22) {
      if (k22 === void 0)
        k22 = k2;
      o2[k22] = m2[k2];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o2, v2) {
      Object.defineProperty(o2, "default", { enumerable: true, value: v2 });
    } : function(o2, v2) {
      o2["default"] = v2;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule)
        return mod;
      var result = {};
      if (mod != null) {
        for (var k2 in mod)
          if (k2 !== "default" && Object.prototype.hasOwnProperty.call(mod, k2))
            __createBinding(result, mod, k2);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    exports2.__esModule = true;
    exports2.adapter = void 0;
    var path67 = __importStar(require("path"));
    var os_paths_1 = __importDefault(require_mod_cjs());
    exports2.adapter = {
      atImportPermissions: { env: true },
      env: {
        get: function(s) {
          return process.env[s];
        }
      },
      osPaths: os_paths_1["default"],
      path: path67,
      process
    };
  }
});

// ../../node_modules/.pnpm/xdg-portable@10.6.0/node_modules/xdg-portable/dist/cjs/mod.cjs.js
var require_mod_cjs2 = __commonJS({
  "../../node_modules/.pnpm/xdg-portable@10.6.0/node_modules/xdg-portable/dist/cjs/mod.cjs.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var XDG_js_1 = require_XDG();
    var node_js_1 = require_node2();
    module3.exports = XDG_js_1.Adapt(node_js_1.adapter).XDG;
  }
});

// ../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/platform-adapters/node.js
var require_node3 = __commonJS({
  "../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/platform-adapters/node.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o2, m2, k2, k22) {
      if (k22 === void 0)
        k22 = k2;
      Object.defineProperty(o2, k22, { enumerable: true, get: function() {
        return m2[k2];
      } });
    } : function(o2, m2, k2, k22) {
      if (k22 === void 0)
        k22 = k2;
      o2[k22] = m2[k2];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o2, v2) {
      Object.defineProperty(o2, "default", { enumerable: true, value: v2 });
    } : function(o2, v2) {
      o2["default"] = v2;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule)
        return mod;
      var result = {};
      if (mod != null) {
        for (var k2 in mod)
          if (k2 !== "default" && Object.prototype.hasOwnProperty.call(mod, k2))
            __createBinding(result, mod, k2);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    exports2.__esModule = true;
    exports2.adapter = void 0;
    var path67 = __importStar(require("path"));
    var xdg_portable_1 = __importDefault(require_mod_cjs2());
    exports2.adapter = {
      atImportPermissions: { env: true, read: true },
      meta: {
        mainFilename: function() {
          var requireMain = typeof require !== "undefined" && require !== null && require.main ? require.main : { filename: void 0 };
          var requireMainFilename = requireMain.filename;
          var filename = (requireMainFilename !== process.execArgv[0] ? requireMainFilename : void 0) || (typeof process._eval === "undefined" ? process.argv[1] : void 0);
          return filename;
        },
        pkgMainFilename: function() {
          return process.pkg ? process.execPath : void 0;
        }
      },
      path: path67,
      process,
      xdg: xdg_portable_1["default"]
    };
  }
});

// ../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/mod.cjs.js
var require_mod_cjs3 = __commonJS({
  "../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/mod.cjs.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var XDGAppPaths_js_1 = require_XDGAppPaths();
    var node_js_1 = require_node3();
    module3.exports = XDGAppPaths_js_1.Adapt(node_js_1.adapter).XDGAppPaths;
  }
});

// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/parser.js
var require_parser = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/parser.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var ParserEND = 1114112;
    var ParserError = class extends Error {
      /* istanbul ignore next */
      constructor(msg, filename, linenumber) {
        super("[ParserError] " + msg, filename, linenumber);
        this.name = "ParserError";
        this.code = "ParserError";
        if (Error.captureStackTrace)
          Error.captureStackTrace(this, ParserError);
      }
    };
    __name(ParserError, "ParserError");
    var State2 = class {
      constructor(parser2) {
        this.parser = parser2;
        this.buf = "";
        this.returned = null;
        this.result = null;
        this.resultTable = null;
        this.resultArr = null;
      }
    };
    __name(State2, "State");
    var Parser2 = class {
      constructor() {
        this.pos = 0;
        this.col = 0;
        this.line = 0;
        this.obj = {};
        this.ctx = this.obj;
        this.stack = [];
        this._buf = "";
        this.char = null;
        this.ii = 0;
        this.state = new State2(this.parseStart);
      }
      parse(str) {
        if (str.length === 0 || str.length == null)
          return;
        this._buf = String(str);
        this.ii = -1;
        this.char = -1;
        let getNext;
        while (getNext === false || this.nextChar()) {
          getNext = this.runOne();
        }
        this._buf = null;
      }
      nextChar() {
        if (this.char === 10) {
          ++this.line;
          this.col = -1;
        }
        ++this.ii;
        this.char = this._buf.codePointAt(this.ii);
        ++this.pos;
        ++this.col;
        return this.haveBuffer();
      }
      haveBuffer() {
        return this.ii < this._buf.length;
      }
      runOne() {
        return this.state.parser.call(this, this.state.returned);
      }
      finish() {
        this.char = ParserEND;
        let last;
        do {
          last = this.state.parser;
          this.runOne();
        } while (this.state.parser !== last);
        this.ctx = null;
        this.state = null;
        this._buf = null;
        return this.obj;
      }
      next(fn2) {
        if (typeof fn2 !== "function")
          throw new ParserError("Tried to set state to non-existent state: " + JSON.stringify(fn2));
        this.state.parser = fn2;
      }
      goto(fn2) {
        this.next(fn2);
        return this.runOne();
      }
      call(fn2, returnWith) {
        if (returnWith)
          this.next(returnWith);
        this.stack.push(this.state);
        this.state = new State2(fn2);
      }
      callNow(fn2, returnWith) {
        this.call(fn2, returnWith);
        return this.runOne();
      }
      return(value) {
        if (this.stack.length === 0)
          throw this.error(new ParserError("Stack underflow"));
        if (value === void 0)
          value = this.state.buf;
        this.state = this.stack.pop();
        this.state.returned = value;
      }
      returnNow(value) {
        this.return(value);
        return this.runOne();
      }
      consume() {
        if (this.char === ParserEND)
          throw this.error(new ParserError("Unexpected end-of-buffer"));
        this.state.buf += this._buf[this.ii];
      }
      error(err) {
        err.line = this.line;
        err.col = this.col;
        err.pos = this.pos;
        return err;
      }
      /* istanbul ignore next */
      parseStart() {
        throw new ParserError("Must declare a parseStart method");
      }
    };
    __name(Parser2, "Parser");
    Parser2.END = ParserEND;
    Parser2.Error = ParserError;
    module3.exports = Parser2;
  }
});

// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/create-datetime.js
var require_create_datetime = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/create-datetime.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = (value) => {
      const date = new Date(value);
      if (isNaN(date)) {
        throw new TypeError("Invalid Datetime");
      } else {
        return date;
      }
    };
  }
});

// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/format-num.js
var require_format_num = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/format-num.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = (d2, num) => {
      num = String(num);
      while (num.length < d2)
        num = "0" + num;
      return num;
    };
  }
});

// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/create-datetime-float.js
var require_create_datetime_float = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/create-datetime-float.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var f = require_format_num();
    var FloatingDateTime = class extends Date {
      constructor(value) {
        super(value + "Z");
        this.isFloating = true;
      }
      toISOString() {
        const date = `${this.getUTCFullYear()}-${f(2, this.getUTCMonth() + 1)}-${f(2, this.getUTCDate())}`;
        const time = `${f(2, this.getUTCHours())}:${f(2, this.getUTCMinutes())}:${f(2, this.getUTCSeconds())}.${f(3, this.getUTCMilliseconds())}`;
        return `${date}T${time}`;
      }
    };
    __name(FloatingDateTime, "FloatingDateTime");
    module3.exports = (value) => {
      const date = new FloatingDateTime(value);
      if (isNaN(date)) {
        throw new TypeError("Invalid Datetime");
      } else {
        return date;
      }
    };
  }
});

// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/create-date.js
var require_create_date = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/create-date.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var f = require_format_num();
    var DateTime = global.Date;
    var Date2 = class extends DateTime {
      constructor(value) {
        super(value);
        this.isDate = true;
      }
      toISOString() {
        return `${this.getUTCFullYear()}-${f(2, this.getUTCMonth() + 1)}-${f(2, this.getUTCDate())}`;
      }
    };
    __name(Date2, "Date");
    module3.exports = (value) => {
      const date = new Date2(value);
      if (isNaN(date)) {
        throw new TypeError("Invalid Datetime");
      } else {
        return date;
      }
    };
  }
});

// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/create-time.js
var require_create_time = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/create-time.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var f = require_format_num();
    var Time = class extends Date {
      constructor(value) {
        super(`0000-01-01T${value}Z`);
        this.isTime = true;
      }
      toISOString() {
        return `${f(2, this.getUTCHours())}:${f(2, this.getUTCMinutes())}:${f(2, this.getUTCSeconds())}.${f(3, this.getUTCMilliseconds())}`;
      }
    };
    __name(Time, "Time");
    module3.exports = (value) => {
      const date = new Time(value);
      if (isNaN(date)) {
        throw new TypeError("Invalid Datetime");
      } else {
        return date;
      }
    };
  }
});

// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/toml-parser.js
var require_toml_parser = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/lib/toml-parser.js"(exports, module) {
    "use strict";
    init_import_meta_url();
    module.exports = makeParserClass(require_parser());
    module.exports.makeParserClass = makeParserClass;
    var TomlError = class extends Error {
      constructor(msg) {
        super(msg);
        this.name = "TomlError";
        if (Error.captureStackTrace)
          Error.captureStackTrace(this, TomlError);
        this.fromTOML = true;
        this.wrapped = null;
      }
    };
    __name(TomlError, "TomlError");
    TomlError.wrap = (err) => {
      const terr = new TomlError(err.message);
      terr.code = err.code;
      terr.wrapped = err;
      return terr;
    };
    module.exports.TomlError = TomlError;
    var createDateTime = require_create_datetime();
    var createDateTimeFloat = require_create_datetime_float();
    var createDate = require_create_date();
    var createTime = require_create_time();
    var CTRL_I = 9;
    var CTRL_J = 10;
    var CTRL_M = 13;
    var CTRL_CHAR_BOUNDARY = 31;
    var CHAR_SP = 32;
    var CHAR_QUOT = 34;
    var CHAR_NUM = 35;
    var CHAR_APOS = 39;
    var CHAR_PLUS = 43;
    var CHAR_COMMA = 44;
    var CHAR_HYPHEN = 45;
    var CHAR_PERIOD = 46;
    var CHAR_0 = 48;
    var CHAR_1 = 49;
    var CHAR_7 = 55;
    var CHAR_9 = 57;
    var CHAR_COLON = 58;
    var CHAR_EQUALS = 61;
    var CHAR_A = 65;
    var CHAR_E = 69;
    var CHAR_F = 70;
    var CHAR_T = 84;
    var CHAR_U = 85;
    var CHAR_Z = 90;
    var CHAR_LOWBAR = 95;
    var CHAR_a = 97;
    var CHAR_b = 98;
    var CHAR_e = 101;
    var CHAR_f = 102;
    var CHAR_i = 105;
    var CHAR_l = 108;
    var CHAR_n = 110;
    var CHAR_o = 111;
    var CHAR_r = 114;
    var CHAR_s = 115;
    var CHAR_t = 116;
    var CHAR_u = 117;
    var CHAR_x = 120;
    var CHAR_z = 122;
    var CHAR_LCUB = 123;
    var CHAR_RCUB = 125;
    var CHAR_LSQB = 91;
    var CHAR_BSOL = 92;
    var CHAR_RSQB = 93;
    var CHAR_DEL = 127;
    var SURROGATE_FIRST = 55296;
    var SURROGATE_LAST = 57343;
    var escapes = {
      [CHAR_b]: "\b",
      [CHAR_t]: "	",
      [CHAR_n]: "\n",
      [CHAR_f]: "\f",
      [CHAR_r]: "\r",
      [CHAR_QUOT]: '"',
      [CHAR_BSOL]: "\\"
    };
    function isDigit(cp2) {
      return cp2 >= CHAR_0 && cp2 <= CHAR_9;
    }
    __name(isDigit, "isDigit");
    function isHexit(cp2) {
      return cp2 >= CHAR_A && cp2 <= CHAR_F || cp2 >= CHAR_a && cp2 <= CHAR_f || cp2 >= CHAR_0 && cp2 <= CHAR_9;
    }
    __name(isHexit, "isHexit");
    function isBit(cp2) {
      return cp2 === CHAR_1 || cp2 === CHAR_0;
    }
    __name(isBit, "isBit");
    function isOctit(cp2) {
      return cp2 >= CHAR_0 && cp2 <= CHAR_7;
    }
    __name(isOctit, "isOctit");
    function isAlphaNumQuoteHyphen(cp2) {
      return cp2 >= CHAR_A && cp2 <= CHAR_Z || cp2 >= CHAR_a && cp2 <= CHAR_z || cp2 >= CHAR_0 && cp2 <= CHAR_9 || cp2 === CHAR_APOS || cp2 === CHAR_QUOT || cp2 === CHAR_LOWBAR || cp2 === CHAR_HYPHEN;
    }
    __name(isAlphaNumQuoteHyphen, "isAlphaNumQuoteHyphen");
    function isAlphaNumHyphen(cp2) {
      return cp2 >= CHAR_A && cp2 <= CHAR_Z || cp2 >= CHAR_a && cp2 <= CHAR_z || cp2 >= CHAR_0 && cp2 <= CHAR_9 || cp2 === CHAR_LOWBAR || cp2 === CHAR_HYPHEN;
    }
    __name(isAlphaNumHyphen, "isAlphaNumHyphen");
    var _type = Symbol("type");
    var _declared = Symbol("declared");
    var hasOwnProperty = Object.prototype.hasOwnProperty;
    var defineProperty = Object.defineProperty;
    var descriptor = { configurable: true, enumerable: true, writable: true, value: void 0 };
    function hasKey(obj, key) {
      if (hasOwnProperty.call(obj, key))
        return true;
      if (key === "__proto__")
        defineProperty(obj, "__proto__", descriptor);
      return false;
    }
    __name(hasKey, "hasKey");
    var INLINE_TABLE = Symbol("inline-table");
    function InlineTable() {
      return Object.defineProperties({}, {
        [_type]: { value: INLINE_TABLE }
      });
    }
    __name(InlineTable, "InlineTable");
    function isInlineTable(obj) {
      if (obj === null || typeof obj !== "object")
        return false;
      return obj[_type] === INLINE_TABLE;
    }
    __name(isInlineTable, "isInlineTable");
    var TABLE = Symbol("table");
    function Table() {
      return Object.defineProperties({}, {
        [_type]: { value: TABLE },
        [_declared]: { value: false, writable: true }
      });
    }
    __name(Table, "Table");
    function isTable(obj) {
      if (obj === null || typeof obj !== "object")
        return false;
      return obj[_type] === TABLE;
    }
    __name(isTable, "isTable");
    var _contentType = Symbol("content-type");
    var INLINE_LIST = Symbol("inline-list");
    function InlineList(type) {
      return Object.defineProperties([], {
        [_type]: { value: INLINE_LIST },
        [_contentType]: { value: type }
      });
    }
    __name(InlineList, "InlineList");
    function isInlineList(obj) {
      if (obj === null || typeof obj !== "object")
        return false;
      return obj[_type] === INLINE_LIST;
    }
    __name(isInlineList, "isInlineList");
    var LIST = Symbol("list");
    function List() {
      return Object.defineProperties([], {
        [_type]: { value: LIST }
      });
    }
    __name(List, "List");
    function isList(obj) {
      if (obj === null || typeof obj !== "object")
        return false;
      return obj[_type] === LIST;
    }
    __name(isList, "isList");
    var _custom;
    try {
      const utilInspect = eval("require('util').inspect");
      _custom = utilInspect.custom;
    } catch (_3) {
    }
    var _inspect = _custom || "inspect";
    var BoxedBigInt = class {
      constructor(value) {
        try {
          this.value = global.BigInt.asIntN(64, value);
        } catch (_3) {
          this.value = null;
        }
        Object.defineProperty(this, _type, { value: INTEGER });
      }
      isNaN() {
        return this.value === null;
      }
      /* istanbul ignore next */
      toString() {
        return String(this.value);
      }
      /* istanbul ignore next */
      [_inspect]() {
        return `[BigInt: ${this.toString()}]}`;
      }
      valueOf() {
        return this.value;
      }
    };
    __name(BoxedBigInt, "BoxedBigInt");
    var INTEGER = Symbol("integer");
    function Integer(value) {
      let num = Number(value);
      if (Object.is(num, -0))
        num = 0;
      if (global.BigInt && !Number.isSafeInteger(num)) {
        return new BoxedBigInt(value);
      } else {
        return Object.defineProperties(new Number(num), {
          isNaN: { value: function() {
            return isNaN(this);
          } },
          [_type]: { value: INTEGER },
          [_inspect]: { value: () => `[Integer: ${value}]` }
        });
      }
    }
    __name(Integer, "Integer");
    function isInteger(obj) {
      if (obj === null || typeof obj !== "object")
        return false;
      return obj[_type] === INTEGER;
    }
    __name(isInteger, "isInteger");
    var FLOAT = Symbol("float");
    function Float(value) {
      return Object.defineProperties(new Number(value), {
        [_type]: { value: FLOAT },
        [_inspect]: { value: () => `[Float: ${value}]` }
      });
    }
    __name(Float, "Float");
    function isFloat(obj) {
      if (obj === null || typeof obj !== "object")
        return false;
      return obj[_type] === FLOAT;
    }
    __name(isFloat, "isFloat");
    function tomlType(value) {
      const type = typeof value;
      if (type === "object") {
        if (value === null)
          return "null";
        if (value instanceof Date)
          return "datetime";
        if (_type in value) {
          switch (value[_type]) {
            case INLINE_TABLE:
              return "inline-table";
            case INLINE_LIST:
              return "inline-list";
            case TABLE:
              return "table";
            case LIST:
              return "list";
            case FLOAT:
              return "float";
            case INTEGER:
              return "integer";
          }
        }
      }
      return type;
    }
    __name(tomlType, "tomlType");
    function makeParserClass(Parser2) {
      class TOMLParser extends Parser2 {
        constructor() {
          super();
          this.ctx = this.obj = Table();
        }
        /* MATCH HELPER */
        atEndOfWord() {
          return this.char === CHAR_NUM || this.char === CTRL_I || this.char === CHAR_SP || this.atEndOfLine();
        }
        atEndOfLine() {
          return this.char === Parser2.END || this.char === CTRL_J || this.char === CTRL_M;
        }
        parseStart() {
          if (this.char === Parser2.END) {
            return null;
          } else if (this.char === CHAR_LSQB) {
            return this.call(this.parseTableOrList);
          } else if (this.char === CHAR_NUM) {
            return this.call(this.parseComment);
          } else if (this.char === CTRL_J || this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
            return null;
          } else if (isAlphaNumQuoteHyphen(this.char)) {
            return this.callNow(this.parseAssignStatement);
          } else {
            throw this.error(new TomlError(`Unknown character "${this.char}"`));
          }
        }
        // HELPER, this strips any whitespace and comments to the end of the line
        // then RETURNS. Last state in a production.
        parseWhitespaceToEOL() {
          if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
            return null;
          } else if (this.char === CHAR_NUM) {
            return this.goto(this.parseComment);
          } else if (this.char === Parser2.END || this.char === CTRL_J) {
            return this.return();
          } else {
            throw this.error(new TomlError("Unexpected character, expected only whitespace or comments till end of line"));
          }
        }
        /* ASSIGNMENT: key = value */
        parseAssignStatement() {
          return this.callNow(this.parseAssign, this.recordAssignStatement);
        }
        recordAssignStatement(kv) {
          let target = this.ctx;
          let finalKey = kv.key.pop();
          for (let kw of kv.key) {
            if (hasKey(target, kw) && !isTable(target[kw])) {
              throw this.error(new TomlError("Can't redefine existing key"));
            }
            target = target[kw] = target[kw] || Table();
          }
          if (hasKey(target, finalKey)) {
            throw this.error(new TomlError("Can't redefine existing key"));
          }
          target[_declared] = true;
          if (isInteger(kv.value) || isFloat(kv.value)) {
            target[finalKey] = kv.value.valueOf();
          } else {
            target[finalKey] = kv.value;
          }
          return this.goto(this.parseWhitespaceToEOL);
        }
        /* ASSSIGNMENT expression, key = value possibly inside an inline table */
        parseAssign() {
          return this.callNow(this.parseKeyword, this.recordAssignKeyword);
        }
        recordAssignKeyword(key) {
          if (this.state.resultTable) {
            this.state.resultTable.push(key);
          } else {
            this.state.resultTable = [key];
          }
          return this.goto(this.parseAssignKeywordPreDot);
        }
        parseAssignKeywordPreDot() {
          if (this.char === CHAR_PERIOD) {
            return this.next(this.parseAssignKeywordPostDot);
          } else if (this.char !== CHAR_SP && this.char !== CTRL_I) {
            return this.goto(this.parseAssignEqual);
          }
        }
        parseAssignKeywordPostDot() {
          if (this.char !== CHAR_SP && this.char !== CTRL_I) {
            return this.callNow(this.parseKeyword, this.recordAssignKeyword);
          }
        }
        parseAssignEqual() {
          if (this.char === CHAR_EQUALS) {
            return this.next(this.parseAssignPreValue);
          } else {
            throw this.error(new TomlError('Invalid character, expected "="'));
          }
        }
        parseAssignPreValue() {
          if (this.char === CHAR_SP || this.char === CTRL_I) {
            return null;
          } else {
            return this.callNow(this.parseValue, this.recordAssignValue);
          }
        }
        recordAssignValue(value) {
          return this.returnNow({ key: this.state.resultTable, value });
        }
        /* COMMENTS: #...eol */
        parseComment() {
          do {
            if (this.char === Parser2.END || this.char === CTRL_J) {
              return this.return();
            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I) {
              throw this.errorControlCharIn("comments");
            }
          } while (this.nextChar());
        }
        /* TABLES AND LISTS, [foo] and [[foo]] */
        parseTableOrList() {
          if (this.char === CHAR_LSQB) {
            this.next(this.parseList);
          } else {
            return this.goto(this.parseTable);
          }
        }
        /* TABLE [foo.bar.baz] */
        parseTable() {
          this.ctx = this.obj;
          return this.goto(this.parseTableNext);
        }
        parseTableNext() {
          if (this.char === CHAR_SP || this.char === CTRL_I) {
            return null;
          } else {
            return this.callNow(this.parseKeyword, this.parseTableMore);
          }
        }
        parseTableMore(keyword) {
          if (this.char === CHAR_SP || this.char === CTRL_I) {
            return null;
          } else if (this.char === CHAR_RSQB) {
            if (hasKey(this.ctx, keyword) && (!isTable(this.ctx[keyword]) || this.ctx[keyword][_declared])) {
              throw this.error(new TomlError("Can't redefine existing key"));
            } else {
              this.ctx = this.ctx[keyword] = this.ctx[keyword] || Table();
              this.ctx[_declared] = true;
            }
            return this.next(this.parseWhitespaceToEOL);
          } else if (this.char === CHAR_PERIOD) {
            if (!hasKey(this.ctx, keyword)) {
              this.ctx = this.ctx[keyword] = Table();
            } else if (isTable(this.ctx[keyword])) {
              this.ctx = this.ctx[keyword];
            } else if (isList(this.ctx[keyword])) {
              this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1];
            } else {
              throw this.error(new TomlError("Can't redefine existing key"));
            }
            return this.next(this.parseTableNext);
          } else {
            throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
          }
        }
        /* LIST [[a.b.c]] */
        parseList() {
          this.ctx = this.obj;
          return this.goto(this.parseListNext);
        }
        parseListNext() {
          if (this.char === CHAR_SP || this.char === CTRL_I) {
            return null;
          } else {
            return this.callNow(this.parseKeyword, this.parseListMore);
          }
        }
        parseListMore(keyword) {
          if (this.char === CHAR_SP || this.char === CTRL_I) {
            return null;
          } else if (this.char === CHAR_RSQB) {
            if (!hasKey(this.ctx, keyword)) {
              this.ctx[keyword] = List();
            }
            if (isInlineList(this.ctx[keyword])) {
              throw this.error(new TomlError("Can't extend an inline array"));
            } else if (isList(this.ctx[keyword])) {
              const next = Table();
              this.ctx[keyword].push(next);
              this.ctx = next;
            } else {
              throw this.error(new TomlError("Can't redefine an existing key"));
            }
            return this.next(this.parseListEnd);
          } else if (this.char === CHAR_PERIOD) {
            if (!hasKey(this.ctx, keyword)) {
              this.ctx = this.ctx[keyword] = Table();
            } else if (isInlineList(this.ctx[keyword])) {
              throw this.error(new TomlError("Can't extend an inline array"));
            } else if (isInlineTable(this.ctx[keyword])) {
              throw this.error(new TomlError("Can't extend an inline table"));
            } else if (isList(this.ctx[keyword])) {
              this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1];
            } else if (isTable(this.ctx[keyword])) {
              this.ctx = this.ctx[keyword];
            } else {
              throw this.error(new TomlError("Can't redefine an existing key"));
            }
            return this.next(this.parseListNext);
          } else {
            throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
          }
        }
        parseListEnd(keyword) {
          if (this.char === CHAR_RSQB) {
            return this.next(this.parseWhitespaceToEOL);
          } else {
            throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
          }
        }
        /* VALUE string, number, boolean, inline list, inline object */
        parseValue() {
          if (this.char === Parser2.END) {
            throw this.error(new TomlError("Key without value"));
          } else if (this.char === CHAR_QUOT) {
            return this.next(this.parseDoubleString);
          }
          if (this.char === CHAR_APOS) {
            return this.next(this.parseSingleString);
          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
            return this.goto(this.parseNumberSign);
          } else if (this.char === CHAR_i) {
            return this.next(this.parseInf);
          } else if (this.char === CHAR_n) {
            return this.next(this.parseNan);
          } else if (isDigit(this.char)) {
            return this.goto(this.parseNumberOrDateTime);
          } else if (this.char === CHAR_t || this.char === CHAR_f) {
            return this.goto(this.parseBoolean);
          } else if (this.char === CHAR_LSQB) {
            return this.call(this.parseInlineList, this.recordValue);
          } else if (this.char === CHAR_LCUB) {
            return this.call(this.parseInlineTable, this.recordValue);
          } else {
            throw this.error(new TomlError("Unexpected character, expecting string, number, datetime, boolean, inline array or inline table"));
          }
        }
        recordValue(value) {
          return this.returnNow(value);
        }
        parseInf() {
          if (this.char === CHAR_n) {
            return this.next(this.parseInf2);
          } else {
            throw this.error(new TomlError('Unexpected character, expected "inf", "+inf" or "-inf"'));
          }
        }
        parseInf2() {
          if (this.char === CHAR_f) {
            if (this.state.buf === "-") {
              return this.return(-Infinity);
            } else {
              return this.return(Infinity);
            }
          } else {
            throw this.error(new TomlError('Unexpected character, expected "inf", "+inf" or "-inf"'));
          }
        }
        parseNan() {
          if (this.char === CHAR_a) {
            return this.next(this.parseNan2);
          } else {
            throw this.error(new TomlError('Unexpected character, expected "nan"'));
          }
        }
        parseNan2() {
          if (this.char === CHAR_n) {
            return this.return(NaN);
          } else {
            throw this.error(new TomlError('Unexpected character, expected "nan"'));
          }
        }
        /* KEYS, barewords or basic, literal, or dotted */
        parseKeyword() {
          if (this.char === CHAR_QUOT) {
            return this.next(this.parseBasicString);
          } else if (this.char === CHAR_APOS) {
            return this.next(this.parseLiteralString);
          } else {
            return this.goto(this.parseBareKey);
          }
        }
        /* KEYS: barewords */
        parseBareKey() {
          do {
            if (this.char === Parser2.END) {
              throw this.error(new TomlError("Key ended without value"));
            } else if (isAlphaNumHyphen(this.char)) {
              this.consume();
            } else if (this.state.buf.length === 0) {
              throw this.error(new TomlError("Empty bare keys are not allowed"));
            } else {
              return this.returnNow();
            }
          } while (this.nextChar());
        }
        /* STRINGS, single quoted (literal) */
        parseSingleString() {
          if (this.char === CHAR_APOS) {
            return this.next(this.parseLiteralMultiStringMaybe);
          } else {
            return this.goto(this.parseLiteralString);
          }
        }
        parseLiteralString() {
          do {
            if (this.char === CHAR_APOS) {
              return this.return();
            } else if (this.atEndOfLine()) {
              throw this.error(new TomlError("Unterminated string"));
            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I) {
              throw this.errorControlCharIn("strings");
            } else {
              this.consume();
            }
          } while (this.nextChar());
        }
        parseLiteralMultiStringMaybe() {
          if (this.char === CHAR_APOS) {
            return this.next(this.parseLiteralMultiString);
          } else {
            return this.returnNow();
          }
        }
        parseLiteralMultiString() {
          if (this.char === CTRL_M) {
            return null;
          } else if (this.char === CTRL_J) {
            return this.next(this.parseLiteralMultiStringContent);
          } else {
            return this.goto(this.parseLiteralMultiStringContent);
          }
        }
        parseLiteralMultiStringContent() {
          do {
            if (this.char === CHAR_APOS) {
              return this.next(this.parseLiteralMultiEnd);
            } else if (this.char === Parser2.END) {
              throw this.error(new TomlError("Unterminated multi-line string"));
            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) {
              throw this.errorControlCharIn("strings");
            } else {
              this.consume();
            }
          } while (this.nextChar());
        }
        parseLiteralMultiEnd() {
          if (this.char === CHAR_APOS) {
            return this.next(this.parseLiteralMultiEnd2);
          } else {
            this.state.buf += "'";
            return this.goto(this.parseLiteralMultiStringContent);
          }
        }
        parseLiteralMultiEnd2() {
          if (this.char === CHAR_APOS) {
            return this.next(this.parseLiteralMultiEnd3);
          } else {
            this.state.buf += "''";
            return this.goto(this.parseLiteralMultiStringContent);
          }
        }
        parseLiteralMultiEnd3() {
          if (this.char === CHAR_APOS) {
            this.state.buf += "'";
            return this.next(this.parseLiteralMultiEnd4);
          } else {
            return this.returnNow();
          }
        }
        parseLiteralMultiEnd4() {
          if (this.char === CHAR_APOS) {
            this.state.buf += "'";
            return this.return();
          } else {
            return this.returnNow();
          }
        }
        /* STRINGS double quoted */
        parseDoubleString() {
          if (this.char === CHAR_QUOT) {
            return this.next(this.parseMultiStringMaybe);
          } else {
            return this.goto(this.parseBasicString);
          }
        }
        parseBasicString() {
          do {
            if (this.char === CHAR_BSOL) {
              return this.call(this.parseEscape, this.recordEscapeReplacement);
            } else if (this.char === CHAR_QUOT) {
              return this.return();
            } else if (this.atEndOfLine()) {
              throw this.error(new TomlError("Unterminated string"));
            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I) {
              throw this.errorControlCharIn("strings");
            } else {
              this.consume();
            }
          } while (this.nextChar());
        }
        recordEscapeReplacement(replacement) {
          this.state.buf += replacement;
          return this.goto(this.parseBasicString);
        }
        parseMultiStringMaybe() {
          if (this.char === CHAR_QUOT) {
            return this.next(this.parseMultiString);
          } else {
            return this.returnNow();
          }
        }
        parseMultiString() {
          if (this.char === CTRL_M) {
            return null;
          } else if (this.char === CTRL_J) {
            return this.next(this.parseMultiStringContent);
          } else {
            return this.goto(this.parseMultiStringContent);
          }
        }
        parseMultiStringContent() {
          do {
            if (this.char === CHAR_BSOL) {
              return this.call(this.parseMultiEscape, this.recordMultiEscapeReplacement);
            } else if (this.char === CHAR_QUOT) {
              return this.next(this.parseMultiEnd);
            } else if (this.char === Parser2.END) {
              throw this.error(new TomlError("Unterminated multi-line string"));
            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) {
              throw this.errorControlCharIn("strings");
            } else {
              this.consume();
            }
          } while (this.nextChar());
        }
        errorControlCharIn(type) {
          let displayCode = "\\u00";
          if (this.char < 16) {
            displayCode += "0";
          }
          displayCode += this.char.toString(16);
          return this.error(new TomlError(`Control characters (codes < 0x1f and 0x7f) are not allowed in ${type}, use ${displayCode} instead`));
        }
        recordMultiEscapeReplacement(replacement) {
          this.state.buf += replacement;
          return this.goto(this.parseMultiStringContent);
        }
        parseMultiEnd() {
          if (this.char === CHAR_QUOT) {
            return this.next(this.parseMultiEnd2);
          } else {
            this.state.buf += '"';
            return this.goto(this.parseMultiStringContent);
          }
        }
        parseMultiEnd2() {
          if (this.char === CHAR_QUOT) {
            return this.next(this.parseMultiEnd3);
          } else {
            this.state.buf += '""';
            return this.goto(this.parseMultiStringContent);
          }
        }
        parseMultiEnd3() {
          if (this.char === CHAR_QUOT) {
            this.state.buf += '"';
            return this.next(this.parseMultiEnd4);
          } else {
            return this.returnNow();
          }
        }
        parseMultiEnd4() {
          if (this.char === CHAR_QUOT) {
            this.state.buf += '"';
            return this.return();
          } else {
            return this.returnNow();
          }
        }
        parseMultiEscape() {
          if (this.char === CTRL_M || this.char === CTRL_J) {
            return this.next(this.parseMultiTrim);
          } else if (this.char === CHAR_SP || this.char === CTRL_I) {
            return this.next(this.parsePreMultiTrim);
          } else {
            return this.goto(this.parseEscape);
          }
        }
        parsePreMultiTrim() {
          if (this.char === CHAR_SP || this.char === CTRL_I) {
            return null;
          } else if (this.char === CTRL_M || this.char === CTRL_J) {
            return this.next(this.parseMultiTrim);
          } else {
            throw this.error(new TomlError("Can't escape whitespace"));
          }
        }
        parseMultiTrim() {
          if (this.char === CTRL_J || this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
            return null;
          } else {
            return this.returnNow();
          }
        }
        parseEscape() {
          if (this.char in escapes) {
            return this.return(escapes[this.char]);
          } else if (this.char === CHAR_u) {
            return this.call(this.parseSmallUnicode, this.parseUnicodeReturn);
          } else if (this.char === CHAR_U) {
            return this.call(this.parseLargeUnicode, this.parseUnicodeReturn);
          } else {
            throw this.error(new TomlError("Unknown escape character: " + this.char));
          }
        }
        parseUnicodeReturn(char) {
          try {
            const codePoint = parseInt(char, 16);
            if (codePoint >= SURROGATE_FIRST && codePoint <= SURROGATE_LAST) {
              throw this.error(new TomlError("Invalid unicode, character in range 0xD800 - 0xDFFF is reserved"));
            }
            return this.returnNow(String.fromCodePoint(codePoint));
          } catch (err) {
            throw this.error(TomlError.wrap(err));
          }
        }
        parseSmallUnicode() {
          if (!isHexit(this.char)) {
            throw this.error(new TomlError("Invalid character in unicode sequence, expected hex"));
          } else {
            this.consume();
            if (this.state.buf.length >= 4)
              return this.return();
          }
        }
        parseLargeUnicode() {
          if (!isHexit(this.char)) {
            throw this.error(new TomlError("Invalid character in unicode sequence, expected hex"));
          } else {
            this.consume();
            if (this.state.buf.length >= 8)
              return this.return();
          }
        }
        /* NUMBERS */
        parseNumberSign() {
          this.consume();
          return this.next(this.parseMaybeSignedInfOrNan);
        }
        parseMaybeSignedInfOrNan() {
          if (this.char === CHAR_i) {
            return this.next(this.parseInf);
          } else if (this.char === CHAR_n) {
            return this.next(this.parseNan);
          } else {
            return this.callNow(this.parseNoUnder, this.parseNumberIntegerStart);
          }
        }
        parseNumberIntegerStart() {
          if (this.char === CHAR_0) {
            this.consume();
            return this.next(this.parseNumberIntegerExponentOrDecimal);
          } else {
            return this.goto(this.parseNumberInteger);
          }
        }
        parseNumberIntegerExponentOrDecimal() {
          if (this.char === CHAR_PERIOD) {
            this.consume();
            return this.call(this.parseNoUnder, this.parseNumberFloat);
          } else if (this.char === CHAR_E || this.char === CHAR_e) {
            this.consume();
            return this.next(this.parseNumberExponentSign);
          } else {
            return this.returnNow(Integer(this.state.buf));
          }
        }
        parseNumberInteger() {
          if (isDigit(this.char)) {
            this.consume();
          } else if (this.char === CHAR_LOWBAR) {
            return this.call(this.parseNoUnder);
          } else if (this.char === CHAR_E || this.char === CHAR_e) {
            this.consume();
            return this.next(this.parseNumberExponentSign);
          } else if (this.char === CHAR_PERIOD) {
            this.consume();
            return this.call(this.parseNoUnder, this.parseNumberFloat);
          } else {
            const result = Integer(this.state.buf);
            if (result.isNaN()) {
              throw this.error(new TomlError("Invalid number"));
            } else {
              return this.returnNow(result);
            }
          }
        }
        parseNoUnder() {
          if (this.char === CHAR_LOWBAR || this.char === CHAR_PERIOD || this.char === CHAR_E || this.char === CHAR_e) {
            throw this.error(new TomlError("Unexpected character, expected digit"));
          } else if (this.atEndOfWord()) {
            throw this.error(new TomlError("Incomplete number"));
          }
          return this.returnNow();
        }
        parseNoUnderHexOctBinLiteral() {
          if (this.char === CHAR_LOWBAR || this.char === CHAR_PERIOD) {
            throw this.error(new TomlError("Unexpected character, expected digit"));
          } else if (this.atEndOfWord()) {
            throw this.error(new TomlError("Incomplete number"));
          }
          return this.returnNow();
        }
        parseNumberFloat() {
          if (this.char === CHAR_LOWBAR) {
            return this.call(this.parseNoUnder, this.parseNumberFloat);
          } else if (isDigit(this.char)) {
            this.consume();
          } else if (this.char === CHAR_E || this.char === CHAR_e) {
            this.consume();
            return this.next(this.parseNumberExponentSign);
          } else {
            return this.returnNow(Float(this.state.buf));
          }
        }
        parseNumberExponentSign() {
          if (isDigit(this.char)) {
            return this.goto(this.parseNumberExponent);
          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
            this.consume();
            this.call(this.parseNoUnder, this.parseNumberExponent);
          } else {
            throw this.error(new TomlError("Unexpected character, expected -, + or digit"));
          }
        }
        parseNumberExponent() {
          if (isDigit(this.char)) {
            this.consume();
          } else if (this.char === CHAR_LOWBAR) {
            return this.call(this.parseNoUnder);
          } else {
            return this.returnNow(Float(this.state.buf));
          }
        }
        /* NUMBERS or DATETIMES  */
        parseNumberOrDateTime() {
          if (this.char === CHAR_0) {
            this.consume();
            return this.next(this.parseNumberBaseOrDateTime);
          } else {
            return this.goto(this.parseNumberOrDateTimeOnly);
          }
        }
        parseNumberOrDateTimeOnly() {
          if (this.char === CHAR_LOWBAR) {
            return this.call(this.parseNoUnder, this.parseNumberInteger);
          } else if (isDigit(this.char)) {
            this.consume();
            if (this.state.buf.length > 4)
              this.next(this.parseNumberInteger);
          } else if (this.char === CHAR_E || this.char === CHAR_e) {
            this.consume();
            return this.next(this.parseNumberExponentSign);
          } else if (this.char === CHAR_PERIOD) {
            this.consume();
            return this.call(this.parseNoUnder, this.parseNumberFloat);
          } else if (this.char === CHAR_HYPHEN) {
            return this.goto(this.parseDateTime);
          } else if (this.char === CHAR_COLON) {
            return this.goto(this.parseOnlyTimeHour);
          } else {
            return this.returnNow(Integer(this.state.buf));
          }
        }
        parseDateTimeOnly() {
          if (this.state.buf.length < 4) {
            if (isDigit(this.char)) {
              return this.consume();
            } else if (this.char === CHAR_COLON) {
              return this.goto(this.parseOnlyTimeHour);
            } else {
              throw this.error(new TomlError("Expected digit while parsing year part of a date"));
            }
          } else {
            if (this.char === CHAR_HYPHEN) {
              return this.goto(this.parseDateTime);
            } else {
              throw this.error(new TomlError("Expected hyphen (-) while parsing year part of date"));
            }
          }
        }
        parseNumberBaseOrDateTime() {
          if (this.char === CHAR_b) {
            this.consume();
            return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerBin);
          } else if (this.char === CHAR_o) {
            this.consume();
            return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerOct);
          } else if (this.char === CHAR_x) {
            this.consume();
            return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerHex);
          } else if (this.char === CHAR_PERIOD) {
            return this.goto(this.parseNumberInteger);
          } else if (isDigit(this.char)) {
            return this.goto(this.parseDateTimeOnly);
          } else {
            return this.returnNow(Integer(this.state.buf));
          }
        }
        parseIntegerHex() {
          if (isHexit(this.char)) {
            this.consume();
          } else if (this.char === CHAR_LOWBAR) {
            return this.call(this.parseNoUnderHexOctBinLiteral);
          } else {
            const result = Integer(this.state.buf);
            if (result.isNaN()) {
              throw this.error(new TomlError("Invalid number"));
            } else {
              return this.returnNow(result);
            }
          }
        }
        parseIntegerOct() {
          if (isOctit(this.char)) {
            this.consume();
          } else if (this.char === CHAR_LOWBAR) {
            return this.call(this.parseNoUnderHexOctBinLiteral);
          } else {
            const result = Integer(this.state.buf);
            if (result.isNaN()) {
              throw this.error(new TomlError("Invalid number"));
            } else {
              return this.returnNow(result);
            }
          }
        }
        parseIntegerBin() {
          if (isBit(this.char)) {
            this.consume();
          } else if (this.char === CHAR_LOWBAR) {
            return this.call(this.parseNoUnderHexOctBinLiteral);
          } else {
            const result = Integer(this.state.buf);
            if (result.isNaN()) {
              throw this.error(new TomlError("Invalid number"));
            } else {
              return this.returnNow(result);
            }
          }
        }
        /* DATETIME */
        parseDateTime() {
          if (this.state.buf.length < 4) {
            throw this.error(new TomlError("Years less than 1000 must be zero padded to four characters"));
          }
          this.state.result = this.state.buf;
          this.state.buf = "";
          return this.next(this.parseDateMonth);
        }
        parseDateMonth() {
          if (this.char === CHAR_HYPHEN) {
            if (this.state.buf.length < 2) {
              throw this.error(new TomlError("Months less than 10 must be zero padded to two characters"));
            }
            this.state.result += "-" + this.state.buf;
            this.state.buf = "";
            return this.next(this.parseDateDay);
          } else if (isDigit(this.char)) {
            this.consume();
          } else {
            throw this.error(new TomlError("Incomplete datetime"));
          }
        }
        parseDateDay() {
          if (this.char === CHAR_T || this.char === CHAR_SP) {
            if (this.state.buf.length < 2) {
              throw this.error(new TomlError("Days less than 10 must be zero padded to two characters"));
            }
            this.state.result += "-" + this.state.buf;
            this.state.buf = "";
            return this.next(this.parseStartTimeHour);
          } else if (this.atEndOfWord()) {
            return this.returnNow(createDate(this.state.result + "-" + this.state.buf));
          } else if (isDigit(this.char)) {
            this.consume();
          } else {
            throw this.error(new TomlError("Incomplete datetime"));
          }
        }
        parseStartTimeHour() {
          if (this.atEndOfWord()) {
            return this.returnNow(createDate(this.state.result));
          } else {
            return this.goto(this.parseTimeHour);
          }
        }
        parseTimeHour() {
          if (this.char === CHAR_COLON) {
            if (this.state.buf.length < 2) {
              throw this.error(new TomlError("Hours less than 10 must be zero padded to two characters"));
            }
            this.state.result += "T" + this.state.buf;
            this.state.buf = "";
            return this.next(this.parseTimeMin);
          } else if (isDigit(this.char)) {
            this.consume();
          } else {
            throw this.error(new TomlError("Incomplete datetime"));
          }
        }
        parseTimeMin() {
          if (this.state.buf.length < 2 && isDigit(this.char)) {
            this.consume();
          } else if (this.state.buf.length === 2 && this.char === CHAR_COLON) {
            this.state.result += ":" + this.state.buf;
            this.state.buf = "";
            return this.next(this.parseTimeSec);
          } else {
            throw this.error(new TomlError("Incomplete datetime"));
          }
        }
        parseTimeSec() {
          if (isDigit(this.char)) {
            this.consume();
            if (this.state.buf.length === 2) {
              this.state.result += ":" + this.state.buf;
              this.state.buf = "";
              return this.next(this.parseTimeZoneOrFraction);
            }
          } else {
            throw this.error(new TomlError("Incomplete datetime"));
          }
        }
        parseOnlyTimeHour() {
          if (this.char === CHAR_COLON) {
            if (this.state.buf.length < 2) {
              throw this.error(new TomlError("Hours less than 10 must be zero padded to two characters"));
            }
            this.state.result = this.state.buf;
            this.state.buf = "";
            return this.next(this.parseOnlyTimeMin);
          } else {
            throw this.error(new TomlError("Incomplete time"));
          }
        }
        parseOnlyTimeMin() {
          if (this.state.buf.length < 2 && isDigit(this.char)) {
            this.consume();
          } else if (this.state.buf.length === 2 && this.char === CHAR_COLON) {
            this.state.result += ":" + this.state.buf;
            this.state.buf = "";
            return this.next(this.parseOnlyTimeSec);
          } else {
            throw this.error(new TomlError("Incomplete time"));
          }
        }
        parseOnlyTimeSec() {
          if (isDigit(this.char)) {
            this.consume();
            if (this.state.buf.length === 2) {
              return this.next(this.parseOnlyTimeFractionMaybe);
            }
          } else {
            throw this.error(new TomlError("Incomplete time"));
          }
        }
        parseOnlyTimeFractionMaybe() {
          this.state.result += ":" + this.state.buf;
          if (this.char === CHAR_PERIOD) {
            this.state.buf = "";
            this.next(this.parseOnlyTimeFraction);
          } else {
            return this.return(createTime(this.state.result));
          }
        }
        parseOnlyTimeFraction() {
          if (isDigit(this.char)) {
            this.consume();
          } else if (this.atEndOfWord()) {
            if (this.state.buf.length === 0)
              throw this.error(new TomlError("Expected digit in milliseconds"));
            return this.returnNow(createTime(this.state.result + "." + this.state.buf));
          } else {
            throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
          }
        }
        parseTimeZoneOrFraction() {
          if (this.char === CHAR_PERIOD) {
            this.consume();
            this.next(this.parseDateTimeFraction);
          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
            this.consume();
            this.next(this.parseTimeZoneHour);
          } else if (this.char === CHAR_Z) {
            this.consume();
            return this.return(createDateTime(this.state.result + this.state.buf));
          } else if (this.atEndOfWord()) {
            return this.returnNow(createDateTimeFloat(this.state.result + this.state.buf));
          } else {
            throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
          }
        }
        parseDateTimeFraction() {
          if (isDigit(this.char)) {
            this.consume();
          } else if (this.state.buf.length === 1) {
            throw this.error(new TomlError("Expected digit in milliseconds"));
          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
            this.consume();
            this.next(this.parseTimeZoneHour);
          } else if (this.char === CHAR_Z) {
            this.consume();
            return this.return(createDateTime(this.state.result + this.state.buf));
          } else if (this.atEndOfWord()) {
            return this.returnNow(createDateTimeFloat(this.state.result + this.state.buf));
          } else {
            throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
          }
        }
        parseTimeZoneHour() {
          if (isDigit(this.char)) {
            this.consume();
            if (/\d\d$/.test(this.state.buf))
              return this.next(this.parseTimeZoneSep);
          } else {
            throw this.error(new TomlError("Unexpected character in datetime, expected digit"));
          }
        }
        parseTimeZoneSep() {
          if (this.char === CHAR_COLON) {
            this.consume();
            this.next(this.parseTimeZoneMin);
          } else {
            throw this.error(new TomlError("Unexpected character in datetime, expected colon"));
          }
        }
        parseTimeZoneMin() {
          if (isDigit(this.char)) {
            this.consume();
            if (/\d\d$/.test(this.state.buf))
              return this.return(createDateTime(this.state.result + this.state.buf));
          } else {
            throw this.error(new TomlError("Unexpected character in datetime, expected digit"));
          }
        }
        /* BOOLEAN */
        parseBoolean() {
          if (this.char === CHAR_t) {
            this.consume();
            return this.next(this.parseTrue_r);
          } else if (this.char === CHAR_f) {
            this.consume();
            return this.next(this.parseFalse_a);
          }
        }
        parseTrue_r() {
          if (this.char === CHAR_r) {
            this.consume();
            return this.next(this.parseTrue_u);
          } else {
            throw this.error(new TomlError("Invalid boolean, expected true or false"));
          }
        }
        parseTrue_u() {
          if (this.char === CHAR_u) {
            this.consume();
            return this.next(this.parseTrue_e);
          } else {
            throw this.error(new TomlError("Invalid boolean, expected true or false"));
          }
        }
        parseTrue_e() {
          if (this.char === CHAR_e) {
            return this.return(true);
          } else {
            throw this.error(new TomlError("Invalid boolean, expected true or false"));
          }
        }
        parseFalse_a() {
          if (this.char === CHAR_a) {
            this.consume();
            return this.next(this.parseFalse_l);
          } else {
            throw this.error(new TomlError("Invalid boolean, expected true or false"));
          }
        }
        parseFalse_l() {
          if (this.char === CHAR_l) {
            this.consume();
            return this.next(this.parseFalse_s);
          } else {
            throw this.error(new TomlError("Invalid boolean, expected true or false"));
          }
        }
        parseFalse_s() {
          if (this.char === CHAR_s) {
            this.consume();
            return this.next(this.parseFalse_e);
          } else {
            throw this.error(new TomlError("Invalid boolean, expected true or false"));
          }
        }
        parseFalse_e() {
          if (this.char === CHAR_e) {
            return this.return(false);
          } else {
            throw this.error(new TomlError("Invalid boolean, expected true or false"));
          }
        }
        /* INLINE LISTS */
        parseInlineList() {
          if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M || this.char === CTRL_J) {
            return null;
          } else if (this.char === Parser2.END) {
            throw this.error(new TomlError("Unterminated inline array"));
          } else if (this.char === CHAR_NUM) {
            return this.call(this.parseComment);
          } else if (this.char === CHAR_RSQB) {
            return this.return(this.state.resultArr || InlineList());
          } else {
            return this.callNow(this.parseValue, this.recordInlineListValue);
          }
        }
        recordInlineListValue(value) {
          if (!this.state.resultArr) {
            this.state.resultArr = InlineList(tomlType(value));
          }
          if (isFloat(value) || isInteger(value)) {
            this.state.resultArr.push(value.valueOf());
          } else {
            this.state.resultArr.push(value);
          }
          return this.goto(this.parseInlineListNext);
        }
        parseInlineListNext() {
          if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M || this.char === CTRL_J) {
            return null;
          } else if (this.char === CHAR_NUM) {
            return this.call(this.parseComment);
          } else if (this.char === CHAR_COMMA) {
            return this.next(this.parseInlineList);
          } else if (this.char === CHAR_RSQB) {
            return this.goto(this.parseInlineList);
          } else {
            throw this.error(new TomlError("Invalid character, expected whitespace, comma (,) or close bracket (])"));
          }
        }
        /* INLINE TABLE */
        parseInlineTable() {
          if (this.char === CHAR_SP || this.char === CTRL_I) {
            return null;
          } else if (this.char === Parser2.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) {
            throw this.error(new TomlError("Unterminated inline array"));
          } else if (this.char === CHAR_RCUB) {
            return this.return(this.state.resultTable || InlineTable());
          } else {
            if (!this.state.resultTable)
              this.state.resultTable = InlineTable();
            return this.callNow(this.parseAssign, this.recordInlineTableValue);
          }
        }
        recordInlineTableValue(kv) {
          let target = this.state.resultTable;
          let finalKey = kv.key.pop();
          for (let kw of kv.key) {
            if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) {
              throw this.error(new TomlError("Can't redefine existing key"));
            }
            target = target[kw] = target[kw] || Table();
          }
          if (hasKey(target, finalKey)) {
            throw this.error(new TomlError("Can't redefine existing key"));
          }
          if (isInteger(kv.value) || isFloat(kv.value)) {
            target[finalKey] = kv.value.valueOf();
          } else {
            target[finalKey] = kv.value;
          }
          return this.goto(this.parseInlineTableNext);
        }
        parseInlineTableNext() {
          if (this.char === CHAR_SP || this.char === CTRL_I) {
            return null;
          } else if (this.char === Parser2.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) {
            throw this.error(new TomlError("Unterminated inline array"));
          } else if (this.char === CHAR_COMMA) {
            return this.next(this.parseInlineTablePostComma);
          } else if (this.char === CHAR_RCUB) {
            return this.goto(this.parseInlineTable);
          } else {
            throw this.error(new TomlError("Invalid character, expected whitespace, comma (,) or close bracket (])"));
          }
        }
        parseInlineTablePostComma() {
          if (this.char === CHAR_SP || this.char === CTRL_I) {
            return null;
          } else if (this.char === Parser2.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) {
            throw this.error(new TomlError("Unterminated inline array"));
          } else if (this.char === CHAR_COMMA) {
            throw this.error(new TomlError("Empty elements in inline tables are not permitted"));
          } else if (this.char === CHAR_RCUB) {
            throw this.error(new TomlError("Trailing commas in inline tables are not permitted"));
          } else {
            return this.goto(this.parseInlineTable);
          }
        }
      }
      __name(TOMLParser, "TOMLParser");
      return TOMLParser;
    }
    __name(makeParserClass, "makeParserClass");
  }
});

// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/parse-pretty-error.js
var require_parse_pretty_error = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/parse-pretty-error.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = prettyError;
    function prettyError(err, buf) {
      if (err.pos == null || err.line == null)
        return err;
      let msg = err.message;
      msg += ` at row ${err.line + 1}, col ${err.col + 1}, pos ${err.pos}:
`;
      if (buf && buf.split) {
        const lines = buf.split(/\n/);
        const lineNumWidth = String(Math.min(lines.length, err.line + 3)).length;
        let linePadding = " ";
        while (linePadding.length < lineNumWidth)
          linePadding += " ";
        for (let ii = Math.max(0, err.line - 1); ii < Math.min(lines.length, err.line + 2); ++ii) {
          let lineNum = String(ii + 1);
          if (lineNum.length < lineNumWidth)
            lineNum = " " + lineNum;
          if (err.line === ii) {
            msg += lineNum + "> " + lines[ii] + "\n";
            msg += linePadding + "  ";
            for (let hh = 0; hh < err.col; ++hh) {
              msg += " ";
            }
            msg += "^\n";
          } else {
            msg += lineNum + ": " + lines[ii] + "\n";
          }
        }
      }
      err.message = msg + "\n";
      return err;
    }
    __name(prettyError, "prettyError");
  }
});

// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/parse-string.js
var require_parse_string = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/parse-string.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = parseString;
    var TOMLParser = require_toml_parser();
    var prettyError = require_parse_pretty_error();
    function parseString(str) {
      if (global.Buffer && global.Buffer.isBuffer(str)) {
        str = str.toString("utf8");
      }
      const parser2 = new TOMLParser();
      try {
        parser2.parse(str);
        return parser2.finish();
      } catch (err) {
        throw prettyError(err, str);
      }
    }
    __name(parseString, "parseString");
  }
});

// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/parse-async.js
var require_parse_async = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/parse-async.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = parseAsync;
    var TOMLParser = require_toml_parser();
    var prettyError = require_parse_pretty_error();
    function parseAsync(str, opts) {
      if (!opts)
        opts = {};
      const index = 0;
      const blocksize = opts.blocksize || 40960;
      const parser2 = new TOMLParser();
      return new Promise((resolve19, reject) => {
        setImmediate(parseAsyncNext, index, blocksize, resolve19, reject);
      });
      function parseAsyncNext(index2, blocksize2, resolve19, reject) {
        if (index2 >= str.length) {
          try {
            return resolve19(parser2.finish());
          } catch (err) {
            return reject(prettyError(err, str));
          }
        }
        try {
          parser2.parse(str.slice(index2, index2 + blocksize2));
          setImmediate(parseAsyncNext, index2 + blocksize2, blocksize2, resolve19, reject);
        } catch (err) {
          reject(prettyError(err, str));
        }
      }
      __name(parseAsyncNext, "parseAsyncNext");
    }
    __name(parseAsync, "parseAsync");
  }
});

// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/parse-stream.js
var require_parse_stream = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/parse-stream.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = parseStream;
    var stream2 = require("stream");
    var TOMLParser = require_toml_parser();
    function parseStream(stm) {
      if (stm) {
        return parseReadable(stm);
      } else {
        return parseTransform(stm);
      }
    }
    __name(parseStream, "parseStream");
    function parseReadable(stm) {
      const parser2 = new TOMLParser();
      stm.setEncoding("utf8");
      return new Promise((resolve19, reject) => {
        let readable;
        let ended = false;
        let errored = false;
        function finish() {
          ended = true;
          if (readable)
            return;
          try {
            resolve19(parser2.finish());
          } catch (err) {
            reject(err);
          }
        }
        __name(finish, "finish");
        function error2(err) {
          errored = true;
          reject(err);
        }
        __name(error2, "error");
        stm.once("end", finish);
        stm.once("error", error2);
        readNext();
        function readNext() {
          readable = true;
          let data;
          while ((data = stm.read()) !== null) {
            try {
              parser2.parse(data);
            } catch (err) {
              return error2(err);
            }
          }
          readable = false;
          if (ended)
            return finish();
          if (errored)
            return;
          stm.once("readable", readNext);
        }
        __name(readNext, "readNext");
      });
    }
    __name(parseReadable, "parseReadable");
    function parseTransform() {
      const parser2 = new TOMLParser();
      return new stream2.Transform({
        objectMode: true,
        transform(chunk, encoding, cb) {
          try {
            parser2.parse(chunk.toString(encoding));
          } catch (err) {
            this.emit("error", err);
          }
          cb();
        },
        flush(cb) {
          try {
            this.push(parser2.finish());
          } catch (err) {
            this.emit("error", err);
          }
          cb();
        }
      });
    }
    __name(parseTransform, "parseTransform");
  }
});

// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/parse.js
var require_parse2 = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/parse.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = require_parse_string();
    module3.exports.async = require_parse_async();
    module3.exports.stream = require_parse_stream();
    module3.exports.prettyError = require_parse_pretty_error();
  }
});

// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/stringify.js
var require_stringify = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/stringify.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = stringify;
    module3.exports.value = stringifyInline;
    function stringify(obj) {
      if (obj === null)
        throw typeError("null");
      if (obj === void 0)
        throw typeError("undefined");
      if (typeof obj !== "object")
        throw typeError(typeof obj);
      if (typeof obj.toJSON === "function")
        obj = obj.toJSON();
      if (obj == null)
        return null;
      const type = tomlType2(obj);
      if (type !== "table")
        throw typeError(type);
      return stringifyObject("", "", obj);
    }
    __name(stringify, "stringify");
    function typeError(type) {
      return new Error("Can only stringify objects, not " + type);
    }
    __name(typeError, "typeError");
    function getInlineKeys(obj) {
      return Object.keys(obj).filter((key) => isInline(obj[key]));
    }
    __name(getInlineKeys, "getInlineKeys");
    function getComplexKeys(obj) {
      return Object.keys(obj).filter((key) => !isInline(obj[key]));
    }
    __name(getComplexKeys, "getComplexKeys");
    function toJSON(obj) {
      let nobj = Array.isArray(obj) ? [] : Object.prototype.hasOwnProperty.call(obj, "__proto__") ? { ["__proto__"]: void 0 } : {};
      for (let prop of Object.keys(obj)) {
        if (obj[prop] && typeof obj[prop].toJSON === "function" && !("toISOString" in obj[prop])) {
          nobj[prop] = obj[prop].toJSON();
        } else {
          nobj[prop] = obj[prop];
        }
      }
      return nobj;
    }
    __name(toJSON, "toJSON");
    function stringifyObject(prefix, indent, obj) {
      obj = toJSON(obj);
      let inlineKeys;
      let complexKeys;
      inlineKeys = getInlineKeys(obj);
      complexKeys = getComplexKeys(obj);
      const result = [];
      const inlineIndent = indent || "";
      inlineKeys.forEach((key) => {
        var type = tomlType2(obj[key]);
        if (type !== "undefined" && type !== "null") {
          result.push(inlineIndent + stringifyKey(key) + " = " + stringifyAnyInline(obj[key], true));
        }
      });
      if (result.length > 0)
        result.push("");
      const complexIndent = prefix && inlineKeys.length > 0 ? indent + "  " : "";
      complexKeys.forEach((key) => {
        result.push(stringifyComplex(prefix, complexIndent, key, obj[key]));
      });
      return result.join("\n");
    }
    __name(stringifyObject, "stringifyObject");
    function isInline(value) {
      switch (tomlType2(value)) {
        case "undefined":
        case "null":
        case "integer":
        case "nan":
        case "float":
        case "boolean":
        case "string":
        case "datetime":
          return true;
        case "array":
          return value.length === 0 || tomlType2(value[0]) !== "table";
        case "table":
          return Object.keys(value).length === 0;
        default:
          return false;
      }
    }
    __name(isInline, "isInline");
    function tomlType2(value) {
      if (value === void 0) {
        return "undefined";
      } else if (value === null) {
        return "null";
      } else if (typeof value === "bigint" || Number.isInteger(value) && !Object.is(value, -0)) {
        return "integer";
      } else if (typeof value === "number") {
        return "float";
      } else if (typeof value === "boolean") {
        return "boolean";
      } else if (typeof value === "string") {
        return "string";
      } else if ("toISOString" in value) {
        return isNaN(value) ? "undefined" : "datetime";
      } else if (Array.isArray(value)) {
        return "array";
      } else {
        return "table";
      }
    }
    __name(tomlType2, "tomlType");
    function stringifyKey(key) {
      const keyStr = String(key);
      if (/^[-A-Za-z0-9_]+$/.test(keyStr)) {
        return keyStr;
      } else {
        return stringifyBasicString(keyStr);
      }
    }
    __name(stringifyKey, "stringifyKey");
    function stringifyBasicString(str) {
      return '"' + escapeString(str).replace(/"/g, '\\"') + '"';
    }
    __name(stringifyBasicString, "stringifyBasicString");
    function stringifyLiteralString(str) {
      return "'" + str + "'";
    }
    __name(stringifyLiteralString, "stringifyLiteralString");
    function numpad(num, str) {
      while (str.length < num)
        str = "0" + str;
      return str;
    }
    __name(numpad, "numpad");
    function escapeString(str) {
      return str.replace(/\\/g, "\\\\").replace(/[\b]/g, "\\b").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\f/g, "\\f").replace(/\r/g, "\\r").replace(/([\u0000-\u001f\u007f])/, (c2) => "\\u" + numpad(4, c2.codePointAt(0).toString(16)));
    }
    __name(escapeString, "escapeString");
    function stringifyMultilineString(str) {
      let escaped = str.split(/\n/).map((str2) => {
        return escapeString(str2).replace(/"(?="")/g, '\\"');
      }).join("\n");
      if (escaped.slice(-1) === '"')
        escaped += "\\\n";
      return '"""\n' + escaped + '"""';
    }
    __name(stringifyMultilineString, "stringifyMultilineString");
    function stringifyAnyInline(value, multilineOk) {
      let type = tomlType2(value);
      if (type === "string") {
        if (multilineOk && /\n/.test(value)) {
          type = "string-multiline";
        } else if (!/[\b\t\n\f\r']/.test(value) && /"/.test(value)) {
          type = "string-literal";
        }
      }
      return stringifyInline(value, type);
    }
    __name(stringifyAnyInline, "stringifyAnyInline");
    function stringifyInline(value, type) {
      if (!type)
        type = tomlType2(value);
      switch (type) {
        case "string-multiline":
          return stringifyMultilineString(value);
        case "string":
          return stringifyBasicString(value);
        case "string-literal":
          return stringifyLiteralString(value);
        case "integer":
          return stringifyInteger(value);
        case "float":
          return stringifyFloat(value);
        case "boolean":
          return stringifyBoolean(value);
        case "datetime":
          return stringifyDatetime(value);
        case "array":
          return stringifyInlineArray(value.filter((_3) => tomlType2(_3) !== "null" && tomlType2(_3) !== "undefined" && tomlType2(_3) !== "nan"));
        case "table":
          return stringifyInlineTable(value);
        default:
          throw typeError(type);
      }
    }
    __name(stringifyInline, "stringifyInline");
    function stringifyInteger(value) {
      return String(value).replace(/\B(?=(\d{3})+(?!\d))/g, "_");
    }
    __name(stringifyInteger, "stringifyInteger");
    function stringifyFloat(value) {
      if (value === Infinity) {
        return "inf";
      } else if (value === -Infinity) {
        return "-inf";
      } else if (Object.is(value, NaN)) {
        return "nan";
      } else if (Object.is(value, -0)) {
        return "-0.0";
      }
      const [int, dec] = String(value).split(".");
      return stringifyInteger(int) + "." + dec;
    }
    __name(stringifyFloat, "stringifyFloat");
    function stringifyBoolean(value) {
      return String(value);
    }
    __name(stringifyBoolean, "stringifyBoolean");
    function stringifyDatetime(value) {
      return value.toISOString();
    }
    __name(stringifyDatetime, "stringifyDatetime");
    function stringifyInlineArray(values) {
      values = toJSON(values);
      let result = "[";
      const stringified = values.map((_3) => stringifyInline(_3));
      if (stringified.join(", ").length > 60 || /\n/.test(stringified)) {
        result += "\n  " + stringified.join(",\n  ") + "\n";
      } else {
        result += " " + stringified.join(", ") + (stringified.length > 0 ? " " : "");
      }
      return result + "]";
    }
    __name(stringifyInlineArray, "stringifyInlineArray");
    function stringifyInlineTable(value) {
      value = toJSON(value);
      const result = [];
      Object.keys(value).forEach((key) => {
        result.push(stringifyKey(key) + " = " + stringifyAnyInline(value[key], false));
      });
      return "{ " + result.join(", ") + (result.length > 0 ? " " : "") + "}";
    }
    __name(stringifyInlineTable, "stringifyInlineTable");
    function stringifyComplex(prefix, indent, key, value) {
      const valueType = tomlType2(value);
      if (valueType === "array") {
        return stringifyArrayOfTables(prefix, indent, key, value);
      } else if (valueType === "table") {
        return stringifyComplexTable(prefix, indent, key, value);
      } else {
        throw typeError(valueType);
      }
    }
    __name(stringifyComplex, "stringifyComplex");
    function stringifyArrayOfTables(prefix, indent, key, values) {
      values = toJSON(values);
      const firstValueType = tomlType2(values[0]);
      if (firstValueType !== "table")
        throw typeError(firstValueType);
      const fullKey = prefix + stringifyKey(key);
      let result = "";
      values.forEach((table) => {
        if (result.length > 0)
          result += "\n";
        result += indent + "[[" + fullKey + "]]\n";
        result += stringifyObject(fullKey + ".", indent, table);
      });
      return result;
    }
    __name(stringifyArrayOfTables, "stringifyArrayOfTables");
    function stringifyComplexTable(prefix, indent, key, value) {
      const fullKey = prefix + stringifyKey(key);
      let result = "";
      if (getInlineKeys(value).length > 0) {
        result += indent + "[" + fullKey + "]\n";
      }
      return result + stringifyObject(fullKey + ".", indent, value);
    }
    __name(stringifyComplexTable, "stringifyComplexTable");
  }
});

// ../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/toml.js
var require_toml = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@3.0.0/node_modules/@iarna/toml/toml.js"(exports2) {
    "use strict";
    init_import_meta_url();
    exports2.parse = require_parse2();
    exports2.stringify = require_stringify();
  }
});

// ../../node_modules/.pnpm/ci-info@3.3.0/node_modules/ci-info/vendors.json
var require_vendors2 = __commonJS({
  "../../node_modules/.pnpm/ci-info@3.3.0/node_modules/ci-info/vendors.json"(exports2, module3) {
    module3.exports = [
      {
        name: "AppVeyor",
        constant: "APPVEYOR",
        env: "APPVEYOR",
        pr: "APPVEYOR_PULL_REQUEST_NUMBER"
      },
      {
        name: "Azure Pipelines",
        constant: "AZURE_PIPELINES",
        env: "SYSTEM_TEAMFOUNDATIONCOLLECTIONURI",
        pr: "SYSTEM_PULLREQUEST_PULLREQUESTID"
      },
      {
        name: "Appcircle",
        constant: "APPCIRCLE",
        env: "AC_APPCIRCLE"
      },
      {
        name: "Bamboo",
        constant: "BAMBOO",
        env: "bamboo_planKey"
      },
      {
        name: "Bitbucket Pipelines",
        constant: "BITBUCKET",
        env: "BITBUCKET_COMMIT",
        pr: "BITBUCKET_PR_ID"
      },
      {
        name: "Bitrise",
        constant: "BITRISE",
        env: "BITRISE_IO",
        pr: "BITRISE_PULL_REQUEST"
      },
      {
        name: "Buddy",
        constant: "BUDDY",
        env: "BUDDY_WORKSPACE_ID",
        pr: "BUDDY_EXECUTION_PULL_REQUEST_ID"
      },
      {
        name: "Buildkite",
        constant: "BUILDKITE",
        env: "BUILDKITE",
        pr: { env: "BUILDKITE_PULL_REQUEST", ne: "false" }
      },
      {
        name: "CircleCI",
        constant: "CIRCLE",
        env: "CIRCLECI",
        pr: "CIRCLE_PULL_REQUEST"
      },
      {
        name: "Cirrus CI",
        constant: "CIRRUS",
        env: "CIRRUS_CI",
        pr: "CIRRUS_PR"
      },
      {
        name: "AWS CodeBuild",
        constant: "CODEBUILD",
        env: "CODEBUILD_BUILD_ARN"
      },
      {
        name: "Codefresh",
        constant: "CODEFRESH",
        env: "CF_BUILD_ID",
        pr: { any: ["CF_PULL_REQUEST_NUMBER", "CF_PULL_REQUEST_ID"] }
      },
      {
        name: "Codeship",
        constant: "CODESHIP",
        env: { CI_NAME: "codeship" }
      },
      {
        name: "Drone",
        constant: "DRONE",
        env: "DRONE",
        pr: { DRONE_BUILD_EVENT: "pull_request" }
      },
      {
        name: "dsari",
        constant: "DSARI",
        env: "DSARI"
      },
      {
        name: "Expo Application Services",
        constant: "EAS",
        env: "EAS_BUILD"
      },
      {
        name: "GitHub Actions",
        constant: "GITHUB_ACTIONS",
        env: "GITHUB_ACTIONS",
        pr: { GITHUB_EVENT_NAME: "pull_request" }
      },
      {
        name: "GitLab CI",
        constant: "GITLAB",
        env: "GITLAB_CI",
        pr: "CI_MERGE_REQUEST_ID"
      },
      {
        name: "GoCD",
        constant: "GOCD",
        env: "GO_PIPELINE_LABEL"
      },
      {
        name: "LayerCI",
        constant: "LAYERCI",
        env: "LAYERCI",
        pr: "LAYERCI_PULL_REQUEST"
      },
      {
        name: "Hudson",
        constant: "HUDSON",
        env: "HUDSON_URL"
      },
      {
        name: "Jenkins",
        constant: "JENKINS",
        env: ["JENKINS_URL", "BUILD_ID"],
        pr: { any: ["ghprbPullId", "CHANGE_ID"] }
      },
      {
        name: "Magnum CI",
        constant: "MAGNUM",
        env: "MAGNUM"
      },
      {
        name: "Netlify CI",
        constant: "NETLIFY",
        env: "NETLIFY",
        pr: { env: "PULL_REQUEST", ne: "false" }
      },
      {
        name: "Nevercode",
        constant: "NEVERCODE",
        env: "NEVERCODE",
        pr: { env: "NEVERCODE_PULL_REQUEST", ne: "false" }
      },
      {
        name: "Render",
        constant: "RENDER",
        env: "RENDER",
        pr: { IS_PULL_REQUEST: "true" }
      },
      {
        name: "Sail CI",
        constant: "SAIL",
        env: "SAILCI",
        pr: "SAIL_PULL_REQUEST_NUMBER"
      },
      {
        name: "Semaphore",
        constant: "SEMAPHORE",
        env: "SEMAPHORE",
        pr: "PULL_REQUEST_NUMBER"
      },
      {
        name: "Screwdriver",
        constant: "SCREWDRIVER",
        env: "SCREWDRIVER",
        pr: { env: "SD_PULL_REQUEST", ne: "false" }
      },
      {
        name: "Shippable",
        constant: "SHIPPABLE",
        env: "SHIPPABLE",
        pr: { IS_PULL_REQUEST: "true" }
      },
      {
        name: "Solano CI",
        constant: "SOLANO",
        env: "TDDIUM",
        pr: "TDDIUM_PR_ID"
      },
      {
        name: "Strider CD",
        constant: "STRIDER",
        env: "STRIDER"
      },
      {
        name: "TaskCluster",
        constant: "TASKCLUSTER",
        env: ["TASK_ID", "RUN_ID"]
      },
      {
        name: "TeamCity",
        constant: "TEAMCITY",
        env: "TEAMCITY_VERSION"
      },
      {
        name: "Travis CI",
        constant: "TRAVIS",
        env: "TRAVIS",
        pr: { env: "TRAVIS_PULL_REQUEST", ne: "false" }
      },
      {
        name: "Vercel",
        constant: "VERCEL",
        env: "NOW_BUILDER"
      },
      {
        name: "Visual Studio App Center",
        constant: "APPCENTER",
        env: "APPCENTER_BUILD_ID"
      }
    ];
  }
});

// ../../node_modules/.pnpm/ci-info@3.3.0/node_modules/ci-info/index.js
var require_ci_info2 = __commonJS({
  "../../node_modules/.pnpm/ci-info@3.3.0/node_modules/ci-info/index.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var vendors = require_vendors2();
    var env5 = process.env;
    Object.defineProperty(exports2, "_vendors", {
      value: vendors.map(function(v2) {
        return v2.constant;
      })
    });
    exports2.name = null;
    exports2.isPR = null;
    vendors.forEach(function(vendor) {
      const envs = Array.isArray(vendor.env) ? vendor.env : [vendor.env];
      const isCI2 = envs.every(function(obj) {
        return checkEnv(obj);
      });
      exports2[vendor.constant] = isCI2;
      if (isCI2) {
        exports2.name = vendor.name;
        switch (typeof vendor.pr) {
          case "string":
            exports2.isPR = !!env5[vendor.pr];
            break;
          case "object":
            if ("env" in vendor.pr) {
              exports2.isPR = vendor.pr.env in env5 && env5[vendor.pr.env] !== vendor.pr.ne;
            } else if ("any" in vendor.pr) {
              exports2.isPR = vendor.pr.any.some(function(key) {
                return !!env5[key];
              });
            } else {
              exports2.isPR = checkEnv(vendor.pr);
            }
            break;
          default:
            exports2.isPR = null;
        }
      }
    });
    exports2.isCI = !!(env5.CI || // Travis CI, CircleCI, Cirrus CI, Gitlab CI, Appveyor, CodeShip, dsari
    env5.CONTINUOUS_INTEGRATION || // Travis CI, Cirrus CI
    env5.BUILD_NUMBER || // Jenkins, TeamCity
    env5.RUN_ID || // TaskCluster, dsari
    exports2.name || false);
    function checkEnv(obj) {
      if (typeof obj === "string")
        return !!env5[obj];
      return Object.keys(obj).every(function(k2) {
        return env5[k2] === obj[k2];
      });
    }
    __name(checkEnv, "checkEnv");
  }
});

// ../../node_modules/.pnpm/is-ci@3.0.1/node_modules/is-ci/index.js
var require_is_ci2 = __commonJS({
  "../../node_modules/.pnpm/is-ci@3.0.1/node_modules/is-ci/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = require_ci_info2().isCI;
  }
});

// ../../node_modules/.pnpm/kleur@3.0.3/node_modules/kleur/index.js
var require_kleur = __commonJS({
  "../../node_modules/.pnpm/kleur@3.0.3/node_modules/kleur/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { FORCE_COLOR, NODE_DISABLE_COLORS, TERM } = process.env;
    var $3 = {
      enabled: !NODE_DISABLE_COLORS && TERM !== "dumb" && FORCE_COLOR !== "0",
      // modifiers
      reset: init3(0, 0),
      bold: init3(1, 22),
      dim: init3(2, 22),
      italic: init3(3, 23),
      underline: init3(4, 24),
      inverse: init3(7, 27),
      hidden: init3(8, 28),
      strikethrough: init3(9, 29),
      // colors
      black: init3(30, 39),
      red: init3(31, 39),
      green: init3(32, 39),
      yellow: init3(33, 39),
      blue: init3(34, 39),
      magenta: init3(35, 39),
      cyan: init3(36, 39),
      white: init3(37, 39),
      gray: init3(90, 39),
      grey: init3(90, 39),
      // background colors
      bgBlack: init3(40, 49),
      bgRed: init3(41, 49),
      bgGreen: init3(42, 49),
      bgYellow: init3(43, 49),
      bgBlue: init3(44, 49),
      bgMagenta: init3(45, 49),
      bgCyan: init3(46, 49),
      bgWhite: init3(47, 49)
    };
    function run(arr, str) {
      let i = 0, tmp, beg = "", end = "";
      for (; i < arr.length; i++) {
        tmp = arr[i];
        beg += tmp.open;
        end += tmp.close;
        if (str.includes(tmp.close)) {
          str = str.replace(tmp.rgx, tmp.close + tmp.open);
        }
      }
      return beg + str + end;
    }
    __name(run, "run");
    function chain(has, keys) {
      let ctx = { has, keys };
      ctx.reset = $3.reset.bind(ctx);
      ctx.bold = $3.bold.bind(ctx);
      ctx.dim = $3.dim.bind(ctx);
      ctx.italic = $3.italic.bind(ctx);
      ctx.underline = $3.underline.bind(ctx);
      ctx.inverse = $3.inverse.bind(ctx);
      ctx.hidden = $3.hidden.bind(ctx);
      ctx.strikethrough = $3.strikethrough.bind(ctx);
      ctx.black = $3.black.bind(ctx);
      ctx.red = $3.red.bind(ctx);
      ctx.green = $3.green.bind(ctx);
      ctx.yellow = $3.yellow.bind(ctx);
      ctx.blue = $3.blue.bind(ctx);
      ctx.magenta = $3.magenta.bind(ctx);
      ctx.cyan = $3.cyan.bind(ctx);
      ctx.white = $3.white.bind(ctx);
      ctx.gray = $3.gray.bind(ctx);
      ctx.grey = $3.grey.bind(ctx);
      ctx.bgBlack = $3.bgBlack.bind(ctx);
      ctx.bgRed = $3.bgRed.bind(ctx);
      ctx.bgGreen = $3.bgGreen.bind(ctx);
      ctx.bgYellow = $3.bgYellow.bind(ctx);
      ctx.bgBlue = $3.bgBlue.bind(ctx);
      ctx.bgMagenta = $3.bgMagenta.bind(ctx);
      ctx.bgCyan = $3.bgCyan.bind(ctx);
      ctx.bgWhite = $3.bgWhite.bind(ctx);
      return ctx;
    }
    __name(chain, "chain");
    function init3(open3, close2) {
      let blk = {
        open: `\x1B[${open3}m`,
        close: `\x1B[${close2}m`,
        rgx: new RegExp(`\\x1b\\[${close2}m`, "g")
      };
      return function(txt) {
        if (this !== void 0 && this.has !== void 0) {
          this.has.includes(open3) || (this.has.push(open3), this.keys.push(blk));
          return txt === void 0 ? this : $3.enabled ? run(this.keys, txt + "") : txt + "";
        }
        return txt === void 0 ? chain([open3], [blk]) : $3.enabled ? run([blk], txt + "") : txt + "";
      };
    }
    __name(init3, "init");
    module3.exports = $3;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/action.js
var require_action = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/action.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = (key, isSelect) => {
      if (key.meta && key.name !== "escape")
        return;
      if (key.ctrl) {
        if (key.name === "a")
          return "first";
        if (key.name === "c")
          return "abort";
        if (key.name === "d")
          return "abort";
        if (key.name === "e")
          return "last";
        if (key.name === "g")
          return "reset";
      }
      if (isSelect) {
        if (key.name === "j")
          return "down";
        if (key.name === "k")
          return "up";
      }
      if (key.name === "return")
        return "submit";
      if (key.name === "enter")
        return "submit";
      if (key.name === "backspace")
        return "delete";
      if (key.name === "delete")
        return "deleteForward";
      if (key.name === "abort")
        return "abort";
      if (key.name === "escape")
        return "exit";
      if (key.name === "tab")
        return "next";
      if (key.name === "pagedown")
        return "nextPage";
      if (key.name === "pageup")
        return "prevPage";
      if (key.name === "home")
        return "home";
      if (key.name === "end")
        return "end";
      if (key.name === "up")
        return "up";
      if (key.name === "down")
        return "down";
      if (key.name === "right")
        return "right";
      if (key.name === "left")
        return "left";
      return false;
    };
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/strip.js
var require_strip = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/strip.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = (str) => {
      const pattern = ["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)", "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PRZcf-ntqry=><~]))"].join("|");
      const RGX = new RegExp(pattern, "g");
      return typeof str === "string" ? str.replace(RGX, "") : str;
    };
  }
});

// ../../node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js
var require_src = __commonJS({
  "../../node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var ESC2 = "\x1B";
    var CSI = `${ESC2}[`;
    var beep = "\x07";
    var cursor = {
      to(x2, y2) {
        if (!y2)
          return `${CSI}${x2 + 1}G`;
        return `${CSI}${y2 + 1};${x2 + 1}H`;
      },
      move(x2, y2) {
        let ret = "";
        if (x2 < 0)
          ret += `${CSI}${-x2}D`;
        else if (x2 > 0)
          ret += `${CSI}${x2}C`;
        if (y2 < 0)
          ret += `${CSI}${-y2}A`;
        else if (y2 > 0)
          ret += `${CSI}${y2}B`;
        return ret;
      },
      up: (count = 1) => `${CSI}${count}A`,
      down: (count = 1) => `${CSI}${count}B`,
      forward: (count = 1) => `${CSI}${count}C`,
      backward: (count = 1) => `${CSI}${count}D`,
      nextLine: (count = 1) => `${CSI}E`.repeat(count),
      prevLine: (count = 1) => `${CSI}F`.repeat(count),
      left: `${CSI}G`,
      hide: `${CSI}?25l`,
      show: `${CSI}?25h`,
      save: `${ESC2}7`,
      restore: `${ESC2}8`
    };
    var scroll = {
      up: (count = 1) => `${CSI}S`.repeat(count),
      down: (count = 1) => `${CSI}T`.repeat(count)
    };
    var erase = {
      screen: `${CSI}2J`,
      up: (count = 1) => `${CSI}1J`.repeat(count),
      down: (count = 1) => `${CSI}J`.repeat(count),
      line: `${CSI}2K`,
      lineEnd: `${CSI}K`,
      lineStart: `${CSI}1K`,
      lines(count) {
        let clear = "";
        for (let i = 0; i < count; i++)
          clear += this.line + (i < count - 1 ? cursor.up() : "");
        if (count)
          clear += cursor.left;
        return clear;
      }
    };
    module3.exports = { cursor, scroll, erase, beep };
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/clear.js
var require_clear = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/clear.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    function _createForOfIteratorHelper(o2, allowArrayLike) {
      var it2 = typeof Symbol !== "undefined" && o2[Symbol.iterator] || o2["@@iterator"];
      if (!it2) {
        if (Array.isArray(o2) || (it2 = _unsupportedIterableToArray4(o2)) || allowArrayLike && o2 && typeof o2.length === "number") {
          if (it2)
            o2 = it2;
          var i = 0;
          var F = /* @__PURE__ */ __name(function F2() {
          }, "F");
          return { s: F, n: /* @__PURE__ */ __name(function n2() {
            if (i >= o2.length)
              return { done: true };
            return { done: false, value: o2[i++] };
          }, "n"), e: /* @__PURE__ */ __name(function e3(_e) {
            throw _e;
          }, "e"), f: F };
        }
        throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
      }
      var normalCompletion = true, didErr = false, err;
      return { s: /* @__PURE__ */ __name(function s() {
        it2 = it2.call(o2);
      }, "s"), n: /* @__PURE__ */ __name(function n2() {
        var step = it2.next();
        normalCompletion = step.done;
        return step;
      }, "n"), e: /* @__PURE__ */ __name(function e3(_e2) {
        didErr = true;
        err = _e2;
      }, "e"), f: /* @__PURE__ */ __name(function f() {
        try {
          if (!normalCompletion && it2.return != null)
            it2.return();
        } finally {
          if (didErr)
            throw err;
        }
      }, "f") };
    }
    __name(_createForOfIteratorHelper, "_createForOfIteratorHelper");
    function _unsupportedIterableToArray4(o2, minLen) {
      if (!o2)
        return;
      if (typeof o2 === "string")
        return _arrayLikeToArray4(o2, minLen);
      var n2 = Object.prototype.toString.call(o2).slice(8, -1);
      if (n2 === "Object" && o2.constructor)
        n2 = o2.constructor.name;
      if (n2 === "Map" || n2 === "Set")
        return Array.from(o2);
      if (n2 === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n2))
        return _arrayLikeToArray4(o2, minLen);
    }
    __name(_unsupportedIterableToArray4, "_unsupportedIterableToArray");
    function _arrayLikeToArray4(arr, len) {
      if (len == null || len > arr.length)
        len = arr.length;
      for (var i = 0, arr2 = new Array(len); i < len; i++)
        arr2[i] = arr[i];
      return arr2;
    }
    __name(_arrayLikeToArray4, "_arrayLikeToArray");
    var strip = require_strip();
    var _require = require_src();
    var erase = _require.erase;
    var cursor = _require.cursor;
    var width = /* @__PURE__ */ __name((str) => [...strip(str)].length, "width");
    module3.exports = function(prompt2, perLine) {
      if (!perLine)
        return erase.line + cursor.to(0);
      let rows = 0;
      const lines = prompt2.split(/\r?\n/);
      var _iterator = _createForOfIteratorHelper(lines), _step;
      try {
        for (_iterator.s(); !(_step = _iterator.n()).done; ) {
          let line = _step.value;
          rows += 1 + Math.floor(Math.max(width(line) - 1, 0) / perLine);
        }
      } catch (err) {
        _iterator.e(err);
      } finally {
        _iterator.f();
      }
      return erase.lines(rows);
    };
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/figures.js
var require_figures = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/figures.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var main2 = {
      arrowUp: "\u2191",
      arrowDown: "\u2193",
      arrowLeft: "\u2190",
      arrowRight: "\u2192",
      radioOn: "\u25C9",
      radioOff: "\u25EF",
      tick: "\u2714",
      cross: "\u2716",
      ellipsis: "\u2026",
      pointerSmall: "\u203A",
      line: "\u2500",
      pointer: "\u276F"
    };
    var win = {
      arrowUp: main2.arrowUp,
      arrowDown: main2.arrowDown,
      arrowLeft: main2.arrowLeft,
      arrowRight: main2.arrowRight,
      radioOn: "(*)",
      radioOff: "( )",
      tick: "\u221A",
      cross: "\xD7",
      ellipsis: "...",
      pointerSmall: "\xBB",
      line: "\u2500",
      pointer: ">"
    };
    var figures = process.platform === "win32" ? win : main2;
    module3.exports = figures;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/style.js
var require_style = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/style.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var c2 = require_kleur();
    var figures = require_figures();
    var styles2 = Object.freeze({
      password: {
        scale: 1,
        render: (input) => "*".repeat(input.length)
      },
      emoji: {
        scale: 2,
        render: (input) => "\u{1F603}".repeat(input.length)
      },
      invisible: {
        scale: 0,
        render: (input) => ""
      },
      default: {
        scale: 1,
        render: (input) => `${input}`
      }
    });
    var render7 = /* @__PURE__ */ __name((type) => styles2[type] || styles2.default, "render");
    var symbols = Object.freeze({
      aborted: c2.red(figures.cross),
      done: c2.green(figures.tick),
      exited: c2.yellow(figures.cross),
      default: c2.cyan("?")
    });
    var symbol = /* @__PURE__ */ __name((done, aborted, exited) => aborted ? symbols.aborted : exited ? symbols.exited : done ? symbols.done : symbols.default, "symbol");
    var delimiter = /* @__PURE__ */ __name((completing) => c2.gray(completing ? figures.ellipsis : figures.pointerSmall), "delimiter");
    var item = /* @__PURE__ */ __name((expandable, expanded) => c2.gray(expandable ? expanded ? figures.pointerSmall : "+" : figures.line), "item");
    module3.exports = {
      styles: styles2,
      render: render7,
      symbols,
      symbol,
      delimiter,
      item
    };
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/lines.js
var require_lines = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/lines.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var strip = require_strip();
    module3.exports = function(msg, perLine) {
      let lines = String(strip(msg) || "").split(/\r?\n/);
      if (!perLine)
        return lines.length;
      return lines.map((l2) => Math.ceil(l2.length / perLine)).reduce((a, b2) => a + b2);
    };
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/wrap.js
var require_wrap = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/wrap.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = (msg, opts = {}) => {
      const tab = Number.isSafeInteger(parseInt(opts.margin)) ? new Array(parseInt(opts.margin)).fill(" ").join("") : opts.margin || "";
      const width = opts.width;
      return (msg || "").split(/\r?\n/g).map((line) => line.split(/\s+/g).reduce((arr, w2) => {
        if (w2.length + tab.length >= width || arr[arr.length - 1].length + w2.length + 1 < width)
          arr[arr.length - 1] += ` ${w2}`;
        else
          arr.push(`${tab}${w2}`);
        return arr;
      }, [tab]).join("\n")).join("\n");
    };
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/entriesToDisplay.js
var require_entriesToDisplay = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/entriesToDisplay.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = (cursor, total, maxVisible) => {
      maxVisible = maxVisible || total;
      let startIndex = Math.min(total - maxVisible, cursor - Math.floor(maxVisible / 2));
      if (startIndex < 0)
        startIndex = 0;
      let endIndex = Math.min(startIndex + maxVisible, total);
      return {
        startIndex,
        endIndex
      };
    };
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/index.js
var require_util9 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/util/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = {
      action: require_action(),
      clear: require_clear(),
      style: require_style(),
      strip: require_strip(),
      figures: require_figures(),
      lines: require_lines(),
      wrap: require_wrap(),
      entriesToDisplay: require_entriesToDisplay()
    };
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/prompt.js
var require_prompt = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/prompt.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var readline3 = require("readline");
    var _require = require_util9();
    var action = _require.action;
    var EventEmitter7 = require("events");
    var _require2 = require_src();
    var beep = _require2.beep;
    var cursor = _require2.cursor;
    var color = require_kleur();
    var Prompt = class extends EventEmitter7 {
      constructor(opts = {}) {
        super();
        this.firstRender = true;
        this.in = opts.stdin || process.stdin;
        this.out = opts.stdout || process.stdout;
        this.onRender = (opts.onRender || (() => void 0)).bind(this);
        const rl = readline3.createInterface({
          input: this.in,
          escapeCodeTimeout: 50
        });
        readline3.emitKeypressEvents(this.in, rl);
        if (this.in.isTTY)
          this.in.setRawMode(true);
        const isSelect = ["SelectPrompt", "MultiselectPrompt"].indexOf(this.constructor.name) > -1;
        const keypress = /* @__PURE__ */ __name((str, key) => {
          let a = action(key, isSelect);
          if (a === false) {
            this._ && this._(str, key);
          } else if (typeof this[a] === "function") {
            this[a](key);
          } else {
            this.bell();
          }
        }, "keypress");
        this.close = () => {
          this.out.write(cursor.show);
          this.in.removeListener("keypress", keypress);
          if (this.in.isTTY)
            this.in.setRawMode(false);
          rl.close();
          this.emit(this.aborted ? "abort" : this.exited ? "exit" : "submit", this.value);
          this.closed = true;
        };
        this.in.on("keypress", keypress);
      }
      fire() {
        this.emit("state", {
          value: this.value,
          aborted: !!this.aborted,
          exited: !!this.exited
        });
      }
      bell() {
        this.out.write(beep);
      }
      render() {
        this.onRender(color);
        if (this.firstRender)
          this.firstRender = false;
      }
    };
    __name(Prompt, "Prompt");
    module3.exports = Prompt;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/text.js
var require_text = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/text.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    function asyncGeneratorStep(gen, resolve19, reject, _next, _throw, key, arg) {
      try {
        var info = gen[key](arg);
        var value = info.value;
      } catch (error2) {
        reject(error2);
        return;
      }
      if (info.done) {
        resolve19(value);
      } else {
        Promise.resolve(value).then(_next, _throw);
      }
    }
    __name(asyncGeneratorStep, "asyncGeneratorStep");
    function _asyncToGenerator(fn2) {
      return function() {
        var self2 = this, args = arguments;
        return new Promise(function(resolve19, reject) {
          var gen = fn2.apply(self2, args);
          function _next(value) {
            asyncGeneratorStep(gen, resolve19, reject, _next, _throw, "next", value);
          }
          __name(_next, "_next");
          function _throw(err) {
            asyncGeneratorStep(gen, resolve19, reject, _next, _throw, "throw", err);
          }
          __name(_throw, "_throw");
          _next(void 0);
        });
      };
    }
    __name(_asyncToGenerator, "_asyncToGenerator");
    var color = require_kleur();
    var Prompt = require_prompt();
    var _require = require_src();
    var erase = _require.erase;
    var cursor = _require.cursor;
    var _require2 = require_util9();
    var style = _require2.style;
    var clear = _require2.clear;
    var lines = _require2.lines;
    var figures = _require2.figures;
    var TextPrompt = class extends Prompt {
      constructor(opts = {}) {
        super(opts);
        this.transform = style.render(opts.style);
        this.scale = this.transform.scale;
        this.msg = opts.message;
        this.initial = opts.initial || ``;
        this.validator = opts.validate || (() => true);
        this.value = ``;
        this.errorMsg = opts.error || `Please Enter A Valid Value`;
        this.cursor = Number(!!this.initial);
        this.cursorOffset = 0;
        this.clear = clear(``, this.out.columns);
        this.render();
      }
      set value(v2) {
        if (!v2 && this.initial) {
          this.placeholder = true;
          this.rendered = color.gray(this.transform.render(this.initial));
        } else {
          this.placeholder = false;
          this.rendered = this.transform.render(v2);
        }
        this._value = v2;
        this.fire();
      }
      get value() {
        return this._value;
      }
      reset() {
        this.value = ``;
        this.cursor = Number(!!this.initial);
        this.cursorOffset = 0;
        this.fire();
        this.render();
      }
      exit() {
        this.abort();
      }
      abort() {
        this.value = this.value || this.initial;
        this.done = this.aborted = true;
        this.error = false;
        this.red = false;
        this.fire();
        this.render();
        this.out.write("\n");
        this.close();
      }
      validate() {
        var _this = this;
        return _asyncToGenerator(function* () {
          let valid = yield _this.validator(_this.value);
          if (typeof valid === `string`) {
            _this.errorMsg = valid;
            valid = false;
          }
          _this.error = !valid;
        })();
      }
      submit() {
        var _this2 = this;
        return _asyncToGenerator(function* () {
          _this2.value = _this2.value || _this2.initial;
          _this2.cursorOffset = 0;
          _this2.cursor = _this2.rendered.length;
          yield _this2.validate();
          if (_this2.error) {
            _this2.red = true;
            _this2.fire();
            _this2.render();
            return;
          }
          _this2.done = true;
          _this2.aborted = false;
          _this2.fire();
          _this2.render();
          _this2.out.write("\n");
          _this2.close();
        })();
      }
      next() {
        if (!this.placeholder)
          return this.bell();
        this.value = this.initial;
        this.cursor = this.rendered.length;
        this.fire();
        this.render();
      }
      moveCursor(n2) {
        if (this.placeholder)
          return;
        this.cursor = this.cursor + n2;
        this.cursorOffset += n2;
      }
      _(c2, key) {
        let s1 = this.value.slice(0, this.cursor);
        let s2 = this.value.slice(this.cursor);
        this.value = `${s1}${c2}${s2}`;
        this.red = false;
        this.cursor = this.placeholder ? 0 : s1.length + 1;
        this.render();
      }
      delete() {
        if (this.isCursorAtStart())
          return this.bell();
        let s1 = this.value.slice(0, this.cursor - 1);
        let s2 = this.value.slice(this.cursor);
        this.value = `${s1}${s2}`;
        this.red = false;
        if (this.isCursorAtStart()) {
          this.cursorOffset = 0;
        } else {
          this.cursorOffset++;
          this.moveCursor(-1);
        }
        this.render();
      }
      deleteForward() {
        if (this.cursor * this.scale >= this.rendered.length || this.placeholder)
          return this.bell();
        let s1 = this.value.slice(0, this.cursor);
        let s2 = this.value.slice(this.cursor + 1);
        this.value = `${s1}${s2}`;
        this.red = false;
        if (this.isCursorAtEnd()) {
          this.cursorOffset = 0;
        } else {
          this.cursorOffset++;
        }
        this.render();
      }
      first() {
        this.cursor = 0;
        this.render();
      }
      last() {
        this.cursor = this.value.length;
        this.render();
      }
      left() {
        if (this.cursor <= 0 || this.placeholder)
          return this.bell();
        this.moveCursor(-1);
        this.render();
      }
      right() {
        if (this.cursor * this.scale >= this.rendered.length || this.placeholder)
          return this.bell();
        this.moveCursor(1);
        this.render();
      }
      isCursorAtStart() {
        return this.cursor === 0 || this.placeholder && this.cursor === 1;
      }
      isCursorAtEnd() {
        return this.cursor === this.rendered.length || this.placeholder && this.cursor === this.rendered.length + 1;
      }
      render() {
        if (this.closed)
          return;
        if (!this.firstRender) {
          if (this.outputError)
            this.out.write(cursor.down(lines(this.outputError, this.out.columns) - 1) + clear(this.outputError, this.out.columns));
          this.out.write(clear(this.outputText, this.out.columns));
        }
        super.render();
        this.outputError = "";
        this.outputText = [style.symbol(this.done, this.aborted), color.bold(this.msg), style.delimiter(this.done), this.red ? color.red(this.rendered) : this.rendered].join(` `);
        if (this.error) {
          this.outputError += this.errorMsg.split(`
`).reduce((a, l2, i) => a + `
${i ? " " : figures.pointerSmall} ${color.red().italic(l2)}`, ``);
        }
        this.out.write(erase.line + cursor.to(0) + this.outputText + cursor.save + this.outputError + cursor.restore + cursor.move(this.cursorOffset, 0));
      }
    };
    __name(TextPrompt, "TextPrompt");
    module3.exports = TextPrompt;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/select.js
var require_select = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/select.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var color = require_kleur();
    var Prompt = require_prompt();
    var _require = require_util9();
    var style = _require.style;
    var clear = _require.clear;
    var figures = _require.figures;
    var wrap4 = _require.wrap;
    var entriesToDisplay = _require.entriesToDisplay;
    var _require2 = require_src();
    var cursor = _require2.cursor;
    var SelectPrompt = class extends Prompt {
      constructor(opts = {}) {
        super(opts);
        this.msg = opts.message;
        this.hint = opts.hint || "- Use arrow-keys. Return to submit.";
        this.warn = opts.warn || "- This option is disabled";
        this.cursor = opts.initial || 0;
        this.choices = opts.choices.map((ch, idx) => {
          if (typeof ch === "string")
            ch = {
              title: ch,
              value: idx
            };
          return {
            title: ch && (ch.title || ch.value || ch),
            value: ch && (ch.value === void 0 ? idx : ch.value),
            description: ch && ch.description,
            selected: ch && ch.selected,
            disabled: ch && ch.disabled
          };
        });
        this.optionsPerPage = opts.optionsPerPage || 10;
        this.value = (this.choices[this.cursor] || {}).value;
        this.clear = clear("", this.out.columns);
        this.render();
      }
      moveCursor(n2) {
        this.cursor = n2;
        this.value = this.choices[n2].value;
        this.fire();
      }
      reset() {
        this.moveCursor(0);
        this.fire();
        this.render();
      }
      exit() {
        this.abort();
      }
      abort() {
        this.done = this.aborted = true;
        this.fire();
        this.render();
        this.out.write("\n");
        this.close();
      }
      submit() {
        if (!this.selection.disabled) {
          this.done = true;
          this.aborted = false;
          this.fire();
          this.render();
          this.out.write("\n");
          this.close();
        } else
          this.bell();
      }
      first() {
        this.moveCursor(0);
        this.render();
      }
      last() {
        this.moveCursor(this.choices.length - 1);
        this.render();
      }
      up() {
        if (this.cursor === 0) {
          this.moveCursor(this.choices.length - 1);
        } else {
          this.moveCursor(this.cursor - 1);
        }
        this.render();
      }
      down() {
        if (this.cursor === this.choices.length - 1) {
          this.moveCursor(0);
        } else {
          this.moveCursor(this.cursor + 1);
        }
        this.render();
      }
      next() {
        this.moveCursor((this.cursor + 1) % this.choices.length);
        this.render();
      }
      _(c2, key) {
        if (c2 === " ")
          return this.submit();
      }
      get selection() {
        return this.choices[this.cursor];
      }
      render() {
        if (this.closed)
          return;
        if (this.firstRender)
          this.out.write(cursor.hide);
        else
          this.out.write(clear(this.outputText, this.out.columns));
        super.render();
        let _entriesToDisplay = entriesToDisplay(this.cursor, this.choices.length, this.optionsPerPage), startIndex = _entriesToDisplay.startIndex, endIndex = _entriesToDisplay.endIndex;
        this.outputText = [style.symbol(this.done, this.aborted), color.bold(this.msg), style.delimiter(false), this.done ? this.selection.title : this.selection.disabled ? color.yellow(this.warn) : color.gray(this.hint)].join(" ");
        if (!this.done) {
          this.outputText += "\n";
          for (let i = startIndex; i < endIndex; i++) {
            let title, prefix, desc = "", v2 = this.choices[i];
            if (i === startIndex && startIndex > 0) {
              prefix = figures.arrowUp;
            } else if (i === endIndex - 1 && endIndex < this.choices.length) {
              prefix = figures.arrowDown;
            } else {
              prefix = " ";
            }
            if (v2.disabled) {
              title = this.cursor === i ? color.gray().underline(v2.title) : color.strikethrough().gray(v2.title);
              prefix = (this.cursor === i ? color.bold().gray(figures.pointer) + " " : "  ") + prefix;
            } else {
              title = this.cursor === i ? color.cyan().underline(v2.title) : v2.title;
              prefix = (this.cursor === i ? color.cyan(figures.pointer) + " " : "  ") + prefix;
              if (v2.description && this.cursor === i) {
                desc = ` - ${v2.description}`;
                if (prefix.length + title.length + desc.length >= this.out.columns || v2.description.split(/\r?\n/).length > 1) {
                  desc = "\n" + wrap4(v2.description, {
                    margin: 3,
                    width: this.out.columns
                  });
                }
              }
            }
            this.outputText += `${prefix} ${title}${color.gray(desc)}
`;
          }
        }
        this.out.write(this.outputText);
      }
    };
    __name(SelectPrompt, "SelectPrompt");
    module3.exports = SelectPrompt;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/toggle.js
var require_toggle = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/toggle.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var color = require_kleur();
    var Prompt = require_prompt();
    var _require = require_util9();
    var style = _require.style;
    var clear = _require.clear;
    var _require2 = require_src();
    var cursor = _require2.cursor;
    var erase = _require2.erase;
    var TogglePrompt = class extends Prompt {
      constructor(opts = {}) {
        super(opts);
        this.msg = opts.message;
        this.value = !!opts.initial;
        this.active = opts.active || "on";
        this.inactive = opts.inactive || "off";
        this.initialValue = this.value;
        this.render();
      }
      reset() {
        this.value = this.initialValue;
        this.fire();
        this.render();
      }
      exit() {
        this.abort();
      }
      abort() {
        this.done = this.aborted = true;
        this.fire();
        this.render();
        this.out.write("\n");
        this.close();
      }
      submit() {
        this.done = true;
        this.aborted = false;
        this.fire();
        this.render();
        this.out.write("\n");
        this.close();
      }
      deactivate() {
        if (this.value === false)
          return this.bell();
        this.value = false;
        this.render();
      }
      activate() {
        if (this.value === true)
          return this.bell();
        this.value = true;
        this.render();
      }
      delete() {
        this.deactivate();
      }
      left() {
        this.deactivate();
      }
      right() {
        this.activate();
      }
      down() {
        this.deactivate();
      }
      up() {
        this.activate();
      }
      next() {
        this.value = !this.value;
        this.fire();
        this.render();
      }
      _(c2, key) {
        if (c2 === " ") {
          this.value = !this.value;
        } else if (c2 === "1") {
          this.value = true;
        } else if (c2 === "0") {
          this.value = false;
        } else
          return this.bell();
        this.render();
      }
      render() {
        if (this.closed)
          return;
        if (this.firstRender)
          this.out.write(cursor.hide);
        else
          this.out.write(clear(this.outputText, this.out.columns));
        super.render();
        this.outputText = [style.symbol(this.done, this.aborted), color.bold(this.msg), style.delimiter(this.done), this.value ? this.inactive : color.cyan().underline(this.inactive), color.gray("/"), this.value ? color.cyan().underline(this.active) : this.active].join(" ");
        this.out.write(erase.line + cursor.to(0) + this.outputText);
      }
    };
    __name(TogglePrompt, "TogglePrompt");
    module3.exports = TogglePrompt;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/datepart.js
var require_datepart = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/datepart.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var DatePart = class {
      constructor({
        token,
        date,
        parts,
        locales
      }) {
        this.token = token;
        this.date = date || /* @__PURE__ */ new Date();
        this.parts = parts || [this];
        this.locales = locales || {};
      }
      up() {
      }
      down() {
      }
      next() {
        const currentIdx = this.parts.indexOf(this);
        return this.parts.find((part, idx) => idx > currentIdx && part instanceof DatePart);
      }
      setTo(val) {
      }
      prev() {
        let parts = [].concat(this.parts).reverse();
        const currentIdx = parts.indexOf(this);
        return parts.find((part, idx) => idx > currentIdx && part instanceof DatePart);
      }
      toString() {
        return String(this.date);
      }
    };
    __name(DatePart, "DatePart");
    module3.exports = DatePart;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/meridiem.js
var require_meridiem = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/meridiem.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var DatePart = require_datepart();
    var Meridiem = class extends DatePart {
      constructor(opts = {}) {
        super(opts);
      }
      up() {
        this.date.setHours((this.date.getHours() + 12) % 24);
      }
      down() {
        this.up();
      }
      toString() {
        let meridiem = this.date.getHours() > 12 ? "pm" : "am";
        return /\A/.test(this.token) ? meridiem.toUpperCase() : meridiem;
      }
    };
    __name(Meridiem, "Meridiem");
    module3.exports = Meridiem;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/day.js
var require_day = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/day.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var DatePart = require_datepart();
    var pos = /* @__PURE__ */ __name((n2) => {
      n2 = n2 % 10;
      return n2 === 1 ? "st" : n2 === 2 ? "nd" : n2 === 3 ? "rd" : "th";
    }, "pos");
    var Day = class extends DatePart {
      constructor(opts = {}) {
        super(opts);
      }
      up() {
        this.date.setDate(this.date.getDate() + 1);
      }
      down() {
        this.date.setDate(this.date.getDate() - 1);
      }
      setTo(val) {
        this.date.setDate(parseInt(val.substr(-2)));
      }
      toString() {
        let date = this.date.getDate();
        let day2 = this.date.getDay();
        return this.token === "DD" ? String(date).padStart(2, "0") : this.token === "Do" ? date + pos(date) : this.token === "d" ? day2 + 1 : this.token === "ddd" ? this.locales.weekdaysShort[day2] : this.token === "dddd" ? this.locales.weekdays[day2] : date;
      }
    };
    __name(Day, "Day");
    module3.exports = Day;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/hours.js
var require_hours = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/hours.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var DatePart = require_datepart();
    var Hours = class extends DatePart {
      constructor(opts = {}) {
        super(opts);
      }
      up() {
        this.date.setHours(this.date.getHours() + 1);
      }
      down() {
        this.date.setHours(this.date.getHours() - 1);
      }
      setTo(val) {
        this.date.setHours(parseInt(val.substr(-2)));
      }
      toString() {
        let hours = this.date.getHours();
        if (/h/.test(this.token))
          hours = hours % 12 || 12;
        return this.token.length > 1 ? String(hours).padStart(2, "0") : hours;
      }
    };
    __name(Hours, "Hours");
    module3.exports = Hours;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/milliseconds.js
var require_milliseconds = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/milliseconds.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var DatePart = require_datepart();
    var Milliseconds = class extends DatePart {
      constructor(opts = {}) {
        super(opts);
      }
      up() {
        this.date.setMilliseconds(this.date.getMilliseconds() + 1);
      }
      down() {
        this.date.setMilliseconds(this.date.getMilliseconds() - 1);
      }
      setTo(val) {
        this.date.setMilliseconds(parseInt(val.substr(-this.token.length)));
      }
      toString() {
        return String(this.date.getMilliseconds()).padStart(4, "0").substr(0, this.token.length);
      }
    };
    __name(Milliseconds, "Milliseconds");
    module3.exports = Milliseconds;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/minutes.js
var require_minutes = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/minutes.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var DatePart = require_datepart();
    var Minutes = class extends DatePart {
      constructor(opts = {}) {
        super(opts);
      }
      up() {
        this.date.setMinutes(this.date.getMinutes() + 1);
      }
      down() {
        this.date.setMinutes(this.date.getMinutes() - 1);
      }
      setTo(val) {
        this.date.setMinutes(parseInt(val.substr(-2)));
      }
      toString() {
        let m2 = this.date.getMinutes();
        return this.token.length > 1 ? String(m2).padStart(2, "0") : m2;
      }
    };
    __name(Minutes, "Minutes");
    module3.exports = Minutes;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/month.js
var require_month = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/month.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var DatePart = require_datepart();
    var Month = class extends DatePart {
      constructor(opts = {}) {
        super(opts);
      }
      up() {
        this.date.setMonth(this.date.getMonth() + 1);
      }
      down() {
        this.date.setMonth(this.date.getMonth() - 1);
      }
      setTo(val) {
        val = parseInt(val.substr(-2)) - 1;
        this.date.setMonth(val < 0 ? 0 : val);
      }
      toString() {
        let month2 = this.date.getMonth();
        let tl = this.token.length;
        return tl === 2 ? String(month2 + 1).padStart(2, "0") : tl === 3 ? this.locales.monthsShort[month2] : tl === 4 ? this.locales.months[month2] : String(month2 + 1);
      }
    };
    __name(Month, "Month");
    module3.exports = Month;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/seconds.js
var require_seconds = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/seconds.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var DatePart = require_datepart();
    var Seconds = class extends DatePart {
      constructor(opts = {}) {
        super(opts);
      }
      up() {
        this.date.setSeconds(this.date.getSeconds() + 1);
      }
      down() {
        this.date.setSeconds(this.date.getSeconds() - 1);
      }
      setTo(val) {
        this.date.setSeconds(parseInt(val.substr(-2)));
      }
      toString() {
        let s = this.date.getSeconds();
        return this.token.length > 1 ? String(s).padStart(2, "0") : s;
      }
    };
    __name(Seconds, "Seconds");
    module3.exports = Seconds;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/year.js
var require_year = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/year.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var DatePart = require_datepart();
    var Year = class extends DatePart {
      constructor(opts = {}) {
        super(opts);
      }
      up() {
        this.date.setFullYear(this.date.getFullYear() + 1);
      }
      down() {
        this.date.setFullYear(this.date.getFullYear() - 1);
      }
      setTo(val) {
        this.date.setFullYear(val.substr(-4));
      }
      toString() {
        let year2 = String(this.date.getFullYear()).padStart(4, "0");
        return this.token.length === 2 ? year2.substr(-2) : year2;
      }
    };
    __name(Year, "Year");
    module3.exports = Year;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/index.js
var require_dateparts = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/dateparts/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = {
      DatePart: require_datepart(),
      Meridiem: require_meridiem(),
      Day: require_day(),
      Hours: require_hours(),
      Milliseconds: require_milliseconds(),
      Minutes: require_minutes(),
      Month: require_month(),
      Seconds: require_seconds(),
      Year: require_year()
    };
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/date.js
var require_date = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/date.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    function asyncGeneratorStep(gen, resolve19, reject, _next, _throw, key, arg) {
      try {
        var info = gen[key](arg);
        var value = info.value;
      } catch (error2) {
        reject(error2);
        return;
      }
      if (info.done) {
        resolve19(value);
      } else {
        Promise.resolve(value).then(_next, _throw);
      }
    }
    __name(asyncGeneratorStep, "asyncGeneratorStep");
    function _asyncToGenerator(fn2) {
      return function() {
        var self2 = this, args = arguments;
        return new Promise(function(resolve19, reject) {
          var gen = fn2.apply(self2, args);
          function _next(value) {
            asyncGeneratorStep(gen, resolve19, reject, _next, _throw, "next", value);
          }
          __name(_next, "_next");
          function _throw(err) {
            asyncGeneratorStep(gen, resolve19, reject, _next, _throw, "throw", err);
          }
          __name(_throw, "_throw");
          _next(void 0);
        });
      };
    }
    __name(_asyncToGenerator, "_asyncToGenerator");
    var color = require_kleur();
    var Prompt = require_prompt();
    var _require = require_util9();
    var style = _require.style;
    var clear = _require.clear;
    var figures = _require.figures;
    var _require2 = require_src();
    var erase = _require2.erase;
    var cursor = _require2.cursor;
    var _require3 = require_dateparts();
    var DatePart = _require3.DatePart;
    var Meridiem = _require3.Meridiem;
    var Day = _require3.Day;
    var Hours = _require3.Hours;
    var Milliseconds = _require3.Milliseconds;
    var Minutes = _require3.Minutes;
    var Month = _require3.Month;
    var Seconds = _require3.Seconds;
    var Year = _require3.Year;
    var regex2 = /\\(.)|"((?:\\["\\]|[^"])+)"|(D[Do]?|d{3,4}|d)|(M{1,4})|(YY(?:YY)?)|([aA])|([Hh]{1,2})|(m{1,2})|(s{1,2})|(S{1,4})|./g;
    var regexGroups = {
      1: ({
        token
      }) => token.replace(/\\(.)/g, "$1"),
      2: (opts) => new Day(opts),
      // Day // TODO
      3: (opts) => new Month(opts),
      // Month
      4: (opts) => new Year(opts),
      // Year
      5: (opts) => new Meridiem(opts),
      // AM/PM // TODO (special)
      6: (opts) => new Hours(opts),
      // Hours
      7: (opts) => new Minutes(opts),
      // Minutes
      8: (opts) => new Seconds(opts),
      // Seconds
      9: (opts) => new Milliseconds(opts)
      // Fractional seconds
    };
    var dfltLocales = {
      months: "January,February,March,April,May,June,July,August,September,October,November,December".split(","),
      monthsShort: "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec".split(","),
      weekdays: "Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday".split(","),
      weekdaysShort: "Sun,Mon,Tue,Wed,Thu,Fri,Sat".split(",")
    };
    var DatePrompt = class extends Prompt {
      constructor(opts = {}) {
        super(opts);
        this.msg = opts.message;
        this.cursor = 0;
        this.typed = "";
        this.locales = Object.assign(dfltLocales, opts.locales);
        this._date = opts.initial || /* @__PURE__ */ new Date();
        this.errorMsg = opts.error || "Please Enter A Valid Value";
        this.validator = opts.validate || (() => true);
        this.mask = opts.mask || "YYYY-MM-DD HH:mm:ss";
        this.clear = clear("", this.out.columns);
        this.render();
      }
      get value() {
        return this.date;
      }
      get date() {
        return this._date;
      }
      set date(date) {
        if (date)
          this._date.setTime(date.getTime());
      }
      set mask(mask) {
        let result;
        this.parts = [];
        while (result = regex2.exec(mask)) {
          let match = result.shift();
          let idx = result.findIndex((gr) => gr != null);
          this.parts.push(idx in regexGroups ? regexGroups[idx]({
            token: result[idx] || match,
            date: this.date,
            parts: this.parts,
            locales: this.locales
          }) : result[idx] || match);
        }
        let parts = this.parts.reduce((arr, i) => {
          if (typeof i === "string" && typeof arr[arr.length - 1] === "string")
            arr[arr.length - 1] += i;
          else
            arr.push(i);
          return arr;
        }, []);
        this.parts.splice(0);
        this.parts.push(...parts);
        this.reset();
      }
      moveCursor(n2) {
        this.typed = "";
        this.cursor = n2;
        this.fire();
      }
      reset() {
        this.moveCursor(this.parts.findIndex((p2) => p2 instanceof DatePart));
        this.fire();
        this.render();
      }
      exit() {
        this.abort();
      }
      abort() {
        this.done = this.aborted = true;
        this.error = false;
        this.fire();
        this.render();
        this.out.write("\n");
        this.close();
      }
      validate() {
        var _this = this;
        return _asyncToGenerator(function* () {
          let valid = yield _this.validator(_this.value);
          if (typeof valid === "string") {
            _this.errorMsg = valid;
            valid = false;
          }
          _this.error = !valid;
        })();
      }
      submit() {
        var _this2 = this;
        return _asyncToGenerator(function* () {
          yield _this2.validate();
          if (_this2.error) {
            _this2.color = "red";
            _this2.fire();
            _this2.render();
            return;
          }
          _this2.done = true;
          _this2.aborted = false;
          _this2.fire();
          _this2.render();
          _this2.out.write("\n");
          _this2.close();
        })();
      }
      up() {
        this.typed = "";
        this.parts[this.cursor].up();
        this.render();
      }
      down() {
        this.typed = "";
        this.parts[this.cursor].down();
        this.render();
      }
      left() {
        let prev = this.parts[this.cursor].prev();
        if (prev == null)
          return this.bell();
        this.moveCursor(this.parts.indexOf(prev));
        this.render();
      }
      right() {
        let next = this.parts[this.cursor].next();
        if (next == null)
          return this.bell();
        this.moveCursor(this.parts.indexOf(next));
        this.render();
      }
      next() {
        let next = this.parts[this.cursor].next();
        this.moveCursor(next ? this.parts.indexOf(next) : this.parts.findIndex((part) => part instanceof DatePart));
        this.render();
      }
      _(c2) {
        if (/\d/.test(c2)) {
          this.typed += c2;
          this.parts[this.cursor].setTo(this.typed);
          this.render();
        }
      }
      render() {
        if (this.closed)
          return;
        if (this.firstRender)
          this.out.write(cursor.hide);
        else
          this.out.write(clear(this.outputText, this.out.columns));
        super.render();
        this.outputText = [style.symbol(this.done, this.aborted), color.bold(this.msg), style.delimiter(false), this.parts.reduce((arr, p2, idx) => arr.concat(idx === this.cursor && !this.done ? color.cyan().underline(p2.toString()) : p2), []).join("")].join(" ");
        if (this.error) {
          this.outputText += this.errorMsg.split("\n").reduce((a, l2, i) => a + `
${i ? ` ` : figures.pointerSmall} ${color.red().italic(l2)}`, ``);
        }
        this.out.write(erase.line + cursor.to(0) + this.outputText);
      }
    };
    __name(DatePrompt, "DatePrompt");
    module3.exports = DatePrompt;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/number.js
var require_number = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/number.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    function asyncGeneratorStep(gen, resolve19, reject, _next, _throw, key, arg) {
      try {
        var info = gen[key](arg);
        var value = info.value;
      } catch (error2) {
        reject(error2);
        return;
      }
      if (info.done) {
        resolve19(value);
      } else {
        Promise.resolve(value).then(_next, _throw);
      }
    }
    __name(asyncGeneratorStep, "asyncGeneratorStep");
    function _asyncToGenerator(fn2) {
      return function() {
        var self2 = this, args = arguments;
        return new Promise(function(resolve19, reject) {
          var gen = fn2.apply(self2, args);
          function _next(value) {
            asyncGeneratorStep(gen, resolve19, reject, _next, _throw, "next", value);
          }
          __name(_next, "_next");
          function _throw(err) {
            asyncGeneratorStep(gen, resolve19, reject, _next, _throw, "throw", err);
          }
          __name(_throw, "_throw");
          _next(void 0);
        });
      };
    }
    __name(_asyncToGenerator, "_asyncToGenerator");
    var color = require_kleur();
    var Prompt = require_prompt();
    var _require = require_src();
    var cursor = _require.cursor;
    var erase = _require.erase;
    var _require2 = require_util9();
    var style = _require2.style;
    var figures = _require2.figures;
    var clear = _require2.clear;
    var lines = _require2.lines;
    var isNumber = /[0-9]/;
    var isDef = /* @__PURE__ */ __name((any) => any !== void 0, "isDef");
    var round = /* @__PURE__ */ __name((number, precision) => {
      let factor = Math.pow(10, precision);
      return Math.round(number * factor) / factor;
    }, "round");
    var NumberPrompt = class extends Prompt {
      constructor(opts = {}) {
        super(opts);
        this.transform = style.render(opts.style);
        this.msg = opts.message;
        this.initial = isDef(opts.initial) ? opts.initial : "";
        this.float = !!opts.float;
        this.round = opts.round || 2;
        this.inc = opts.increment || 1;
        this.min = isDef(opts.min) ? opts.min : -Infinity;
        this.max = isDef(opts.max) ? opts.max : Infinity;
        this.errorMsg = opts.error || `Please Enter A Valid Value`;
        this.validator = opts.validate || (() => true);
        this.color = `cyan`;
        this.value = ``;
        this.typed = ``;
        this.lastHit = 0;
        this.render();
      }
      set value(v2) {
        if (!v2 && v2 !== 0) {
          this.placeholder = true;
          this.rendered = color.gray(this.transform.render(`${this.initial}`));
          this._value = ``;
        } else {
          this.placeholder = false;
          this.rendered = this.transform.render(`${round(v2, this.round)}`);
          this._value = round(v2, this.round);
        }
        this.fire();
      }
      get value() {
        return this._value;
      }
      parse(x2) {
        return this.float ? parseFloat(x2) : parseInt(x2);
      }
      valid(c2) {
        return c2 === `-` || c2 === `.` && this.float || isNumber.test(c2);
      }
      reset() {
        this.typed = ``;
        this.value = ``;
        this.fire();
        this.render();
      }
      exit() {
        this.abort();
      }
      abort() {
        let x2 = this.value;
        this.value = x2 !== `` ? x2 : this.initial;
        this.done = this.aborted = true;
        this.error = false;
        this.fire();
        this.render();
        this.out.write(`
`);
        this.close();
      }
      validate() {
        var _this = this;
        return _asyncToGenerator(function* () {
          let valid = yield _this.validator(_this.value);
          if (typeof valid === `string`) {
            _this.errorMsg = valid;
            valid = false;
          }
          _this.error = !valid;
        })();
      }
      submit() {
        var _this2 = this;
        return _asyncToGenerator(function* () {
          yield _this2.validate();
          if (_this2.error) {
            _this2.color = `red`;
            _this2.fire();
            _this2.render();
            return;
          }
          let x2 = _this2.value;
          _this2.value = x2 !== `` ? x2 : _this2.initial;
          _this2.done = true;
          _this2.aborted = false;
          _this2.error = false;
          _this2.fire();
          _this2.render();
          _this2.out.write(`
`);
          _this2.close();
        })();
      }
      up() {
        this.typed = ``;
        if (this.value === "") {
          this.value = this.min - this.inc;
        }
        if (this.value >= this.max)
          return this.bell();
        this.value += this.inc;
        this.color = `cyan`;
        this.fire();
        this.render();
      }
      down() {
        this.typed = ``;
        if (this.value === "") {
          this.value = this.min + this.inc;
        }
        if (this.value <= this.min)
          return this.bell();
        this.value -= this.inc;
        this.color = `cyan`;
        this.fire();
        this.render();
      }
      delete() {
        let val = this.value.toString();
        if (val.length === 0)
          return this.bell();
        this.value = this.parse(val = val.slice(0, -1)) || ``;
        if (this.value !== "" && this.value < this.min) {
          this.value = this.min;
        }
        this.color = `cyan`;
        this.fire();
        this.render();
      }
      next() {
        this.value = this.initial;
        this.fire();
        this.render();
      }
      _(c2, key) {
        if (!this.valid(c2))
          return this.bell();
        const now = Date.now();
        if (now - this.lastHit > 1e3)
          this.typed = ``;
        this.typed += c2;
        this.lastHit = now;
        this.color = `cyan`;
        if (c2 === `.`)
          return this.fire();
        this.value = Math.min(this.parse(this.typed), this.max);
        if (this.value > this.max)
          this.value = this.max;
        if (this.value < this.min)
          this.value = this.min;
        this.fire();
        this.render();
      }
      render() {
        if (this.closed)
          return;
        if (!this.firstRender) {
          if (this.outputError)
            this.out.write(cursor.down(lines(this.outputError, this.out.columns) - 1) + clear(this.outputError, this.out.columns));
          this.out.write(clear(this.outputText, this.out.columns));
        }
        super.render();
        this.outputError = "";
        this.outputText = [style.symbol(this.done, this.aborted), color.bold(this.msg), style.delimiter(this.done), !this.done || !this.done && !this.placeholder ? color[this.color]().underline(this.rendered) : this.rendered].join(` `);
        if (this.error) {
          this.outputError += this.errorMsg.split(`
`).reduce((a, l2, i) => a + `
${i ? ` ` : figures.pointerSmall} ${color.red().italic(l2)}`, ``);
        }
        this.out.write(erase.line + cursor.to(0) + this.outputText + cursor.save + this.outputError + cursor.restore);
      }
    };
    __name(NumberPrompt, "NumberPrompt");
    module3.exports = NumberPrompt;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/multiselect.js
var require_multiselect = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/multiselect.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var color = require_kleur();
    var _require = require_src();
    var cursor = _require.cursor;
    var Prompt = require_prompt();
    var _require2 = require_util9();
    var clear = _require2.clear;
    var figures = _require2.figures;
    var style = _require2.style;
    var wrap4 = _require2.wrap;
    var entriesToDisplay = _require2.entriesToDisplay;
    var MultiselectPrompt = class extends Prompt {
      constructor(opts = {}) {
        super(opts);
        this.msg = opts.message;
        this.cursor = opts.cursor || 0;
        this.scrollIndex = opts.cursor || 0;
        this.hint = opts.hint || "";
        this.warn = opts.warn || "- This option is disabled -";
        this.minSelected = opts.min;
        this.showMinError = false;
        this.maxChoices = opts.max;
        this.instructions = opts.instructions;
        this.optionsPerPage = opts.optionsPerPage || 10;
        this.value = opts.choices.map((ch, idx) => {
          if (typeof ch === "string")
            ch = {
              title: ch,
              value: idx
            };
          return {
            title: ch && (ch.title || ch.value || ch),
            description: ch && ch.description,
            value: ch && (ch.value === void 0 ? idx : ch.value),
            selected: ch && ch.selected,
            disabled: ch && ch.disabled
          };
        });
        this.clear = clear("", this.out.columns);
        if (!opts.overrideRender) {
          this.render();
        }
      }
      reset() {
        this.value.map((v2) => !v2.selected);
        this.cursor = 0;
        this.fire();
        this.render();
      }
      selected() {
        return this.value.filter((v2) => v2.selected);
      }
      exit() {
        this.abort();
      }
      abort() {
        this.done = this.aborted = true;
        this.fire();
        this.render();
        this.out.write("\n");
        this.close();
      }
      submit() {
        const selected = this.value.filter((e3) => e3.selected);
        if (this.minSelected && selected.length < this.minSelected) {
          this.showMinError = true;
          this.render();
        } else {
          this.done = true;
          this.aborted = false;
          this.fire();
          this.render();
          this.out.write("\n");
          this.close();
        }
      }
      first() {
        this.cursor = 0;
        this.render();
      }
      last() {
        this.cursor = this.value.length - 1;
        this.render();
      }
      next() {
        this.cursor = (this.cursor + 1) % this.value.length;
        this.render();
      }
      up() {
        if (this.cursor === 0) {
          this.cursor = this.value.length - 1;
        } else {
          this.cursor--;
        }
        this.render();
      }
      down() {
        if (this.cursor === this.value.length - 1) {
          this.cursor = 0;
        } else {
          this.cursor++;
        }
        this.render();
      }
      left() {
        this.value[this.cursor].selected = false;
        this.render();
      }
      right() {
        if (this.value.filter((e3) => e3.selected).length >= this.maxChoices)
          return this.bell();
        this.value[this.cursor].selected = true;
        this.render();
      }
      handleSpaceToggle() {
        const v2 = this.value[this.cursor];
        if (v2.selected) {
          v2.selected = false;
          this.render();
        } else if (v2.disabled || this.value.filter((e3) => e3.selected).length >= this.maxChoices) {
          return this.bell();
        } else {
          v2.selected = true;
          this.render();
        }
      }
      toggleAll() {
        if (this.maxChoices !== void 0 || this.value[this.cursor].disabled) {
          return this.bell();
        }
        const newSelected = !this.value[this.cursor].selected;
        this.value.filter((v2) => !v2.disabled).forEach((v2) => v2.selected = newSelected);
        this.render();
      }
      _(c2, key) {
        if (c2 === " ") {
          this.handleSpaceToggle();
        } else if (c2 === "a") {
          this.toggleAll();
        } else {
          return this.bell();
        }
      }
      renderInstructions() {
        if (this.instructions === void 0 || this.instructions) {
          if (typeof this.instructions === "string") {
            return this.instructions;
          }
          return `
Instructions:
    ${figures.arrowUp}/${figures.arrowDown}: Highlight option
    ${figures.arrowLeft}/${figures.arrowRight}/[space]: Toggle selection
` + (this.maxChoices === void 0 ? `    a: Toggle all
` : "") + `    enter/return: Complete answer`;
        }
        return "";
      }
      renderOption(cursor2, v2, i, arrowIndicator) {
        const prefix = (v2.selected ? color.green(figures.radioOn) : figures.radioOff) + " " + arrowIndicator + " ";
        let title, desc;
        if (v2.disabled) {
          title = cursor2 === i ? color.gray().underline(v2.title) : color.strikethrough().gray(v2.title);
        } else {
          title = cursor2 === i ? color.cyan().underline(v2.title) : v2.title;
          if (cursor2 === i && v2.description) {
            desc = ` - ${v2.description}`;
            if (prefix.length + title.length + desc.length >= this.out.columns || v2.description.split(/\r?\n/).length > 1) {
              desc = "\n" + wrap4(v2.description, {
                margin: prefix.length,
                width: this.out.columns
              });
            }
          }
        }
        return prefix + title + color.gray(desc || "");
      }
      // shared with autocompleteMultiselect
      paginateOptions(options29) {
        if (options29.length === 0) {
          return color.red("No matches for this query.");
        }
        let _entriesToDisplay = entriesToDisplay(this.cursor, options29.length, this.optionsPerPage), startIndex = _entriesToDisplay.startIndex, endIndex = _entriesToDisplay.endIndex;
        let prefix, styledOptions = [];
        for (let i = startIndex; i < endIndex; i++) {
          if (i === startIndex && startIndex > 0) {
            prefix = figures.arrowUp;
          } else if (i === endIndex - 1 && endIndex < options29.length) {
            prefix = figures.arrowDown;
          } else {
            prefix = " ";
          }
          styledOptions.push(this.renderOption(this.cursor, options29[i], i, prefix));
        }
        return "\n" + styledOptions.join("\n");
      }
      // shared with autocomleteMultiselect
      renderOptions(options29) {
        if (!this.done) {
          return this.paginateOptions(options29);
        }
        return "";
      }
      renderDoneOrInstructions() {
        if (this.done) {
          return this.value.filter((e3) => e3.selected).map((v2) => v2.title).join(", ");
        }
        const output = [color.gray(this.hint), this.renderInstructions()];
        if (this.value[this.cursor].disabled) {
          output.push(color.yellow(this.warn));
        }
        return output.join(" ");
      }
      render() {
        if (this.closed)
          return;
        if (this.firstRender)
          this.out.write(cursor.hide);
        super.render();
        let prompt2 = [style.symbol(this.done, this.aborted), color.bold(this.msg), style.delimiter(false), this.renderDoneOrInstructions()].join(" ");
        if (this.showMinError) {
          prompt2 += color.red(`You must select a minimum of ${this.minSelected} choices.`);
          this.showMinError = false;
        }
        prompt2 += this.renderOptions(this.value);
        this.out.write(this.clear + prompt2);
        this.clear = clear(prompt2, this.out.columns);
      }
    };
    __name(MultiselectPrompt, "MultiselectPrompt");
    module3.exports = MultiselectPrompt;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/autocomplete.js
var require_autocomplete = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/autocomplete.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    function asyncGeneratorStep(gen, resolve19, reject, _next, _throw, key, arg) {
      try {
        var info = gen[key](arg);
        var value = info.value;
      } catch (error2) {
        reject(error2);
        return;
      }
      if (info.done) {
        resolve19(value);
      } else {
        Promise.resolve(value).then(_next, _throw);
      }
    }
    __name(asyncGeneratorStep, "asyncGeneratorStep");
    function _asyncToGenerator(fn2) {
      return function() {
        var self2 = this, args = arguments;
        return new Promise(function(resolve19, reject) {
          var gen = fn2.apply(self2, args);
          function _next(value) {
            asyncGeneratorStep(gen, resolve19, reject, _next, _throw, "next", value);
          }
          __name(_next, "_next");
          function _throw(err) {
            asyncGeneratorStep(gen, resolve19, reject, _next, _throw, "throw", err);
          }
          __name(_throw, "_throw");
          _next(void 0);
        });
      };
    }
    __name(_asyncToGenerator, "_asyncToGenerator");
    var color = require_kleur();
    var Prompt = require_prompt();
    var _require = require_src();
    var erase = _require.erase;
    var cursor = _require.cursor;
    var _require2 = require_util9();
    var style = _require2.style;
    var clear = _require2.clear;
    var figures = _require2.figures;
    var wrap4 = _require2.wrap;
    var entriesToDisplay = _require2.entriesToDisplay;
    var getVal = /* @__PURE__ */ __name((arr, i) => arr[i] && (arr[i].value || arr[i].title || arr[i]), "getVal");
    var getTitle = /* @__PURE__ */ __name((arr, i) => arr[i] && (arr[i].title || arr[i].value || arr[i]), "getTitle");
    var getIndex2 = /* @__PURE__ */ __name((arr, valOrTitle) => {
      const index = arr.findIndex((el) => el.value === valOrTitle || el.title === valOrTitle);
      return index > -1 ? index : void 0;
    }, "getIndex");
    var AutocompletePrompt = class extends Prompt {
      constructor(opts = {}) {
        super(opts);
        this.msg = opts.message;
        this.suggest = opts.suggest;
        this.choices = opts.choices;
        this.initial = typeof opts.initial === "number" ? opts.initial : getIndex2(opts.choices, opts.initial);
        this.select = this.initial || opts.cursor || 0;
        this.i18n = {
          noMatches: opts.noMatches || "no matches found"
        };
        this.fallback = opts.fallback || this.initial;
        this.clearFirst = opts.clearFirst || false;
        this.suggestions = [];
        this.input = "";
        this.limit = opts.limit || 10;
        this.cursor = 0;
        this.transform = style.render(opts.style);
        this.scale = this.transform.scale;
        this.render = this.render.bind(this);
        this.complete = this.complete.bind(this);
        this.clear = clear("", this.out.columns);
        this.complete(this.render);
        this.render();
      }
      set fallback(fb) {
        this._fb = Number.isSafeInteger(parseInt(fb)) ? parseInt(fb) : fb;
      }
      get fallback() {
        let choice;
        if (typeof this._fb === "number")
          choice = this.choices[this._fb];
        else if (typeof this._fb === "string")
          choice = {
            title: this._fb
          };
        return choice || this._fb || {
          title: this.i18n.noMatches
        };
      }
      moveSelect(i) {
        this.select = i;
        if (this.suggestions.length > 0)
          this.value = getVal(this.suggestions, i);
        else
          this.value = this.fallback.value;
        this.fire();
      }
      complete(cb) {
        var _this = this;
        return _asyncToGenerator(function* () {
          const p2 = _this.completing = _this.suggest(_this.input, _this.choices);
          const suggestions = yield p2;
          if (_this.completing !== p2)
            return;
          _this.suggestions = suggestions.map((s, i, arr) => ({
            title: getTitle(arr, i),
            value: getVal(arr, i),
            description: s.description
          }));
          _this.completing = false;
          const l2 = Math.max(suggestions.length - 1, 0);
          _this.moveSelect(Math.min(l2, _this.select));
          cb && cb();
        })();
      }
      reset() {
        this.input = "";
        this.complete(() => {
          this.moveSelect(this.initial !== void 0 ? this.initial : 0);
          this.render();
        });
        this.render();
      }
      exit() {
        if (this.clearFirst && this.input.length > 0) {
          this.reset();
        } else {
          this.done = this.exited = true;
          this.aborted = false;
          this.fire();
          this.render();
          this.out.write("\n");
          this.close();
        }
      }
      abort() {
        this.done = this.aborted = true;
        this.exited = false;
        this.fire();
        this.render();
        this.out.write("\n");
        this.close();
      }
      submit() {
        this.done = true;
        this.aborted = this.exited = false;
        this.fire();
        this.render();
        this.out.write("\n");
        this.close();
      }
      _(c2, key) {
        let s1 = this.input.slice(0, this.cursor);
        let s2 = this.input.slice(this.cursor);
        this.input = `${s1}${c2}${s2}`;
        this.cursor = s1.length + 1;
        this.complete(this.render);
        this.render();
      }
      delete() {
        if (this.cursor === 0)
          return this.bell();
        let s1 = this.input.slice(0, this.cursor - 1);
        let s2 = this.input.slice(this.cursor);
        this.input = `${s1}${s2}`;
        this.complete(this.render);
        this.cursor = this.cursor - 1;
        this.render();
      }
      deleteForward() {
        if (this.cursor * this.scale >= this.rendered.length)
          return this.bell();
        let s1 = this.input.slice(0, this.cursor);
        let s2 = this.input.slice(this.cursor + 1);
        this.input = `${s1}${s2}`;
        this.complete(this.render);
        this.render();
      }
      first() {
        this.moveSelect(0);
        this.render();
      }
      last() {
        this.moveSelect(this.suggestions.length - 1);
        this.render();
      }
      up() {
        if (this.select === 0) {
          this.moveSelect(this.suggestions.length - 1);
        } else {
          this.moveSelect(this.select - 1);
        }
        this.render();
      }
      down() {
        if (this.select === this.suggestions.length - 1) {
          this.moveSelect(0);
        } else {
          this.moveSelect(this.select + 1);
        }
        this.render();
      }
      next() {
        if (this.select === this.suggestions.length - 1) {
          this.moveSelect(0);
        } else
          this.moveSelect(this.select + 1);
        this.render();
      }
      nextPage() {
        this.moveSelect(Math.min(this.select + this.limit, this.suggestions.length - 1));
        this.render();
      }
      prevPage() {
        this.moveSelect(Math.max(this.select - this.limit, 0));
        this.render();
      }
      left() {
        if (this.cursor <= 0)
          return this.bell();
        this.cursor = this.cursor - 1;
        this.render();
      }
      right() {
        if (this.cursor * this.scale >= this.rendered.length)
          return this.bell();
        this.cursor = this.cursor + 1;
        this.render();
      }
      renderOption(v2, hovered, isStart, isEnd) {
        let desc;
        let prefix = isStart ? figures.arrowUp : isEnd ? figures.arrowDown : " ";
        let title = hovered ? color.cyan().underline(v2.title) : v2.title;
        prefix = (hovered ? color.cyan(figures.pointer) + " " : "  ") + prefix;
        if (v2.description) {
          desc = ` - ${v2.description}`;
          if (prefix.length + title.length + desc.length >= this.out.columns || v2.description.split(/\r?\n/).length > 1) {
            desc = "\n" + wrap4(v2.description, {
              margin: 3,
              width: this.out.columns
            });
          }
        }
        return prefix + " " + title + color.gray(desc || "");
      }
      render() {
        if (this.closed)
          return;
        if (this.firstRender)
          this.out.write(cursor.hide);
        else
          this.out.write(clear(this.outputText, this.out.columns));
        super.render();
        let _entriesToDisplay = entriesToDisplay(this.select, this.choices.length, this.limit), startIndex = _entriesToDisplay.startIndex, endIndex = _entriesToDisplay.endIndex;
        this.outputText = [style.symbol(this.done, this.aborted, this.exited), color.bold(this.msg), style.delimiter(this.completing), this.done && this.suggestions[this.select] ? this.suggestions[this.select].title : this.rendered = this.transform.render(this.input)].join(" ");
        if (!this.done) {
          const suggestions = this.suggestions.slice(startIndex, endIndex).map((item, i) => this.renderOption(item, this.select === i + startIndex, i === 0 && startIndex > 0, i + startIndex === endIndex - 1 && endIndex < this.choices.length)).join("\n");
          this.outputText += `
` + (suggestions || color.gray(this.fallback.title));
        }
        this.out.write(erase.line + cursor.to(0) + this.outputText);
      }
    };
    __name(AutocompletePrompt, "AutocompletePrompt");
    module3.exports = AutocompletePrompt;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/autocompleteMultiselect.js
var require_autocompleteMultiselect = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/autocompleteMultiselect.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var color = require_kleur();
    var _require = require_src();
    var cursor = _require.cursor;
    var MultiselectPrompt = require_multiselect();
    var _require2 = require_util9();
    var clear = _require2.clear;
    var style = _require2.style;
    var figures = _require2.figures;
    var AutocompleteMultiselectPrompt = class extends MultiselectPrompt {
      constructor(opts = {}) {
        opts.overrideRender = true;
        super(opts);
        this.inputValue = "";
        this.clear = clear("", this.out.columns);
        this.filteredOptions = this.value;
        this.render();
      }
      last() {
        this.cursor = this.filteredOptions.length - 1;
        this.render();
      }
      next() {
        this.cursor = (this.cursor + 1) % this.filteredOptions.length;
        this.render();
      }
      up() {
        if (this.cursor === 0) {
          this.cursor = this.filteredOptions.length - 1;
        } else {
          this.cursor--;
        }
        this.render();
      }
      down() {
        if (this.cursor === this.filteredOptions.length - 1) {
          this.cursor = 0;
        } else {
          this.cursor++;
        }
        this.render();
      }
      left() {
        this.filteredOptions[this.cursor].selected = false;
        this.render();
      }
      right() {
        if (this.value.filter((e3) => e3.selected).length >= this.maxChoices)
          return this.bell();
        this.filteredOptions[this.cursor].selected = true;
        this.render();
      }
      delete() {
        if (this.inputValue.length) {
          this.inputValue = this.inputValue.substr(0, this.inputValue.length - 1);
          this.updateFilteredOptions();
        }
      }
      updateFilteredOptions() {
        const currentHighlight = this.filteredOptions[this.cursor];
        this.filteredOptions = this.value.filter((v2) => {
          if (this.inputValue) {
            if (typeof v2.title === "string") {
              if (v2.title.toLowerCase().includes(this.inputValue.toLowerCase())) {
                return true;
              }
            }
            if (typeof v2.value === "string") {
              if (v2.value.toLowerCase().includes(this.inputValue.toLowerCase())) {
                return true;
              }
            }
            return false;
          }
          return true;
        });
        const newHighlightIndex = this.filteredOptions.findIndex((v2) => v2 === currentHighlight);
        this.cursor = newHighlightIndex < 0 ? 0 : newHighlightIndex;
        this.render();
      }
      handleSpaceToggle() {
        const v2 = this.filteredOptions[this.cursor];
        if (v2.selected) {
          v2.selected = false;
          this.render();
        } else if (v2.disabled || this.value.filter((e3) => e3.selected).length >= this.maxChoices) {
          return this.bell();
        } else {
          v2.selected = true;
          this.render();
        }
      }
      handleInputChange(c2) {
        this.inputValue = this.inputValue + c2;
        this.updateFilteredOptions();
      }
      _(c2, key) {
        if (c2 === " ") {
          this.handleSpaceToggle();
        } else {
          this.handleInputChange(c2);
        }
      }
      renderInstructions() {
        if (this.instructions === void 0 || this.instructions) {
          if (typeof this.instructions === "string") {
            return this.instructions;
          }
          return `
Instructions:
    ${figures.arrowUp}/${figures.arrowDown}: Highlight option
    ${figures.arrowLeft}/${figures.arrowRight}/[space]: Toggle selection
    [a,b,c]/delete: Filter choices
    enter/return: Complete answer
`;
        }
        return "";
      }
      renderCurrentInput() {
        return `
Filtered results for: ${this.inputValue ? this.inputValue : color.gray("Enter something to filter")}
`;
      }
      renderOption(cursor2, v2, i) {
        let title;
        if (v2.disabled)
          title = cursor2 === i ? color.gray().underline(v2.title) : color.strikethrough().gray(v2.title);
        else
          title = cursor2 === i ? color.cyan().underline(v2.title) : v2.title;
        return (v2.selected ? color.green(figures.radioOn) : figures.radioOff) + "  " + title;
      }
      renderDoneOrInstructions() {
        if (this.done) {
          return this.value.filter((e3) => e3.selected).map((v2) => v2.title).join(", ");
        }
        const output = [color.gray(this.hint), this.renderInstructions(), this.renderCurrentInput()];
        if (this.filteredOptions.length && this.filteredOptions[this.cursor].disabled) {
          output.push(color.yellow(this.warn));
        }
        return output.join(" ");
      }
      render() {
        if (this.closed)
          return;
        if (this.firstRender)
          this.out.write(cursor.hide);
        super.render();
        let prompt2 = [style.symbol(this.done, this.aborted), color.bold(this.msg), style.delimiter(false), this.renderDoneOrInstructions()].join(" ");
        if (this.showMinError) {
          prompt2 += color.red(`You must select a minimum of ${this.minSelected} choices.`);
          this.showMinError = false;
        }
        prompt2 += this.renderOptions(this.filteredOptions);
        this.out.write(this.clear + prompt2);
        this.clear = clear(prompt2, this.out.columns);
      }
    };
    __name(AutocompleteMultiselectPrompt, "AutocompleteMultiselectPrompt");
    module3.exports = AutocompleteMultiselectPrompt;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/confirm.js
var require_confirm = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/confirm.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var color = require_kleur();
    var Prompt = require_prompt();
    var _require = require_util9();
    var style = _require.style;
    var clear = _require.clear;
    var _require2 = require_src();
    var erase = _require2.erase;
    var cursor = _require2.cursor;
    var ConfirmPrompt = class extends Prompt {
      constructor(opts = {}) {
        super(opts);
        this.msg = opts.message;
        this.value = opts.initial;
        this.initialValue = !!opts.initial;
        this.yesMsg = opts.yes || "yes";
        this.yesOption = opts.yesOption || "(Y/n)";
        this.noMsg = opts.no || "no";
        this.noOption = opts.noOption || "(y/N)";
        this.render();
      }
      reset() {
        this.value = this.initialValue;
        this.fire();
        this.render();
      }
      exit() {
        this.abort();
      }
      abort() {
        this.done = this.aborted = true;
        this.fire();
        this.render();
        this.out.write("\n");
        this.close();
      }
      submit() {
        this.value = this.value || false;
        this.done = true;
        this.aborted = false;
        this.fire();
        this.render();
        this.out.write("\n");
        this.close();
      }
      _(c2, key) {
        if (c2.toLowerCase() === "y") {
          this.value = true;
          return this.submit();
        }
        if (c2.toLowerCase() === "n") {
          this.value = false;
          return this.submit();
        }
        return this.bell();
      }
      render() {
        if (this.closed)
          return;
        if (this.firstRender)
          this.out.write(cursor.hide);
        else
          this.out.write(clear(this.outputText, this.out.columns));
        super.render();
        this.outputText = [style.symbol(this.done, this.aborted), color.bold(this.msg), style.delimiter(this.done), this.done ? this.value ? this.yesMsg : this.noMsg : color.gray(this.initialValue ? this.yesOption : this.noOption)].join(" ");
        this.out.write(erase.line + cursor.to(0) + this.outputText);
      }
    };
    __name(ConfirmPrompt, "ConfirmPrompt");
    module3.exports = ConfirmPrompt;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/index.js
var require_elements = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/elements/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = {
      TextPrompt: require_text(),
      SelectPrompt: require_select(),
      TogglePrompt: require_toggle(),
      DatePrompt: require_date(),
      NumberPrompt: require_number(),
      MultiselectPrompt: require_multiselect(),
      AutocompletePrompt: require_autocomplete(),
      AutocompleteMultiselectPrompt: require_autocompleteMultiselect(),
      ConfirmPrompt: require_confirm()
    };
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/prompts.js
var require_prompts = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/prompts.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var $3 = exports2;
    var el = require_elements();
    var noop = /* @__PURE__ */ __name((v2) => v2, "noop");
    function toPrompt(type, args, opts = {}) {
      return new Promise((res, rej) => {
        const p2 = new el[type](args);
        const onAbort = opts.onAbort || noop;
        const onSubmit = opts.onSubmit || noop;
        const onExit9 = opts.onExit || noop;
        p2.on("state", args.onState || noop);
        p2.on("submit", (x2) => res(onSubmit(x2)));
        p2.on("exit", (x2) => res(onExit9(x2)));
        p2.on("abort", (x2) => rej(onAbort(x2)));
      });
    }
    __name(toPrompt, "toPrompt");
    $3.text = (args) => toPrompt("TextPrompt", args);
    $3.password = (args) => {
      args.style = "password";
      return $3.text(args);
    };
    $3.invisible = (args) => {
      args.style = "invisible";
      return $3.text(args);
    };
    $3.number = (args) => toPrompt("NumberPrompt", args);
    $3.date = (args) => toPrompt("DatePrompt", args);
    $3.confirm = (args) => toPrompt("ConfirmPrompt", args);
    $3.list = (args) => {
      const sep3 = args.separator || ",";
      return toPrompt("TextPrompt", args, {
        onSubmit: (str) => str.split(sep3).map((s) => s.trim())
      });
    };
    $3.toggle = (args) => toPrompt("TogglePrompt", args);
    $3.select = (args) => toPrompt("SelectPrompt", args);
    $3.multiselect = (args) => {
      args.choices = [].concat(args.choices || []);
      const toSelected = /* @__PURE__ */ __name((items) => items.filter((item) => item.selected).map((item) => item.value), "toSelected");
      return toPrompt("MultiselectPrompt", args, {
        onAbort: toSelected,
        onSubmit: toSelected
      });
    };
    $3.autocompleteMultiselect = (args) => {
      args.choices = [].concat(args.choices || []);
      const toSelected = /* @__PURE__ */ __name((items) => items.filter((item) => item.selected).map((item) => item.value), "toSelected");
      return toPrompt("AutocompleteMultiselectPrompt", args, {
        onAbort: toSelected,
        onSubmit: toSelected
      });
    };
    var byTitle = /* @__PURE__ */ __name((input, choices) => Promise.resolve(choices.filter((item) => item.title.slice(0, input.length).toLowerCase() === input.toLowerCase())), "byTitle");
    $3.autocomplete = (args) => {
      args.suggest = args.suggest || byTitle;
      args.choices = [].concat(args.choices || []);
      return toPrompt("AutocompletePrompt", args);
    };
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/index.js
var require_dist2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/dist/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    function ownKeys11(object, enumerableOnly) {
      var keys = Object.keys(object);
      if (Object.getOwnPropertySymbols) {
        var symbols = Object.getOwnPropertySymbols(object);
        if (enumerableOnly) {
          symbols = symbols.filter(function(sym) {
            return Object.getOwnPropertyDescriptor(object, sym).enumerable;
          });
        }
        keys.push.apply(keys, symbols);
      }
      return keys;
    }
    __name(ownKeys11, "ownKeys");
    function _objectSpread11(target) {
      for (var i = 1; i < arguments.length; i++) {
        var source = arguments[i] != null ? arguments[i] : {};
        if (i % 2) {
          ownKeys11(Object(source), true).forEach(function(key) {
            _defineProperty11(target, key, source[key]);
          });
        } else if (Object.getOwnPropertyDescriptors) {
          Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
        } else {
          ownKeys11(Object(source)).forEach(function(key) {
            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
          });
        }
      }
      return target;
    }
    __name(_objectSpread11, "_objectSpread");
    function _defineProperty11(obj, key, value) {
      if (key in obj) {
        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
      } else {
        obj[key] = value;
      }
      return obj;
    }
    __name(_defineProperty11, "_defineProperty");
    function _createForOfIteratorHelper(o2, allowArrayLike) {
      var it2 = typeof Symbol !== "undefined" && o2[Symbol.iterator] || o2["@@iterator"];
      if (!it2) {
        if (Array.isArray(o2) || (it2 = _unsupportedIterableToArray4(o2)) || allowArrayLike && o2 && typeof o2.length === "number") {
          if (it2)
            o2 = it2;
          var i = 0;
          var F = /* @__PURE__ */ __name(function F2() {
          }, "F");
          return { s: F, n: /* @__PURE__ */ __name(function n2() {
            if (i >= o2.length)
              return { done: true };
            return { done: false, value: o2[i++] };
          }, "n"), e: /* @__PURE__ */ __name(function e3(_e) {
            throw _e;
          }, "e"), f: F };
        }
        throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
      }
      var normalCompletion = true, didErr = false, err;
      return { s: /* @__PURE__ */ __name(function s() {
        it2 = it2.call(o2);
      }, "s"), n: /* @__PURE__ */ __name(function n2() {
        var step = it2.next();
        normalCompletion = step.done;
        return step;
      }, "n"), e: /* @__PURE__ */ __name(function e3(_e2) {
        didErr = true;
        err = _e2;
      }, "e"), f: /* @__PURE__ */ __name(function f() {
        try {
          if (!normalCompletion && it2.return != null)
            it2.return();
        } finally {
          if (didErr)
            throw err;
        }
      }, "f") };
    }
    __name(_createForOfIteratorHelper, "_createForOfIteratorHelper");
    function _unsupportedIterableToArray4(o2, minLen) {
      if (!o2)
        return;
      if (typeof o2 === "string")
        return _arrayLikeToArray4(o2, minLen);
      var n2 = Object.prototype.toString.call(o2).slice(8, -1);
      if (n2 === "Object" && o2.constructor)
        n2 = o2.constructor.name;
      if (n2 === "Map" || n2 === "Set")
        return Array.from(o2);
      if (n2 === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n2))
        return _arrayLikeToArray4(o2, minLen);
    }
    __name(_unsupportedIterableToArray4, "_unsupportedIterableToArray");
    function _arrayLikeToArray4(arr, len) {
      if (len == null || len > arr.length)
        len = arr.length;
      for (var i = 0, arr2 = new Array(len); i < len; i++)
        arr2[i] = arr[i];
      return arr2;
    }
    __name(_arrayLikeToArray4, "_arrayLikeToArray");
    function asyncGeneratorStep(gen, resolve19, reject, _next, _throw, key, arg) {
      try {
        var info = gen[key](arg);
        var value = info.value;
      } catch (error2) {
        reject(error2);
        return;
      }
      if (info.done) {
        resolve19(value);
      } else {
        Promise.resolve(value).then(_next, _throw);
      }
    }
    __name(asyncGeneratorStep, "asyncGeneratorStep");
    function _asyncToGenerator(fn2) {
      return function() {
        var self2 = this, args = arguments;
        return new Promise(function(resolve19, reject) {
          var gen = fn2.apply(self2, args);
          function _next(value) {
            asyncGeneratorStep(gen, resolve19, reject, _next, _throw, "next", value);
          }
          __name(_next, "_next");
          function _throw(err) {
            asyncGeneratorStep(gen, resolve19, reject, _next, _throw, "throw", err);
          }
          __name(_throw, "_throw");
          _next(void 0);
        });
      };
    }
    __name(_asyncToGenerator, "_asyncToGenerator");
    var prompts2 = require_prompts();
    var passOn = ["suggest", "format", "onState", "validate", "onRender", "type"];
    var noop = /* @__PURE__ */ __name(() => {
    }, "noop");
    function prompt2() {
      return _prompt.apply(this, arguments);
    }
    __name(prompt2, "prompt");
    function _prompt() {
      _prompt = _asyncToGenerator(function* (questions = [], {
        onSubmit = noop,
        onCancel = noop
      } = {}) {
        const answers = {};
        const override2 = prompt2._override || {};
        questions = [].concat(questions);
        let answer, question, quit, name, type, lastPrompt;
        const getFormattedAnswer = /* @__PURE__ */ function() {
          var _ref = _asyncToGenerator(function* (question2, answer2, skipValidation = false) {
            if (!skipValidation && question2.validate && question2.validate(answer2) !== true) {
              return;
            }
            return question2.format ? yield question2.format(answer2, answers) : answer2;
          });
          return /* @__PURE__ */ __name(function getFormattedAnswer2(_x, _x2) {
            return _ref.apply(this, arguments);
          }, "getFormattedAnswer");
        }();
        var _iterator = _createForOfIteratorHelper(questions), _step;
        try {
          for (_iterator.s(); !(_step = _iterator.n()).done; ) {
            question = _step.value;
            var _question = question;
            name = _question.name;
            type = _question.type;
            if (typeof type === "function") {
              type = yield type(answer, _objectSpread11({}, answers), question);
              question["type"] = type;
            }
            if (!type)
              continue;
            for (let key in question) {
              if (passOn.includes(key))
                continue;
              let value = question[key];
              question[key] = typeof value === "function" ? yield value(answer, _objectSpread11({}, answers), lastPrompt) : value;
            }
            lastPrompt = question;
            if (typeof question.message !== "string") {
              throw new Error("prompt message is required");
            }
            var _question2 = question;
            name = _question2.name;
            type = _question2.type;
            if (prompts2[type] === void 0) {
              throw new Error(`prompt type (${type}) is not defined`);
            }
            if (override2[question.name] !== void 0) {
              answer = yield getFormattedAnswer(question, override2[question.name]);
              if (answer !== void 0) {
                answers[name] = answer;
                continue;
              }
            }
            try {
              answer = prompt2._injected ? getInjectedAnswer(prompt2._injected, question.initial) : yield prompts2[type](question);
              answers[name] = answer = yield getFormattedAnswer(question, answer, true);
              quit = yield onSubmit(question, answer, answers);
            } catch (err) {
              quit = !(yield onCancel(question, answers));
            }
            if (quit)
              return answers;
          }
        } catch (err) {
          _iterator.e(err);
        } finally {
          _iterator.f();
        }
        return answers;
      });
      return _prompt.apply(this, arguments);
    }
    __name(_prompt, "_prompt");
    function getInjectedAnswer(injected, deafultValue) {
      const answer = injected.shift();
      if (answer instanceof Error) {
        throw answer;
      }
      return answer === void 0 ? deafultValue : answer;
    }
    __name(getInjectedAnswer, "getInjectedAnswer");
    function inject(answers) {
      prompt2._injected = (prompt2._injected || []).concat(answers);
    }
    __name(inject, "inject");
    function override(answers) {
      prompt2._override = Object.assign({}, answers);
    }
    __name(override, "override");
    module3.exports = Object.assign(prompt2, {
      prompt: prompt2,
      prompts: prompts2,
      inject,
      override
    });
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/action.js
var require_action2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/action.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = (key, isSelect) => {
      if (key.meta && key.name !== "escape")
        return;
      if (key.ctrl) {
        if (key.name === "a")
          return "first";
        if (key.name === "c")
          return "abort";
        if (key.name === "d")
          return "abort";
        if (key.name === "e")
          return "last";
        if (key.name === "g")
          return "reset";
      }
      if (isSelect) {
        if (key.name === "j")
          return "down";
        if (key.name === "k")
          return "up";
      }
      if (key.name === "return")
        return "submit";
      if (key.name === "enter")
        return "submit";
      if (key.name === "backspace")
        return "delete";
      if (key.name === "delete")
        return "deleteForward";
      if (key.name === "abort")
        return "abort";
      if (key.name === "escape")
        return "exit";
      if (key.name === "tab")
        return "next";
      if (key.name === "pagedown")
        return "nextPage";
      if (key.name === "pageup")
        return "prevPage";
      if (key.name === "home")
        return "home";
      if (key.name === "end")
        return "end";
      if (key.name === "up")
        return "up";
      if (key.name === "down")
        return "down";
      if (key.name === "right")
        return "right";
      if (key.name === "left")
        return "left";
      return false;
    };
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/strip.js
var require_strip2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/strip.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = (str) => {
      const pattern = [
        "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
        "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PRZcf-ntqry=><~]))"
      ].join("|");
      const RGX = new RegExp(pattern, "g");
      return typeof str === "string" ? str.replace(RGX, "") : str;
    };
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/clear.js
var require_clear2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/clear.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var strip = require_strip2();
    var { erase, cursor } = require_src();
    var width = /* @__PURE__ */ __name((str) => [...strip(str)].length, "width");
    module3.exports = function(prompt2, perLine) {
      if (!perLine)
        return erase.line + cursor.to(0);
      let rows = 0;
      const lines = prompt2.split(/\r?\n/);
      for (let line of lines) {
        rows += 1 + Math.floor(Math.max(width(line) - 1, 0) / perLine);
      }
      return erase.lines(rows);
    };
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/figures.js
var require_figures2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/figures.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var main2 = {
      arrowUp: "\u2191",
      arrowDown: "\u2193",
      arrowLeft: "\u2190",
      arrowRight: "\u2192",
      radioOn: "\u25C9",
      radioOff: "\u25EF",
      tick: "\u2714",
      cross: "\u2716",
      ellipsis: "\u2026",
      pointerSmall: "\u203A",
      line: "\u2500",
      pointer: "\u276F"
    };
    var win = {
      arrowUp: main2.arrowUp,
      arrowDown: main2.arrowDown,
      arrowLeft: main2.arrowLeft,
      arrowRight: main2.arrowRight,
      radioOn: "(*)",
      radioOff: "( )",
      tick: "\u221A",
      cross: "\xD7",
      ellipsis: "...",
      pointerSmall: "\xBB",
      line: "\u2500",
      pointer: ">"
    };
    var figures = process.platform === "win32" ? win : main2;
    module3.exports = figures;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/style.js
var require_style2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/style.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var c2 = require_kleur();
    var figures = require_figures2();
    var styles2 = Object.freeze({
      password: { scale: 1, render: (input) => "*".repeat(input.length) },
      emoji: { scale: 2, render: (input) => "\u{1F603}".repeat(input.length) },
      invisible: { scale: 0, render: (input) => "" },
      default: { scale: 1, render: (input) => `${input}` }
    });
    var render7 = /* @__PURE__ */ __name((type) => styles2[type] || styles2.default, "render");
    var symbols = Object.freeze({
      aborted: c2.red(figures.cross),
      done: c2.green(figures.tick),
      exited: c2.yellow(figures.cross),
      default: c2.cyan("?")
    });
    var symbol = /* @__PURE__ */ __name((done, aborted, exited) => aborted ? symbols.aborted : exited ? symbols.exited : done ? symbols.done : symbols.default, "symbol");
    var delimiter = /* @__PURE__ */ __name((completing) => c2.gray(completing ? figures.ellipsis : figures.pointerSmall), "delimiter");
    var item = /* @__PURE__ */ __name((expandable, expanded) => c2.gray(expandable ? expanded ? figures.pointerSmall : "+" : figures.line), "item");
    module3.exports = {
      styles: styles2,
      render: render7,
      symbols,
      symbol,
      delimiter,
      item
    };
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/lines.js
var require_lines2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/lines.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var strip = require_strip2();
    module3.exports = function(msg, perLine) {
      let lines = String(strip(msg) || "").split(/\r?\n/);
      if (!perLine)
        return lines.length;
      return lines.map((l2) => Math.ceil(l2.length / perLine)).reduce((a, b2) => a + b2);
    };
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/wrap.js
var require_wrap2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/wrap.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = (msg, opts = {}) => {
      const tab = Number.isSafeInteger(parseInt(opts.margin)) ? new Array(parseInt(opts.margin)).fill(" ").join("") : opts.margin || "";
      const width = opts.width;
      return (msg || "").split(/\r?\n/g).map((line) => line.split(/\s+/g).reduce((arr, w2) => {
        if (w2.length + tab.length >= width || arr[arr.length - 1].length + w2.length + 1 < width)
          arr[arr.length - 1] += ` ${w2}`;
        else
          arr.push(`${tab}${w2}`);
        return arr;
      }, [tab]).join("\n")).join("\n");
    };
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/entriesToDisplay.js
var require_entriesToDisplay2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/entriesToDisplay.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = (cursor, total, maxVisible) => {
      maxVisible = maxVisible || total;
      let startIndex = Math.min(total - maxVisible, cursor - Math.floor(maxVisible / 2));
      if (startIndex < 0)
        startIndex = 0;
      let endIndex = Math.min(startIndex + maxVisible, total);
      return { startIndex, endIndex };
    };
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/index.js
var require_util10 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/util/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = {
      action: require_action2(),
      clear: require_clear2(),
      style: require_style2(),
      strip: require_strip2(),
      figures: require_figures2(),
      lines: require_lines2(),
      wrap: require_wrap2(),
      entriesToDisplay: require_entriesToDisplay2()
    };
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/prompt.js
var require_prompt2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/prompt.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var readline3 = require("readline");
    var { action } = require_util10();
    var EventEmitter7 = require("events");
    var { beep, cursor } = require_src();
    var color = require_kleur();
    var Prompt = class extends EventEmitter7 {
      constructor(opts = {}) {
        super();
        this.firstRender = true;
        this.in = opts.stdin || process.stdin;
        this.out = opts.stdout || process.stdout;
        this.onRender = (opts.onRender || (() => void 0)).bind(this);
        const rl = readline3.createInterface({ input: this.in, escapeCodeTimeout: 50 });
        readline3.emitKeypressEvents(this.in, rl);
        if (this.in.isTTY)
          this.in.setRawMode(true);
        const isSelect = ["SelectPrompt", "MultiselectPrompt"].indexOf(this.constructor.name) > -1;
        const keypress = /* @__PURE__ */ __name((str, key) => {
          let a = action(key, isSelect);
          if (a === false) {
            this._ && this._(str, key);
          } else if (typeof this[a] === "function") {
            this[a](key);
          } else {
            this.bell();
          }
        }, "keypress");
        this.close = () => {
          this.out.write(cursor.show);
          this.in.removeListener("keypress", keypress);
          if (this.in.isTTY)
            this.in.setRawMode(false);
          rl.close();
          this.emit(this.aborted ? "abort" : this.exited ? "exit" : "submit", this.value);
          this.closed = true;
        };
        this.in.on("keypress", keypress);
      }
      fire() {
        this.emit("state", {
          value: this.value,
          aborted: !!this.aborted,
          exited: !!this.exited
        });
      }
      bell() {
        this.out.write(beep);
      }
      render() {
        this.onRender(color);
        if (this.firstRender)
          this.firstRender = false;
      }
    };
    __name(Prompt, "Prompt");
    module3.exports = Prompt;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/text.js
var require_text2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/text.js"(exports2, module3) {
    init_import_meta_url();
    var color = require_kleur();
    var Prompt = require_prompt2();
    var { erase, cursor } = require_src();
    var { style, clear, lines, figures } = require_util10();
    var TextPrompt = class extends Prompt {
      constructor(opts = {}) {
        super(opts);
        this.transform = style.render(opts.style);
        this.scale = this.transform.scale;
        this.msg = opts.message;
        this.initial = opts.initial || ``;
        this.validator = opts.validate || (() => true);
        this.value = ``;
        this.errorMsg = opts.error || `Please Enter A Valid Value`;
        this.cursor = Number(!!this.initial);
        this.cursorOffset = 0;
        this.clear = clear(``, this.out.columns);
        this.render();
      }
      set value(v2) {
        if (!v2 && this.initial) {
          this.placeholder = true;
          this.rendered = color.gray(this.transform.render(this.initial));
        } else {
          this.placeholder = false;
          this.rendered = this.transform.render(v2);
        }
        this._value = v2;
        this.fire();
      }
      get value() {
        return this._value;
      }
      reset() {
        this.value = ``;
        this.cursor = Number(!!this.initial);
        this.cursorOffset = 0;
        this.fire();
        this.render();
      }
      exit() {
        this.abort();
      }
      abort() {
        this.value = this.value || this.initial;
        this.done = this.aborted = true;
        this.error = false;
        this.red = false;
        this.fire();
        this.render();
        this.out.write("\n");
        this.close();
      }
      async validate() {
        let valid = await this.validator(this.value);
        if (typeof valid === `string`) {
          this.errorMsg = valid;
          valid = false;
        }
        this.error = !valid;
      }
      async submit() {
        this.value = this.value || this.initial;
        this.cursorOffset = 0;
        this.cursor = this.rendered.length;
        await this.validate();
        if (this.error) {
          this.red = true;
          this.fire();
          this.render();
          return;
        }
        this.done = true;
        this.aborted = false;
        this.fire();
        this.render();
        this.out.write("\n");
        this.close();
      }
      next() {
        if (!this.placeholder)
          return this.bell();
        this.value = this.initial;
        this.cursor = this.rendered.length;
        this.fire();
        this.render();
      }
      moveCursor(n2) {
        if (this.placeholder)
          return;
        this.cursor = this.cursor + n2;
        this.cursorOffset += n2;
      }
      _(c2, key) {
        let s1 = this.value.slice(0, this.cursor);
        let s2 = this.value.slice(this.cursor);
        this.value = `${s1}${c2}${s2}`;
        this.red = false;
        this.cursor = this.placeholder ? 0 : s1.length + 1;
        this.render();
      }
      delete() {
        if (this.isCursorAtStart())
          return this.bell();
        let s1 = this.value.slice(0, this.cursor - 1);
        let s2 = this.value.slice(this.cursor);
        this.value = `${s1}${s2}`;
        this.red = false;
        if (this.isCursorAtStart()) {
          this.cursorOffset = 0;
        } else {
          this.cursorOffset++;
          this.moveCursor(-1);
        }
        this.render();
      }
      deleteForward() {
        if (this.cursor * this.scale >= this.rendered.length || this.placeholder)
          return this.bell();
        let s1 = this.value.slice(0, this.cursor);
        let s2 = this.value.slice(this.cursor + 1);
        this.value = `${s1}${s2}`;
        this.red = false;
        if (this.isCursorAtEnd()) {
          this.cursorOffset = 0;
        } else {
          this.cursorOffset++;
        }
        this.render();
      }
      first() {
        this.cursor = 0;
        this.render();
      }
      last() {
        this.cursor = this.value.length;
        this.render();
      }
      left() {
        if (this.cursor <= 0 || this.placeholder)
          return this.bell();
        this.moveCursor(-1);
        this.render();
      }
      right() {
        if (this.cursor * this.scale >= this.rendered.length || this.placeholder)
          return this.bell();
        this.moveCursor(1);
        this.render();
      }
      isCursorAtStart() {
        return this.cursor === 0 || this.placeholder && this.cursor === 1;
      }
      isCursorAtEnd() {
        return this.cursor === this.rendered.length || this.placeholder && this.cursor === this.rendered.length + 1;
      }
      render() {
        if (this.closed)
          return;
        if (!this.firstRender) {
          if (this.outputError)
            this.out.write(cursor.down(lines(this.outputError, this.out.columns) - 1) + clear(this.outputError, this.out.columns));
          this.out.write(clear(this.outputText, this.out.columns));
        }
        super.render();
        this.outputError = "";
        this.outputText = [
          style.symbol(this.done, this.aborted),
          color.bold(this.msg),
          style.delimiter(this.done),
          this.red ? color.red(this.rendered) : this.rendered
        ].join(` `);
        if (this.error) {
          this.outputError += this.errorMsg.split(`
`).reduce((a, l2, i) => a + `
${i ? " " : figures.pointerSmall} ${color.red().italic(l2)}`, ``);
        }
        this.out.write(erase.line + cursor.to(0) + this.outputText + cursor.save + this.outputError + cursor.restore + cursor.move(this.cursorOffset, 0));
      }
    };
    __name(TextPrompt, "TextPrompt");
    module3.exports = TextPrompt;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/select.js
var require_select2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/select.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var color = require_kleur();
    var Prompt = require_prompt2();
    var { style, clear, figures, wrap: wrap4, entriesToDisplay } = require_util10();
    var { cursor } = require_src();
    var SelectPrompt = class extends Prompt {
      constructor(opts = {}) {
        super(opts);
        this.msg = opts.message;
        this.hint = opts.hint || "- Use arrow-keys. Return to submit.";
        this.warn = opts.warn || "- This option is disabled";
        this.cursor = opts.initial || 0;
        this.choices = opts.choices.map((ch, idx) => {
          if (typeof ch === "string")
            ch = { title: ch, value: idx };
          return {
            title: ch && (ch.title || ch.value || ch),
            value: ch && (ch.value === void 0 ? idx : ch.value),
            description: ch && ch.description,
            selected: ch && ch.selected,
            disabled: ch && ch.disabled
          };
        });
        this.optionsPerPage = opts.optionsPerPage || 10;
        this.value = (this.choices[this.cursor] || {}).value;
        this.clear = clear("", this.out.columns);
        this.render();
      }
      moveCursor(n2) {
        this.cursor = n2;
        this.value = this.choices[n2].value;
        this.fire();
      }
      reset() {
        this.moveCursor(0);
        this.fire();
        this.render();
      }
      exit() {
        this.abort();
      }
      abort() {
        this.done = this.aborted = true;
        this.fire();
        this.render();
        this.out.write("\n");
        this.close();
      }
      submit() {
        if (!this.selection.disabled) {
          this.done = true;
          this.aborted = false;
          this.fire();
          this.render();
          this.out.write("\n");
          this.close();
        } else
          this.bell();
      }
      first() {
        this.moveCursor(0);
        this.render();
      }
      last() {
        this.moveCursor(this.choices.length - 1);
        this.render();
      }
      up() {
        if (this.cursor === 0) {
          this.moveCursor(this.choices.length - 1);
        } else {
          this.moveCursor(this.cursor - 1);
        }
        this.render();
      }
      down() {
        if (this.cursor === this.choices.length - 1) {
          this.moveCursor(0);
        } else {
          this.moveCursor(this.cursor + 1);
        }
        this.render();
      }
      next() {
        this.moveCursor((this.cursor + 1) % this.choices.length);
        this.render();
      }
      _(c2, key) {
        if (c2 === " ")
          return this.submit();
      }
      get selection() {
        return this.choices[this.cursor];
      }
      render() {
        if (this.closed)
          return;
        if (this.firstRender)
          this.out.write(cursor.hide);
        else
          this.out.write(clear(this.outputText, this.out.columns));
        super.render();
        let { startIndex, endIndex } = entriesToDisplay(this.cursor, this.choices.length, this.optionsPerPage);
        this.outputText = [
          style.symbol(this.done, this.aborted),
          color.bold(this.msg),
          style.delimiter(false),
          this.done ? this.selection.title : this.selection.disabled ? color.yellow(this.warn) : color.gray(this.hint)
        ].join(" ");
        if (!this.done) {
          this.outputText += "\n";
          for (let i = startIndex; i < endIndex; i++) {
            let title, prefix, desc = "", v2 = this.choices[i];
            if (i === startIndex && startIndex > 0) {
              prefix = figures.arrowUp;
            } else if (i === endIndex - 1 && endIndex < this.choices.length) {
              prefix = figures.arrowDown;
            } else {
              prefix = " ";
            }
            if (v2.disabled) {
              title = this.cursor === i ? color.gray().underline(v2.title) : color.strikethrough().gray(v2.title);
              prefix = (this.cursor === i ? color.bold().gray(figures.pointer) + " " : "  ") + prefix;
            } else {
              title = this.cursor === i ? color.cyan().underline(v2.title) : v2.title;
              prefix = (this.cursor === i ? color.cyan(figures.pointer) + " " : "  ") + prefix;
              if (v2.description && this.cursor === i) {
                desc = ` - ${v2.description}`;
                if (prefix.length + title.length + desc.length >= this.out.columns || v2.description.split(/\r?\n/).length > 1) {
                  desc = "\n" + wrap4(v2.description, { margin: 3, width: this.out.columns });
                }
              }
            }
            this.outputText += `${prefix} ${title}${color.gray(desc)}
`;
          }
        }
        this.out.write(this.outputText);
      }
    };
    __name(SelectPrompt, "SelectPrompt");
    module3.exports = SelectPrompt;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/toggle.js
var require_toggle2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/toggle.js"(exports2, module3) {
    init_import_meta_url();
    var color = require_kleur();
    var Prompt = require_prompt2();
    var { style, clear } = require_util10();
    var { cursor, erase } = require_src();
    var TogglePrompt = class extends Prompt {
      constructor(opts = {}) {
        super(opts);
        this.msg = opts.message;
        this.value = !!opts.initial;
        this.active = opts.active || "on";
        this.inactive = opts.inactive || "off";
        this.initialValue = this.value;
        this.render();
      }
      reset() {
        this.value = this.initialValue;
        this.fire();
        this.render();
      }
      exit() {
        this.abort();
      }
      abort() {
        this.done = this.aborted = true;
        this.fire();
        this.render();
        this.out.write("\n");
        this.close();
      }
      submit() {
        this.done = true;
        this.aborted = false;
        this.fire();
        this.render();
        this.out.write("\n");
        this.close();
      }
      deactivate() {
        if (this.value === false)
          return this.bell();
        this.value = false;
        this.render();
      }
      activate() {
        if (this.value === true)
          return this.bell();
        this.value = true;
        this.render();
      }
      delete() {
        this.deactivate();
      }
      left() {
        this.deactivate();
      }
      right() {
        this.activate();
      }
      down() {
        this.deactivate();
      }
      up() {
        this.activate();
      }
      next() {
        this.value = !this.value;
        this.fire();
        this.render();
      }
      _(c2, key) {
        if (c2 === " ") {
          this.value = !this.value;
        } else if (c2 === "1") {
          this.value = true;
        } else if (c2 === "0") {
          this.value = false;
        } else
          return this.bell();
        this.render();
      }
      render() {
        if (this.closed)
          return;
        if (this.firstRender)
          this.out.write(cursor.hide);
        else
          this.out.write(clear(this.outputText, this.out.columns));
        super.render();
        this.outputText = [
          style.symbol(this.done, this.aborted),
          color.bold(this.msg),
          style.delimiter(this.done),
          this.value ? this.inactive : color.cyan().underline(this.inactive),
          color.gray("/"),
          this.value ? color.cyan().underline(this.active) : this.active
        ].join(" ");
        this.out.write(erase.line + cursor.to(0) + this.outputText);
      }
    };
    __name(TogglePrompt, "TogglePrompt");
    module3.exports = TogglePrompt;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/datepart.js
var require_datepart2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/datepart.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var DatePart = class {
      constructor({ token, date, parts, locales }) {
        this.token = token;
        this.date = date || /* @__PURE__ */ new Date();
        this.parts = parts || [this];
        this.locales = locales || {};
      }
      up() {
      }
      down() {
      }
      next() {
        const currentIdx = this.parts.indexOf(this);
        return this.parts.find((part, idx) => idx > currentIdx && part instanceof DatePart);
      }
      setTo(val) {
      }
      prev() {
        let parts = [].concat(this.parts).reverse();
        const currentIdx = parts.indexOf(this);
        return parts.find((part, idx) => idx > currentIdx && part instanceof DatePart);
      }
      toString() {
        return String(this.date);
      }
    };
    __name(DatePart, "DatePart");
    module3.exports = DatePart;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/meridiem.js
var require_meridiem2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/meridiem.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var DatePart = require_datepart2();
    var Meridiem = class extends DatePart {
      constructor(opts = {}) {
        super(opts);
      }
      up() {
        this.date.setHours((this.date.getHours() + 12) % 24);
      }
      down() {
        this.up();
      }
      toString() {
        let meridiem = this.date.getHours() > 12 ? "pm" : "am";
        return /\A/.test(this.token) ? meridiem.toUpperCase() : meridiem;
      }
    };
    __name(Meridiem, "Meridiem");
    module3.exports = Meridiem;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/day.js
var require_day2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/day.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var DatePart = require_datepart2();
    var pos = /* @__PURE__ */ __name((n2) => {
      n2 = n2 % 10;
      return n2 === 1 ? "st" : n2 === 2 ? "nd" : n2 === 3 ? "rd" : "th";
    }, "pos");
    var Day = class extends DatePart {
      constructor(opts = {}) {
        super(opts);
      }
      up() {
        this.date.setDate(this.date.getDate() + 1);
      }
      down() {
        this.date.setDate(this.date.getDate() - 1);
      }
      setTo(val) {
        this.date.setDate(parseInt(val.substr(-2)));
      }
      toString() {
        let date = this.date.getDate();
        let day2 = this.date.getDay();
        return this.token === "DD" ? String(date).padStart(2, "0") : this.token === "Do" ? date + pos(date) : this.token === "d" ? day2 + 1 : this.token === "ddd" ? this.locales.weekdaysShort[day2] : this.token === "dddd" ? this.locales.weekdays[day2] : date;
      }
    };
    __name(Day, "Day");
    module3.exports = Day;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/hours.js
var require_hours2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/hours.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var DatePart = require_datepart2();
    var Hours = class extends DatePart {
      constructor(opts = {}) {
        super(opts);
      }
      up() {
        this.date.setHours(this.date.getHours() + 1);
      }
      down() {
        this.date.setHours(this.date.getHours() - 1);
      }
      setTo(val) {
        this.date.setHours(parseInt(val.substr(-2)));
      }
      toString() {
        let hours = this.date.getHours();
        if (/h/.test(this.token))
          hours = hours % 12 || 12;
        return this.token.length > 1 ? String(hours).padStart(2, "0") : hours;
      }
    };
    __name(Hours, "Hours");
    module3.exports = Hours;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/milliseconds.js
var require_milliseconds2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/milliseconds.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var DatePart = require_datepart2();
    var Milliseconds = class extends DatePart {
      constructor(opts = {}) {
        super(opts);
      }
      up() {
        this.date.setMilliseconds(this.date.getMilliseconds() + 1);
      }
      down() {
        this.date.setMilliseconds(this.date.getMilliseconds() - 1);
      }
      setTo(val) {
        this.date.setMilliseconds(parseInt(val.substr(-this.token.length)));
      }
      toString() {
        return String(this.date.getMilliseconds()).padStart(4, "0").substr(0, this.token.length);
      }
    };
    __name(Milliseconds, "Milliseconds");
    module3.exports = Milliseconds;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/minutes.js
var require_minutes2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/minutes.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var DatePart = require_datepart2();
    var Minutes = class extends DatePart {
      constructor(opts = {}) {
        super(opts);
      }
      up() {
        this.date.setMinutes(this.date.getMinutes() + 1);
      }
      down() {
        this.date.setMinutes(this.date.getMinutes() - 1);
      }
      setTo(val) {
        this.date.setMinutes(parseInt(val.substr(-2)));
      }
      toString() {
        let m2 = this.date.getMinutes();
        return this.token.length > 1 ? String(m2).padStart(2, "0") : m2;
      }
    };
    __name(Minutes, "Minutes");
    module3.exports = Minutes;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/month.js
var require_month2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/month.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var DatePart = require_datepart2();
    var Month = class extends DatePart {
      constructor(opts = {}) {
        super(opts);
      }
      up() {
        this.date.setMonth(this.date.getMonth() + 1);
      }
      down() {
        this.date.setMonth(this.date.getMonth() - 1);
      }
      setTo(val) {
        val = parseInt(val.substr(-2)) - 1;
        this.date.setMonth(val < 0 ? 0 : val);
      }
      toString() {
        let month2 = this.date.getMonth();
        let tl = this.token.length;
        return tl === 2 ? String(month2 + 1).padStart(2, "0") : tl === 3 ? this.locales.monthsShort[month2] : tl === 4 ? this.locales.months[month2] : String(month2 + 1);
      }
    };
    __name(Month, "Month");
    module3.exports = Month;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/seconds.js
var require_seconds2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/seconds.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var DatePart = require_datepart2();
    var Seconds = class extends DatePart {
      constructor(opts = {}) {
        super(opts);
      }
      up() {
        this.date.setSeconds(this.date.getSeconds() + 1);
      }
      down() {
        this.date.setSeconds(this.date.getSeconds() - 1);
      }
      setTo(val) {
        this.date.setSeconds(parseInt(val.substr(-2)));
      }
      toString() {
        let s = this.date.getSeconds();
        return this.token.length > 1 ? String(s).padStart(2, "0") : s;
      }
    };
    __name(Seconds, "Seconds");
    module3.exports = Seconds;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/year.js
var require_year2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/year.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var DatePart = require_datepart2();
    var Year = class extends DatePart {
      constructor(opts = {}) {
        super(opts);
      }
      up() {
        this.date.setFullYear(this.date.getFullYear() + 1);
      }
      down() {
        this.date.setFullYear(this.date.getFullYear() - 1);
      }
      setTo(val) {
        this.date.setFullYear(val.substr(-4));
      }
      toString() {
        let year2 = String(this.date.getFullYear()).padStart(4, "0");
        return this.token.length === 2 ? year2.substr(-2) : year2;
      }
    };
    __name(Year, "Year");
    module3.exports = Year;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/index.js
var require_dateparts2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/dateparts/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = {
      DatePart: require_datepart2(),
      Meridiem: require_meridiem2(),
      Day: require_day2(),
      Hours: require_hours2(),
      Milliseconds: require_milliseconds2(),
      Minutes: require_minutes2(),
      Month: require_month2(),
      Seconds: require_seconds2(),
      Year: require_year2()
    };
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/date.js
var require_date2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/date.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var color = require_kleur();
    var Prompt = require_prompt2();
    var { style, clear, figures } = require_util10();
    var { erase, cursor } = require_src();
    var { DatePart, Meridiem, Day, Hours, Milliseconds, Minutes, Month, Seconds, Year } = require_dateparts2();
    var regex2 = /\\(.)|"((?:\\["\\]|[^"])+)"|(D[Do]?|d{3,4}|d)|(M{1,4})|(YY(?:YY)?)|([aA])|([Hh]{1,2})|(m{1,2})|(s{1,2})|(S{1,4})|./g;
    var regexGroups = {
      1: ({ token }) => token.replace(/\\(.)/g, "$1"),
      2: (opts) => new Day(opts),
      // Day // TODO
      3: (opts) => new Month(opts),
      // Month
      4: (opts) => new Year(opts),
      // Year
      5: (opts) => new Meridiem(opts),
      // AM/PM // TODO (special)
      6: (opts) => new Hours(opts),
      // Hours
      7: (opts) => new Minutes(opts),
      // Minutes
      8: (opts) => new Seconds(opts),
      // Seconds
      9: (opts) => new Milliseconds(opts)
      // Fractional seconds
    };
    var dfltLocales = {
      months: "January,February,March,April,May,June,July,August,September,October,November,December".split(","),
      monthsShort: "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec".split(","),
      weekdays: "Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday".split(","),
      weekdaysShort: "Sun,Mon,Tue,Wed,Thu,Fri,Sat".split(",")
    };
    var DatePrompt = class extends Prompt {
      constructor(opts = {}) {
        super(opts);
        this.msg = opts.message;
        this.cursor = 0;
        this.typed = "";
        this.locales = Object.assign(dfltLocales, opts.locales);
        this._date = opts.initial || /* @__PURE__ */ new Date();
        this.errorMsg = opts.error || "Please Enter A Valid Value";
        this.validator = opts.validate || (() => true);
        this.mask = opts.mask || "YYYY-MM-DD HH:mm:ss";
        this.clear = clear("", this.out.columns);
        this.render();
      }
      get value() {
        return this.date;
      }
      get date() {
        return this._date;
      }
      set date(date) {
        if (date)
          this._date.setTime(date.getTime());
      }
      set mask(mask) {
        let result;
        this.parts = [];
        while (result = regex2.exec(mask)) {
          let match = result.shift();
          let idx = result.findIndex((gr) => gr != null);
          this.parts.push(idx in regexGroups ? regexGroups[idx]({ token: result[idx] || match, date: this.date, parts: this.parts, locales: this.locales }) : result[idx] || match);
        }
        let parts = this.parts.reduce((arr, i) => {
          if (typeof i === "string" && typeof arr[arr.length - 1] === "string")
            arr[arr.length - 1] += i;
          else
            arr.push(i);
          return arr;
        }, []);
        this.parts.splice(0);
        this.parts.push(...parts);
        this.reset();
      }
      moveCursor(n2) {
        this.typed = "";
        this.cursor = n2;
        this.fire();
      }
      reset() {
        this.moveCursor(this.parts.findIndex((p2) => p2 instanceof DatePart));
        this.fire();
        this.render();
      }
      exit() {
        this.abort();
      }
      abort() {
        this.done = this.aborted = true;
        this.error = false;
        this.fire();
        this.render();
        this.out.write("\n");
        this.close();
      }
      async validate() {
        let valid = await this.validator(this.value);
        if (typeof valid === "string") {
          this.errorMsg = valid;
          valid = false;
        }
        this.error = !valid;
      }
      async submit() {
        await this.validate();
        if (this.error) {
          this.color = "red";
          this.fire();
          this.render();
          return;
        }
        this.done = true;
        this.aborted = false;
        this.fire();
        this.render();
        this.out.write("\n");
        this.close();
      }
      up() {
        this.typed = "";
        this.parts[this.cursor].up();
        this.render();
      }
      down() {
        this.typed = "";
        this.parts[this.cursor].down();
        this.render();
      }
      left() {
        let prev = this.parts[this.cursor].prev();
        if (prev == null)
          return this.bell();
        this.moveCursor(this.parts.indexOf(prev));
        this.render();
      }
      right() {
        let next = this.parts[this.cursor].next();
        if (next == null)
          return this.bell();
        this.moveCursor(this.parts.indexOf(next));
        this.render();
      }
      next() {
        let next = this.parts[this.cursor].next();
        this.moveCursor(next ? this.parts.indexOf(next) : this.parts.findIndex((part) => part instanceof DatePart));
        this.render();
      }
      _(c2) {
        if (/\d/.test(c2)) {
          this.typed += c2;
          this.parts[this.cursor].setTo(this.typed);
          this.render();
        }
      }
      render() {
        if (this.closed)
          return;
        if (this.firstRender)
          this.out.write(cursor.hide);
        else
          this.out.write(clear(this.outputText, this.out.columns));
        super.render();
        this.outputText = [
          style.symbol(this.done, this.aborted),
          color.bold(this.msg),
          style.delimiter(false),
          this.parts.reduce((arr, p2, idx) => arr.concat(idx === this.cursor && !this.done ? color.cyan().underline(p2.toString()) : p2), []).join("")
        ].join(" ");
        if (this.error) {
          this.outputText += this.errorMsg.split("\n").reduce(
            (a, l2, i) => a + `
${i ? ` ` : figures.pointerSmall} ${color.red().italic(l2)}`,
            ``
          );
        }
        this.out.write(erase.line + cursor.to(0) + this.outputText);
      }
    };
    __name(DatePrompt, "DatePrompt");
    module3.exports = DatePrompt;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/number.js
var require_number2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/number.js"(exports2, module3) {
    init_import_meta_url();
    var color = require_kleur();
    var Prompt = require_prompt2();
    var { cursor, erase } = require_src();
    var { style, figures, clear, lines } = require_util10();
    var isNumber = /[0-9]/;
    var isDef = /* @__PURE__ */ __name((any) => any !== void 0, "isDef");
    var round = /* @__PURE__ */ __name((number, precision) => {
      let factor = Math.pow(10, precision);
      return Math.round(number * factor) / factor;
    }, "round");
    var NumberPrompt = class extends Prompt {
      constructor(opts = {}) {
        super(opts);
        this.transform = style.render(opts.style);
        this.msg = opts.message;
        this.initial = isDef(opts.initial) ? opts.initial : "";
        this.float = !!opts.float;
        this.round = opts.round || 2;
        this.inc = opts.increment || 1;
        this.min = isDef(opts.min) ? opts.min : -Infinity;
        this.max = isDef(opts.max) ? opts.max : Infinity;
        this.errorMsg = opts.error || `Please Enter A Valid Value`;
        this.validator = opts.validate || (() => true);
        this.color = `cyan`;
        this.value = ``;
        this.typed = ``;
        this.lastHit = 0;
        this.render();
      }
      set value(v2) {
        if (!v2 && v2 !== 0) {
          this.placeholder = true;
          this.rendered = color.gray(this.transform.render(`${this.initial}`));
          this._value = ``;
        } else {
          this.placeholder = false;
          this.rendered = this.transform.render(`${round(v2, this.round)}`);
          this._value = round(v2, this.round);
        }
        this.fire();
      }
      get value() {
        return this._value;
      }
      parse(x2) {
        return this.float ? parseFloat(x2) : parseInt(x2);
      }
      valid(c2) {
        return c2 === `-` || c2 === `.` && this.float || isNumber.test(c2);
      }
      reset() {
        this.typed = ``;
        this.value = ``;
        this.fire();
        this.render();
      }
      exit() {
        this.abort();
      }
      abort() {
        let x2 = this.value;
        this.value = x2 !== `` ? x2 : this.initial;
        this.done = this.aborted = true;
        this.error = false;
        this.fire();
        this.render();
        this.out.write(`
`);
        this.close();
      }
      async validate() {
        let valid = await this.validator(this.value);
        if (typeof valid === `string`) {
          this.errorMsg = valid;
          valid = false;
        }
        this.error = !valid;
      }
      async submit() {
        await this.validate();
        if (this.error) {
          this.color = `red`;
          this.fire();
          this.render();
          return;
        }
        let x2 = this.value;
        this.value = x2 !== `` ? x2 : this.initial;
        this.done = true;
        this.aborted = false;
        this.error = false;
        this.fire();
        this.render();
        this.out.write(`
`);
        this.close();
      }
      up() {
        this.typed = ``;
        if (this.value === "") {
          this.value = this.min - this.inc;
        }
        if (this.value >= this.max)
          return this.bell();
        this.value += this.inc;
        this.color = `cyan`;
        this.fire();
        this.render();
      }
      down() {
        this.typed = ``;
        if (this.value === "") {
          this.value = this.min + this.inc;
        }
        if (this.value <= this.min)
          return this.bell();
        this.value -= this.inc;
        this.color = `cyan`;
        this.fire();
        this.render();
      }
      delete() {
        let val = this.value.toString();
        if (val.length === 0)
          return this.bell();
        this.value = this.parse(val = val.slice(0, -1)) || ``;
        if (this.value !== "" && this.value < this.min) {
          this.value = this.min;
        }
        this.color = `cyan`;
        this.fire();
        this.render();
      }
      next() {
        this.value = this.initial;
        this.fire();
        this.render();
      }
      _(c2, key) {
        if (!this.valid(c2))
          return this.bell();
        const now = Date.now();
        if (now - this.lastHit > 1e3)
          this.typed = ``;
        this.typed += c2;
        this.lastHit = now;
        this.color = `cyan`;
        if (c2 === `.`)
          return this.fire();
        this.value = Math.min(this.parse(this.typed), this.max);
        if (this.value > this.max)
          this.value = this.max;
        if (this.value < this.min)
          this.value = this.min;
        this.fire();
        this.render();
      }
      render() {
        if (this.closed)
          return;
        if (!this.firstRender) {
          if (this.outputError)
            this.out.write(cursor.down(lines(this.outputError, this.out.columns) - 1) + clear(this.outputError, this.out.columns));
          this.out.write(clear(this.outputText, this.out.columns));
        }
        super.render();
        this.outputError = "";
        this.outputText = [
          style.symbol(this.done, this.aborted),
          color.bold(this.msg),
          style.delimiter(this.done),
          !this.done || !this.done && !this.placeholder ? color[this.color]().underline(this.rendered) : this.rendered
        ].join(` `);
        if (this.error) {
          this.outputError += this.errorMsg.split(`
`).reduce((a, l2, i) => a + `
${i ? ` ` : figures.pointerSmall} ${color.red().italic(l2)}`, ``);
        }
        this.out.write(erase.line + cursor.to(0) + this.outputText + cursor.save + this.outputError + cursor.restore);
      }
    };
    __name(NumberPrompt, "NumberPrompt");
    module3.exports = NumberPrompt;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/multiselect.js
var require_multiselect2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/multiselect.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var color = require_kleur();
    var { cursor } = require_src();
    var Prompt = require_prompt2();
    var { clear, figures, style, wrap: wrap4, entriesToDisplay } = require_util10();
    var MultiselectPrompt = class extends Prompt {
      constructor(opts = {}) {
        super(opts);
        this.msg = opts.message;
        this.cursor = opts.cursor || 0;
        this.scrollIndex = opts.cursor || 0;
        this.hint = opts.hint || "";
        this.warn = opts.warn || "- This option is disabled -";
        this.minSelected = opts.min;
        this.showMinError = false;
        this.maxChoices = opts.max;
        this.instructions = opts.instructions;
        this.optionsPerPage = opts.optionsPerPage || 10;
        this.value = opts.choices.map((ch, idx) => {
          if (typeof ch === "string")
            ch = { title: ch, value: idx };
          return {
            title: ch && (ch.title || ch.value || ch),
            description: ch && ch.description,
            value: ch && (ch.value === void 0 ? idx : ch.value),
            selected: ch && ch.selected,
            disabled: ch && ch.disabled
          };
        });
        this.clear = clear("", this.out.columns);
        if (!opts.overrideRender) {
          this.render();
        }
      }
      reset() {
        this.value.map((v2) => !v2.selected);
        this.cursor = 0;
        this.fire();
        this.render();
      }
      selected() {
        return this.value.filter((v2) => v2.selected);
      }
      exit() {
        this.abort();
      }
      abort() {
        this.done = this.aborted = true;
        this.fire();
        this.render();
        this.out.write("\n");
        this.close();
      }
      submit() {
        const selected = this.value.filter((e3) => e3.selected);
        if (this.minSelected && selected.length < this.minSelected) {
          this.showMinError = true;
          this.render();
        } else {
          this.done = true;
          this.aborted = false;
          this.fire();
          this.render();
          this.out.write("\n");
          this.close();
        }
      }
      first() {
        this.cursor = 0;
        this.render();
      }
      last() {
        this.cursor = this.value.length - 1;
        this.render();
      }
      next() {
        this.cursor = (this.cursor + 1) % this.value.length;
        this.render();
      }
      up() {
        if (this.cursor === 0) {
          this.cursor = this.value.length - 1;
        } else {
          this.cursor--;
        }
        this.render();
      }
      down() {
        if (this.cursor === this.value.length - 1) {
          this.cursor = 0;
        } else {
          this.cursor++;
        }
        this.render();
      }
      left() {
        this.value[this.cursor].selected = false;
        this.render();
      }
      right() {
        if (this.value.filter((e3) => e3.selected).length >= this.maxChoices)
          return this.bell();
        this.value[this.cursor].selected = true;
        this.render();
      }
      handleSpaceToggle() {
        const v2 = this.value[this.cursor];
        if (v2.selected) {
          v2.selected = false;
          this.render();
        } else if (v2.disabled || this.value.filter((e3) => e3.selected).length >= this.maxChoices) {
          return this.bell();
        } else {
          v2.selected = true;
          this.render();
        }
      }
      toggleAll() {
        if (this.maxChoices !== void 0 || this.value[this.cursor].disabled) {
          return this.bell();
        }
        const newSelected = !this.value[this.cursor].selected;
        this.value.filter((v2) => !v2.disabled).forEach((v2) => v2.selected = newSelected);
        this.render();
      }
      _(c2, key) {
        if (c2 === " ") {
          this.handleSpaceToggle();
        } else if (c2 === "a") {
          this.toggleAll();
        } else {
          return this.bell();
        }
      }
      renderInstructions() {
        if (this.instructions === void 0 || this.instructions) {
          if (typeof this.instructions === "string") {
            return this.instructions;
          }
          return `
Instructions:
    ${figures.arrowUp}/${figures.arrowDown}: Highlight option
    ${figures.arrowLeft}/${figures.arrowRight}/[space]: Toggle selection
` + (this.maxChoices === void 0 ? `    a: Toggle all
` : "") + `    enter/return: Complete answer`;
        }
        return "";
      }
      renderOption(cursor2, v2, i, arrowIndicator) {
        const prefix = (v2.selected ? color.green(figures.radioOn) : figures.radioOff) + " " + arrowIndicator + " ";
        let title, desc;
        if (v2.disabled) {
          title = cursor2 === i ? color.gray().underline(v2.title) : color.strikethrough().gray(v2.title);
        } else {
          title = cursor2 === i ? color.cyan().underline(v2.title) : v2.title;
          if (cursor2 === i && v2.description) {
            desc = ` - ${v2.description}`;
            if (prefix.length + title.length + desc.length >= this.out.columns || v2.description.split(/\r?\n/).length > 1) {
              desc = "\n" + wrap4(v2.description, { margin: prefix.length, width: this.out.columns });
            }
          }
        }
        return prefix + title + color.gray(desc || "");
      }
      // shared with autocompleteMultiselect
      paginateOptions(options29) {
        if (options29.length === 0) {
          return color.red("No matches for this query.");
        }
        let { startIndex, endIndex } = entriesToDisplay(this.cursor, options29.length, this.optionsPerPage);
        let prefix, styledOptions = [];
        for (let i = startIndex; i < endIndex; i++) {
          if (i === startIndex && startIndex > 0) {
            prefix = figures.arrowUp;
          } else if (i === endIndex - 1 && endIndex < options29.length) {
            prefix = figures.arrowDown;
          } else {
            prefix = " ";
          }
          styledOptions.push(this.renderOption(this.cursor, options29[i], i, prefix));
        }
        return "\n" + styledOptions.join("\n");
      }
      // shared with autocomleteMultiselect
      renderOptions(options29) {
        if (!this.done) {
          return this.paginateOptions(options29);
        }
        return "";
      }
      renderDoneOrInstructions() {
        if (this.done) {
          return this.value.filter((e3) => e3.selected).map((v2) => v2.title).join(", ");
        }
        const output = [color.gray(this.hint), this.renderInstructions()];
        if (this.value[this.cursor].disabled) {
          output.push(color.yellow(this.warn));
        }
        return output.join(" ");
      }
      render() {
        if (this.closed)
          return;
        if (this.firstRender)
          this.out.write(cursor.hide);
        super.render();
        let prompt2 = [
          style.symbol(this.done, this.aborted),
          color.bold(this.msg),
          style.delimiter(false),
          this.renderDoneOrInstructions()
        ].join(" ");
        if (this.showMinError) {
          prompt2 += color.red(`You must select a minimum of ${this.minSelected} choices.`);
          this.showMinError = false;
        }
        prompt2 += this.renderOptions(this.value);
        this.out.write(this.clear + prompt2);
        this.clear = clear(prompt2, this.out.columns);
      }
    };
    __name(MultiselectPrompt, "MultiselectPrompt");
    module3.exports = MultiselectPrompt;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/autocomplete.js
var require_autocomplete2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/autocomplete.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var color = require_kleur();
    var Prompt = require_prompt2();
    var { erase, cursor } = require_src();
    var { style, clear, figures, wrap: wrap4, entriesToDisplay } = require_util10();
    var getVal = /* @__PURE__ */ __name((arr, i) => arr[i] && (arr[i].value || arr[i].title || arr[i]), "getVal");
    var getTitle = /* @__PURE__ */ __name((arr, i) => arr[i] && (arr[i].title || arr[i].value || arr[i]), "getTitle");
    var getIndex2 = /* @__PURE__ */ __name((arr, valOrTitle) => {
      const index = arr.findIndex((el) => el.value === valOrTitle || el.title === valOrTitle);
      return index > -1 ? index : void 0;
    }, "getIndex");
    var AutocompletePrompt = class extends Prompt {
      constructor(opts = {}) {
        super(opts);
        this.msg = opts.message;
        this.suggest = opts.suggest;
        this.choices = opts.choices;
        this.initial = typeof opts.initial === "number" ? opts.initial : getIndex2(opts.choices, opts.initial);
        this.select = this.initial || opts.cursor || 0;
        this.i18n = { noMatches: opts.noMatches || "no matches found" };
        this.fallback = opts.fallback || this.initial;
        this.clearFirst = opts.clearFirst || false;
        this.suggestions = [];
        this.input = "";
        this.limit = opts.limit || 10;
        this.cursor = 0;
        this.transform = style.render(opts.style);
        this.scale = this.transform.scale;
        this.render = this.render.bind(this);
        this.complete = this.complete.bind(this);
        this.clear = clear("", this.out.columns);
        this.complete(this.render);
        this.render();
      }
      set fallback(fb) {
        this._fb = Number.isSafeInteger(parseInt(fb)) ? parseInt(fb) : fb;
      }
      get fallback() {
        let choice;
        if (typeof this._fb === "number")
          choice = this.choices[this._fb];
        else if (typeof this._fb === "string")
          choice = { title: this._fb };
        return choice || this._fb || { title: this.i18n.noMatches };
      }
      moveSelect(i) {
        this.select = i;
        if (this.suggestions.length > 0)
          this.value = getVal(this.suggestions, i);
        else
          this.value = this.fallback.value;
        this.fire();
      }
      async complete(cb) {
        const p2 = this.completing = this.suggest(this.input, this.choices);
        const suggestions = await p2;
        if (this.completing !== p2)
          return;
        this.suggestions = suggestions.map((s, i, arr) => ({ title: getTitle(arr, i), value: getVal(arr, i), description: s.description }));
        this.completing = false;
        const l2 = Math.max(suggestions.length - 1, 0);
        this.moveSelect(Math.min(l2, this.select));
        cb && cb();
      }
      reset() {
        this.input = "";
        this.complete(() => {
          this.moveSelect(this.initial !== void 0 ? this.initial : 0);
          this.render();
        });
        this.render();
      }
      exit() {
        if (this.clearFirst && this.input.length > 0) {
          this.reset();
        } else {
          this.done = this.exited = true;
          this.aborted = false;
          this.fire();
          this.render();
          this.out.write("\n");
          this.close();
        }
      }
      abort() {
        this.done = this.aborted = true;
        this.exited = false;
        this.fire();
        this.render();
        this.out.write("\n");
        this.close();
      }
      submit() {
        this.done = true;
        this.aborted = this.exited = false;
        this.fire();
        this.render();
        this.out.write("\n");
        this.close();
      }
      _(c2, key) {
        let s1 = this.input.slice(0, this.cursor);
        let s2 = this.input.slice(this.cursor);
        this.input = `${s1}${c2}${s2}`;
        this.cursor = s1.length + 1;
        this.complete(this.render);
        this.render();
      }
      delete() {
        if (this.cursor === 0)
          return this.bell();
        let s1 = this.input.slice(0, this.cursor - 1);
        let s2 = this.input.slice(this.cursor);
        this.input = `${s1}${s2}`;
        this.complete(this.render);
        this.cursor = this.cursor - 1;
        this.render();
      }
      deleteForward() {
        if (this.cursor * this.scale >= this.rendered.length)
          return this.bell();
        let s1 = this.input.slice(0, this.cursor);
        let s2 = this.input.slice(this.cursor + 1);
        this.input = `${s1}${s2}`;
        this.complete(this.render);
        this.render();
      }
      first() {
        this.moveSelect(0);
        this.render();
      }
      last() {
        this.moveSelect(this.suggestions.length - 1);
        this.render();
      }
      up() {
        if (this.select === 0) {
          this.moveSelect(this.suggestions.length - 1);
        } else {
          this.moveSelect(this.select - 1);
        }
        this.render();
      }
      down() {
        if (this.select === this.suggestions.length - 1) {
          this.moveSelect(0);
        } else {
          this.moveSelect(this.select + 1);
        }
        this.render();
      }
      next() {
        if (this.select === this.suggestions.length - 1) {
          this.moveSelect(0);
        } else
          this.moveSelect(this.select + 1);
        this.render();
      }
      nextPage() {
        this.moveSelect(Math.min(this.select + this.limit, this.suggestions.length - 1));
        this.render();
      }
      prevPage() {
        this.moveSelect(Math.max(this.select - this.limit, 0));
        this.render();
      }
      left() {
        if (this.cursor <= 0)
          return this.bell();
        this.cursor = this.cursor - 1;
        this.render();
      }
      right() {
        if (this.cursor * this.scale >= this.rendered.length)
          return this.bell();
        this.cursor = this.cursor + 1;
        this.render();
      }
      renderOption(v2, hovered, isStart, isEnd) {
        let desc;
        let prefix = isStart ? figures.arrowUp : isEnd ? figures.arrowDown : " ";
        let title = hovered ? color.cyan().underline(v2.title) : v2.title;
        prefix = (hovered ? color.cyan(figures.pointer) + " " : "  ") + prefix;
        if (v2.description) {
          desc = ` - ${v2.description}`;
          if (prefix.length + title.length + desc.length >= this.out.columns || v2.description.split(/\r?\n/).length > 1) {
            desc = "\n" + wrap4(v2.description, { margin: 3, width: this.out.columns });
          }
        }
        return prefix + " " + title + color.gray(desc || "");
      }
      render() {
        if (this.closed)
          return;
        if (this.firstRender)
          this.out.write(cursor.hide);
        else
          this.out.write(clear(this.outputText, this.out.columns));
        super.render();
        let { startIndex, endIndex } = entriesToDisplay(this.select, this.choices.length, this.limit);
        this.outputText = [
          style.symbol(this.done, this.aborted, this.exited),
          color.bold(this.msg),
          style.delimiter(this.completing),
          this.done && this.suggestions[this.select] ? this.suggestions[this.select].title : this.rendered = this.transform.render(this.input)
        ].join(" ");
        if (!this.done) {
          const suggestions = this.suggestions.slice(startIndex, endIndex).map((item, i) => this.renderOption(
            item,
            this.select === i + startIndex,
            i === 0 && startIndex > 0,
            i + startIndex === endIndex - 1 && endIndex < this.choices.length
          )).join("\n");
          this.outputText += `
` + (suggestions || color.gray(this.fallback.title));
        }
        this.out.write(erase.line + cursor.to(0) + this.outputText);
      }
    };
    __name(AutocompletePrompt, "AutocompletePrompt");
    module3.exports = AutocompletePrompt;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/autocompleteMultiselect.js
var require_autocompleteMultiselect2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/autocompleteMultiselect.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var color = require_kleur();
    var { cursor } = require_src();
    var MultiselectPrompt = require_multiselect2();
    var { clear, style, figures } = require_util10();
    var AutocompleteMultiselectPrompt = class extends MultiselectPrompt {
      constructor(opts = {}) {
        opts.overrideRender = true;
        super(opts);
        this.inputValue = "";
        this.clear = clear("", this.out.columns);
        this.filteredOptions = this.value;
        this.render();
      }
      last() {
        this.cursor = this.filteredOptions.length - 1;
        this.render();
      }
      next() {
        this.cursor = (this.cursor + 1) % this.filteredOptions.length;
        this.render();
      }
      up() {
        if (this.cursor === 0) {
          this.cursor = this.filteredOptions.length - 1;
        } else {
          this.cursor--;
        }
        this.render();
      }
      down() {
        if (this.cursor === this.filteredOptions.length - 1) {
          this.cursor = 0;
        } else {
          this.cursor++;
        }
        this.render();
      }
      left() {
        this.filteredOptions[this.cursor].selected = false;
        this.render();
      }
      right() {
        if (this.value.filter((e3) => e3.selected).length >= this.maxChoices)
          return this.bell();
        this.filteredOptions[this.cursor].selected = true;
        this.render();
      }
      delete() {
        if (this.inputValue.length) {
          this.inputValue = this.inputValue.substr(0, this.inputValue.length - 1);
          this.updateFilteredOptions();
        }
      }
      updateFilteredOptions() {
        const currentHighlight = this.filteredOptions[this.cursor];
        this.filteredOptions = this.value.filter((v2) => {
          if (this.inputValue) {
            if (typeof v2.title === "string") {
              if (v2.title.toLowerCase().includes(this.inputValue.toLowerCase())) {
                return true;
              }
            }
            if (typeof v2.value === "string") {
              if (v2.value.toLowerCase().includes(this.inputValue.toLowerCase())) {
                return true;
              }
            }
            return false;
          }
          return true;
        });
        const newHighlightIndex = this.filteredOptions.findIndex((v2) => v2 === currentHighlight);
        this.cursor = newHighlightIndex < 0 ? 0 : newHighlightIndex;
        this.render();
      }
      handleSpaceToggle() {
        const v2 = this.filteredOptions[this.cursor];
        if (v2.selected) {
          v2.selected = false;
          this.render();
        } else if (v2.disabled || this.value.filter((e3) => e3.selected).length >= this.maxChoices) {
          return this.bell();
        } else {
          v2.selected = true;
          this.render();
        }
      }
      handleInputChange(c2) {
        this.inputValue = this.inputValue + c2;
        this.updateFilteredOptions();
      }
      _(c2, key) {
        if (c2 === " ") {
          this.handleSpaceToggle();
        } else {
          this.handleInputChange(c2);
        }
      }
      renderInstructions() {
        if (this.instructions === void 0 || this.instructions) {
          if (typeof this.instructions === "string") {
            return this.instructions;
          }
          return `
Instructions:
    ${figures.arrowUp}/${figures.arrowDown}: Highlight option
    ${figures.arrowLeft}/${figures.arrowRight}/[space]: Toggle selection
    [a,b,c]/delete: Filter choices
    enter/return: Complete answer
`;
        }
        return "";
      }
      renderCurrentInput() {
        return `
Filtered results for: ${this.inputValue ? this.inputValue : color.gray("Enter something to filter")}
`;
      }
      renderOption(cursor2, v2, i) {
        let title;
        if (v2.disabled)
          title = cursor2 === i ? color.gray().underline(v2.title) : color.strikethrough().gray(v2.title);
        else
          title = cursor2 === i ? color.cyan().underline(v2.title) : v2.title;
        return (v2.selected ? color.green(figures.radioOn) : figures.radioOff) + "  " + title;
      }
      renderDoneOrInstructions() {
        if (this.done) {
          return this.value.filter((e3) => e3.selected).map((v2) => v2.title).join(", ");
        }
        const output = [color.gray(this.hint), this.renderInstructions(), this.renderCurrentInput()];
        if (this.filteredOptions.length && this.filteredOptions[this.cursor].disabled) {
          output.push(color.yellow(this.warn));
        }
        return output.join(" ");
      }
      render() {
        if (this.closed)
          return;
        if (this.firstRender)
          this.out.write(cursor.hide);
        super.render();
        let prompt2 = [
          style.symbol(this.done, this.aborted),
          color.bold(this.msg),
          style.delimiter(false),
          this.renderDoneOrInstructions()
        ].join(" ");
        if (this.showMinError) {
          prompt2 += color.red(`You must select a minimum of ${this.minSelected} choices.`);
          this.showMinError = false;
        }
        prompt2 += this.renderOptions(this.filteredOptions);
        this.out.write(this.clear + prompt2);
        this.clear = clear(prompt2, this.out.columns);
      }
    };
    __name(AutocompleteMultiselectPrompt, "AutocompleteMultiselectPrompt");
    module3.exports = AutocompleteMultiselectPrompt;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/confirm.js
var require_confirm2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/confirm.js"(exports2, module3) {
    init_import_meta_url();
    var color = require_kleur();
    var Prompt = require_prompt2();
    var { style, clear } = require_util10();
    var { erase, cursor } = require_src();
    var ConfirmPrompt = class extends Prompt {
      constructor(opts = {}) {
        super(opts);
        this.msg = opts.message;
        this.value = opts.initial;
        this.initialValue = !!opts.initial;
        this.yesMsg = opts.yes || "yes";
        this.yesOption = opts.yesOption || "(Y/n)";
        this.noMsg = opts.no || "no";
        this.noOption = opts.noOption || "(y/N)";
        this.render();
      }
      reset() {
        this.value = this.initialValue;
        this.fire();
        this.render();
      }
      exit() {
        this.abort();
      }
      abort() {
        this.done = this.aborted = true;
        this.fire();
        this.render();
        this.out.write("\n");
        this.close();
      }
      submit() {
        this.value = this.value || false;
        this.done = true;
        this.aborted = false;
        this.fire();
        this.render();
        this.out.write("\n");
        this.close();
      }
      _(c2, key) {
        if (c2.toLowerCase() === "y") {
          this.value = true;
          return this.submit();
        }
        if (c2.toLowerCase() === "n") {
          this.value = false;
          return this.submit();
        }
        return this.bell();
      }
      render() {
        if (this.closed)
          return;
        if (this.firstRender)
          this.out.write(cursor.hide);
        else
          this.out.write(clear(this.outputText, this.out.columns));
        super.render();
        this.outputText = [
          style.symbol(this.done, this.aborted),
          color.bold(this.msg),
          style.delimiter(this.done),
          this.done ? this.value ? this.yesMsg : this.noMsg : color.gray(this.initialValue ? this.yesOption : this.noOption)
        ].join(" ");
        this.out.write(erase.line + cursor.to(0) + this.outputText);
      }
    };
    __name(ConfirmPrompt, "ConfirmPrompt");
    module3.exports = ConfirmPrompt;
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/index.js
var require_elements2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/elements/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = {
      TextPrompt: require_text2(),
      SelectPrompt: require_select2(),
      TogglePrompt: require_toggle2(),
      DatePrompt: require_date2(),
      NumberPrompt: require_number2(),
      MultiselectPrompt: require_multiselect2(),
      AutocompletePrompt: require_autocomplete2(),
      AutocompleteMultiselectPrompt: require_autocompleteMultiselect2(),
      ConfirmPrompt: require_confirm2()
    };
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/prompts.js
var require_prompts2 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/prompts.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var $3 = exports2;
    var el = require_elements2();
    var noop = /* @__PURE__ */ __name((v2) => v2, "noop");
    function toPrompt(type, args, opts = {}) {
      return new Promise((res, rej) => {
        const p2 = new el[type](args);
        const onAbort = opts.onAbort || noop;
        const onSubmit = opts.onSubmit || noop;
        const onExit9 = opts.onExit || noop;
        p2.on("state", args.onState || noop);
        p2.on("submit", (x2) => res(onSubmit(x2)));
        p2.on("exit", (x2) => res(onExit9(x2)));
        p2.on("abort", (x2) => rej(onAbort(x2)));
      });
    }
    __name(toPrompt, "toPrompt");
    $3.text = (args) => toPrompt("TextPrompt", args);
    $3.password = (args) => {
      args.style = "password";
      return $3.text(args);
    };
    $3.invisible = (args) => {
      args.style = "invisible";
      return $3.text(args);
    };
    $3.number = (args) => toPrompt("NumberPrompt", args);
    $3.date = (args) => toPrompt("DatePrompt", args);
    $3.confirm = (args) => toPrompt("ConfirmPrompt", args);
    $3.list = (args) => {
      const sep3 = args.separator || ",";
      return toPrompt("TextPrompt", args, {
        onSubmit: (str) => str.split(sep3).map((s) => s.trim())
      });
    };
    $3.toggle = (args) => toPrompt("TogglePrompt", args);
    $3.select = (args) => toPrompt("SelectPrompt", args);
    $3.multiselect = (args) => {
      args.choices = [].concat(args.choices || []);
      const toSelected = /* @__PURE__ */ __name((items) => items.filter((item) => item.selected).map((item) => item.value), "toSelected");
      return toPrompt("MultiselectPrompt", args, {
        onAbort: toSelected,
        onSubmit: toSelected
      });
    };
    $3.autocompleteMultiselect = (args) => {
      args.choices = [].concat(args.choices || []);
      const toSelected = /* @__PURE__ */ __name((items) => items.filter((item) => item.selected).map((item) => item.value), "toSelected");
      return toPrompt("AutocompleteMultiselectPrompt", args, {
        onAbort: toSelected,
        onSubmit: toSelected
      });
    };
    var byTitle = /* @__PURE__ */ __name((input, choices) => Promise.resolve(
      choices.filter((item) => item.title.slice(0, input.length).toLowerCase() === input.toLowerCase())
    ), "byTitle");
    $3.autocomplete = (args) => {
      args.suggest = args.suggest || byTitle;
      args.choices = [].concat(args.choices || []);
      return toPrompt("AutocompletePrompt", args);
    };
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/index.js
var require_lib = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/lib/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var prompts2 = require_prompts2();
    var passOn = ["suggest", "format", "onState", "validate", "onRender", "type"];
    var noop = /* @__PURE__ */ __name(() => {
    }, "noop");
    async function prompt2(questions = [], { onSubmit = noop, onCancel = noop } = {}) {
      const answers = {};
      const override2 = prompt2._override || {};
      questions = [].concat(questions);
      let answer, question, quit, name, type, lastPrompt;
      const getFormattedAnswer = /* @__PURE__ */ __name(async (question2, answer2, skipValidation = false) => {
        if (!skipValidation && question2.validate && question2.validate(answer2) !== true) {
          return;
        }
        return question2.format ? await question2.format(answer2, answers) : answer2;
      }, "getFormattedAnswer");
      for (question of questions) {
        ({ name, type } = question);
        if (typeof type === "function") {
          type = await type(answer, { ...answers }, question);
          question["type"] = type;
        }
        if (!type)
          continue;
        for (let key in question) {
          if (passOn.includes(key))
            continue;
          let value = question[key];
          question[key] = typeof value === "function" ? await value(answer, { ...answers }, lastPrompt) : value;
        }
        lastPrompt = question;
        if (typeof question.message !== "string") {
          throw new Error("prompt message is required");
        }
        ({ name, type } = question);
        if (prompts2[type] === void 0) {
          throw new Error(`prompt type (${type}) is not defined`);
        }
        if (override2[question.name] !== void 0) {
          answer = await getFormattedAnswer(question, override2[question.name]);
          if (answer !== void 0) {
            answers[name] = answer;
            continue;
          }
        }
        try {
          answer = prompt2._injected ? getInjectedAnswer(prompt2._injected, question.initial) : await prompts2[type](question);
          answers[name] = answer = await getFormattedAnswer(question, answer, true);
          quit = await onSubmit(question, answer, answers);
        } catch (err) {
          quit = !await onCancel(question, answers);
        }
        if (quit)
          return answers;
      }
      return answers;
    }
    __name(prompt2, "prompt");
    function getInjectedAnswer(injected, deafultValue) {
      const answer = injected.shift();
      if (answer instanceof Error) {
        throw answer;
      }
      return answer === void 0 ? deafultValue : answer;
    }
    __name(getInjectedAnswer, "getInjectedAnswer");
    function inject(answers) {
      prompt2._injected = (prompt2._injected || []).concat(answers);
    }
    __name(inject, "inject");
    function override(answers) {
      prompt2._override = Object.assign({}, answers);
    }
    __name(override, "override");
    module3.exports = Object.assign(prompt2, { prompt: prompt2, prompts: prompts2, inject, override });
  }
});

// ../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/index.js
var require_prompts3 = __commonJS({
  "../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/index.js"(exports2, module3) {
    init_import_meta_url();
    function isNodeLT(tar) {
      tar = (Array.isArray(tar) ? tar : tar.split(".")).map(Number);
      let i = 0, src = process.versions.node.split(".").map(Number);
      for (; i < tar.length; i++) {
        if (src[i] > tar[i])
          return false;
        if (tar[i] > src[i])
          return true;
      }
      return false;
    }
    __name(isNodeLT, "isNodeLT");
    module3.exports = isNodeLT("8.6.0") ? require_dist2() : require_lib();
  }
});

// ../../node_modules/.pnpm/is-docker@2.2.1/node_modules/is-docker/index.js
var require_is_docker = __commonJS({
  "../../node_modules/.pnpm/is-docker@2.2.1/node_modules/is-docker/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var fs26 = require("fs");
    var isDocker;
    function hasDockerEnv() {
      try {
        fs26.statSync("/.dockerenv");
        return true;
      } catch (_3) {
        return false;
      }
    }
    __name(hasDockerEnv, "hasDockerEnv");
    function hasDockerCGroup() {
      try {
        return fs26.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
      } catch (_3) {
        return false;
      }
    }
    __name(hasDockerCGroup, "hasDockerCGroup");
    module3.exports = () => {
      if (isDocker === void 0) {
        isDocker = hasDockerEnv() || hasDockerCGroup();
      }
      return isDocker;
    };
  }
});

// ../../node_modules/.pnpm/is-wsl@2.2.0/node_modules/is-wsl/index.js
var require_is_wsl = __commonJS({
  "../../node_modules/.pnpm/is-wsl@2.2.0/node_modules/is-wsl/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var os11 = require("os");
    var fs26 = require("fs");
    var isDocker = require_is_docker();
    var isWsl = /* @__PURE__ */ __name(() => {
      if (process.platform !== "linux") {
        return false;
      }
      if (os11.release().toLowerCase().includes("microsoft")) {
        if (isDocker()) {
          return false;
        }
        return true;
      }
      try {
        return fs26.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isDocker() : false;
      } catch (_3) {
        return false;
      }
    }, "isWsl");
    if (process.env.__IS_WSL_TEST__) {
      module3.exports = isWsl;
    } else {
      module3.exports = isWsl();
    }
  }
});

// ../../node_modules/.pnpm/define-lazy-prop@2.0.0/node_modules/define-lazy-prop/index.js
var require_define_lazy_prop = __commonJS({
  "../../node_modules/.pnpm/define-lazy-prop@2.0.0/node_modules/define-lazy-prop/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = (object, propertyName, fn2) => {
      const define2 = /* @__PURE__ */ __name((value) => Object.defineProperty(object, propertyName, { value, enumerable: true, writable: true }), "define");
      Object.defineProperty(object, propertyName, {
        configurable: true,
        enumerable: true,
        get() {
          const result = fn2();
          define2(result);
          return result;
        },
        set(value) {
          define2(value);
        }
      });
      return object;
    };
  }
});

// ../../node_modules/.pnpm/open@8.4.0/node_modules/open/index.js
var require_open = __commonJS({
  "../../node_modules/.pnpm/open@8.4.0/node_modules/open/index.js"(exports2, module3) {
    init_import_meta_url();
    var path67 = require("path");
    var childProcess2 = require("child_process");
    var { promises: fs26, constants: fsConstants } = require("fs");
    var isWsl = require_is_wsl();
    var isDocker = require_is_docker();
    var defineLazyProperty = require_define_lazy_prop();
    var localXdgOpenPath = path67.join(__dirname, "xdg-open");
    var { platform: platform2, arch: arch3 } = process;
    var getWslDrivesMountPoint = (() => {
      const defaultMountPoint = "/mnt/";
      let mountPoint;
      return async function() {
        if (mountPoint) {
          return mountPoint;
        }
        const configFilePath = "/etc/wsl.conf";
        let isConfigFileExists = false;
        try {
          await fs26.access(configFilePath, fsConstants.F_OK);
          isConfigFileExists = true;
        } catch {
        }
        if (!isConfigFileExists) {
          return defaultMountPoint;
        }
        const configContent = await fs26.readFile(configFilePath, { encoding: "utf8" });
        const configMountPoint = /(?<!#.*)root\s*=\s*(?<mountPoint>.*)/g.exec(configContent);
        if (!configMountPoint) {
          return defaultMountPoint;
        }
        mountPoint = configMountPoint.groups.mountPoint.trim();
        mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
        return mountPoint;
      };
    })();
    var pTryEach = /* @__PURE__ */ __name(async (array, mapper) => {
      let latestError;
      for (const item of array) {
        try {
          return await mapper(item);
        } catch (error2) {
          latestError = error2;
        }
      }
      throw latestError;
    }, "pTryEach");
    var baseOpen = /* @__PURE__ */ __name(async (options29) => {
      options29 = {
        wait: false,
        background: false,
        newInstance: false,
        allowNonzeroExitCode: false,
        ...options29
      };
      if (Array.isArray(options29.app)) {
        return pTryEach(options29.app, (singleApp) => baseOpen({
          ...options29,
          app: singleApp
        }));
      }
      let { name: app, arguments: appArguments = [] } = options29.app || {};
      appArguments = [...appArguments];
      if (Array.isArray(app)) {
        return pTryEach(app, (appName) => baseOpen({
          ...options29,
          app: {
            name: appName,
            arguments: appArguments
          }
        }));
      }
      let command2;
      const cliArguments = [];
      const childProcessOptions = {};
      if (platform2 === "darwin") {
        command2 = "open";
        if (options29.wait) {
          cliArguments.push("--wait-apps");
        }
        if (options29.background) {
          cliArguments.push("--background");
        }
        if (options29.newInstance) {
          cliArguments.push("--new");
        }
        if (app) {
          cliArguments.push("-a", app);
        }
      } else if (platform2 === "win32" || isWsl && !isDocker()) {
        const mountPoint = await getWslDrivesMountPoint();
        command2 = isWsl ? `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe` : `${process.env.SYSTEMROOT}\\System32\\WindowsPowerShell\\v1.0\\powershell`;
        cliArguments.push(
          "-NoProfile",
          "-NonInteractive",
          "\u2013ExecutionPolicy",
          "Bypass",
          "-EncodedCommand"
        );
        if (!isWsl) {
          childProcessOptions.windowsVerbatimArguments = true;
        }
        const encodedArguments = ["Start"];
        if (options29.wait) {
          encodedArguments.push("-Wait");
        }
        if (app) {
          encodedArguments.push(`"\`"${app}\`""`, "-ArgumentList");
          if (options29.target) {
            appArguments.unshift(options29.target);
          }
        } else if (options29.target) {
          encodedArguments.push(`"${options29.target}"`);
        }
        if (appArguments.length > 0) {
          appArguments = appArguments.map((arg) => `"\`"${arg}\`""`);
          encodedArguments.push(appArguments.join(","));
        }
        options29.target = Buffer.from(encodedArguments.join(" "), "utf16le").toString("base64");
      } else {
        if (app) {
          command2 = app;
        } else {
          const isBundled = !__dirname || __dirname === "/";
          let exeLocalXdgOpen = false;
          try {
            await fs26.access(localXdgOpenPath, fsConstants.X_OK);
            exeLocalXdgOpen = true;
          } catch {
          }
          const useSystemXdgOpen = process.versions.electron || platform2 === "android" || isBundled || !exeLocalXdgOpen;
          command2 = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
        }
        if (appArguments.length > 0) {
          cliArguments.push(...appArguments);
        }
        if (!options29.wait) {
          childProcessOptions.stdio = "ignore";
          childProcessOptions.detached = true;
        }
      }
      if (options29.target) {
        cliArguments.push(options29.target);
      }
      if (platform2 === "darwin" && appArguments.length > 0) {
        cliArguments.push("--args", ...appArguments);
      }
      const subprocess = childProcess2.spawn(command2, cliArguments, childProcessOptions);
      if (options29.wait) {
        return new Promise((resolve19, reject) => {
          subprocess.once("error", reject);
          subprocess.once("close", (exitCode) => {
            if (options29.allowNonzeroExitCode && exitCode > 0) {
              reject(new Error(`Exited with code ${exitCode}`));
              return;
            }
            resolve19(subprocess);
          });
        });
      }
      subprocess.unref();
      return subprocess;
    }, "baseOpen");
    var open3 = /* @__PURE__ */ __name((target, options29) => {
      if (typeof target !== "string") {
        throw new TypeError("Expected a `target`");
      }
      return baseOpen({
        ...options29,
        target
      });
    }, "open");
    var openApp = /* @__PURE__ */ __name((name, options29) => {
      if (typeof name !== "string") {
        throw new TypeError("Expected a `name`");
      }
      const { arguments: appArguments = [] } = options29 || {};
      if (appArguments !== void 0 && appArguments !== null && !Array.isArray(appArguments)) {
        throw new TypeError("Expected `appArguments` as Array type");
      }
      return baseOpen({
        ...options29,
        app: {
          name,
          arguments: appArguments
        }
      });
    }, "openApp");
    function detectArchBinary(binary) {
      if (typeof binary === "string" || Array.isArray(binary)) {
        return binary;
      }
      const { [arch3]: archBinary } = binary;
      if (!archBinary) {
        throw new Error(`${arch3} is not supported`);
      }
      return archBinary;
    }
    __name(detectArchBinary, "detectArchBinary");
    function detectPlatformBinary({ [platform2]: platformBinary }, { wsl }) {
      if (wsl && isWsl) {
        return detectArchBinary(wsl);
      }
      if (!platformBinary) {
        throw new Error(`${platform2} is not supported`);
      }
      return detectArchBinary(platformBinary);
    }
    __name(detectPlatformBinary, "detectPlatformBinary");
    var apps = {};
    defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
      darwin: "google chrome",
      win32: "chrome",
      linux: ["google-chrome", "google-chrome-stable", "chromium"]
    }, {
      wsl: {
        ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
        x64: ["/mnt/c/Program Files/Google/Chrome/Application/chrome.exe", "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"]
      }
    }));
    defineLazyProperty(apps, "firefox", () => detectPlatformBinary({
      darwin: "firefox",
      win32: "C:\\Program Files\\Mozilla Firefox\\firefox.exe",
      linux: "firefox"
    }, {
      wsl: "/mnt/c/Program Files/Mozilla Firefox/firefox.exe"
    }));
    defineLazyProperty(apps, "edge", () => detectPlatformBinary({
      darwin: "microsoft edge",
      win32: "msedge",
      linux: ["microsoft-edge", "microsoft-edge-dev"]
    }, {
      wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe"
    }));
    open3.apps = apps;
    open3.openApp = openApp;
    module3.exports = open3;
  }
});

// ../../node_modules/.pnpm/glob-to-regexp@0.4.1/node_modules/glob-to-regexp/index.js
var require_glob_to_regexp = __commonJS({
  "../../node_modules/.pnpm/glob-to-regexp@0.4.1/node_modules/glob-to-regexp/index.js"(exports2, module3) {
    init_import_meta_url();
    module3.exports = function(glob, opts) {
      if (typeof glob !== "string") {
        throw new TypeError("Expected a string");
      }
      var str = String(glob);
      var reStr = "";
      var extended = opts ? !!opts.extended : false;
      var globstar = opts ? !!opts.globstar : false;
      var inGroup = false;
      var flags = opts && typeof opts.flags === "string" ? opts.flags : "";
      var c2;
      for (var i = 0, len = str.length; i < len; i++) {
        c2 = str[i];
        switch (c2) {
          case "/":
          case "$":
          case "^":
          case "+":
          case ".":
          case "(":
          case ")":
          case "=":
          case "!":
          case "|":
            reStr += "\\" + c2;
            break;
          case "?":
            if (extended) {
              reStr += ".";
              break;
            }
          case "[":
          case "]":
            if (extended) {
              reStr += c2;
              break;
            }
          case "{":
            if (extended) {
              inGroup = true;
              reStr += "(";
              break;
            }
          case "}":
            if (extended) {
              inGroup = false;
              reStr += ")";
              break;
            }
          case ",":
            if (inGroup) {
              reStr += "|";
              break;
            }
            reStr += "\\" + c2;
            break;
          case "*":
            var prevChar = str[i - 1];
            var starCount = 1;
            while (str[i + 1] === "*") {
              starCount++;
              i++;
            }
            var nextChar = str[i + 1];
            if (!globstar) {
              reStr += ".*";
            } else {
              var isGlobstar = starCount > 1 && (prevChar === "/" || prevChar === void 0) && (nextChar === "/" || nextChar === void 0);
              if (isGlobstar) {
                reStr += "((?:[^/]*(?:/|$))*)";
                i++;
              } else {
                reStr += "([^/]*)";
              }
            }
            break;
          default:
            reStr += c2;
        }
      }
      if (!flags || !~flags.indexOf("g")) {
        reStr = "^" + reStr + "$";
      }
      return new RegExp(reStr, flags);
    };
  }
});

// ../../node_modules/.pnpm/resolve@1.22.8/node_modules/resolve/lib/homedir.js
var require_homedir = __commonJS({
  "../../node_modules/.pnpm/resolve@1.22.8/node_modules/resolve/lib/homedir.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var os11 = require("os");
    module3.exports = os11.homedir || /* @__PURE__ */ __name(function homedir2() {
      var home = process.env.HOME;
      var user = process.env.LOGNAME || process.env.USER || process.env.LNAME || process.env.USERNAME;
      if (process.platform === "win32") {
        return process.env.USERPROFILE || process.env.HOMEDRIVE + process.env.HOMEPATH || home || null;
      }
      if (process.platform === "darwin") {
        return home || (user ? "/Users/" + user : null);
      }
      if (process.platform === "linux") {
        return home || (process.getuid() === 0 ? "/root" : user ? "/home/" + user : null);
      }
      return home || null;
    }, "homedir");
  }
});

// ../../node_modules/.pnpm/resolve@1.22.8/node_modules/resolve/lib/caller.js
var require_caller = __commonJS({
  "../../node_modules/.pnpm/resolve@1.22.8/node_modules/resolve/lib/caller.js"(exports2, module3) {
    init_import_meta_url();
    module3.exports = function() {
      var origPrepareStackTrace = Error.prepareStackTrace;
      Error.prepareStackTrace = function(_3, stack2) {
        return stack2;
      };
      var stack = new Error().stack;
      Error.prepareStackTrace = origPrepareStackTrace;
      return stack[2].getFileName();
    };
  }
});

// ../../node_modules/.pnpm/path-parse@1.0.7/node_modules/path-parse/index.js
var require_path_parse = __commonJS({
  "../../node_modules/.pnpm/path-parse@1.0.7/node_modules/path-parse/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var isWindows2 = process.platform === "win32";
    var splitWindowsRe = /^(((?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?[\\\/]?)(?:[^\\\/]*[\\\/])*)((\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))[\\\/]*$/;
    var win32 = {};
    function win32SplitPath(filename) {
      return splitWindowsRe.exec(filename).slice(1);
    }
    __name(win32SplitPath, "win32SplitPath");
    win32.parse = function(pathString) {
      if (typeof pathString !== "string") {
        throw new TypeError(
          "Parameter 'pathString' must be a string, not " + typeof pathString
        );
      }
      var allParts = win32SplitPath(pathString);
      if (!allParts || allParts.length !== 5) {
        throw new TypeError("Invalid path '" + pathString + "'");
      }
      return {
        root: allParts[1],
        dir: allParts[0] === allParts[1] ? allParts[0] : allParts[0].slice(0, -1),
        base: allParts[2],
        ext: allParts[4],
        name: allParts[3]
      };
    };
    var splitPathRe = /^((\/?)(?:[^\/]*\/)*)((\.{1,2}|[^\/]+?|)(\.[^.\/]*|))[\/]*$/;
    var posix2 = {};
    function posixSplitPath(filename) {
      return splitPathRe.exec(filename).slice(1);
    }
    __name(posixSplitPath, "posixSplitPath");
    posix2.parse = function(pathString) {
      if (typeof pathString !== "string") {
        throw new TypeError(
          "Parameter 'pathString' must be a string, not " + typeof pathString
        );
      }
      var allParts = posixSplitPath(pathString);
      if (!allParts || allParts.length !== 5) {
        throw new TypeError("Invalid path '" + pathString + "'");
      }
      return {
        root: allParts[1],
        dir: allParts[0].slice(0, -1),
        base: allParts[2],
        ext: allParts[4],
        name: allParts[3]
      };
    };
    if (isWindows2)
      module3.exports = win32.parse;
    else
      module3.exports = posix2.parse;
    module3.exports.posix = posix2.parse;
    module3.exports.win32 = win32.parse;
  }
});

// ../../node_modules/.pnpm/resolve@1.22.8/node_modules/resolve/lib/node-modules-paths.js
var require_node_modules_paths = __commonJS({
  "../../node_modules/.pnpm/resolve@1.22.8/node_modules/resolve/lib/node-modules-paths.js"(exports2, module3) {
    init_import_meta_url();
    var path67 = require("path");
    var parse7 = path67.parse || require_path_parse();
    var getNodeModulesDirs = /* @__PURE__ */ __name(function getNodeModulesDirs2(absoluteStart, modules) {
      var prefix = "/";
      if (/^([A-Za-z]:)/.test(absoluteStart)) {
        prefix = "";
      } else if (/^\\\\/.test(absoluteStart)) {
        prefix = "\\\\";
      }
      var paths = [absoluteStart];
      var parsed = parse7(absoluteStart);
      while (parsed.dir !== paths[paths.length - 1]) {
        paths.push(parsed.dir);
        parsed = parse7(parsed.dir);
      }
      return paths.reduce(function(dirs, aPath) {
        return dirs.concat(modules.map(function(moduleDir) {
          return path67.resolve(prefix, aPath, moduleDir);
        }));
      }, []);
    }, "getNodeModulesDirs");
    module3.exports = /* @__PURE__ */ __name(function nodeModulesPaths(start, opts, request3) {
      var modules = opts && opts.moduleDirectory ? [].concat(opts.moduleDirectory) : ["node_modules"];
      if (opts && typeof opts.paths === "function") {
        return opts.paths(
          request3,
          start,
          function() {
            return getNodeModulesDirs(start, modules);
          },
          opts
        );
      }
      var dirs = getNodeModulesDirs(start, modules);
      return opts && opts.paths ? dirs.concat(opts.paths) : dirs;
    }, "nodeModulesPaths");
  }
});

// ../../node_modules/.pnpm/resolve@1.22.8/node_modules/resolve/lib/normalize-options.js
var require_normalize_options = __commonJS({
  "../../node_modules/.pnpm/resolve@1.22.8/node_modules/resolve/lib/normalize-options.js"(exports2, module3) {
    init_import_meta_url();
    module3.exports = function(x2, opts) {
      return opts || {};
    };
  }
});

// ../../node_modules/.pnpm/function-bind@1.1.1/node_modules/function-bind/implementation.js
var require_implementation = __commonJS({
  "../../node_modules/.pnpm/function-bind@1.1.1/node_modules/function-bind/implementation.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
    var slice = Array.prototype.slice;
    var toStr = Object.prototype.toString;
    var funcType = "[object Function]";
    module3.exports = /* @__PURE__ */ __name(function bind(that) {
      var target = this;
      if (typeof target !== "function" || toStr.call(target) !== funcType) {
        throw new TypeError(ERROR_MESSAGE + target);
      }
      var args = slice.call(arguments, 1);
      var bound;
      var binder = /* @__PURE__ */ __name(function() {
        if (this instanceof bound) {
          var result = target.apply(
            this,
            args.concat(slice.call(arguments))
          );
          if (Object(result) === result) {
            return result;
          }
          return this;
        } else {
          return target.apply(
            that,
            args.concat(slice.call(arguments))
          );
        }
      }, "binder");
      var boundLength = Math.max(0, target.length - args.length);
      var boundArgs = [];
      for (var i = 0; i < boundLength; i++) {
        boundArgs.push("$" + i);
      }
      bound = Function("binder", "return function (" + boundArgs.join(",") + "){ return binder.apply(this,arguments); }")(binder);
      if (target.prototype) {
        var Empty = /* @__PURE__ */ __name(function Empty2() {
        }, "Empty");
        Empty.prototype = target.prototype;
        bound.prototype = new Empty();
        Empty.prototype = null;
      }
      return bound;
    }, "bind");
  }
});

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

// ../../node_modules/.pnpm/has@1.0.3/node_modules/has/src/index.js
var require_src2 = __commonJS({
  "../../node_modules/.pnpm/has@1.0.3/node_modules/has/src/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var bind = require_function_bind();
    module3.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);
  }
});

// ../../node_modules/.pnpm/is-core-module@2.13.0/node_modules/is-core-module/core.json
var require_core = __commonJS({
  "../../node_modules/.pnpm/is-core-module@2.13.0/node_modules/is-core-module/core.json"(exports2, module3) {
    module3.exports = {
      assert: true,
      "node:assert": [">= 14.18 && < 15", ">= 16"],
      "assert/strict": ">= 15",
      "node:assert/strict": ">= 16",
      async_hooks: ">= 8",
      "node:async_hooks": [">= 14.18 && < 15", ">= 16"],
      buffer_ieee754: ">= 0.5 && < 0.9.7",
      buffer: true,
      "node:buffer": [">= 14.18 && < 15", ">= 16"],
      child_process: true,
      "node:child_process": [">= 14.18 && < 15", ">= 16"],
      cluster: ">= 0.5",
      "node:cluster": [">= 14.18 && < 15", ">= 16"],
      console: true,
      "node:console": [">= 14.18 && < 15", ">= 16"],
      constants: true,
      "node:constants": [">= 14.18 && < 15", ">= 16"],
      crypto: true,
      "node:crypto": [">= 14.18 && < 15", ">= 16"],
      _debug_agent: ">= 1 && < 8",
      _debugger: "< 8",
      dgram: true,
      "node:dgram": [">= 14.18 && < 15", ">= 16"],
      diagnostics_channel: [">= 14.17 && < 15", ">= 15.1"],
      "node:diagnostics_channel": [">= 14.18 && < 15", ">= 16"],
      dns: true,
      "node:dns": [">= 14.18 && < 15", ">= 16"],
      "dns/promises": ">= 15",
      "node:dns/promises": ">= 16",
      domain: ">= 0.7.12",
      "node:domain": [">= 14.18 && < 15", ">= 16"],
      events: true,
      "node:events": [">= 14.18 && < 15", ">= 16"],
      freelist: "< 6",
      fs: true,
      "node:fs": [">= 14.18 && < 15", ">= 16"],
      "fs/promises": [">= 10 && < 10.1", ">= 14"],
      "node:fs/promises": [">= 14.18 && < 15", ">= 16"],
      _http_agent: ">= 0.11.1",
      "node:_http_agent": [">= 14.18 && < 15", ">= 16"],
      _http_client: ">= 0.11.1",
      "node:_http_client": [">= 14.18 && < 15", ">= 16"],
      _http_common: ">= 0.11.1",
      "node:_http_common": [">= 14.18 && < 15", ">= 16"],
      _http_incoming: ">= 0.11.1",
      "node:_http_incoming": [">= 14.18 && < 15", ">= 16"],
      _http_outgoing: ">= 0.11.1",
      "node:_http_outgoing": [">= 14.18 && < 15", ">= 16"],
      _http_server: ">= 0.11.1",
      "node:_http_server": [">= 14.18 && < 15", ">= 16"],
      http: true,
      "node:http": [">= 14.18 && < 15", ">= 16"],
      http2: ">= 8.8",
      "node:http2": [">= 14.18 && < 15", ">= 16"],
      https: true,
      "node:https": [">= 14.18 && < 15", ">= 16"],
      inspector: ">= 8",
      "node:inspector": [">= 14.18 && < 15", ">= 16"],
      "inspector/promises": [">= 19"],
      "node:inspector/promises": [">= 19"],
      _linklist: "< 8",
      module: true,
      "node:module": [">= 14.18 && < 15", ">= 16"],
      net: true,
      "node:net": [">= 14.18 && < 15", ">= 16"],
      "node-inspect/lib/_inspect": ">= 7.6 && < 12",
      "node-inspect/lib/internal/inspect_client": ">= 7.6 && < 12",
      "node-inspect/lib/internal/inspect_repl": ">= 7.6 && < 12",
      os: true,
      "node:os": [">= 14.18 && < 15", ">= 16"],
      path: true,
      "node:path": [">= 14.18 && < 15", ">= 16"],
      "path/posix": ">= 15.3",
      "node:path/posix": ">= 16",
      "path/win32": ">= 15.3",
      "node:path/win32": ">= 16",
      perf_hooks: ">= 8.5",
      "node:perf_hooks": [">= 14.18 && < 15", ">= 16"],
      process: ">= 1",
      "node:process": [">= 14.18 && < 15", ">= 16"],
      punycode: ">= 0.5",
      "node:punycode": [">= 14.18 && < 15", ">= 16"],
      querystring: true,
      "node:querystring": [">= 14.18 && < 15", ">= 16"],
      readline: true,
      "node:readline": [">= 14.18 && < 15", ">= 16"],
      "readline/promises": ">= 17",
      "node:readline/promises": ">= 17",
      repl: true,
      "node:repl": [">= 14.18 && < 15", ">= 16"],
      smalloc: ">= 0.11.5 && < 3",
      _stream_duplex: ">= 0.9.4",
      "node:_stream_duplex": [">= 14.18 && < 15", ">= 16"],
      _stream_transform: ">= 0.9.4",
      "node:_stream_transform": [">= 14.18 && < 15", ">= 16"],
      _stream_wrap: ">= 1.4.1",
      "node:_stream_wrap": [">= 14.18 && < 15", ">= 16"],
      _stream_passthrough: ">= 0.9.4",
      "node:_stream_passthrough": [">= 14.18 && < 15", ">= 16"],
      _stream_readable: ">= 0.9.4",
      "node:_stream_readable": [">= 14.18 && < 15", ">= 16"],
      _stream_writable: ">= 0.9.4",
      "node:_stream_writable": [">= 14.18 && < 15", ">= 16"],
      stream: true,
      "node:stream": [">= 14.18 && < 15", ">= 16"],
      "stream/consumers": ">= 16.7",
      "node:stream/consumers": ">= 16.7",
      "stream/promises": ">= 15",
      "node:stream/promises": ">= 16",
      "stream/web": ">= 16.5",
      "node:stream/web": ">= 16.5",
      string_decoder: true,
      "node:string_decoder": [">= 14.18 && < 15", ">= 16"],
      sys: [">= 0.4 && < 0.7", ">= 0.8"],
      "node:sys": [">= 14.18 && < 15", ">= 16"],
      "test/reporters": ">= 19.9 && < 20.2",
      "node:test/reporters": [">= 18.17 && < 19", ">= 19.9", ">= 20"],
      "node:test": [">= 16.17 && < 17", ">= 18"],
      timers: true,
      "node:timers": [">= 14.18 && < 15", ">= 16"],
      "timers/promises": ">= 15",
      "node:timers/promises": ">= 16",
      _tls_common: ">= 0.11.13",
      "node:_tls_common": [">= 14.18 && < 15", ">= 16"],
      _tls_legacy: ">= 0.11.3 && < 10",
      _tls_wrap: ">= 0.11.3",
      "node:_tls_wrap": [">= 14.18 && < 15", ">= 16"],
      tls: true,
      "node:tls": [">= 14.18 && < 15", ">= 16"],
      trace_events: ">= 10",
      "node:trace_events": [">= 14.18 && < 15", ">= 16"],
      tty: true,
      "node:tty": [">= 14.18 && < 15", ">= 16"],
      url: true,
      "node:url": [">= 14.18 && < 15", ">= 16"],
      util: true,
      "node:util": [">= 14.18 && < 15", ">= 16"],
      "util/types": ">= 15.3",
      "node:util/types": ">= 16",
      "v8/tools/arguments": ">= 10 && < 12",
      "v8/tools/codemap": [">= 4.4 && < 5", ">= 5.2 && < 12"],
      "v8/tools/consarray": [">= 4.4 && < 5", ">= 5.2 && < 12"],
      "v8/tools/csvparser": [">= 4.4 && < 5", ">= 5.2 && < 12"],
      "v8/tools/logreader": [">= 4.4 && < 5", ">= 5.2 && < 12"],
      "v8/tools/profile_view": [">= 4.4 && < 5", ">= 5.2 && < 12"],
      "v8/tools/splaytree": [">= 4.4 && < 5", ">= 5.2 && < 12"],
      v8: ">= 1",
      "node:v8": [">= 14.18 && < 15", ">= 16"],
      vm: true,
      "node:vm": [">= 14.18 && < 15", ">= 16"],
      wasi: [">= 13.4 && < 13.5", ">= 18.17 && < 19", ">= 20"],
      "node:wasi": [">= 18.17 && < 19", ">= 20"],
      worker_threads: ">= 11.7",
      "node:worker_threads": [">= 14.18 && < 15", ">= 16"],
      zlib: ">= 0.5",
      "node:zlib": [">= 14.18 && < 15", ">= 16"]
    };
  }
});

// ../../node_modules/.pnpm/is-core-module@2.13.0/node_modules/is-core-module/index.js
var require_is_core_module = __commonJS({
  "../../node_modules/.pnpm/is-core-module@2.13.0/node_modules/is-core-module/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var has = require_src2();
    function specifierIncluded(current, specifier) {
      var nodeParts = current.split(".");
      var parts = specifier.split(" ");
      var op = parts.length > 1 ? parts[0] : "=";
      var versionParts = (parts.length > 1 ? parts[1] : parts[0]).split(".");
      for (var i = 0; i < 3; ++i) {
        var cur = parseInt(nodeParts[i] || 0, 10);
        var ver = parseInt(versionParts[i] || 0, 10);
        if (cur === ver) {
          continue;
        }
        if (op === "<") {
          return cur < ver;
        }
        if (op === ">=") {
          return cur >= ver;
        }
        return false;
      }
      return op === ">=";
    }
    __name(specifierIncluded, "specifierIncluded");
    function matchesRange(current, range) {
      var specifiers = range.split(/ ?&& ?/);
      if (specifiers.length === 0) {
        return false;
      }
      for (var i = 0; i < specifiers.length; ++i) {
        if (!specifierIncluded(current, specifiers[i])) {
          return false;
        }
      }
      return true;
    }
    __name(matchesRange, "matchesRange");
    function versionIncluded(nodeVersion2, specifierValue) {
      if (typeof specifierValue === "boolean") {
        return specifierValue;
      }
      var current = typeof nodeVersion2 === "undefined" ? process.versions && process.versions.node : nodeVersion2;
      if (typeof current !== "string") {
        throw new TypeError(typeof nodeVersion2 === "undefined" ? "Unable to determine current node version" : "If provided, a valid node version is required");
      }
      if (specifierValue && typeof specifierValue === "object") {
        for (var i = 0; i < specifierValue.length; ++i) {
          if (matchesRange(current, specifierValue[i])) {
            return true;
          }
        }
        return false;
      }
      return matchesRange(current, specifierValue);
    }
    __name(versionIncluded, "versionIncluded");
    var data = require_core();
    module3.exports = /* @__PURE__ */ __name(function isCore(x2, nodeVersion2) {
      return has(data, x2) && versionIncluded(nodeVersion2, data[x2]);
    }, "isCore");
  }
});

// ../../node_modules/.pnpm/resolve@1.22.8/node_modules/resolve/lib/async.js
var require_async = __commonJS({
  "../../node_modules/.pnpm/resolve@1.22.8/node_modules/resolve/lib/async.js"(exports2, module3) {
    init_import_meta_url();
    var fs26 = require("fs");
    var getHomedir = require_homedir();
    var path67 = require("path");
    var caller = require_caller();
    var nodeModulesPaths = require_node_modules_paths();
    var normalizeOptions = require_normalize_options();
    var isCore = require_is_core_module();
    var realpathFS = process.platform !== "win32" && fs26.realpath && typeof fs26.realpath.native === "function" ? fs26.realpath.native : fs26.realpath;
    var homedir2 = getHomedir();
    var defaultPaths = /* @__PURE__ */ __name(function() {
      return [
        path67.join(homedir2, ".node_modules"),
        path67.join(homedir2, ".node_libraries")
      ];
    }, "defaultPaths");
    var defaultIsFile = /* @__PURE__ */ __name(function isFile(file, cb) {
      fs26.stat(file, function(err, stat4) {
        if (!err) {
          return cb(null, stat4.isFile() || stat4.isFIFO());
        }
        if (err.code === "ENOENT" || err.code === "ENOTDIR")
          return cb(null, false);
        return cb(err);
      });
    }, "isFile");
    var defaultIsDir = /* @__PURE__ */ __name(function isDirectory2(dir, cb) {
      fs26.stat(dir, function(err, stat4) {
        if (!err) {
          return cb(null, stat4.isDirectory());
        }
        if (err.code === "ENOENT" || err.code === "ENOTDIR")
          return cb(null, false);
        return cb(err);
      });
    }, "isDirectory");
    var defaultRealpath = /* @__PURE__ */ __name(function realpath(x2, cb) {
      realpathFS(x2, function(realpathErr, realPath) {
        if (realpathErr && realpathErr.code !== "ENOENT")
          cb(realpathErr);
        else
          cb(null, realpathErr ? x2 : realPath);
      });
    }, "realpath");
    var maybeRealpath = /* @__PURE__ */ __name(function maybeRealpath2(realpath, x2, opts, cb) {
      if (opts && opts.preserveSymlinks === false) {
        realpath(x2, cb);
      } else {
        cb(null, x2);
      }
    }, "maybeRealpath");
    var defaultReadPackage = /* @__PURE__ */ __name(function defaultReadPackage2(readFile11, pkgfile, cb) {
      readFile11(pkgfile, function(readFileErr, body) {
        if (readFileErr)
          cb(readFileErr);
        else {
          try {
            var pkg = JSON.parse(body);
            cb(null, pkg);
          } catch (jsonErr) {
            cb(null);
          }
        }
      });
    }, "defaultReadPackage");
    var getPackageCandidates = /* @__PURE__ */ __name(function getPackageCandidates2(x2, start, opts) {
      var dirs = nodeModulesPaths(start, opts, x2);
      for (var i = 0; i < dirs.length; i++) {
        dirs[i] = path67.join(dirs[i], x2);
      }
      return dirs;
    }, "getPackageCandidates");
    module3.exports = /* @__PURE__ */ __name(function resolve19(x2, options29, callback) {
      var cb = callback;
      var opts = options29;
      if (typeof options29 === "function") {
        cb = opts;
        opts = {};
      }
      if (typeof x2 !== "string") {
        var err = new TypeError("Path must be a string.");
        return process.nextTick(function() {
          cb(err);
        });
      }
      opts = normalizeOptions(x2, opts);
      var isFile = opts.isFile || defaultIsFile;
      var isDirectory2 = opts.isDirectory || defaultIsDir;
      var readFile11 = opts.readFile || fs26.readFile;
      var realpath = opts.realpath || defaultRealpath;
      var readPackage = opts.readPackage || defaultReadPackage;
      if (opts.readFile && opts.readPackage) {
        var conflictErr = new TypeError("`readFile` and `readPackage` are mutually exclusive.");
        return process.nextTick(function() {
          cb(conflictErr);
        });
      }
      var packageIterator = opts.packageIterator;
      var extensions = opts.extensions || [".js"];
      var includeCoreModules = opts.includeCoreModules !== false;
      var basedir = opts.basedir || path67.dirname(caller());
      var parent = opts.filename || basedir;
      opts.paths = opts.paths || defaultPaths();
      var absoluteStart = path67.resolve(basedir);
      maybeRealpath(
        realpath,
        absoluteStart,
        opts,
        function(err2, realStart) {
          if (err2)
            cb(err2);
          else
            init3(realStart);
        }
      );
      var res;
      function init3(basedir2) {
        if (/^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/.test(x2)) {
          res = path67.resolve(basedir2, x2);
          if (x2 === "." || x2 === ".." || x2.slice(-1) === "/")
            res += "/";
          if (/\/$/.test(x2) && res === basedir2) {
            loadAsDirectory(res, opts.package, onfile);
          } else
            loadAsFile(res, opts.package, onfile);
        } else if (includeCoreModules && isCore(x2)) {
          return cb(null, x2);
        } else
          loadNodeModules(x2, basedir2, function(err2, n2, pkg) {
            if (err2)
              cb(err2);
            else if (n2) {
              return maybeRealpath(realpath, n2, opts, function(err3, realN) {
                if (err3) {
                  cb(err3);
                } else {
                  cb(null, realN, pkg);
                }
              });
            } else {
              var moduleError = new Error("Cannot find module '" + x2 + "' from '" + parent + "'");
              moduleError.code = "MODULE_NOT_FOUND";
              cb(moduleError);
            }
          });
      }
      __name(init3, "init");
      function onfile(err2, m2, pkg) {
        if (err2)
          cb(err2);
        else if (m2)
          cb(null, m2, pkg);
        else
          loadAsDirectory(res, function(err3, d2, pkg2) {
            if (err3)
              cb(err3);
            else if (d2) {
              maybeRealpath(realpath, d2, opts, function(err4, realD) {
                if (err4) {
                  cb(err4);
                } else {
                  cb(null, realD, pkg2);
                }
              });
            } else {
              var moduleError = new Error("Cannot find module '" + x2 + "' from '" + parent + "'");
              moduleError.code = "MODULE_NOT_FOUND";
              cb(moduleError);
            }
          });
      }
      __name(onfile, "onfile");
      function loadAsFile(x3, thePackage, callback2) {
        var loadAsFilePackage = thePackage;
        var cb2 = callback2;
        if (typeof loadAsFilePackage === "function") {
          cb2 = loadAsFilePackage;
          loadAsFilePackage = void 0;
        }
        var exts = [""].concat(extensions);
        load(exts, x3, loadAsFilePackage);
        function load(exts2, x4, loadPackage) {
          if (exts2.length === 0)
            return cb2(null, void 0, loadPackage);
          var file = x4 + exts2[0];
          var pkg = loadPackage;
          if (pkg)
            onpkg(null, pkg);
          else
            loadpkg(path67.dirname(file), onpkg);
          function onpkg(err2, pkg_, dir) {
            pkg = pkg_;
            if (err2)
              return cb2(err2);
            if (dir && pkg && opts.pathFilter) {
              var rfile = path67.relative(dir, file);
              var rel = rfile.slice(0, rfile.length - exts2[0].length);
              var r3 = opts.pathFilter(pkg, x4, rel);
              if (r3)
                return load(
                  [""].concat(extensions.slice()),
                  path67.resolve(dir, r3),
                  pkg
                );
            }
            isFile(file, onex);
          }
          __name(onpkg, "onpkg");
          function onex(err2, ex) {
            if (err2)
              return cb2(err2);
            if (ex)
              return cb2(null, file, pkg);
            load(exts2.slice(1), x4, pkg);
          }
          __name(onex, "onex");
        }
        __name(load, "load");
      }
      __name(loadAsFile, "loadAsFile");
      function loadpkg(dir, cb2) {
        if (dir === "" || dir === "/")
          return cb2(null);
        if (process.platform === "win32" && /^\w:[/\\]*$/.test(dir)) {
          return cb2(null);
        }
        if (/[/\\]node_modules[/\\]*$/.test(dir))
          return cb2(null);
        maybeRealpath(realpath, dir, opts, function(unwrapErr, pkgdir) {
          if (unwrapErr)
            return loadpkg(path67.dirname(dir), cb2);
          var pkgfile = path67.join(pkgdir, "package.json");
          isFile(pkgfile, function(err2, ex) {
            if (!ex)
              return loadpkg(path67.dirname(dir), cb2);
            readPackage(readFile11, pkgfile, function(err3, pkgParam) {
              if (err3)
                cb2(err3);
              var pkg = pkgParam;
              if (pkg && opts.packageFilter) {
                pkg = opts.packageFilter(pkg, pkgfile);
              }
              cb2(null, pkg, dir);
            });
          });
        });
      }
      __name(loadpkg, "loadpkg");
      function loadAsDirectory(x3, loadAsDirectoryPackage, callback2) {
        var cb2 = callback2;
        var fpkg = loadAsDirectoryPackage;
        if (typeof fpkg === "function") {
          cb2 = fpkg;
          fpkg = opts.package;
        }
        maybeRealpath(realpath, x3, opts, function(unwrapErr, pkgdir) {
          if (unwrapErr)
            return cb2(unwrapErr);
          var pkgfile = path67.join(pkgdir, "package.json");
          isFile(pkgfile, function(err2, ex) {
            if (err2)
              return cb2(err2);
            if (!ex)
              return loadAsFile(path67.join(x3, "index"), fpkg, cb2);
            readPackage(readFile11, pkgfile, function(err3, pkgParam) {
              if (err3)
                return cb2(err3);
              var pkg = pkgParam;
              if (pkg && opts.packageFilter) {
                pkg = opts.packageFilter(pkg, pkgfile);
              }
              if (pkg && pkg.main) {
                if (typeof pkg.main !== "string") {
                  var mainError = new TypeError("package \u201C" + pkg.name + "\u201D `main` must be a string");
                  mainError.code = "INVALID_PACKAGE_MAIN";
                  return cb2(mainError);
                }
                if (pkg.main === "." || pkg.main === "./") {
                  pkg.main = "index";
                }
                loadAsFile(path67.resolve(x3, pkg.main), pkg, function(err4, m2, pkg2) {
                  if (err4)
                    return cb2(err4);
                  if (m2)
                    return cb2(null, m2, pkg2);
                  if (!pkg2)
                    return loadAsFile(path67.join(x3, "index"), pkg2, cb2);
                  var dir = path67.resolve(x3, pkg2.main);
                  loadAsDirectory(dir, pkg2, function(err5, n2, pkg3) {
                    if (err5)
                      return cb2(err5);
                    if (n2)
                      return cb2(null, n2, pkg3);
                    loadAsFile(path67.join(x3, "index"), pkg3, cb2);
                  });
                });
                return;
              }
              loadAsFile(path67.join(x3, "/index"), pkg, cb2);
            });
          });
        });
      }
      __name(loadAsDirectory, "loadAsDirectory");
      function processDirs(cb2, dirs) {
        if (dirs.length === 0)
          return cb2(null, void 0);
        var dir = dirs[0];
        isDirectory2(path67.dirname(dir), isdir);
        function isdir(err2, isdir2) {
          if (err2)
            return cb2(err2);
          if (!isdir2)
            return processDirs(cb2, dirs.slice(1));
          loadAsFile(dir, opts.package, onfile2);
        }
        __name(isdir, "isdir");
        function onfile2(err2, m2, pkg) {
          if (err2)
            return cb2(err2);
          if (m2)
            return cb2(null, m2, pkg);
          loadAsDirectory(dir, opts.package, ondir);
        }
        __name(onfile2, "onfile");
        function ondir(err2, n2, pkg) {
          if (err2)
            return cb2(err2);
          if (n2)
            return cb2(null, n2, pkg);
          processDirs(cb2, dirs.slice(1));
        }
        __name(ondir, "ondir");
      }
      __name(processDirs, "processDirs");
      function loadNodeModules(x3, start, cb2) {
        var thunk = /* @__PURE__ */ __name(function() {
          return getPackageCandidates(x3, start, opts);
        }, "thunk");
        processDirs(
          cb2,
          packageIterator ? packageIterator(x3, start, thunk, opts) : thunk()
        );
      }
      __name(loadNodeModules, "loadNodeModules");
    }, "resolve");
  }
});

// ../../node_modules/.pnpm/resolve@1.22.8/node_modules/resolve/lib/core.json
var require_core2 = __commonJS({
  "../../node_modules/.pnpm/resolve@1.22.8/node_modules/resolve/lib/core.json"(exports2, module3) {
    module3.exports = {
      assert: true,
      "node:assert": [">= 14.18 && < 15", ">= 16"],
      "assert/strict": ">= 15",
      "node:assert/strict": ">= 16",
      async_hooks: ">= 8",
      "node:async_hooks": [">= 14.18 && < 15", ">= 16"],
      buffer_ieee754: ">= 0.5 && < 0.9.7",
      buffer: true,
      "node:buffer": [">= 14.18 && < 15", ">= 16"],
      child_process: true,
      "node:child_process": [">= 14.18 && < 15", ">= 16"],
      cluster: ">= 0.5",
      "node:cluster": [">= 14.18 && < 15", ">= 16"],
      console: true,
      "node:console": [">= 14.18 && < 15", ">= 16"],
      constants: true,
      "node:constants": [">= 14.18 && < 15", ">= 16"],
      crypto: true,
      "node:crypto": [">= 14.18 && < 15", ">= 16"],
      _debug_agent: ">= 1 && < 8",
      _debugger: "< 8",
      dgram: true,
      "node:dgram": [">= 14.18 && < 15", ">= 16"],
      diagnostics_channel: [">= 14.17 && < 15", ">= 15.1"],
      "node:diagnostics_channel": [">= 14.18 && < 15", ">= 16"],
      dns: true,
      "node:dns": [">= 14.18 && < 15", ">= 16"],
      "dns/promises": ">= 15",
      "node:dns/promises": ">= 16",
      domain: ">= 0.7.12",
      "node:domain": [">= 14.18 && < 15", ">= 16"],
      events: true,
      "node:events": [">= 14.18 && < 15", ">= 16"],
      freelist: "< 6",
      fs: true,
      "node:fs": [">= 14.18 && < 15", ">= 16"],
      "fs/promises": [">= 10 && < 10.1", ">= 14"],
      "node:fs/promises": [">= 14.18 && < 15", ">= 16"],
      _http_agent: ">= 0.11.1",
      "node:_http_agent": [">= 14.18 && < 15", ">= 16"],
      _http_client: ">= 0.11.1",
      "node:_http_client": [">= 14.18 && < 15", ">= 16"],
      _http_common: ">= 0.11.1",
      "node:_http_common": [">= 14.18 && < 15", ">= 16"],
      _http_incoming: ">= 0.11.1",
      "node:_http_incoming": [">= 14.18 && < 15", ">= 16"],
      _http_outgoing: ">= 0.11.1",
      "node:_http_outgoing": [">= 14.18 && < 15", ">= 16"],
      _http_server: ">= 0.11.1",
      "node:_http_server": [">= 14.18 && < 15", ">= 16"],
      http: true,
      "node:http": [">= 14.18 && < 15", ">= 16"],
      http2: ">= 8.8",
      "node:http2": [">= 14.18 && < 15", ">= 16"],
      https: true,
      "node:https": [">= 14.18 && < 15", ">= 16"],
      inspector: ">= 8",
      "node:inspector": [">= 14.18 && < 15", ">= 16"],
      "inspector/promises": [">= 19"],
      "node:inspector/promises": [">= 19"],
      _linklist: "< 8",
      module: true,
      "node:module": [">= 14.18 && < 15", ">= 16"],
      net: true,
      "node:net": [">= 14.18 && < 15", ">= 16"],
      "node-inspect/lib/_inspect": ">= 7.6 && < 12",
      "node-inspect/lib/internal/inspect_client": ">= 7.6 && < 12",
      "node-inspect/lib/internal/inspect_repl": ">= 7.6 && < 12",
      os: true,
      "node:os": [">= 14.18 && < 15", ">= 16"],
      path: true,
      "node:path": [">= 14.18 && < 15", ">= 16"],
      "path/posix": ">= 15.3",
      "node:path/posix": ">= 16",
      "path/win32": ">= 15.3",
      "node:path/win32": ">= 16",
      perf_hooks: ">= 8.5",
      "node:perf_hooks": [">= 14.18 && < 15", ">= 16"],
      process: ">= 1",
      "node:process": [">= 14.18 && < 15", ">= 16"],
      punycode: ">= 0.5",
      "node:punycode": [">= 14.18 && < 15", ">= 16"],
      querystring: true,
      "node:querystring": [">= 14.18 && < 15", ">= 16"],
      readline: true,
      "node:readline": [">= 14.18 && < 15", ">= 16"],
      "readline/promises": ">= 17",
      "node:readline/promises": ">= 17",
      repl: true,
      "node:repl": [">= 14.18 && < 15", ">= 16"],
      smalloc: ">= 0.11.5 && < 3",
      _stream_duplex: ">= 0.9.4",
      "node:_stream_duplex": [">= 14.18 && < 15", ">= 16"],
      _stream_transform: ">= 0.9.4",
      "node:_stream_transform": [">= 14.18 && < 15", ">= 16"],
      _stream_wrap: ">= 1.4.1",
      "node:_stream_wrap": [">= 14.18 && < 15", ">= 16"],
      _stream_passthrough: ">= 0.9.4",
      "node:_stream_passthrough": [">= 14.18 && < 15", ">= 16"],
      _stream_readable: ">= 0.9.4",
      "node:_stream_readable": [">= 14.18 && < 15", ">= 16"],
      _stream_writable: ">= 0.9.4",
      "node:_stream_writable": [">= 14.18 && < 15", ">= 16"],
      stream: true,
      "node:stream": [">= 14.18 && < 15", ">= 16"],
      "stream/consumers": ">= 16.7",
      "node:stream/consumers": ">= 16.7",
      "stream/promises": ">= 15",
      "node:stream/promises": ">= 16",
      "stream/web": ">= 16.5",
      "node:stream/web": ">= 16.5",
      string_decoder: true,
      "node:string_decoder": [">= 14.18 && < 15", ">= 16"],
      sys: [">= 0.4 && < 0.7", ">= 0.8"],
      "node:sys": [">= 14.18 && < 15", ">= 16"],
      "test/reporters": ">= 19.9 && < 20.2",
      "node:test/reporters": [">= 18.17 && < 19", ">= 19.9", ">= 20"],
      "node:test": [">= 16.17 && < 17", ">= 18"],
      timers: true,
      "node:timers": [">= 14.18 && < 15", ">= 16"],
      "timers/promises": ">= 15",
      "node:timers/promises": ">= 16",
      _tls_common: ">= 0.11.13",
      "node:_tls_common": [">= 14.18 && < 15", ">= 16"],
      _tls_legacy: ">= 0.11.3 && < 10",
      _tls_wrap: ">= 0.11.3",
      "node:_tls_wrap": [">= 14.18 && < 15", ">= 16"],
      tls: true,
      "node:tls": [">= 14.18 && < 15", ">= 16"],
      trace_events: ">= 10",
      "node:trace_events": [">= 14.18 && < 15", ">= 16"],
      tty: true,
      "node:tty": [">= 14.18 && < 15", ">= 16"],
      url: true,
      "node:url": [">= 14.18 && < 15", ">= 16"],
      util: true,
      "node:util": [">= 14.18 && < 15", ">= 16"],
      "util/types": ">= 15.3",
      "node:util/types": ">= 16",
      "v8/tools/arguments": ">= 10 && < 12",
      "v8/tools/codemap": [">= 4.4 && < 5", ">= 5.2 && < 12"],
      "v8/tools/consarray": [">= 4.4 && < 5", ">= 5.2 && < 12"],
      "v8/tools/csvparser": [">= 4.4 && < 5", ">= 5.2 && < 12"],
      "v8/tools/logreader": [">= 4.4 && < 5", ">= 5.2 && < 12"],
      "v8/tools/profile_view": [">= 4.4 && < 5", ">= 5.2 && < 12"],
      "v8/tools/splaytree": [">= 4.4 && < 5", ">= 5.2 && < 12"],
      v8: ">= 1",
      "node:v8": [">= 14.18 && < 15", ">= 16"],
      vm: true,
      "node:vm": [">= 14.18 && < 15", ">= 16"],
      wasi: [">= 13.4 && < 13.5", ">= 18.17 && < 19", ">= 20"],
      "node:wasi": [">= 18.17 && < 19", ">= 20"],
      worker_threads: ">= 11.7",
      "node:worker_threads": [">= 14.18 && < 15", ">= 16"],
      zlib: ">= 0.5",
      "node:zlib": [">= 14.18 && < 15", ">= 16"]
    };
  }
});

// ../../node_modules/.pnpm/resolve@1.22.8/node_modules/resolve/lib/core.js
var require_core3 = __commonJS({
  "../../node_modules/.pnpm/resolve@1.22.8/node_modules/resolve/lib/core.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var isCoreModule = require_is_core_module();
    var data = require_core2();
    var core = {};
    for (mod in data) {
      if (Object.prototype.hasOwnProperty.call(data, mod)) {
        core[mod] = isCoreModule(mod);
      }
    }
    var mod;
    module3.exports = core;
  }
});

// ../../node_modules/.pnpm/resolve@1.22.8/node_modules/resolve/lib/is-core.js
var require_is_core = __commonJS({
  "../../node_modules/.pnpm/resolve@1.22.8/node_modules/resolve/lib/is-core.js"(exports2, module3) {
    init_import_meta_url();
    var isCoreModule = require_is_core_module();
    module3.exports = /* @__PURE__ */ __name(function isCore(x2) {
      return isCoreModule(x2);
    }, "isCore");
  }
});

// ../../node_modules/.pnpm/resolve@1.22.8/node_modules/resolve/lib/sync.js
var require_sync = __commonJS({
  "../../node_modules/.pnpm/resolve@1.22.8/node_modules/resolve/lib/sync.js"(exports2, module3) {
    init_import_meta_url();
    var isCore = require_is_core_module();
    var fs26 = require("fs");
    var path67 = require("path");
    var getHomedir = require_homedir();
    var caller = require_caller();
    var nodeModulesPaths = require_node_modules_paths();
    var normalizeOptions = require_normalize_options();
    var realpathFS = process.platform !== "win32" && fs26.realpathSync && typeof fs26.realpathSync.native === "function" ? fs26.realpathSync.native : fs26.realpathSync;
    var homedir2 = getHomedir();
    var defaultPaths = /* @__PURE__ */ __name(function() {
      return [
        path67.join(homedir2, ".node_modules"),
        path67.join(homedir2, ".node_libraries")
      ];
    }, "defaultPaths");
    var defaultIsFile = /* @__PURE__ */ __name(function isFile(file) {
      try {
        var stat4 = fs26.statSync(file, { throwIfNoEntry: false });
      } catch (e3) {
        if (e3 && (e3.code === "ENOENT" || e3.code === "ENOTDIR"))
          return false;
        throw e3;
      }
      return !!stat4 && (stat4.isFile() || stat4.isFIFO());
    }, "isFile");
    var defaultIsDir = /* @__PURE__ */ __name(function isDirectory2(dir) {
      try {
        var stat4 = fs26.statSync(dir, { throwIfNoEntry: false });
      } catch (e3) {
        if (e3 && (e3.code === "ENOENT" || e3.code === "ENOTDIR"))
          return false;
        throw e3;
      }
      return !!stat4 && stat4.isDirectory();
    }, "isDirectory");
    var defaultRealpathSync = /* @__PURE__ */ __name(function realpathSync3(x2) {
      try {
        return realpathFS(x2);
      } catch (realpathErr) {
        if (realpathErr.code !== "ENOENT") {
          throw realpathErr;
        }
      }
      return x2;
    }, "realpathSync");
    var maybeRealpathSync = /* @__PURE__ */ __name(function maybeRealpathSync2(realpathSync3, x2, opts) {
      if (opts && opts.preserveSymlinks === false) {
        return realpathSync3(x2);
      }
      return x2;
    }, "maybeRealpathSync");
    var defaultReadPackageSync = /* @__PURE__ */ __name(function defaultReadPackageSync2(readFileSync25, pkgfile) {
      var body = readFileSync25(pkgfile);
      try {
        var pkg = JSON.parse(body);
        return pkg;
      } catch (jsonErr) {
      }
    }, "defaultReadPackageSync");
    var getPackageCandidates = /* @__PURE__ */ __name(function getPackageCandidates2(x2, start, opts) {
      var dirs = nodeModulesPaths(start, opts, x2);
      for (var i = 0; i < dirs.length; i++) {
        dirs[i] = path67.join(dirs[i], x2);
      }
      return dirs;
    }, "getPackageCandidates");
    module3.exports = /* @__PURE__ */ __name(function resolveSync2(x2, options29) {
      if (typeof x2 !== "string") {
        throw new TypeError("Path must be a string.");
      }
      var opts = normalizeOptions(x2, options29);
      var isFile = opts.isFile || defaultIsFile;
      var readFileSync25 = opts.readFileSync || fs26.readFileSync;
      var isDirectory2 = opts.isDirectory || defaultIsDir;
      var realpathSync3 = opts.realpathSync || defaultRealpathSync;
      var readPackageSync = opts.readPackageSync || defaultReadPackageSync;
      if (opts.readFileSync && opts.readPackageSync) {
        throw new TypeError("`readFileSync` and `readPackageSync` are mutually exclusive.");
      }
      var packageIterator = opts.packageIterator;
      var extensions = opts.extensions || [".js"];
      var includeCoreModules = opts.includeCoreModules !== false;
      var basedir = opts.basedir || path67.dirname(caller());
      var parent = opts.filename || basedir;
      opts.paths = opts.paths || defaultPaths();
      var absoluteStart = maybeRealpathSync(realpathSync3, path67.resolve(basedir), opts);
      if (/^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/.test(x2)) {
        var res = path67.resolve(absoluteStart, x2);
        if (x2 === "." || x2 === ".." || x2.slice(-1) === "/")
          res += "/";
        var m2 = loadAsFileSync(res) || loadAsDirectorySync(res);
        if (m2)
          return maybeRealpathSync(realpathSync3, m2, opts);
      } else if (includeCoreModules && isCore(x2)) {
        return x2;
      } else {
        var n2 = loadNodeModulesSync(x2, absoluteStart);
        if (n2)
          return maybeRealpathSync(realpathSync3, n2, opts);
      }
      var err = new Error("Cannot find module '" + x2 + "' from '" + parent + "'");
      err.code = "MODULE_NOT_FOUND";
      throw err;
      function loadAsFileSync(x3) {
        var pkg = loadpkg(path67.dirname(x3));
        if (pkg && pkg.dir && pkg.pkg && opts.pathFilter) {
          var rfile = path67.relative(pkg.dir, x3);
          var r3 = opts.pathFilter(pkg.pkg, x3, rfile);
          if (r3) {
            x3 = path67.resolve(pkg.dir, r3);
          }
        }
        if (isFile(x3)) {
          return x3;
        }
        for (var i = 0; i < extensions.length; i++) {
          var file = x3 + extensions[i];
          if (isFile(file)) {
            return file;
          }
        }
      }
      __name(loadAsFileSync, "loadAsFileSync");
      function loadpkg(dir) {
        if (dir === "" || dir === "/")
          return;
        if (process.platform === "win32" && /^\w:[/\\]*$/.test(dir)) {
          return;
        }
        if (/[/\\]node_modules[/\\]*$/.test(dir))
          return;
        var pkgfile = path67.join(maybeRealpathSync(realpathSync3, dir, opts), "package.json");
        if (!isFile(pkgfile)) {
          return loadpkg(path67.dirname(dir));
        }
        var pkg = readPackageSync(readFileSync25, pkgfile);
        if (pkg && opts.packageFilter) {
          pkg = opts.packageFilter(
            pkg,
            /*pkgfile,*/
            dir
          );
        }
        return { pkg, dir };
      }
      __name(loadpkg, "loadpkg");
      function loadAsDirectorySync(x3) {
        var pkgfile = path67.join(maybeRealpathSync(realpathSync3, x3, opts), "/package.json");
        if (isFile(pkgfile)) {
          try {
            var pkg = readPackageSync(readFileSync25, pkgfile);
          } catch (e3) {
          }
          if (pkg && opts.packageFilter) {
            pkg = opts.packageFilter(
              pkg,
              /*pkgfile,*/
              x3
            );
          }
          if (pkg && pkg.main) {
            if (typeof pkg.main !== "string") {
              var mainError = new TypeError("package \u201C" + pkg.name + "\u201D `main` must be a string");
              mainError.code = "INVALID_PACKAGE_MAIN";
              throw mainError;
            }
            if (pkg.main === "." || pkg.main === "./") {
              pkg.main = "index";
            }
            try {
              var m3 = loadAsFileSync(path67.resolve(x3, pkg.main));
              if (m3)
                return m3;
              var n3 = loadAsDirectorySync(path67.resolve(x3, pkg.main));
              if (n3)
                return n3;
            } catch (e3) {
            }
          }
        }
        return loadAsFileSync(path67.join(x3, "/index"));
      }
      __name(loadAsDirectorySync, "loadAsDirectorySync");
      function loadNodeModulesSync(x3, start) {
        var thunk = /* @__PURE__ */ __name(function() {
          return getPackageCandidates(x3, start, opts);
        }, "thunk");
        var dirs = packageIterator ? packageIterator(x3, start, thunk, opts) : thunk();
        for (var i = 0; i < dirs.length; i++) {
          var dir = dirs[i];
          if (isDirectory2(path67.dirname(dir))) {
            var m3 = loadAsFileSync(dir);
            if (m3)
              return m3;
            var n3 = loadAsDirectorySync(dir);
            if (n3)
              return n3;
          }
        }
      }
      __name(loadNodeModulesSync, "loadNodeModulesSync");
    }, "resolveSync");
  }
});

// ../../node_modules/.pnpm/resolve@1.22.8/node_modules/resolve/index.js
var require_resolve = __commonJS({
  "../../node_modules/.pnpm/resolve@1.22.8/node_modules/resolve/index.js"(exports2, module3) {
    init_import_meta_url();
    var async = require_async();
    async.core = require_core3();
    async.isCore = require_is_core();
    async.sync = require_sync();
    module3.exports = async;
  }
});

// ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js
var require_windows = __commonJS({
  "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js"(exports2, module3) {
    init_import_meta_url();
    module3.exports = isexe;
    isexe.sync = sync;
    var fs26 = require("fs");
    function checkPathExt(path67, options29) {
      var pathext = options29.pathExt !== void 0 ? options29.pathExt : process.env.PATHEXT;
      if (!pathext) {
        return true;
      }
      pathext = pathext.split(";");
      if (pathext.indexOf("") !== -1) {
        return true;
      }
      for (var i = 0; i < pathext.length; i++) {
        var p2 = pathext[i].toLowerCase();
        if (p2 && path67.substr(-p2.length).toLowerCase() === p2) {
          return true;
        }
      }
      return false;
    }
    __name(checkPathExt, "checkPathExt");
    function checkStat(stat4, path67, options29) {
      if (!stat4.isSymbolicLink() && !stat4.isFile()) {
        return false;
      }
      return checkPathExt(path67, options29);
    }
    __name(checkStat, "checkStat");
    function isexe(path67, options29, cb) {
      fs26.stat(path67, function(er, stat4) {
        cb(er, er ? false : checkStat(stat4, path67, options29));
      });
    }
    __name(isexe, "isexe");
    function sync(path67, options29) {
      return checkStat(fs26.statSync(path67), path67, options29);
    }
    __name(sync, "sync");
  }
});

// ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js
var require_mode = __commonJS({
  "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js"(exports2, module3) {
    init_import_meta_url();
    module3.exports = isexe;
    isexe.sync = sync;
    var fs26 = require("fs");
    function isexe(path67, options29, cb) {
      fs26.stat(path67, function(er, stat4) {
        cb(er, er ? false : checkStat(stat4, options29));
      });
    }
    __name(isexe, "isexe");
    function sync(path67, options29) {
      return checkStat(fs26.statSync(path67), options29);
    }
    __name(sync, "sync");
    function checkStat(stat4, options29) {
      return stat4.isFile() && checkMode(stat4, options29);
    }
    __name(checkStat, "checkStat");
    function checkMode(stat4, options29) {
      var mod = stat4.mode;
      var uid = stat4.uid;
      var gid = stat4.gid;
      var myUid = options29.uid !== void 0 ? options29.uid : process.getuid && process.getuid();
      var myGid = options29.gid !== void 0 ? options29.gid : process.getgid && process.getgid();
      var u = parseInt("100", 8);
      var g2 = parseInt("010", 8);
      var o2 = parseInt("001", 8);
      var ug = u | g2;
      var ret = mod & o2 || mod & g2 && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
      return ret;
    }
    __name(checkMode, "checkMode");
  }
});

// ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
var require_isexe = __commonJS({
  "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js"(exports2, module3) {
    init_import_meta_url();
    var fs26 = require("fs");
    var core;
    if (process.platform === "win32" || global.TESTING_WINDOWS) {
      core = require_windows();
    } else {
      core = require_mode();
    }
    module3.exports = isexe;
    isexe.sync = sync;
    function isexe(path67, options29, cb) {
      if (typeof options29 === "function") {
        cb = options29;
        options29 = {};
      }
      if (!cb) {
        if (typeof Promise !== "function") {
          throw new TypeError("callback not provided");
        }
        return new Promise(function(resolve19, reject) {
          isexe(path67, options29 || {}, function(er, is2) {
            if (er) {
              reject(er);
            } else {
              resolve19(is2);
            }
          });
        });
      }
      core(path67, options29 || {}, function(er, is2) {
        if (er) {
          if (er.code === "EACCES" || options29 && options29.ignoreErrors) {
            er = null;
            is2 = false;
          }
        }
        cb(er, is2);
      });
    }
    __name(isexe, "isexe");
    function sync(path67, options29) {
      try {
        return core.sync(path67, options29 || {});
      } catch (er) {
        if (options29 && options29.ignoreErrors || er.code === "EACCES") {
          return false;
        } else {
          throw er;
        }
      }
    }
    __name(sync, "sync");
  }
});

// ../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js
var require_which = __commonJS({
  "../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js"(exports2, module3) {
    init_import_meta_url();
    var isWindows2 = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
    var path67 = require("path");
    var COLON = isWindows2 ? ";" : ":";
    var isexe = require_isexe();
    var getNotFoundError = /* @__PURE__ */ __name((cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" }), "getNotFoundError");
    var getPathInfo = /* @__PURE__ */ __name((cmd, opt) => {
      const colon = opt.colon || COLON;
      const pathEnv = cmd.match(/\//) || isWindows2 && cmd.match(/\\/) ? [""] : [
        // windows always checks the cwd first
        ...isWindows2 ? [process.cwd()] : [],
        ...(opt.path || process.env.PATH || /* istanbul ignore next: very unusual */
        "").split(colon)
      ];
      const pathExtExe = isWindows2 ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
      const pathExt = isWindows2 ? pathExtExe.split(colon) : [""];
      if (isWindows2) {
        if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
          pathExt.unshift("");
      }
      return {
        pathEnv,
        pathExt,
        pathExtExe
      };
    }, "getPathInfo");
    var which = /* @__PURE__ */ __name((cmd, opt, cb) => {
      if (typeof opt === "function") {
        cb = opt;
        opt = {};
      }
      if (!opt)
        opt = {};
      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
      const found = [];
      const step = /* @__PURE__ */ __name((i) => new Promise((resolve19, reject) => {
        if (i === pathEnv.length)
          return opt.all && found.length ? resolve19(found) : reject(getNotFoundError(cmd));
        const ppRaw = pathEnv[i];
        const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
        const pCmd = path67.join(pathPart, cmd);
        const p2 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
        resolve19(subStep(p2, i, 0));
      }), "step");
      const subStep = /* @__PURE__ */ __name((p2, i, ii) => new Promise((resolve19, reject) => {
        if (ii === pathExt.length)
          return resolve19(step(i + 1));
        const ext = pathExt[ii];
        isexe(p2 + ext, { pathExt: pathExtExe }, (er, is2) => {
          if (!er && is2) {
            if (opt.all)
              found.push(p2 + ext);
            else
              return resolve19(p2 + ext);
          }
          return resolve19(subStep(p2, i, ii + 1));
        });
      }), "subStep");
      return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
    }, "which");
    var whichSync = /* @__PURE__ */ __name((cmd, opt) => {
      opt = opt || {};
      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
      const found = [];
      for (let i = 0; i < pathEnv.length; i++) {
        const ppRaw = pathEnv[i];
        const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
        const pCmd = path67.join(pathPart, cmd);
        const p2 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
        for (let j2 = 0; j2 < pathExt.length; j2++) {
          const cur = p2 + pathExt[j2];
          try {
            const is2 = isexe.sync(cur, { pathExt: pathExtExe });
            if (is2) {
              if (opt.all)
                found.push(cur);
              else
                return cur;
            }
          } catch (ex) {
          }
        }
      }
      if (opt.all && found.length)
        return found;
      if (opt.nothrow)
        return null;
      throw getNotFoundError(cmd);
    }, "whichSync");
    module3.exports = which;
    which.sync = whichSync;
  }
});

// ../../node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js
var require_path_key = __commonJS({
  "../../node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var pathKey2 = /* @__PURE__ */ __name((options29 = {}) => {
      const environment = options29.env || process.env;
      const platform2 = options29.platform || process.platform;
      if (platform2 !== "win32") {
        return "PATH";
      }
      return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
    }, "pathKey");
    module3.exports = pathKey2;
    module3.exports.default = pathKey2;
  }
});

// ../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/util/resolveCommand.js
var require_resolveCommand = __commonJS({
  "../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/util/resolveCommand.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var path67 = require("path");
    var which = require_which();
    var getPathKey = require_path_key();
    function resolveCommandAttempt(parsed, withoutPathExt) {
      const env5 = parsed.options.env || process.env;
      const cwd2 = process.cwd();
      const hasCustomCwd = parsed.options.cwd != null;
      const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
      if (shouldSwitchCwd) {
        try {
          process.chdir(parsed.options.cwd);
        } catch (err) {
        }
      }
      let resolved;
      try {
        resolved = which.sync(parsed.command, {
          path: env5[getPathKey({ env: env5 })],
          pathExt: withoutPathExt ? path67.delimiter : void 0
        });
      } catch (e3) {
      } finally {
        if (shouldSwitchCwd) {
          process.chdir(cwd2);
        }
      }
      if (resolved) {
        resolved = path67.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
      }
      return resolved;
    }
    __name(resolveCommandAttempt, "resolveCommandAttempt");
    function resolveCommand(parsed) {
      return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
    }
    __name(resolveCommand, "resolveCommand");
    module3.exports = resolveCommand;
  }
});

// ../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/util/escape.js
var require_escape = __commonJS({
  "../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/util/escape.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
    function escapeCommand(arg) {
      arg = arg.replace(metaCharsRegExp, "^$1");
      return arg;
    }
    __name(escapeCommand, "escapeCommand");
    function escapeArgument(arg, doubleEscapeMetaChars) {
      arg = `${arg}`;
      arg = arg.replace(/(\\*)"/g, '$1$1\\"');
      arg = arg.replace(/(\\*)$/, "$1$1");
      arg = `"${arg}"`;
      arg = arg.replace(metaCharsRegExp, "^$1");
      if (doubleEscapeMetaChars) {
        arg = arg.replace(metaCharsRegExp, "^$1");
      }
      return arg;
    }
    __name(escapeArgument, "escapeArgument");
    module3.exports.command = escapeCommand;
    module3.exports.argument = escapeArgument;
  }
});

// ../../node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js
var require_shebang_regex = __commonJS({
  "../../node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /^#!(.*)/;
  }
});

// ../../node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js
var require_shebang_command = __commonJS({
  "../../node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var shebangRegex = require_shebang_regex();
    module3.exports = (string = "") => {
      const match = string.match(shebangRegex);
      if (!match) {
        return null;
      }
      const [path67, argument] = match[0].replace(/#! ?/, "").split(" ");
      const binary = path67.split("/").pop();
      if (binary === "env") {
        return argument;
      }
      return argument ? `${binary} ${argument}` : binary;
    };
  }
});

// ../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/util/readShebang.js
var require_readShebang = __commonJS({
  "../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/util/readShebang.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var fs26 = require("fs");
    var shebangCommand = require_shebang_command();
    function readShebang(command2) {
      const size = 150;
      const buffer = Buffer.alloc(size);
      let fd;
      try {
        fd = fs26.openSync(command2, "r");
        fs26.readSync(fd, buffer, 0, size, 0);
        fs26.closeSync(fd);
      } catch (e3) {
      }
      return shebangCommand(buffer.toString());
    }
    __name(readShebang, "readShebang");
    module3.exports = readShebang;
  }
});

// ../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/parse.js
var require_parse3 = __commonJS({
  "../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/parse.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var path67 = require("path");
    var resolveCommand = require_resolveCommand();
    var escape2 = require_escape();
    var readShebang = require_readShebang();
    var isWin = process.platform === "win32";
    var isExecutableRegExp = /\.(?:com|exe)$/i;
    var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
    function detectShebang(parsed) {
      parsed.file = resolveCommand(parsed);
      const shebang = parsed.file && readShebang(parsed.file);
      if (shebang) {
        parsed.args.unshift(parsed.file);
        parsed.command = shebang;
        return resolveCommand(parsed);
      }
      return parsed.file;
    }
    __name(detectShebang, "detectShebang");
    function parseNonShell(parsed) {
      if (!isWin) {
        return parsed;
      }
      const commandFile = detectShebang(parsed);
      const needsShell = !isExecutableRegExp.test(commandFile);
      if (parsed.options.forceShell || needsShell) {
        const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
        parsed.command = path67.normalize(parsed.command);
        parsed.command = escape2.command(parsed.command);
        parsed.args = parsed.args.map((arg) => escape2.argument(arg, needsDoubleEscapeMetaChars));
        const shellCommand = [parsed.command].concat(parsed.args).join(" ");
        parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
        parsed.command = process.env.comspec || "cmd.exe";
        parsed.options.windowsVerbatimArguments = true;
      }
      return parsed;
    }
    __name(parseNonShell, "parseNonShell");
    function parse7(command2, args, options29) {
      if (args && !Array.isArray(args)) {
        options29 = args;
        args = null;
      }
      args = args ? args.slice(0) : [];
      options29 = Object.assign({}, options29);
      const parsed = {
        command: command2,
        args,
        options: options29,
        file: void 0,
        original: {
          command: command2,
          args
        }
      };
      return options29.shell ? parsed : parseNonShell(parsed);
    }
    __name(parse7, "parse");
    module3.exports = parse7;
  }
});

// ../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/enoent.js
var require_enoent = __commonJS({
  "../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/lib/enoent.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var isWin = process.platform === "win32";
    function notFoundError(original, syscall) {
      return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
        code: "ENOENT",
        errno: "ENOENT",
        syscall: `${syscall} ${original.command}`,
        path: original.command,
        spawnargs: original.args
      });
    }
    __name(notFoundError, "notFoundError");
    function hookChildProcess(cp2, parsed) {
      if (!isWin) {
        return;
      }
      const originalEmit = cp2.emit;
      cp2.emit = function(name, arg1) {
        if (name === "exit") {
          const err = verifyENOENT(arg1, parsed, "spawn");
          if (err) {
            return originalEmit.call(cp2, "error", err);
          }
        }
        return originalEmit.apply(cp2, arguments);
      };
    }
    __name(hookChildProcess, "hookChildProcess");
    function verifyENOENT(status2, parsed) {
      if (isWin && status2 === 1 && !parsed.file) {
        return notFoundError(parsed.original, "spawn");
      }
      return null;
    }
    __name(verifyENOENT, "verifyENOENT");
    function verifyENOENTSync(status2, parsed) {
      if (isWin && status2 === 1 && !parsed.file) {
        return notFoundError(parsed.original, "spawnSync");
      }
      return null;
    }
    __name(verifyENOENTSync, "verifyENOENTSync");
    module3.exports = {
      hookChildProcess,
      verifyENOENT,
      verifyENOENTSync,
      notFoundError
    };
  }
});

// ../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/index.js
var require_cross_spawn = __commonJS({
  "../../node_modules/.pnpm/cross-spawn@7.0.3/node_modules/cross-spawn/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var cp2 = require("child_process");
    var parse7 = require_parse3();
    var enoent = require_enoent();
    function spawn3(command2, args, options29) {
      const parsed = parse7(command2, args, options29);
      const spawned = cp2.spawn(parsed.command, parsed.args, parsed.options);
      enoent.hookChildProcess(spawned, parsed);
      return spawned;
    }
    __name(spawn3, "spawn");
    function spawnSync3(command2, args, options29) {
      const parsed = parse7(command2, args, options29);
      const result = cp2.spawnSync(parsed.command, parsed.args, parsed.options);
      result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
      return result;
    }
    __name(spawnSync3, "spawnSync");
    module3.exports = spawn3;
    module3.exports.spawn = spawn3;
    module3.exports.sync = spawnSync3;
    module3.exports._parse = parse7;
    module3.exports._enoent = enoent;
  }
});

// ../../node_modules/.pnpm/strip-final-newline@3.0.0/node_modules/strip-final-newline/index.js
function stripFinalNewline(input) {
  const LF = typeof input === "string" ? "\n" : "\n".charCodeAt();
  const CR = typeof input === "string" ? "\r" : "\r".charCodeAt();
  if (input[input.length - 1] === LF) {
    input = input.slice(0, -1);
  }
  if (input[input.length - 1] === CR) {
    input = input.slice(0, -1);
  }
  return input;
}
var init_strip_final_newline = __esm({
  "../../node_modules/.pnpm/strip-final-newline@3.0.0/node_modules/strip-final-newline/index.js"() {
    init_import_meta_url();
    __name(stripFinalNewline, "stripFinalNewline");
  }
});

// ../../node_modules/.pnpm/path-key@4.0.0/node_modules/path-key/index.js
function pathKey(options29 = {}) {
  const {
    env: env5 = process.env,
    platform: platform2 = process.platform
  } = options29;
  if (platform2 !== "win32") {
    return "PATH";
  }
  return Object.keys(env5).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
}
var init_path_key = __esm({
  "../../node_modules/.pnpm/path-key@4.0.0/node_modules/path-key/index.js"() {
    init_import_meta_url();
    __name(pathKey, "pathKey");
  }
});

// ../../node_modules/.pnpm/npm-run-path@5.1.0/node_modules/npm-run-path/index.js
function npmRunPath(options29 = {}) {
  const {
    cwd: cwd2 = import_node_process2.default.cwd(),
    path: path_ = import_node_process2.default.env[pathKey()],
    execPath = import_node_process2.default.execPath
  } = options29;
  let previous;
  const cwdString = cwd2 instanceof URL ? import_node_url5.default.fileURLToPath(cwd2) : cwd2;
  let cwdPath = import_node_path12.default.resolve(cwdString);
  const result = [];
  while (previous !== cwdPath) {
    result.push(import_node_path12.default.join(cwdPath, "node_modules/.bin"));
    previous = cwdPath;
    cwdPath = import_node_path12.default.resolve(cwdPath, "..");
  }
  result.push(import_node_path12.default.resolve(cwdString, execPath, ".."));
  return [...result, path_].join(import_node_path12.default.delimiter);
}
function npmRunPathEnv({ env: env5 = import_node_process2.default.env, ...options29 } = {}) {
  env5 = { ...env5 };
  const path67 = pathKey({ env: env5 });
  options29.path = env5[path67];
  env5[path67] = npmRunPath(options29);
  return env5;
}
var import_node_process2, import_node_path12, import_node_url5;
var init_npm_run_path = __esm({
  "../../node_modules/.pnpm/npm-run-path@5.1.0/node_modules/npm-run-path/index.js"() {
    init_import_meta_url();
    import_node_process2 = __toESM(require("node:process"), 1);
    import_node_path12 = __toESM(require("node:path"), 1);
    import_node_url5 = __toESM(require("node:url"), 1);
    init_path_key();
    __name(npmRunPath, "npmRunPath");
    __name(npmRunPathEnv, "npmRunPathEnv");
  }
});

// ../../node_modules/.pnpm/mimic-fn@4.0.0/node_modules/mimic-fn/index.js
function mimicFunction(to, from, { ignoreNonConfigurable = false } = {}) {
  const { name } = to;
  for (const property of Reflect.ownKeys(from)) {
    copyProperty(to, from, property, ignoreNonConfigurable);
  }
  changePrototype(to, from);
  changeToString(to, from, name);
  return to;
}
var copyProperty, canCopyProperty, changePrototype, wrappedToString, toStringDescriptor, toStringName, changeToString;
var init_mimic_fn = __esm({
  "../../node_modules/.pnpm/mimic-fn@4.0.0/node_modules/mimic-fn/index.js"() {
    init_import_meta_url();
    copyProperty = /* @__PURE__ */ __name((to, from, property, ignoreNonConfigurable) => {
      if (property === "length" || property === "prototype") {
        return;
      }
      if (property === "arguments" || property === "caller") {
        return;
      }
      const toDescriptor = Object.getOwnPropertyDescriptor(to, property);
      const fromDescriptor = Object.getOwnPropertyDescriptor(from, property);
      if (!canCopyProperty(toDescriptor, fromDescriptor) && ignoreNonConfigurable) {
        return;
      }
      Object.defineProperty(to, property, fromDescriptor);
    }, "copyProperty");
    canCopyProperty = /* @__PURE__ */ __name(function(toDescriptor, fromDescriptor) {
      return toDescriptor === void 0 || toDescriptor.configurable || toDescriptor.writable === fromDescriptor.writable && toDescriptor.enumerable === fromDescriptor.enumerable && toDescriptor.configurable === fromDescriptor.configurable && (toDescriptor.writable || toDescriptor.value === fromDescriptor.value);
    }, "canCopyProperty");
    changePrototype = /* @__PURE__ */ __name((to, from) => {
      const fromPrototype = Object.getPrototypeOf(from);
      if (fromPrototype === Object.getPrototypeOf(to)) {
        return;
      }
      Object.setPrototypeOf(to, fromPrototype);
    }, "changePrototype");
    wrappedToString = /* @__PURE__ */ __name((withName, fromBody) => `/* Wrapped ${withName}*/
${fromBody}`, "wrappedToString");
    toStringDescriptor = Object.getOwnPropertyDescriptor(Function.prototype, "toString");
    toStringName = Object.getOwnPropertyDescriptor(Function.prototype.toString, "name");
    changeToString = /* @__PURE__ */ __name((to, from, name) => {
      const withName = name === "" ? "" : `with ${name.trim()}() `;
      const newToString = wrappedToString.bind(null, withName, from.toString());
      Object.defineProperty(newToString, "name", toStringName);
      Object.defineProperty(to, "toString", { ...toStringDescriptor, value: newToString });
    }, "changeToString");
    __name(mimicFunction, "mimicFunction");
  }
});

// ../../node_modules/.pnpm/onetime@6.0.0/node_modules/onetime/index.js
var calledFunctions, onetime, onetime_default;
var init_onetime = __esm({
  "../../node_modules/.pnpm/onetime@6.0.0/node_modules/onetime/index.js"() {
    init_import_meta_url();
    init_mimic_fn();
    calledFunctions = /* @__PURE__ */ new WeakMap();
    onetime = /* @__PURE__ */ __name((function_, options29 = {}) => {
      if (typeof function_ !== "function") {
        throw new TypeError("Expected a function");
      }
      let returnValue;
      let callCount = 0;
      const functionName = function_.displayName || function_.name || "<anonymous>";
      const onetime3 = /* @__PURE__ */ __name(function(...arguments_) {
        calledFunctions.set(onetime3, ++callCount);
        if (callCount === 1) {
          returnValue = function_.apply(this, arguments_);
          function_ = null;
        } else if (options29.throw === true) {
          throw new Error(`Function \`${functionName}\` can only be called once`);
        }
        return returnValue;
      }, "onetime");
      mimicFunction(onetime3, function_);
      calledFunctions.set(onetime3, callCount);
      return onetime3;
    }, "onetime");
    onetime.callCount = (function_) => {
      if (!calledFunctions.has(function_)) {
        throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
      }
      return calledFunctions.get(function_);
    };
    onetime_default = onetime;
  }
});

// ../../node_modules/.pnpm/human-signals@3.0.1/node_modules/human-signals/build/src/realtime.js
var getRealtimeSignals, getRealtimeSignal, SIGRTMIN, SIGRTMAX;
var init_realtime = __esm({
  "../../node_modules/.pnpm/human-signals@3.0.1/node_modules/human-signals/build/src/realtime.js"() {
    init_import_meta_url();
    getRealtimeSignals = /* @__PURE__ */ __name(function() {
      const length = SIGRTMAX - SIGRTMIN + 1;
      return Array.from({ length }, getRealtimeSignal);
    }, "getRealtimeSignals");
    getRealtimeSignal = /* @__PURE__ */ __name(function(value, index) {
      return {
        name: `SIGRT${index + 1}`,
        number: SIGRTMIN + index,
        action: "terminate",
        description: "Application-specific signal (realtime)",
        standard: "posix"
      };
    }, "getRealtimeSignal");
    SIGRTMIN = 34;
    SIGRTMAX = 64;
  }
});

// ../../node_modules/.pnpm/human-signals@3.0.1/node_modules/human-signals/build/src/core.js
var SIGNALS;
var init_core = __esm({
  "../../node_modules/.pnpm/human-signals@3.0.1/node_modules/human-signals/build/src/core.js"() {
    init_import_meta_url();
    SIGNALS = [
      {
        name: "SIGHUP",
        number: 1,
        action: "terminate",
        description: "Terminal closed",
        standard: "posix"
      },
      {
        name: "SIGINT",
        number: 2,
        action: "terminate",
        description: "User interruption with CTRL-C",
        standard: "ansi"
      },
      {
        name: "SIGQUIT",
        number: 3,
        action: "core",
        description: "User interruption with CTRL-\\",
        standard: "posix"
      },
      {
        name: "SIGILL",
        number: 4,
        action: "core",
        description: "Invalid machine instruction",
        standard: "ansi"
      },
      {
        name: "SIGTRAP",
        number: 5,
        action: "core",
        description: "Debugger breakpoint",
        standard: "posix"
      },
      {
        name: "SIGABRT",
        number: 6,
        action: "core",
        description: "Aborted",
        standard: "ansi"
      },
      {
        name: "SIGIOT",
        number: 6,
        action: "core",
        description: "Aborted",
        standard: "bsd"
      },
      {
        name: "SIGBUS",
        number: 7,
        action: "core",
        description: "Bus error due to misaligned, non-existing address or paging error",
        standard: "bsd"
      },
      {
        name: "SIGEMT",
        number: 7,
        action: "terminate",
        description: "Command should be emulated but is not implemented",
        standard: "other"
      },
      {
        name: "SIGFPE",
        number: 8,
        action: "core",
        description: "Floating point arithmetic error",
        standard: "ansi"
      },
      {
        name: "SIGKILL",
        number: 9,
        action: "terminate",
        description: "Forced termination",
        standard: "posix",
        forced: true
      },
      {
        name: "SIGUSR1",
        number: 10,
        action: "terminate",
        description: "Application-specific signal",
        standard: "posix"
      },
      {
        name: "SIGSEGV",
        number: 11,
        action: "core",
        description: "Segmentation fault",
        standard: "ansi"
      },
      {
        name: "SIGUSR2",
        number: 12,
        action: "terminate",
        description: "Application-specific signal",
        standard: "posix"
      },
      {
        name: "SIGPIPE",
        number: 13,
        action: "terminate",
        description: "Broken pipe or socket",
        standard: "posix"
      },
      {
        name: "SIGALRM",
        number: 14,
        action: "terminate",
        description: "Timeout or timer",
        standard: "posix"
      },
      {
        name: "SIGTERM",
        number: 15,
        action: "terminate",
        description: "Termination",
        standard: "ansi"
      },
      {
        name: "SIGSTKFLT",
        number: 16,
        action: "terminate",
        description: "Stack is empty or overflowed",
        standard: "other"
      },
      {
        name: "SIGCHLD",
        number: 17,
        action: "ignore",
        description: "Child process terminated, paused or unpaused",
        standard: "posix"
      },
      {
        name: "SIGCLD",
        number: 17,
        action: "ignore",
        description: "Child process terminated, paused or unpaused",
        standard: "other"
      },
      {
        name: "SIGCONT",
        number: 18,
        action: "unpause",
        description: "Unpaused",
        standard: "posix",
        forced: true
      },
      {
        name: "SIGSTOP",
        number: 19,
        action: "pause",
        description: "Paused",
        standard: "posix",
        forced: true
      },
      {
        name: "SIGTSTP",
        number: 20,
        action: "pause",
        description: 'Paused using CTRL-Z or "suspend"',
        standard: "posix"
      },
      {
        name: "SIGTTIN",
        number: 21,
        action: "pause",
        description: "Background process cannot read terminal input",
        standard: "posix"
      },
      {
        name: "SIGBREAK",
        number: 21,
        action: "terminate",
        description: "User interruption with CTRL-BREAK",
        standard: "other"
      },
      {
        name: "SIGTTOU",
        number: 22,
        action: "pause",
        description: "Background process cannot write to terminal output",
        standard: "posix"
      },
      {
        name: "SIGURG",
        number: 23,
        action: "ignore",
        description: "Socket received out-of-band data",
        standard: "bsd"
      },
      {
        name: "SIGXCPU",
        number: 24,
        action: "core",
        description: "Process timed out",
        standard: "bsd"
      },
      {
        name: "SIGXFSZ",
        number: 25,
        action: "core",
        description: "File too big",
        standard: "bsd"
      },
      {
        name: "SIGVTALRM",
        number: 26,
        action: "terminate",
        description: "Timeout or timer",
        standard: "bsd"
      },
      {
        name: "SIGPROF",
        number: 27,
        action: "terminate",
        description: "Timeout or timer",
        standard: "bsd"
      },
      {
        name: "SIGWINCH",
        number: 28,
        action: "ignore",
        description: "Terminal window size changed",
        standard: "bsd"
      },
      {
        name: "SIGIO",
        number: 29,
        action: "terminate",
        description: "I/O is available",
        standard: "other"
      },
      {
        name: "SIGPOLL",
        number: 29,
        action: "terminate",
        description: "Watched event",
        standard: "other"
      },
      {
        name: "SIGINFO",
        number: 29,
        action: "ignore",
        description: "Request for process information",
        standard: "other"
      },
      {
        name: "SIGPWR",
        number: 30,
        action: "terminate",
        description: "Device running out of power",
        standard: "systemv"
      },
      {
        name: "SIGSYS",
        number: 31,
        action: "core",
        description: "Invalid system call",
        standard: "other"
      },
      {
        name: "SIGUNUSED",
        number: 31,
        action: "terminate",
        description: "Invalid system call",
        standard: "other"
      }
    ];
  }
});

// ../../node_modules/.pnpm/human-signals@3.0.1/node_modules/human-signals/build/src/signals.js
var import_os, getSignals, normalizeSignal;
var init_signals = __esm({
  "../../node_modules/.pnpm/human-signals@3.0.1/node_modules/human-signals/build/src/signals.js"() {
    init_import_meta_url();
    import_os = require("os");
    init_core();
    init_realtime();
    getSignals = /* @__PURE__ */ __name(function() {
      const realtimeSignals = getRealtimeSignals();
      const signals = [...SIGNALS, ...realtimeSignals].map(normalizeSignal);
      return signals;
    }, "getSignals");
    normalizeSignal = /* @__PURE__ */ __name(function({
      name,
      number: defaultNumber,
      description,
      action,
      forced = false,
      standard
    }) {
      const {
        signals: { [name]: constantSignal }
      } = import_os.constants;
      const supported = constantSignal !== void 0;
      const number = supported ? constantSignal : defaultNumber;
      return { name, number, description, supported, action, forced, standard };
    }, "normalizeSignal");
  }
});

// ../../node_modules/.pnpm/human-signals@3.0.1/node_modules/human-signals/build/src/main.js
var import_os2, getSignalsByName, getSignalByName, signalsByName, getSignalsByNumber, getSignalByNumber, findSignalByNumber, signalsByNumber;
var init_main = __esm({
  "../../node_modules/.pnpm/human-signals@3.0.1/node_modules/human-signals/build/src/main.js"() {
    init_import_meta_url();
    import_os2 = require("os");
    init_realtime();
    init_signals();
    getSignalsByName = /* @__PURE__ */ __name(function() {
      const signals = getSignals();
      return signals.reduce(getSignalByName, {});
    }, "getSignalsByName");
    getSignalByName = /* @__PURE__ */ __name(function(signalByNameMemo, { name, number, description, supported, action, forced, standard }) {
      return {
        ...signalByNameMemo,
        [name]: { name, number, description, supported, action, forced, standard }
      };
    }, "getSignalByName");
    signalsByName = getSignalsByName();
    getSignalsByNumber = /* @__PURE__ */ __name(function() {
      const signals = getSignals();
      const length = SIGRTMAX + 1;
      const signalsA = Array.from({ length }, (value, number) => getSignalByNumber(number, signals));
      return Object.assign({}, ...signalsA);
    }, "getSignalsByNumber");
    getSignalByNumber = /* @__PURE__ */ __name(function(number, signals) {
      const signal = findSignalByNumber(number, signals);
      if (signal === void 0) {
        return {};
      }
      const { name, description, supported, action, forced, standard } = signal;
      return {
        [number]: {
          name,
          number,
          description,
          supported,
          action,
          forced,
          standard
        }
      };
    }, "getSignalByNumber");
    findSignalByNumber = /* @__PURE__ */ __name(function(number, signals) {
      const signal = signals.find(({ name }) => import_os2.constants.signals[name] === number);
      if (signal !== void 0) {
        return signal;
      }
      return signals.find((signalA) => signalA.number === number);
    }, "findSignalByNumber");
    signalsByNumber = getSignalsByNumber();
  }
});

// ../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/lib/error.js
var getErrorPrefix, makeError;
var init_error = __esm({
  "../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/lib/error.js"() {
    init_import_meta_url();
    init_main();
    getErrorPrefix = /* @__PURE__ */ __name(({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled }) => {
      if (timedOut) {
        return `timed out after ${timeout} milliseconds`;
      }
      if (isCanceled) {
        return "was canceled";
      }
      if (errorCode !== void 0) {
        return `failed with ${errorCode}`;
      }
      if (signal !== void 0) {
        return `was killed with ${signal} (${signalDescription})`;
      }
      if (exitCode !== void 0) {
        return `failed with exit code ${exitCode}`;
      }
      return "failed";
    }, "getErrorPrefix");
    makeError = /* @__PURE__ */ __name(({
      stdout: stdout2,
      stderr: stderr2,
      all: all2,
      error: error2,
      signal,
      exitCode,
      command: command2,
      escapedCommand,
      timedOut,
      isCanceled,
      killed,
      parsed: { options: { timeout } }
    }) => {
      exitCode = exitCode === null ? void 0 : exitCode;
      signal = signal === null ? void 0 : signal;
      const signalDescription = signal === void 0 ? void 0 : signalsByName[signal].description;
      const errorCode = error2 && error2.code;
      const prefix = getErrorPrefix({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled });
      const execaMessage = `Command ${prefix}: ${command2}`;
      const isError2 = Object.prototype.toString.call(error2) === "[object Error]";
      const shortMessage = isError2 ? `${execaMessage}
${error2.message}` : execaMessage;
      const message = [shortMessage, stderr2, stdout2].filter(Boolean).join("\n");
      if (isError2) {
        error2.originalMessage = error2.message;
        error2.message = message;
      } else {
        error2 = new Error(message);
      }
      error2.shortMessage = shortMessage;
      error2.command = command2;
      error2.escapedCommand = escapedCommand;
      error2.exitCode = exitCode;
      error2.signal = signal;
      error2.signalDescription = signalDescription;
      error2.stdout = stdout2;
      error2.stderr = stderr2;
      if (all2 !== void 0) {
        error2.all = all2;
      }
      if ("bufferedData" in error2) {
        delete error2.bufferedData;
      }
      error2.failed = true;
      error2.timedOut = Boolean(timedOut);
      error2.isCanceled = isCanceled;
      error2.killed = killed && !timedOut;
      return error2;
    }, "makeError");
  }
});

// ../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/lib/stdio.js
var aliases, hasAlias, normalizeStdio;
var init_stdio = __esm({
  "../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/lib/stdio.js"() {
    init_import_meta_url();
    aliases = ["stdin", "stdout", "stderr"];
    hasAlias = /* @__PURE__ */ __name((options29) => aliases.some((alias) => options29[alias] !== void 0), "hasAlias");
    normalizeStdio = /* @__PURE__ */ __name((options29) => {
      if (!options29) {
        return;
      }
      const { stdio } = options29;
      if (stdio === void 0) {
        return aliases.map((alias) => options29[alias]);
      }
      if (hasAlias(options29)) {
        throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${aliases.map((alias) => `\`${alias}\``).join(", ")}`);
      }
      if (typeof stdio === "string") {
        return stdio;
      }
      if (!Array.isArray(stdio)) {
        throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof stdio}\``);
      }
      const length = Math.max(stdio.length, aliases.length);
      return Array.from({ length }, (value, index) => stdio[index]);
    }, "normalizeStdio");
  }
});

// ../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/lib/kill.js
var import_node_os3, import_signal_exit3, DEFAULT_FORCE_KILL_TIMEOUT, spawnedKill, setKillTimeout, shouldForceKill, isSigterm, getForceKillAfterTimeout, spawnedCancel, timeoutKill, setupTimeout, validateTimeout, setExitHandler;
var init_kill = __esm({
  "../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/lib/kill.js"() {
    init_import_meta_url();
    import_node_os3 = __toESM(require("node:os"), 1);
    import_signal_exit3 = __toESM(require_signal_exit(), 1);
    DEFAULT_FORCE_KILL_TIMEOUT = 1e3 * 5;
    spawnedKill = /* @__PURE__ */ __name((kill, signal = "SIGTERM", options29 = {}) => {
      const killResult = kill(signal);
      setKillTimeout(kill, signal, options29, killResult);
      return killResult;
    }, "spawnedKill");
    setKillTimeout = /* @__PURE__ */ __name((kill, signal, options29, killResult) => {
      if (!shouldForceKill(signal, options29, killResult)) {
        return;
      }
      const timeout = getForceKillAfterTimeout(options29);
      const t3 = setTimeout(() => {
        kill("SIGKILL");
      }, timeout);
      if (t3.unref) {
        t3.unref();
      }
    }, "setKillTimeout");
    shouldForceKill = /* @__PURE__ */ __name((signal, { forceKillAfterTimeout }, killResult) => isSigterm(signal) && forceKillAfterTimeout !== false && killResult, "shouldForceKill");
    isSigterm = /* @__PURE__ */ __name((signal) => signal === import_node_os3.default.constants.signals.SIGTERM || typeof signal === "string" && signal.toUpperCase() === "SIGTERM", "isSigterm");
    getForceKillAfterTimeout = /* @__PURE__ */ __name(({ forceKillAfterTimeout = true }) => {
      if (forceKillAfterTimeout === true) {
        return DEFAULT_FORCE_KILL_TIMEOUT;
      }
      if (!Number.isFinite(forceKillAfterTimeout) || forceKillAfterTimeout < 0) {
        throw new TypeError(`Expected the \`forceKillAfterTimeout\` option to be a non-negative integer, got \`${forceKillAfterTimeout}\` (${typeof forceKillAfterTimeout})`);
      }
      return forceKillAfterTimeout;
    }, "getForceKillAfterTimeout");
    spawnedCancel = /* @__PURE__ */ __name((spawned, context2) => {
      const killResult = spawned.kill();
      if (killResult) {
        context2.isCanceled = true;
      }
    }, "spawnedCancel");
    timeoutKill = /* @__PURE__ */ __name((spawned, signal, reject) => {
      spawned.kill(signal);
      reject(Object.assign(new Error("Timed out"), { timedOut: true, signal }));
    }, "timeoutKill");
    setupTimeout = /* @__PURE__ */ __name((spawned, { timeout, killSignal = "SIGTERM" }, spawnedPromise) => {
      if (timeout === 0 || timeout === void 0) {
        return spawnedPromise;
      }
      let timeoutId;
      const timeoutPromise = new Promise((resolve19, reject) => {
        timeoutId = setTimeout(() => {
          timeoutKill(spawned, killSignal, reject);
        }, timeout);
      });
      const safeSpawnedPromise = spawnedPromise.finally(() => {
        clearTimeout(timeoutId);
      });
      return Promise.race([timeoutPromise, safeSpawnedPromise]);
    }, "setupTimeout");
    validateTimeout = /* @__PURE__ */ __name(({ timeout }) => {
      if (timeout !== void 0 && (!Number.isFinite(timeout) || timeout < 0)) {
        throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
      }
    }, "validateTimeout");
    setExitHandler = /* @__PURE__ */ __name(async (spawned, { cleanup, detached }, timedPromise) => {
      if (!cleanup || detached) {
        return timedPromise;
      }
      const removeExitHandler = (0, import_signal_exit3.default)(() => {
        spawned.kill();
      });
      return timedPromise.finally(() => {
        removeExitHandler();
      });
    }, "setExitHandler");
  }
});

// ../../node_modules/.pnpm/is-stream@3.0.0/node_modules/is-stream/index.js
function isStream(stream2) {
  return stream2 !== null && typeof stream2 === "object" && typeof stream2.pipe === "function";
}
var init_is_stream = __esm({
  "../../node_modules/.pnpm/is-stream@3.0.0/node_modules/is-stream/index.js"() {
    init_import_meta_url();
    __name(isStream, "isStream");
  }
});

// ../../node_modules/.pnpm/get-stream@6.0.1/node_modules/get-stream/buffer-stream.js
var require_buffer_stream = __commonJS({
  "../../node_modules/.pnpm/get-stream@6.0.1/node_modules/get-stream/buffer-stream.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { PassThrough: PassThroughStream } = require("stream");
    module3.exports = (options29) => {
      options29 = { ...options29 };
      const { array } = options29;
      let { encoding } = options29;
      const isBuffer = encoding === "buffer";
      let objectMode = false;
      if (array) {
        objectMode = !(encoding || isBuffer);
      } else {
        encoding = encoding || "utf8";
      }
      if (isBuffer) {
        encoding = null;
      }
      const stream2 = new PassThroughStream({ objectMode });
      if (encoding) {
        stream2.setEncoding(encoding);
      }
      let length = 0;
      const chunks = [];
      stream2.on("data", (chunk) => {
        chunks.push(chunk);
        if (objectMode) {
          length = chunks.length;
        } else {
          length += chunk.length;
        }
      });
      stream2.getBufferedValue = () => {
        if (array) {
          return chunks;
        }
        return isBuffer ? Buffer.concat(chunks, length) : chunks.join("");
      };
      stream2.getBufferedLength = () => length;
      return stream2;
    };
  }
});

// ../../node_modules/.pnpm/get-stream@6.0.1/node_modules/get-stream/index.js
var require_get_stream = __commonJS({
  "../../node_modules/.pnpm/get-stream@6.0.1/node_modules/get-stream/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { constants: BufferConstants } = require("buffer");
    var stream2 = require("stream");
    var { promisify: promisify2 } = require("util");
    var bufferStream = require_buffer_stream();
    var streamPipelinePromisified = promisify2(stream2.pipeline);
    var MaxBufferError = class extends Error {
      constructor() {
        super("maxBuffer exceeded");
        this.name = "MaxBufferError";
      }
    };
    __name(MaxBufferError, "MaxBufferError");
    async function getStream2(inputStream, options29) {
      if (!inputStream) {
        throw new Error("Expected a stream");
      }
      options29 = {
        maxBuffer: Infinity,
        ...options29
      };
      const { maxBuffer } = options29;
      const stream3 = bufferStream(options29);
      await new Promise((resolve19, reject) => {
        const rejectPromise = /* @__PURE__ */ __name((error2) => {
          if (error2 && stream3.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
            error2.bufferedData = stream3.getBufferedValue();
          }
          reject(error2);
        }, "rejectPromise");
        (async () => {
          try {
            await streamPipelinePromisified(inputStream, stream3);
            resolve19();
          } catch (error2) {
            rejectPromise(error2);
          }
        })();
        stream3.on("data", () => {
          if (stream3.getBufferedLength() > maxBuffer) {
            rejectPromise(new MaxBufferError());
          }
        });
      });
      return stream3.getBufferedValue();
    }
    __name(getStream2, "getStream");
    module3.exports = getStream2;
    module3.exports.buffer = (stream3, options29) => getStream2(stream3, { ...options29, encoding: "buffer" });
    module3.exports.array = (stream3, options29) => getStream2(stream3, { ...options29, array: true });
    module3.exports.MaxBufferError = MaxBufferError;
  }
});

// ../../node_modules/.pnpm/merge-stream@2.0.0/node_modules/merge-stream/index.js
var require_merge_stream = __commonJS({
  "../../node_modules/.pnpm/merge-stream@2.0.0/node_modules/merge-stream/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { PassThrough } = require("stream");
    module3.exports = function() {
      var sources = [];
      var output = new PassThrough({ objectMode: true });
      output.setMaxListeners(0);
      output.add = add;
      output.isEmpty = isEmpty;
      output.on("unpipe", remove);
      Array.prototype.slice.call(arguments).forEach(add);
      return output;
      function add(source) {
        if (Array.isArray(source)) {
          source.forEach(add);
          return this;
        }
        sources.push(source);
        source.once("end", remove.bind(null, source));
        source.once("error", output.emit.bind(output, "error"));
        source.pipe(output, { end: false });
        return this;
      }
      __name(add, "add");
      function isEmpty() {
        return sources.length == 0;
      }
      __name(isEmpty, "isEmpty");
      function remove(source) {
        sources = sources.filter(function(it2) {
          return it2 !== source;
        });
        if (!sources.length && output.readable) {
          output.end();
        }
      }
      __name(remove, "remove");
    };
  }
});

// ../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/lib/stream.js
var import_get_stream, import_merge_stream, handleInput, makeAllStream, getBufferedData, getStreamPromise, getSpawnedResult, validateInputSync;
var init_stream = __esm({
  "../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/lib/stream.js"() {
    init_import_meta_url();
    init_is_stream();
    import_get_stream = __toESM(require_get_stream(), 1);
    import_merge_stream = __toESM(require_merge_stream(), 1);
    handleInput = /* @__PURE__ */ __name((spawned, input) => {
      if (input === void 0 || spawned.stdin === void 0) {
        return;
      }
      if (isStream(input)) {
        input.pipe(spawned.stdin);
      } else {
        spawned.stdin.end(input);
      }
    }, "handleInput");
    makeAllStream = /* @__PURE__ */ __name((spawned, { all: all2 }) => {
      if (!all2 || !spawned.stdout && !spawned.stderr) {
        return;
      }
      const mixed = (0, import_merge_stream.default)();
      if (spawned.stdout) {
        mixed.add(spawned.stdout);
      }
      if (spawned.stderr) {
        mixed.add(spawned.stderr);
      }
      return mixed;
    }, "makeAllStream");
    getBufferedData = /* @__PURE__ */ __name(async (stream2, streamPromise) => {
      if (!stream2) {
        return;
      }
      stream2.destroy();
      try {
        return await streamPromise;
      } catch (error2) {
        return error2.bufferedData;
      }
    }, "getBufferedData");
    getStreamPromise = /* @__PURE__ */ __name((stream2, { encoding, buffer, maxBuffer }) => {
      if (!stream2 || !buffer) {
        return;
      }
      if (encoding) {
        return (0, import_get_stream.default)(stream2, { encoding, maxBuffer });
      }
      return import_get_stream.default.buffer(stream2, { maxBuffer });
    }, "getStreamPromise");
    getSpawnedResult = /* @__PURE__ */ __name(async ({ stdout: stdout2, stderr: stderr2, all: all2 }, { encoding, buffer, maxBuffer }, processDone) => {
      const stdoutPromise = getStreamPromise(stdout2, { encoding, buffer, maxBuffer });
      const stderrPromise = getStreamPromise(stderr2, { encoding, buffer, maxBuffer });
      const allPromise = getStreamPromise(all2, { encoding, buffer, maxBuffer: maxBuffer * 2 });
      try {
        return await Promise.all([processDone, stdoutPromise, stderrPromise, allPromise]);
      } catch (error2) {
        return Promise.all([
          { error: error2, signal: error2.signal, timedOut: error2.timedOut },
          getBufferedData(stdout2, stdoutPromise),
          getBufferedData(stderr2, stderrPromise),
          getBufferedData(all2, allPromise)
        ]);
      }
    }, "getSpawnedResult");
    validateInputSync = /* @__PURE__ */ __name(({ input }) => {
      if (isStream(input)) {
        throw new TypeError("The `input` option cannot be a stream in sync mode");
      }
    }, "validateInputSync");
  }
});

// ../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/lib/promise.js
var nativePromisePrototype, descriptors, mergePromise, getSpawnedPromise;
var init_promise = __esm({
  "../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/lib/promise.js"() {
    init_import_meta_url();
    nativePromisePrototype = (async () => {
    })().constructor.prototype;
    descriptors = ["then", "catch", "finally"].map((property) => [
      property,
      Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property)
    ]);
    mergePromise = /* @__PURE__ */ __name((spawned, promise) => {
      for (const [property, descriptor2] of descriptors) {
        const value = typeof promise === "function" ? (...args) => Reflect.apply(descriptor2.value, promise(), args) : descriptor2.value.bind(promise);
        Reflect.defineProperty(spawned, property, { ...descriptor2, value });
      }
      return spawned;
    }, "mergePromise");
    getSpawnedPromise = /* @__PURE__ */ __name((spawned) => new Promise((resolve19, reject) => {
      spawned.on("exit", (exitCode, signal) => {
        resolve19({ exitCode, signal });
      });
      spawned.on("error", (error2) => {
        reject(error2);
      });
      if (spawned.stdin) {
        spawned.stdin.on("error", (error2) => {
          reject(error2);
        });
      }
    }), "getSpawnedPromise");
  }
});

// ../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/lib/command.js
var normalizeArgs, NO_ESCAPE_REGEXP, DOUBLE_QUOTES_REGEXP, escapeArg, joinCommand, getEscapedCommand, SPACES_REGEXP, parseCommand;
var init_command = __esm({
  "../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/lib/command.js"() {
    init_import_meta_url();
    normalizeArgs = /* @__PURE__ */ __name((file, args = []) => {
      if (!Array.isArray(args)) {
        return [file];
      }
      return [file, ...args];
    }, "normalizeArgs");
    NO_ESCAPE_REGEXP = /^[\w.-]+$/;
    DOUBLE_QUOTES_REGEXP = /"/g;
    escapeArg = /* @__PURE__ */ __name((arg) => {
      if (typeof arg !== "string" || NO_ESCAPE_REGEXP.test(arg)) {
        return arg;
      }
      return `"${arg.replace(DOUBLE_QUOTES_REGEXP, '\\"')}"`;
    }, "escapeArg");
    joinCommand = /* @__PURE__ */ __name((file, args) => normalizeArgs(file, args).join(" "), "joinCommand");
    getEscapedCommand = /* @__PURE__ */ __name((file, args) => normalizeArgs(file, args).map((arg) => escapeArg(arg)).join(" "), "getEscapedCommand");
    SPACES_REGEXP = / +/g;
    parseCommand = /* @__PURE__ */ __name((command2) => {
      const tokens = [];
      for (const token of command2.trim().split(SPACES_REGEXP)) {
        const previousToken = tokens[tokens.length - 1];
        if (previousToken && previousToken.endsWith("\\")) {
          tokens[tokens.length - 1] = `${previousToken.slice(0, -1)} ${token}`;
        } else {
          tokens.push(token);
        }
      }
      return tokens;
    }, "parseCommand");
  }
});

// ../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/index.js
function execa(file, args, options29) {
  const parsed = handleArguments(file, args, options29);
  const command2 = joinCommand(file, args);
  const escapedCommand = getEscapedCommand(file, args);
  validateTimeout(parsed.options);
  let spawned;
  try {
    spawned = import_node_child_process.default.spawn(parsed.file, parsed.args, parsed.options);
  } catch (error2) {
    const dummySpawned = new import_node_child_process.default.ChildProcess();
    const errorPromise = Promise.reject(makeError({
      error: error2,
      stdout: "",
      stderr: "",
      all: "",
      command: command2,
      escapedCommand,
      parsed,
      timedOut: false,
      isCanceled: false,
      killed: false
    }));
    return mergePromise(dummySpawned, errorPromise);
  }
  const spawnedPromise = getSpawnedPromise(spawned);
  const timedPromise = setupTimeout(spawned, parsed.options, spawnedPromise);
  const processDone = setExitHandler(spawned, parsed.options, timedPromise);
  const context2 = { isCanceled: false };
  spawned.kill = spawnedKill.bind(null, spawned.kill.bind(spawned));
  spawned.cancel = spawnedCancel.bind(null, spawned, context2);
  const handlePromise = /* @__PURE__ */ __name(async () => {
    const [{ error: error2, exitCode, signal, timedOut }, stdoutResult, stderrResult, allResult] = await getSpawnedResult(spawned, parsed.options, processDone);
    const stdout2 = handleOutput(parsed.options, stdoutResult);
    const stderr2 = handleOutput(parsed.options, stderrResult);
    const all2 = handleOutput(parsed.options, allResult);
    if (error2 || exitCode !== 0 || signal !== null) {
      const returnedError = makeError({
        error: error2,
        exitCode,
        signal,
        stdout: stdout2,
        stderr: stderr2,
        all: all2,
        command: command2,
        escapedCommand,
        parsed,
        timedOut,
        isCanceled: context2.isCanceled || (parsed.options.signal ? parsed.options.signal.aborted : false),
        killed: spawned.killed
      });
      if (!parsed.options.reject) {
        return returnedError;
      }
      throw returnedError;
    }
    return {
      command: command2,
      escapedCommand,
      exitCode: 0,
      stdout: stdout2,
      stderr: stderr2,
      all: all2,
      failed: false,
      timedOut: false,
      isCanceled: false,
      killed: false
    };
  }, "handlePromise");
  const handlePromiseOnce = onetime_default(handlePromise);
  handleInput(spawned, parsed.options.input);
  spawned.all = makeAllStream(spawned, parsed.options);
  return mergePromise(spawned, handlePromiseOnce);
}
function execaSync(file, args, options29) {
  const parsed = handleArguments(file, args, options29);
  const command2 = joinCommand(file, args);
  const escapedCommand = getEscapedCommand(file, args);
  validateInputSync(parsed.options);
  let result;
  try {
    result = import_node_child_process.default.spawnSync(parsed.file, parsed.args, parsed.options);
  } catch (error2) {
    throw makeError({
      error: error2,
      stdout: "",
      stderr: "",
      all: "",
      command: command2,
      escapedCommand,
      parsed,
      timedOut: false,
      isCanceled: false,
      killed: false
    });
  }
  const stdout2 = handleOutput(parsed.options, result.stdout, result.error);
  const stderr2 = handleOutput(parsed.options, result.stderr, result.error);
  if (result.error || result.status !== 0 || result.signal !== null) {
    const error2 = makeError({
      stdout: stdout2,
      stderr: stderr2,
      error: result.error,
      signal: result.signal,
      exitCode: result.status,
      command: command2,
      escapedCommand,
      parsed,
      timedOut: result.error && result.error.code === "ETIMEDOUT",
      isCanceled: false,
      killed: result.signal !== null
    });
    if (!parsed.options.reject) {
      return error2;
    }
    throw error2;
  }
  return {
    command: command2,
    escapedCommand,
    exitCode: 0,
    stdout: stdout2,
    stderr: stderr2,
    failed: false,
    timedOut: false,
    isCanceled: false,
    killed: false
  };
}
function execaCommand(command2, options29) {
  const [file, ...args] = parseCommand(command2);
  return execa(file, args, options29);
}
function execaCommandSync(command2, options29) {
  const [file, ...args] = parseCommand(command2);
  return execaSync(file, args, options29);
}
var import_node_buffer, import_node_path13, import_node_child_process, import_node_process3, import_cross_spawn, DEFAULT_MAX_BUFFER, getEnv, handleArguments, handleOutput;
var init_execa = __esm({
  "../../node_modules/.pnpm/execa@6.1.0/node_modules/execa/index.js"() {
    init_import_meta_url();
    import_node_buffer = require("node:buffer");
    import_node_path13 = __toESM(require("node:path"), 1);
    import_node_child_process = __toESM(require("node:child_process"), 1);
    import_node_process3 = __toESM(require("node:process"), 1);
    import_cross_spawn = __toESM(require_cross_spawn(), 1);
    init_strip_final_newline();
    init_npm_run_path();
    init_onetime();
    init_error();
    init_stdio();
    init_kill();
    init_stream();
    init_promise();
    init_command();
    DEFAULT_MAX_BUFFER = 1e3 * 1e3 * 100;
    getEnv = /* @__PURE__ */ __name(({ env: envOption, extendEnv, preferLocal, localDir, execPath }) => {
      const env5 = extendEnv ? { ...import_node_process3.default.env, ...envOption } : envOption;
      if (preferLocal) {
        return npmRunPathEnv({ env: env5, cwd: localDir, execPath });
      }
      return env5;
    }, "getEnv");
    handleArguments = /* @__PURE__ */ __name((file, args, options29 = {}) => {
      const parsed = import_cross_spawn.default._parse(file, args, options29);
      file = parsed.command;
      args = parsed.args;
      options29 = parsed.options;
      options29 = {
        maxBuffer: DEFAULT_MAX_BUFFER,
        buffer: true,
        stripFinalNewline: true,
        extendEnv: true,
        preferLocal: false,
        localDir: options29.cwd || import_node_process3.default.cwd(),
        execPath: import_node_process3.default.execPath,
        encoding: "utf8",
        reject: true,
        cleanup: true,
        all: false,
        windowsHide: true,
        ...options29
      };
      options29.env = getEnv(options29);
      options29.stdio = normalizeStdio(options29);
      if (import_node_process3.default.platform === "win32" && import_node_path13.default.basename(file, ".exe") === "cmd") {
        args.unshift("/q");
      }
      return { file, args, options: options29, parsed };
    }, "handleArguments");
    handleOutput = /* @__PURE__ */ __name((options29, value, error2) => {
      if (typeof value !== "string" && !import_node_buffer.Buffer.isBuffer(value)) {
        return error2 === void 0 ? void 0 : "";
      }
      if (options29.stripFinalNewline) {
        return stripFinalNewline(value);
      }
      return value;
    }, "handleOutput");
    __name(execa, "execa");
    __name(execaSync, "execaSync");
    __name(execaCommand, "execaCommand");
    __name(execaCommandSync, "execaCommandSync");
  }
});

// ../../node_modules/.pnpm/strip-final-newline@2.0.0/node_modules/strip-final-newline/index.js
var require_strip_final_newline = __commonJS({
  "../../node_modules/.pnpm/strip-final-newline@2.0.0/node_modules/strip-final-newline/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = (input) => {
      const LF = typeof input === "string" ? "\n" : "\n".charCodeAt();
      const CR = typeof input === "string" ? "\r" : "\r".charCodeAt();
      if (input[input.length - 1] === LF) {
        input = input.slice(0, input.length - 1);
      }
      if (input[input.length - 1] === CR) {
        input = input.slice(0, input.length - 1);
      }
      return input;
    };
  }
});

// ../../node_modules/.pnpm/npm-run-path@4.0.1/node_modules/npm-run-path/index.js
var require_npm_run_path = __commonJS({
  "../../node_modules/.pnpm/npm-run-path@4.0.1/node_modules/npm-run-path/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var path67 = require("path");
    var pathKey2 = require_path_key();
    var npmRunPath2 = /* @__PURE__ */ __name((options29) => {
      options29 = {
        cwd: process.cwd(),
        path: process.env[pathKey2()],
        execPath: process.execPath,
        ...options29
      };
      let previous;
      let cwdPath = path67.resolve(options29.cwd);
      const result = [];
      while (previous !== cwdPath) {
        result.push(path67.join(cwdPath, "node_modules/.bin"));
        previous = cwdPath;
        cwdPath = path67.resolve(cwdPath, "..");
      }
      const execPathDir = path67.resolve(options29.cwd, options29.execPath, "..");
      result.push(execPathDir);
      return result.concat(options29.path).join(path67.delimiter);
    }, "npmRunPath");
    module3.exports = npmRunPath2;
    module3.exports.default = npmRunPath2;
    module3.exports.env = (options29) => {
      options29 = {
        env: process.env,
        ...options29
      };
      const env5 = { ...options29.env };
      const path68 = pathKey2({ env: env5 });
      options29.path = env5[path68];
      env5[path68] = module3.exports(options29);
      return env5;
    };
  }
});

// ../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/core.js
var require_core4 = __commonJS({
  "../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/core.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.SIGNALS = void 0;
    var SIGNALS2 = [
      {
        name: "SIGHUP",
        number: 1,
        action: "terminate",
        description: "Terminal closed",
        standard: "posix"
      },
      {
        name: "SIGINT",
        number: 2,
        action: "terminate",
        description: "User interruption with CTRL-C",
        standard: "ansi"
      },
      {
        name: "SIGQUIT",
        number: 3,
        action: "core",
        description: "User interruption with CTRL-\\",
        standard: "posix"
      },
      {
        name: "SIGILL",
        number: 4,
        action: "core",
        description: "Invalid machine instruction",
        standard: "ansi"
      },
      {
        name: "SIGTRAP",
        number: 5,
        action: "core",
        description: "Debugger breakpoint",
        standard: "posix"
      },
      {
        name: "SIGABRT",
        number: 6,
        action: "core",
        description: "Aborted",
        standard: "ansi"
      },
      {
        name: "SIGIOT",
        number: 6,
        action: "core",
        description: "Aborted",
        standard: "bsd"
      },
      {
        name: "SIGBUS",
        number: 7,
        action: "core",
        description: "Bus error due to misaligned, non-existing address or paging error",
        standard: "bsd"
      },
      {
        name: "SIGEMT",
        number: 7,
        action: "terminate",
        description: "Command should be emulated but is not implemented",
        standard: "other"
      },
      {
        name: "SIGFPE",
        number: 8,
        action: "core",
        description: "Floating point arithmetic error",
        standard: "ansi"
      },
      {
        name: "SIGKILL",
        number: 9,
        action: "terminate",
        description: "Forced termination",
        standard: "posix",
        forced: true
      },
      {
        name: "SIGUSR1",
        number: 10,
        action: "terminate",
        description: "Application-specific signal",
        standard: "posix"
      },
      {
        name: "SIGSEGV",
        number: 11,
        action: "core",
        description: "Segmentation fault",
        standard: "ansi"
      },
      {
        name: "SIGUSR2",
        number: 12,
        action: "terminate",
        description: "Application-specific signal",
        standard: "posix"
      },
      {
        name: "SIGPIPE",
        number: 13,
        action: "terminate",
        description: "Broken pipe or socket",
        standard: "posix"
      },
      {
        name: "SIGALRM",
        number: 14,
        action: "terminate",
        description: "Timeout or timer",
        standard: "posix"
      },
      {
        name: "SIGTERM",
        number: 15,
        action: "terminate",
        description: "Termination",
        standard: "ansi"
      },
      {
        name: "SIGSTKFLT",
        number: 16,
        action: "terminate",
        description: "Stack is empty or overflowed",
        standard: "other"
      },
      {
        name: "SIGCHLD",
        number: 17,
        action: "ignore",
        description: "Child process terminated, paused or unpaused",
        standard: "posix"
      },
      {
        name: "SIGCLD",
        number: 17,
        action: "ignore",
        description: "Child process terminated, paused or unpaused",
        standard: "other"
      },
      {
        name: "SIGCONT",
        number: 18,
        action: "unpause",
        description: "Unpaused",
        standard: "posix",
        forced: true
      },
      {
        name: "SIGSTOP",
        number: 19,
        action: "pause",
        description: "Paused",
        standard: "posix",
        forced: true
      },
      {
        name: "SIGTSTP",
        number: 20,
        action: "pause",
        description: 'Paused using CTRL-Z or "suspend"',
        standard: "posix"
      },
      {
        name: "SIGTTIN",
        number: 21,
        action: "pause",
        description: "Background process cannot read terminal input",
        standard: "posix"
      },
      {
        name: "SIGBREAK",
        number: 21,
        action: "terminate",
        description: "User interruption with CTRL-BREAK",
        standard: "other"
      },
      {
        name: "SIGTTOU",
        number: 22,
        action: "pause",
        description: "Background process cannot write to terminal output",
        standard: "posix"
      },
      {
        name: "SIGURG",
        number: 23,
        action: "ignore",
        description: "Socket received out-of-band data",
        standard: "bsd"
      },
      {
        name: "SIGXCPU",
        number: 24,
        action: "core",
        description: "Process timed out",
        standard: "bsd"
      },
      {
        name: "SIGXFSZ",
        number: 25,
        action: "core",
        description: "File too big",
        standard: "bsd"
      },
      {
        name: "SIGVTALRM",
        number: 26,
        action: "terminate",
        description: "Timeout or timer",
        standard: "bsd"
      },
      {
        name: "SIGPROF",
        number: 27,
        action: "terminate",
        description: "Timeout or timer",
        standard: "bsd"
      },
      {
        name: "SIGWINCH",
        number: 28,
        action: "ignore",
        description: "Terminal window size changed",
        standard: "bsd"
      },
      {
        name: "SIGIO",
        number: 29,
        action: "terminate",
        description: "I/O is available",
        standard: "other"
      },
      {
        name: "SIGPOLL",
        number: 29,
        action: "terminate",
        description: "Watched event",
        standard: "other"
      },
      {
        name: "SIGINFO",
        number: 29,
        action: "ignore",
        description: "Request for process information",
        standard: "other"
      },
      {
        name: "SIGPWR",
        number: 30,
        action: "terminate",
        description: "Device running out of power",
        standard: "systemv"
      },
      {
        name: "SIGSYS",
        number: 31,
        action: "core",
        description: "Invalid system call",
        standard: "other"
      },
      {
        name: "SIGUNUSED",
        number: 31,
        action: "terminate",
        description: "Invalid system call",
        standard: "other"
      }
    ];
    exports2.SIGNALS = SIGNALS2;
  }
});

// ../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/realtime.js
var require_realtime = __commonJS({
  "../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/realtime.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.SIGRTMAX = exports2.getRealtimeSignals = void 0;
    var getRealtimeSignals2 = /* @__PURE__ */ __name(function() {
      const length = SIGRTMAX2 - SIGRTMIN2 + 1;
      return Array.from({ length }, getRealtimeSignal2);
    }, "getRealtimeSignals");
    exports2.getRealtimeSignals = getRealtimeSignals2;
    var getRealtimeSignal2 = /* @__PURE__ */ __name(function(value, index) {
      return {
        name: `SIGRT${index + 1}`,
        number: SIGRTMIN2 + index,
        action: "terminate",
        description: "Application-specific signal (realtime)",
        standard: "posix"
      };
    }, "getRealtimeSignal");
    var SIGRTMIN2 = 34;
    var SIGRTMAX2 = 64;
    exports2.SIGRTMAX = SIGRTMAX2;
  }
});

// ../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/signals.js
var require_signals2 = __commonJS({
  "../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/signals.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.getSignals = void 0;
    var _os = require("os");
    var _core = require_core4();
    var _realtime = require_realtime();
    var getSignals2 = /* @__PURE__ */ __name(function() {
      const realtimeSignals = (0, _realtime.getRealtimeSignals)();
      const signals = [..._core.SIGNALS, ...realtimeSignals].map(normalizeSignal2);
      return signals;
    }, "getSignals");
    exports2.getSignals = getSignals2;
    var normalizeSignal2 = /* @__PURE__ */ __name(function({
      name,
      number: defaultNumber,
      description,
      action,
      forced = false,
      standard
    }) {
      const {
        signals: { [name]: constantSignal }
      } = _os.constants;
      const supported = constantSignal !== void 0;
      const number = supported ? constantSignal : defaultNumber;
      return { name, number, description, supported, action, forced, standard };
    }, "normalizeSignal");
  }
});

// ../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/main.js
var require_main3 = __commonJS({
  "../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/main.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.signalsByNumber = exports2.signalsByName = void 0;
    var _os = require("os");
    var _signals = require_signals2();
    var _realtime = require_realtime();
    var getSignalsByName2 = /* @__PURE__ */ __name(function() {
      const signals = (0, _signals.getSignals)();
      return signals.reduce(getSignalByName2, {});
    }, "getSignalsByName");
    var getSignalByName2 = /* @__PURE__ */ __name(function(signalByNameMemo, { name, number, description, supported, action, forced, standard }) {
      return {
        ...signalByNameMemo,
        [name]: { name, number, description, supported, action, forced, standard }
      };
    }, "getSignalByName");
    var signalsByName2 = getSignalsByName2();
    exports2.signalsByName = signalsByName2;
    var getSignalsByNumber2 = /* @__PURE__ */ __name(function() {
      const signals = (0, _signals.getSignals)();
      const length = _realtime.SIGRTMAX + 1;
      const signalsA = Array.from({ length }, (value, number) => getSignalByNumber2(number, signals));
      return Object.assign({}, ...signalsA);
    }, "getSignalsByNumber");
    var getSignalByNumber2 = /* @__PURE__ */ __name(function(number, signals) {
      const signal = findSignalByNumber2(number, signals);
      if (signal === void 0) {
        return {};
      }
      const { name, description, supported, action, forced, standard } = signal;
      return {
        [number]: {
          name,
          number,
          description,
          supported,
          action,
          forced,
          standard
        }
      };
    }, "getSignalByNumber");
    var findSignalByNumber2 = /* @__PURE__ */ __name(function(number, signals) {
      const signal = signals.find(({ name }) => _os.constants.signals[name] === number);
      if (signal !== void 0) {
        return signal;
      }
      return signals.find((signalA) => signalA.number === number);
    }, "findSignalByNumber");
    var signalsByNumber2 = getSignalsByNumber2();
    exports2.signalsByNumber = signalsByNumber2;
  }
});

// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/error.js
var require_error = __commonJS({
  "../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/error.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { signalsByName: signalsByName2 } = require_main3();
    var getErrorPrefix2 = /* @__PURE__ */ __name(({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled }) => {
      if (timedOut) {
        return `timed out after ${timeout} milliseconds`;
      }
      if (isCanceled) {
        return "was canceled";
      }
      if (errorCode !== void 0) {
        return `failed with ${errorCode}`;
      }
      if (signal !== void 0) {
        return `was killed with ${signal} (${signalDescription})`;
      }
      if (exitCode !== void 0) {
        return `failed with exit code ${exitCode}`;
      }
      return "failed";
    }, "getErrorPrefix");
    var makeError3 = /* @__PURE__ */ __name(({
      stdout: stdout2,
      stderr: stderr2,
      all: all2,
      error: error2,
      signal,
      exitCode,
      command: command2,
      escapedCommand,
      timedOut,
      isCanceled,
      killed,
      parsed: { options: { timeout } }
    }) => {
      exitCode = exitCode === null ? void 0 : exitCode;
      signal = signal === null ? void 0 : signal;
      const signalDescription = signal === void 0 ? void 0 : signalsByName2[signal].description;
      const errorCode = error2 && error2.code;
      const prefix = getErrorPrefix2({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled });
      const execaMessage = `Command ${prefix}: ${command2}`;
      const isError2 = Object.prototype.toString.call(error2) === "[object Error]";
      const shortMessage = isError2 ? `${execaMessage}
${error2.message}` : execaMessage;
      const message = [shortMessage, stderr2, stdout2].filter(Boolean).join("\n");
      if (isError2) {
        error2.originalMessage = error2.message;
        error2.message = message;
      } else {
        error2 = new Error(message);
      }
      error2.shortMessage = shortMessage;
      error2.command = command2;
      error2.escapedCommand = escapedCommand;
      error2.exitCode = exitCode;
      error2.signal = signal;
      error2.signalDescription = signalDescription;
      error2.stdout = stdout2;
      error2.stderr = stderr2;
      if (all2 !== void 0) {
        error2.all = all2;
      }
      if ("bufferedData" in error2) {
        delete error2.bufferedData;
      }
      error2.failed = true;
      error2.timedOut = Boolean(timedOut);
      error2.isCanceled = isCanceled;
      error2.killed = killed && !timedOut;
      return error2;
    }, "makeError");
    module3.exports = makeError3;
  }
});

// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/stdio.js
var require_stdio = __commonJS({
  "../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/stdio.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var aliases2 = ["stdin", "stdout", "stderr"];
    var hasAlias2 = /* @__PURE__ */ __name((options29) => aliases2.some((alias) => options29[alias] !== void 0), "hasAlias");
    var normalizeStdio2 = /* @__PURE__ */ __name((options29) => {
      if (!options29) {
        return;
      }
      const { stdio } = options29;
      if (stdio === void 0) {
        return aliases2.map((alias) => options29[alias]);
      }
      if (hasAlias2(options29)) {
        throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${aliases2.map((alias) => `\`${alias}\``).join(", ")}`);
      }
      if (typeof stdio === "string") {
        return stdio;
      }
      if (!Array.isArray(stdio)) {
        throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof stdio}\``);
      }
      const length = Math.max(stdio.length, aliases2.length);
      return Array.from({ length }, (value, index) => stdio[index]);
    }, "normalizeStdio");
    module3.exports = normalizeStdio2;
    module3.exports.node = (options29) => {
      const stdio = normalizeStdio2(options29);
      if (stdio === "ipc") {
        return "ipc";
      }
      if (stdio === void 0 || typeof stdio === "string") {
        return [stdio, stdio, stdio, "ipc"];
      }
      if (stdio.includes("ipc")) {
        return stdio;
      }
      return [...stdio, "ipc"];
    };
  }
});

// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/kill.js
var require_kill = __commonJS({
  "../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/kill.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var os11 = require("os");
    var onExit9 = require_signal_exit();
    var DEFAULT_FORCE_KILL_TIMEOUT2 = 1e3 * 5;
    var spawnedKill2 = /* @__PURE__ */ __name((kill, signal = "SIGTERM", options29 = {}) => {
      const killResult = kill(signal);
      setKillTimeout2(kill, signal, options29, killResult);
      return killResult;
    }, "spawnedKill");
    var setKillTimeout2 = /* @__PURE__ */ __name((kill, signal, options29, killResult) => {
      if (!shouldForceKill2(signal, options29, killResult)) {
        return;
      }
      const timeout = getForceKillAfterTimeout2(options29);
      const t3 = setTimeout(() => {
        kill("SIGKILL");
      }, timeout);
      if (t3.unref) {
        t3.unref();
      }
    }, "setKillTimeout");
    var shouldForceKill2 = /* @__PURE__ */ __name((signal, { forceKillAfterTimeout }, killResult) => {
      return isSigterm2(signal) && forceKillAfterTimeout !== false && killResult;
    }, "shouldForceKill");
    var isSigterm2 = /* @__PURE__ */ __name((signal) => {
      return signal === os11.constants.signals.SIGTERM || typeof signal === "string" && signal.toUpperCase() === "SIGTERM";
    }, "isSigterm");
    var getForceKillAfterTimeout2 = /* @__PURE__ */ __name(({ forceKillAfterTimeout = true }) => {
      if (forceKillAfterTimeout === true) {
        return DEFAULT_FORCE_KILL_TIMEOUT2;
      }
      if (!Number.isFinite(forceKillAfterTimeout) || forceKillAfterTimeout < 0) {
        throw new TypeError(`Expected the \`forceKillAfterTimeout\` option to be a non-negative integer, got \`${forceKillAfterTimeout}\` (${typeof forceKillAfterTimeout})`);
      }
      return forceKillAfterTimeout;
    }, "getForceKillAfterTimeout");
    var spawnedCancel2 = /* @__PURE__ */ __name((spawned, context2) => {
      const killResult = spawned.kill();
      if (killResult) {
        context2.isCanceled = true;
      }
    }, "spawnedCancel");
    var timeoutKill2 = /* @__PURE__ */ __name((spawned, signal, reject) => {
      spawned.kill(signal);
      reject(Object.assign(new Error("Timed out"), { timedOut: true, signal }));
    }, "timeoutKill");
    var setupTimeout2 = /* @__PURE__ */ __name((spawned, { timeout, killSignal = "SIGTERM" }, spawnedPromise) => {
      if (timeout === 0 || timeout === void 0) {
        return spawnedPromise;
      }
      let timeoutId;
      const timeoutPromise = new Promise((resolve19, reject) => {
        timeoutId = setTimeout(() => {
          timeoutKill2(spawned, killSignal, reject);
        }, timeout);
      });
      const safeSpawnedPromise = spawnedPromise.finally(() => {
        clearTimeout(timeoutId);
      });
      return Promise.race([timeoutPromise, safeSpawnedPromise]);
    }, "setupTimeout");
    var validateTimeout2 = /* @__PURE__ */ __name(({ timeout }) => {
      if (timeout !== void 0 && (!Number.isFinite(timeout) || timeout < 0)) {
        throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
      }
    }, "validateTimeout");
    var setExitHandler2 = /* @__PURE__ */ __name(async (spawned, { cleanup, detached }, timedPromise) => {
      if (!cleanup || detached) {
        return timedPromise;
      }
      const removeExitHandler = onExit9(() => {
        spawned.kill();
      });
      return timedPromise.finally(() => {
        removeExitHandler();
      });
    }, "setExitHandler");
    module3.exports = {
      spawnedKill: spawnedKill2,
      spawnedCancel: spawnedCancel2,
      setupTimeout: setupTimeout2,
      validateTimeout: validateTimeout2,
      setExitHandler: setExitHandler2
    };
  }
});

// ../../node_modules/.pnpm/is-stream@2.0.1/node_modules/is-stream/index.js
var require_is_stream = __commonJS({
  "../../node_modules/.pnpm/is-stream@2.0.1/node_modules/is-stream/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var isStream2 = /* @__PURE__ */ __name((stream2) => stream2 !== null && typeof stream2 === "object" && typeof stream2.pipe === "function", "isStream");
    isStream2.writable = (stream2) => isStream2(stream2) && stream2.writable !== false && typeof stream2._write === "function" && typeof stream2._writableState === "object";
    isStream2.readable = (stream2) => isStream2(stream2) && stream2.readable !== false && typeof stream2._read === "function" && typeof stream2._readableState === "object";
    isStream2.duplex = (stream2) => isStream2.writable(stream2) && isStream2.readable(stream2);
    isStream2.transform = (stream2) => isStream2.duplex(stream2) && typeof stream2._transform === "function";
    module3.exports = isStream2;
  }
});

// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/stream.js
var require_stream2 = __commonJS({
  "../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/stream.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var isStream2 = require_is_stream();
    var getStream2 = require_get_stream();
    var mergeStream2 = require_merge_stream();
    var handleInput2 = /* @__PURE__ */ __name((spawned, input) => {
      if (input === void 0 || spawned.stdin === void 0) {
        return;
      }
      if (isStream2(input)) {
        input.pipe(spawned.stdin);
      } else {
        spawned.stdin.end(input);
      }
    }, "handleInput");
    var makeAllStream2 = /* @__PURE__ */ __name((spawned, { all: all2 }) => {
      if (!all2 || !spawned.stdout && !spawned.stderr) {
        return;
      }
      const mixed = mergeStream2();
      if (spawned.stdout) {
        mixed.add(spawned.stdout);
      }
      if (spawned.stderr) {
        mixed.add(spawned.stderr);
      }
      return mixed;
    }, "makeAllStream");
    var getBufferedData2 = /* @__PURE__ */ __name(async (stream2, streamPromise) => {
      if (!stream2) {
        return;
      }
      stream2.destroy();
      try {
        return await streamPromise;
      } catch (error2) {
        return error2.bufferedData;
      }
    }, "getBufferedData");
    var getStreamPromise2 = /* @__PURE__ */ __name((stream2, { encoding, buffer, maxBuffer }) => {
      if (!stream2 || !buffer) {
        return;
      }
      if (encoding) {
        return getStream2(stream2, { encoding, maxBuffer });
      }
      return getStream2.buffer(stream2, { maxBuffer });
    }, "getStreamPromise");
    var getSpawnedResult2 = /* @__PURE__ */ __name(async ({ stdout: stdout2, stderr: stderr2, all: all2 }, { encoding, buffer, maxBuffer }, processDone) => {
      const stdoutPromise = getStreamPromise2(stdout2, { encoding, buffer, maxBuffer });
      const stderrPromise = getStreamPromise2(stderr2, { encoding, buffer, maxBuffer });
      const allPromise = getStreamPromise2(all2, { encoding, buffer, maxBuffer: maxBuffer * 2 });
      try {
        return await Promise.all([processDone, stdoutPromise, stderrPromise, allPromise]);
      } catch (error2) {
        return Promise.all([
          { error: error2, signal: error2.signal, timedOut: error2.timedOut },
          getBufferedData2(stdout2, stdoutPromise),
          getBufferedData2(stderr2, stderrPromise),
          getBufferedData2(all2, allPromise)
        ]);
      }
    }, "getSpawnedResult");
    var validateInputSync2 = /* @__PURE__ */ __name(({ input }) => {
      if (isStream2(input)) {
        throw new TypeError("The `input` option cannot be a stream in sync mode");
      }
    }, "validateInputSync");
    module3.exports = {
      handleInput: handleInput2,
      makeAllStream: makeAllStream2,
      getSpawnedResult: getSpawnedResult2,
      validateInputSync: validateInputSync2
    };
  }
});

// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/promise.js
var require_promise = __commonJS({
  "../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/promise.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var nativePromisePrototype2 = (async () => {
    })().constructor.prototype;
    var descriptors2 = ["then", "catch", "finally"].map((property) => [
      property,
      Reflect.getOwnPropertyDescriptor(nativePromisePrototype2, property)
    ]);
    var mergePromise2 = /* @__PURE__ */ __name((spawned, promise) => {
      for (const [property, descriptor2] of descriptors2) {
        const value = typeof promise === "function" ? (...args) => Reflect.apply(descriptor2.value, promise(), args) : descriptor2.value.bind(promise);
        Reflect.defineProperty(spawned, property, { ...descriptor2, value });
      }
      return spawned;
    }, "mergePromise");
    var getSpawnedPromise2 = /* @__PURE__ */ __name((spawned) => {
      return new Promise((resolve19, reject) => {
        spawned.on("exit", (exitCode, signal) => {
          resolve19({ exitCode, signal });
        });
        spawned.on("error", (error2) => {
          reject(error2);
        });
        if (spawned.stdin) {
          spawned.stdin.on("error", (error2) => {
            reject(error2);
          });
        }
      });
    }, "getSpawnedPromise");
    module3.exports = {
      mergePromise: mergePromise2,
      getSpawnedPromise: getSpawnedPromise2
    };
  }
});

// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/command.js
var require_command = __commonJS({
  "../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/command.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var normalizeArgs2 = /* @__PURE__ */ __name((file, args = []) => {
      if (!Array.isArray(args)) {
        return [file];
      }
      return [file, ...args];
    }, "normalizeArgs");
    var NO_ESCAPE_REGEXP2 = /^[\w.-]+$/;
    var DOUBLE_QUOTES_REGEXP2 = /"/g;
    var escapeArg2 = /* @__PURE__ */ __name((arg) => {
      if (typeof arg !== "string" || NO_ESCAPE_REGEXP2.test(arg)) {
        return arg;
      }
      return `"${arg.replace(DOUBLE_QUOTES_REGEXP2, '\\"')}"`;
    }, "escapeArg");
    var joinCommand2 = /* @__PURE__ */ __name((file, args) => {
      return normalizeArgs2(file, args).join(" ");
    }, "joinCommand");
    var getEscapedCommand2 = /* @__PURE__ */ __name((file, args) => {
      return normalizeArgs2(file, args).map((arg) => escapeArg2(arg)).join(" ");
    }, "getEscapedCommand");
    var SPACES_REGEXP2 = / +/g;
    var parseCommand3 = /* @__PURE__ */ __name((command2) => {
      const tokens = [];
      for (const token of command2.trim().split(SPACES_REGEXP2)) {
        const previousToken = tokens[tokens.length - 1];
        if (previousToken && previousToken.endsWith("\\")) {
          tokens[tokens.length - 1] = `${previousToken.slice(0, -1)} ${token}`;
        } else {
          tokens.push(token);
        }
      }
      return tokens;
    }, "parseCommand");
    module3.exports = {
      joinCommand: joinCommand2,
      getEscapedCommand: getEscapedCommand2,
      parseCommand: parseCommand3
    };
  }
});

// ../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/index.js
var require_execa = __commonJS({
  "../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var path67 = require("path");
    var childProcess2 = require("child_process");
    var crossSpawn2 = require_cross_spawn();
    var stripFinalNewline2 = require_strip_final_newline();
    var npmRunPath2 = require_npm_run_path();
    var onetime3 = require_onetime();
    var makeError3 = require_error();
    var normalizeStdio2 = require_stdio();
    var { spawnedKill: spawnedKill2, spawnedCancel: spawnedCancel2, setupTimeout: setupTimeout2, validateTimeout: validateTimeout2, setExitHandler: setExitHandler2 } = require_kill();
    var { handleInput: handleInput2, getSpawnedResult: getSpawnedResult2, makeAllStream: makeAllStream2, validateInputSync: validateInputSync2 } = require_stream2();
    var { mergePromise: mergePromise2, getSpawnedPromise: getSpawnedPromise2 } = require_promise();
    var { joinCommand: joinCommand2, parseCommand: parseCommand3, getEscapedCommand: getEscapedCommand2 } = require_command();
    var DEFAULT_MAX_BUFFER2 = 1e3 * 1e3 * 100;
    var getEnv2 = /* @__PURE__ */ __name(({ env: envOption, extendEnv, preferLocal, localDir, execPath }) => {
      const env5 = extendEnv ? { ...process.env, ...envOption } : envOption;
      if (preferLocal) {
        return npmRunPath2.env({ env: env5, cwd: localDir, execPath });
      }
      return env5;
    }, "getEnv");
    var handleArguments2 = /* @__PURE__ */ __name((file, args, options29 = {}) => {
      const parsed = crossSpawn2._parse(file, args, options29);
      file = parsed.command;
      args = parsed.args;
      options29 = parsed.options;
      options29 = {
        maxBuffer: DEFAULT_MAX_BUFFER2,
        buffer: true,
        stripFinalNewline: true,
        extendEnv: true,
        preferLocal: false,
        localDir: options29.cwd || process.cwd(),
        execPath: process.execPath,
        encoding: "utf8",
        reject: true,
        cleanup: true,
        all: false,
        windowsHide: true,
        ...options29
      };
      options29.env = getEnv2(options29);
      options29.stdio = normalizeStdio2(options29);
      if (process.platform === "win32" && path67.basename(file, ".exe") === "cmd") {
        args.unshift("/q");
      }
      return { file, args, options: options29, parsed };
    }, "handleArguments");
    var handleOutput2 = /* @__PURE__ */ __name((options29, value, error2) => {
      if (typeof value !== "string" && !Buffer.isBuffer(value)) {
        return error2 === void 0 ? void 0 : "";
      }
      if (options29.stripFinalNewline) {
        return stripFinalNewline2(value);
      }
      return value;
    }, "handleOutput");
    var execa6 = /* @__PURE__ */ __name((file, args, options29) => {
      const parsed = handleArguments2(file, args, options29);
      const command2 = joinCommand2(file, args);
      const escapedCommand = getEscapedCommand2(file, args);
      validateTimeout2(parsed.options);
      let spawned;
      try {
        spawned = childProcess2.spawn(parsed.file, parsed.args, parsed.options);
      } catch (error2) {
        const dummySpawned = new childProcess2.ChildProcess();
        const errorPromise = Promise.reject(makeError3({
          error: error2,
          stdout: "",
          stderr: "",
          all: "",
          command: command2,
          escapedCommand,
          parsed,
          timedOut: false,
          isCanceled: false,
          killed: false
        }));
        return mergePromise2(dummySpawned, errorPromise);
      }
      const spawnedPromise = getSpawnedPromise2(spawned);
      const timedPromise = setupTimeout2(spawned, parsed.options, spawnedPromise);
      const processDone = setExitHandler2(spawned, parsed.options, timedPromise);
      const context2 = { isCanceled: false };
      spawned.kill = spawnedKill2.bind(null, spawned.kill.bind(spawned));
      spawned.cancel = spawnedCancel2.bind(null, spawned, context2);
      const handlePromise = /* @__PURE__ */ __name(async () => {
        const [{ error: error2, exitCode, signal, timedOut }, stdoutResult, stderrResult, allResult] = await getSpawnedResult2(spawned, parsed.options, processDone);
        const stdout2 = handleOutput2(parsed.options, stdoutResult);
        const stderr2 = handleOutput2(parsed.options, stderrResult);
        const all2 = handleOutput2(parsed.options, allResult);
        if (error2 || exitCode !== 0 || signal !== null) {
          const returnedError = makeError3({
            error: error2,
            exitCode,
            signal,
            stdout: stdout2,
            stderr: stderr2,
            all: all2,
            command: command2,
            escapedCommand,
            parsed,
            timedOut,
            isCanceled: context2.isCanceled,
            killed: spawned.killed
          });
          if (!parsed.options.reject) {
            return returnedError;
          }
          throw returnedError;
        }
        return {
          command: command2,
          escapedCommand,
          exitCode: 0,
          stdout: stdout2,
          stderr: stderr2,
          all: all2,
          failed: false,
          timedOut: false,
          isCanceled: false,
          killed: false
        };
      }, "handlePromise");
      const handlePromiseOnce = onetime3(handlePromise);
      handleInput2(spawned, parsed.options.input);
      spawned.all = makeAllStream2(spawned, parsed.options);
      return mergePromise2(spawned, handlePromiseOnce);
    }, "execa");
    module3.exports = execa6;
    module3.exports.sync = (file, args, options29) => {
      const parsed = handleArguments2(file, args, options29);
      const command2 = joinCommand2(file, args);
      const escapedCommand = getEscapedCommand2(file, args);
      validateInputSync2(parsed.options);
      let result;
      try {
        result = childProcess2.spawnSync(parsed.file, parsed.args, parsed.options);
      } catch (error2) {
        throw makeError3({
          error: error2,
          stdout: "",
          stderr: "",
          all: "",
          command: command2,
          escapedCommand,
          parsed,
          timedOut: false,
          isCanceled: false,
          killed: false
        });
      }
      const stdout2 = handleOutput2(parsed.options, result.stdout, result.error);
      const stderr2 = handleOutput2(parsed.options, result.stderr, result.error);
      if (result.error || result.status !== 0 || result.signal !== null) {
        const error2 = makeError3({
          stdout: stdout2,
          stderr: stderr2,
          error: result.error,
          signal: result.signal,
          exitCode: result.status,
          command: command2,
          escapedCommand,
          parsed,
          timedOut: result.error && result.error.code === "ETIMEDOUT",
          isCanceled: false,
          killed: result.signal !== null
        });
        if (!parsed.options.reject) {
          return error2;
        }
        throw error2;
      }
      return {
        command: command2,
        escapedCommand,
        exitCode: 0,
        stdout: stdout2,
        stderr: stderr2,
        failed: false,
        timedOut: false,
        isCanceled: false,
        killed: false
      };
    };
    module3.exports.command = (command2, options29) => {
      const [file, ...args] = parseCommand3(command2);
      return execa6(file, args, options29);
    };
    module3.exports.commandSync = (command2, options29) => {
      const [file, ...args] = parseCommand3(command2);
      return execa6.sync(file, args, options29);
    };
    module3.exports.node = (scriptPath3, args, options29 = {}) => {
      if (args && !Array.isArray(args) && typeof args === "object") {
        options29 = args;
        args = [];
      }
      const stdio = normalizeStdio2.node(options29);
      const defaultExecArgv = process.execArgv.filter((arg) => !arg.startsWith("--inspect"));
      const {
        nodePath = process.execPath,
        nodeOptions = defaultExecArgv
      } = options29;
      return execa6(
        nodePath,
        [
          ...nodeOptions,
          scriptPath3,
          ...Array.isArray(args) ? args : []
        ],
        {
          ...options29,
          stdin: void 0,
          stdout: void 0,
          stderr: void 0,
          stdio,
          shell: false
        }
      );
    };
  }
});

// ../../node_modules/.pnpm/arch@2.2.0/node_modules/arch/index.js
var require_arch = __commonJS({
  "../../node_modules/.pnpm/arch@2.2.0/node_modules/arch/index.js"(exports2, module3) {
    init_import_meta_url();
    var cp2 = require("child_process");
    var fs26 = require("fs");
    var path67 = require("path");
    module3.exports = /* @__PURE__ */ __name(function arch3() {
      if (process.arch === "x64") {
        return "x64";
      }
      if (process.platform === "darwin") {
        return "x64";
      }
      if (process.platform === "win32") {
        var useEnv = false;
        try {
          useEnv = !!(process.env.SYSTEMROOT && fs26.statSync(process.env.SYSTEMROOT));
        } catch (err) {
        }
        var sysRoot = useEnv ? process.env.SYSTEMROOT : "C:\\Windows";
        var isWOW64 = false;
        try {
          isWOW64 = !!fs26.statSync(path67.join(sysRoot, "sysnative"));
        } catch (err) {
        }
        return isWOW64 ? "x64" : "x86";
      }
      if (process.platform === "linux") {
        var output = cp2.execSync("getconf LONG_BIT", { encoding: "utf8" });
        return output === "64\n" ? "x64" : "x86";
      }
      return "x86";
    }, "arch");
  }
});

// ../../node_modules/.pnpm/command-exists@1.2.9/node_modules/command-exists/lib/command-exists.js
var require_command_exists = __commonJS({
  "../../node_modules/.pnpm/command-exists@1.2.9/node_modules/command-exists/lib/command-exists.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var exec2 = require("child_process").exec;
    var execSync4 = require("child_process").execSync;
    var fs26 = require("fs");
    var path67 = require("path");
    var access3 = fs26.access;
    var accessSync = fs26.accessSync;
    var constants3 = fs26.constants || fs26;
    var isUsingWindows = process.platform == "win32";
    var fileNotExists = /* @__PURE__ */ __name(function(commandName, callback) {
      access3(
        commandName,
        constants3.F_OK,
        function(err) {
          callback(!err);
        }
      );
    }, "fileNotExists");
    var fileNotExistsSync = /* @__PURE__ */ __name(function(commandName) {
      try {
        accessSync(commandName, constants3.F_OK);
        return false;
      } catch (e3) {
        return true;
      }
    }, "fileNotExistsSync");
    var localExecutable = /* @__PURE__ */ __name(function(commandName, callback) {
      access3(
        commandName,
        constants3.F_OK | constants3.X_OK,
        function(err) {
          callback(null, !err);
        }
      );
    }, "localExecutable");
    var localExecutableSync = /* @__PURE__ */ __name(function(commandName) {
      try {
        accessSync(commandName, constants3.F_OK | constants3.X_OK);
        return true;
      } catch (e3) {
        return false;
      }
    }, "localExecutableSync");
    var commandExistsUnix = /* @__PURE__ */ __name(function(commandName, cleanedCommandName, callback) {
      fileNotExists(commandName, function(isFile) {
        if (!isFile) {
          var child = exec2(
            "command -v " + cleanedCommandName + " 2>/dev/null && { echo >&1 " + cleanedCommandName + "; exit 0; }",
            function(error2, stdout2, stderr2) {
              callback(null, !!stdout2);
            }
          );
          return;
        }
        localExecutable(commandName, callback);
      });
    }, "commandExistsUnix");
    var commandExistsWindows = /* @__PURE__ */ __name(function(commandName, cleanedCommandName, callback) {
      if (!/^(?!(?:.*\s|.*\.|\W+)$)(?:[a-zA-Z]:)?(?:(?:[^<>:"\|\?\*\n])+(?:\/\/|\/|\\\\|\\)?)+$/m.test(commandName)) {
        callback(null, false);
        return;
      }
      var child = exec2(
        "where " + cleanedCommandName,
        function(error2) {
          if (error2 !== null) {
            callback(null, false);
          } else {
            callback(null, true);
          }
        }
      );
    }, "commandExistsWindows");
    var commandExistsUnixSync = /* @__PURE__ */ __name(function(commandName, cleanedCommandName) {
      if (fileNotExistsSync(commandName)) {
        try {
          var stdout2 = execSync4(
            "command -v " + cleanedCommandName + " 2>/dev/null && { echo >&1 " + cleanedCommandName + "; exit 0; }"
          );
          return !!stdout2;
        } catch (error2) {
          return false;
        }
      }
      return localExecutableSync(commandName);
    }, "commandExistsUnixSync");
    var commandExistsWindowsSync = /* @__PURE__ */ __name(function(commandName, cleanedCommandName, callback) {
      if (!/^(?!(?:.*\s|.*\.|\W+)$)(?:[a-zA-Z]:)?(?:(?:[^<>:"\|\?\*\n])+(?:\/\/|\/|\\\\|\\)?)+$/m.test(commandName)) {
        return false;
      }
      try {
        var stdout2 = execSync4("where " + cleanedCommandName, { stdio: [] });
        return !!stdout2;
      } catch (error2) {
        return false;
      }
    }, "commandExistsWindowsSync");
    var cleanInput = /* @__PURE__ */ __name(function(s) {
      if (/[^A-Za-z0-9_\/:=-]/.test(s)) {
        s = "'" + s.replace(/'/g, "'\\''") + "'";
        s = s.replace(/^(?:'')+/g, "").replace(/\\'''/g, "\\'");
      }
      return s;
    }, "cleanInput");
    if (isUsingWindows) {
      cleanInput = /* @__PURE__ */ __name(function(s) {
        var isPathName = /[\\]/.test(s);
        if (isPathName) {
          var dirname13 = '"' + path67.dirname(s) + '"';
          var basename4 = '"' + path67.basename(s) + '"';
          return dirname13 + ":" + basename4;
        }
        return '"' + s + '"';
      }, "cleanInput");
    }
    module3.exports = /* @__PURE__ */ __name(function commandExists2(commandName, callback) {
      var cleanedCommandName = cleanInput(commandName);
      if (!callback && typeof Promise !== "undefined") {
        return new Promise(function(resolve19, reject) {
          commandExists2(commandName, function(error2, output) {
            if (output) {
              resolve19(commandName);
            } else {
              reject(error2);
            }
          });
        });
      }
      if (isUsingWindows) {
        commandExistsWindows(commandName, cleanedCommandName, callback);
      } else {
        commandExistsUnix(commandName, cleanedCommandName, callback);
      }
    }, "commandExists");
    module3.exports.sync = function(commandName) {
      var cleanedCommandName = cleanInput(commandName);
      if (isUsingWindows) {
        return commandExistsWindowsSync(commandName, cleanedCommandName);
      } else {
        return commandExistsUnixSync(commandName, cleanedCommandName);
      }
    };
  }
});

// ../../node_modules/.pnpm/command-exists@1.2.9/node_modules/command-exists/index.js
var require_command_exists2 = __commonJS({
  "../../node_modules/.pnpm/command-exists@1.2.9/node_modules/command-exists/index.js"(exports2, module3) {
    init_import_meta_url();
    module3.exports = require_command_exists();
  }
});

// ../../node_modules/.pnpm/depd@2.0.0/node_modules/depd/index.js
var require_depd = __commonJS({
  "../../node_modules/.pnpm/depd@2.0.0/node_modules/depd/index.js"(exports2, module3) {
    init_import_meta_url();
    var relative13 = require("path").relative;
    module3.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;
    }
    __name(containsNamespace, "containsNamespace");
    function convertDataDescriptorToAccessor(obj, prop, message) {
      var descriptor2 = Object.getOwnPropertyDescriptor(obj, prop);
      var value = descriptor2.value;
      descriptor2.get = /* @__PURE__ */ __name(function getter() {
        return value;
      }, "getter");
      if (descriptor2.writable) {
        descriptor2.set = /* @__PURE__ */ __name(function setter(val) {
          return value = val;
        }, "setter");
      }
      delete descriptor2.value;
      delete descriptor2.writable;
      Object.defineProperty(obj, prop, descriptor2);
      return descriptor2;
    }
    __name(convertDataDescriptorToAccessor, "convertDataDescriptorToAccessor");
    function createArgumentsString(arity) {
      var str = "";
      for (var i = 0; i < arity; i++) {
        str += ", arg" + i;
      }
      return str.substr(2);
    }
    __name(createArgumentsString, "createArgumentsString");
    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;
    }
    __name(createStackString, "createStackString");
    function depd(namespace) {
      if (!namespace) {
        throw new TypeError("argument namespace is required");
      }
      var stack = getStack();
      var site = callSiteLocation(stack[1]);
      var file = site[0];
      function deprecate(message) {
        log2.call(deprecate, message);
      }
      __name(deprecate, "deprecate");
      deprecate._file = file;
      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;
    }
    __name(depd, "depd");
    function eehaslisteners(emitter, type) {
      var count = typeof emitter.listenerCount !== "function" ? emitter.listeners(type).length : emitter.listenerCount(type);
      return count > 0;
    }
    __name(eehaslisteners, "eehaslisteners");
    function isignored(namespace) {
      if (process.noDeprecation) {
        return true;
      }
      var str = process.env.NO_DEPRECATION || "";
      return containsNamespace(str, namespace);
    }
    __name(isignored, "isignored");
    function istraced(namespace) {
      if (process.traceDeprecation) {
        return true;
      }
      var str = process.env.TRACE_DEPRECATION || "";
      return containsNamespace(str, namespace);
    }
    __name(istraced, "istraced");
    function log2(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 file = this._file;
      if (site) {
        depSite = site;
        callSite = callSiteLocation(stack[1]);
        callSite.name = depSite.name;
        file = 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 === file) {
          seen = true;
        } else if (callFile === this._file) {
          file = 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 = DeprecationError2(this._namespace, msg, stack.slice(i));
        process.emit("deprecation", err);
        return;
      }
      var format10 = process.stderr.isTTY ? formatColor : formatPlain;
      var output = format10.call(this, msg, caller, stack.slice(i));
      process.stderr.write(output + "\n", "utf8");
    }
    __name(log2, "log");
    function callSiteLocation(callSite) {
      var file = callSite.getFileName() || "<anonymous>";
      var line = callSite.getLineNumber();
      var colm = callSite.getColumnNumber();
      if (callSite.isEval()) {
        file = callSite.getEvalOrigin() + ", " + file;
      }
      var site = [file, line, colm];
      site.callSite = callSite;
      site.name = callSite.getFunctionName();
      return site;
    }
    __name(callSiteLocation, "callSiteLocation");
    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;
    }
    __name(defaultMessage, "defaultMessage");
    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;
    }
    __name(formatPlain, "formatPlain");
    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;
    }
    __name(formatColor, "formatColor");
    function formatLocation(callSite) {
      return relative13(basePath, callSite[0]) + ":" + callSite[1] + ":" + callSite[2];
    }
    __name(formatLocation, "formatLocation");
    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;
    }
    __name(getStack, "getStack");
    function prepareObjectStackTrace(obj, stack) {
      return stack;
    }
    __name(prepareObjectStackTrace, "prepareObjectStackTrace");
    function wrapfunction(fn2, message) {
      if (typeof fn2 !== "function") {
        throw new TypeError("argument fn must be a function");
      }
      var args = createArgumentsString(fn2.length);
      var stack = getStack();
      var site = callSiteLocation(stack[1]);
      site.name = fn2.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}"
      )(fn2, log2, this, message, site);
      return deprecatedfn;
    }
    __name(wrapfunction, "wrapfunction");
    function wrapproperty(obj, prop, message) {
      if (!obj || typeof obj !== "object" && typeof obj !== "function") {
        throw new TypeError("argument obj must be object");
      }
      var descriptor2 = Object.getOwnPropertyDescriptor(obj, prop);
      if (!descriptor2) {
        throw new TypeError("must call property on owner object");
      }
      if (!descriptor2.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 descriptor2) {
        descriptor2 = convertDataDescriptorToAccessor(obj, prop, message);
      }
      var get = descriptor2.get;
      var set = descriptor2.set;
      if (typeof get === "function") {
        descriptor2.get = /* @__PURE__ */ __name(function getter() {
          log2.call(deprecate, message, site);
          return get.apply(this, arguments);
        }, "getter");
      }
      if (typeof set === "function") {
        descriptor2.set = /* @__PURE__ */ __name(function setter() {
          log2.call(deprecate, message, site);
          return set.apply(this, arguments);
        }, "setter");
      }
      Object.defineProperty(obj, prop, descriptor2);
    }
    __name(wrapproperty, "wrapproperty");
    function DeprecationError2(namespace, message, stack) {
      var error2 = new Error();
      var stackString;
      Object.defineProperty(error2, "constructor", {
        value: DeprecationError2
      });
      Object.defineProperty(error2, "message", {
        configurable: true,
        enumerable: false,
        value: message,
        writable: true
      });
      Object.defineProperty(error2, "name", {
        enumerable: false,
        configurable: true,
        value: "DeprecationError",
        writable: true
      });
      Object.defineProperty(error2, "namespace", {
        configurable: true,
        enumerable: false,
        value: namespace,
        writable: true
      });
      Object.defineProperty(error2, "stack", {
        configurable: true,
        enumerable: false,
        get: function() {
          if (stackString !== void 0) {
            return stackString;
          }
          return stackString = createStackString.call(this, stack);
        },
        set: /* @__PURE__ */ __name(function setter(val) {
          stackString = val;
        }, "setter")
      });
      return error2;
    }
    __name(DeprecationError2, "DeprecationError");
  }
});

// ../../node_modules/.pnpm/bytes@3.1.2/node_modules/bytes/index.js
var require_bytes = __commonJS({
  "../../node_modules/.pnpm/bytes@3.1.2/node_modules/bytes/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = bytes;
    module3.exports.format = format10;
    module3.exports.parse = parse7;
    var formatThousandsRegExp = /\B(?=(\d{3})+(?!\d))/g;
    var formatDecimalsRegExp = /(?:\.0*|(\.[^0]+)0+)$/;
    var map = {
      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, options29) {
      if (typeof value === "string") {
        return parse7(value);
      }
      if (typeof value === "number") {
        return format10(value, options29);
      }
      return null;
    }
    __name(bytes, "bytes");
    function format10(value, options29) {
      if (!Number.isFinite(value)) {
        return null;
      }
      var mag = Math.abs(value);
      var thousandsSeparator = options29 && options29.thousandsSeparator || "";
      var unitSeparator = options29 && options29.unitSeparator || "";
      var decimalPlaces = options29 && options29.decimalPlaces !== void 0 ? options29.decimalPlaces : 2;
      var fixedDecimals = Boolean(options29 && options29.fixedDecimals);
      var unit = options29 && options29.unit || "";
      if (!unit || !map[unit.toLowerCase()]) {
        if (mag >= map.pb) {
          unit = "PB";
        } else if (mag >= map.tb) {
          unit = "TB";
        } else if (mag >= map.gb) {
          unit = "GB";
        } else if (mag >= map.mb) {
          unit = "MB";
        } else if (mag >= map.kb) {
          unit = "KB";
        } else {
          unit = "B";
        }
      }
      var val = value / map[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;
    }
    __name(format10, "format");
    function parse7(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(map[unit] * floatValue);
    }
    __name(parse7, "parse");
  }
});

// ../../node_modules/.pnpm/content-type@1.0.4/node_modules/content-type/index.js
var require_content_type = __commonJS({
  "../../node_modules/.pnpm/content-type@1.0.4/node_modules/content-type/index.js"(exports2) {
    "use strict";
    init_import_meta_url();
    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 = format10;
    exports2.parse = parse7;
    function format10(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 string = 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");
          }
          string += "; " + param + "=" + qstring(parameters[param]);
        }
      }
      return string;
    }
    __name(format10, "format");
    function parse7(string) {
      if (!string) {
        throw new TypeError("argument string is required");
      }
      var header = typeof string === "object" ? getcontenttype(string) : string;
      if (typeof header !== "string") {
        throw new TypeError("argument string is required to be a string");
      }
      var index = header.indexOf(";");
      var type = index !== -1 ? header.substr(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[0] === '"') {
            value = value.substr(1, value.length - 2).replace(QESC_REGEXP, "$1");
          }
          obj.parameters[key] = value;
        }
        if (index !== header.length) {
          throw new TypeError("invalid parameter format");
        }
      }
      return obj;
    }
    __name(parse7, "parse");
    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;
    }
    __name(getcontenttype, "getcontenttype");
    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") + '"';
    }
    __name(qstring, "qstring");
    function ContentType(type) {
      this.parameters = /* @__PURE__ */ Object.create(null);
      this.type = type;
    }
    __name(ContentType, "ContentType");
  }
});

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

// ../../node_modules/.pnpm/statuses@2.0.1/node_modules/statuses/codes.json
var require_codes = __commonJS({
  "../../node_modules/.pnpm/statuses@2.0.1/node_modules/statuses/codes.json"(exports2, module3) {
    module3.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/.pnpm/statuses@2.0.1/node_modules/statuses/index.js
var require_statuses = __commonJS({
  "../../node_modules/.pnpm/statuses@2.0.1/node_modules/statuses/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var codes = require_codes();
    module3.exports = status2;
    status2.message = codes;
    status2.code = createMessageToStatusCodeMap(codes);
    status2.codes = createStatusCodeList(codes);
    status2.redirect = {
      300: true,
      301: true,
      302: true,
      303: true,
      305: true,
      307: true,
      308: true
    };
    status2.empty = {
      204: true,
      205: true,
      304: true
    };
    status2.retry = {
      502: true,
      503: true,
      504: true
    };
    function createMessageToStatusCodeMap(codes2) {
      var map = {};
      Object.keys(codes2).forEach(/* @__PURE__ */ __name(function forEachCode(code) {
        var message = codes2[code];
        var status3 = Number(code);
        map[message.toLowerCase()] = status3;
      }, "forEachCode"));
      return map;
    }
    __name(createMessageToStatusCodeMap, "createMessageToStatusCodeMap");
    function createStatusCodeList(codes2) {
      return Object.keys(codes2).map(/* @__PURE__ */ __name(function mapCode(code) {
        return Number(code);
      }, "mapCode"));
    }
    __name(createStatusCodeList, "createStatusCodeList");
    function getStatusCode(message) {
      var msg = message.toLowerCase();
      if (!Object.prototype.hasOwnProperty.call(status2.code, msg)) {
        throw new Error('invalid status message: "' + message + '"');
      }
      return status2.code[msg];
    }
    __name(getStatusCode, "getStatusCode");
    function getStatusMessage(code) {
      if (!Object.prototype.hasOwnProperty.call(status2.message, code)) {
        throw new Error("invalid status code: " + code);
      }
      return status2.message[code];
    }
    __name(getStatusMessage, "getStatusMessage");
    function status2(code) {
      if (typeof code === "number") {
        return getStatusMessage(code);
      }
      if (typeof code !== "string") {
        throw new TypeError("code must be a number or string");
      }
      var n2 = parseInt(code, 10);
      if (!isNaN(n2)) {
        return getStatusMessage(n2);
      }
      return getStatusCode(code);
    }
    __name(status2, "status");
  }
});

// ../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js
var require_inherits_browser = __commonJS({
  "../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js"(exports2, module3) {
    init_import_meta_url();
    if (typeof Object.create === "function") {
      module3.exports = /* @__PURE__ */ __name(function inherits(ctor, superCtor) {
        if (superCtor) {
          ctor.super_ = superCtor;
          ctor.prototype = Object.create(superCtor.prototype, {
            constructor: {
              value: ctor,
              enumerable: false,
              writable: true,
              configurable: true
            }
          });
        }
      }, "inherits");
    } else {
      module3.exports = /* @__PURE__ */ __name(function inherits(ctor, superCtor) {
        if (superCtor) {
          ctor.super_ = superCtor;
          var TempCtor = /* @__PURE__ */ __name(function() {
          }, "TempCtor");
          TempCtor.prototype = superCtor.prototype;
          ctor.prototype = new TempCtor();
          ctor.prototype.constructor = ctor;
        }
      }, "inherits");
    }
  }
});

// ../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits.js
var require_inherits = __commonJS({
  "../../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits.js"(exports2, module3) {
    init_import_meta_url();
    try {
      util4 = require("util");
      if (typeof util4.inherits !== "function")
        throw "";
      module3.exports = util4.inherits;
    } catch (e3) {
      module3.exports = require_inherits_browser();
    }
    var util4;
  }
});

// ../../node_modules/.pnpm/toidentifier@1.0.1/node_modules/toidentifier/index.js
var require_toidentifier = __commonJS({
  "../../node_modules/.pnpm/toidentifier@1.0.1/node_modules/toidentifier/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.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, "");
    }
    __name(toIdentifier, "toIdentifier");
  }
});

// ../../node_modules/.pnpm/http-errors@2.0.0/node_modules/http-errors/index.js
var require_http_errors = __commonJS({
  "../../node_modules/.pnpm/http-errors@2.0.0/node_modules/http-errors/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var deprecate = require_depd()("http-errors");
    var setPrototypeOf = require_setprototypeof();
    var statuses = require_statuses();
    var inherits = require_inherits();
    var toIdentifier = require_toidentifier();
    module3.exports = createError;
    module3.exports.HttpError = createHttpErrorConstructor();
    module3.exports.isHttpError = createIsHttpErrorFunction(module3.exports.HttpError);
    populateConstructorExports(module3.exports, statuses.codes, module3.exports.HttpError);
    function codeClass(status2) {
      return Number(String(status2).charAt(0) + "00");
    }
    __name(codeClass, "codeClass");
    function createError() {
      var err;
      var msg;
      var status2 = 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;
          status2 = err.status || err.statusCode || status2;
        } else if (type === "number" && i === 0) {
          status2 = 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 status2 === "number" && (status2 < 400 || status2 >= 600)) {
        deprecate("non-error status code; use only 4xx or 5xx status codes");
      }
      if (typeof status2 !== "number" || !statuses.message[status2] && (status2 < 400 || status2 >= 600)) {
        status2 = 500;
      }
      var HttpError = createError[status2] || createError[codeClass(status2)];
      if (!err) {
        err = HttpError ? new HttpError(msg) : new Error(msg || statuses.message[status2]);
        Error.captureStackTrace(err, createError);
      }
      if (!HttpError || !(err instanceof HttpError) || err.status !== status2) {
        err.expose = status2 < 500;
        err.status = err.statusCode = status2;
      }
      for (var key in props) {
        if (key !== "status" && key !== "statusCode") {
          err[key] = props[key];
        }
      }
      return err;
    }
    __name(createError, "createError");
    function createHttpErrorConstructor() {
      function HttpError() {
        throw new TypeError("cannot construct abstract class");
      }
      __name(HttpError, "HttpError");
      inherits(HttpError, Error);
      return HttpError;
    }
    __name(createHttpErrorConstructor, "createHttpErrorConstructor");
    function createClientErrorConstructor(HttpError, name, code) {
      var className = toClassName(name);
      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;
      }
      __name(ClientError, "ClientError");
      inherits(ClientError, HttpError);
      nameFunc(ClientError, className);
      ClientError.prototype.status = code;
      ClientError.prototype.statusCode = code;
      ClientError.prototype.expose = true;
      return ClientError;
    }
    __name(createClientErrorConstructor, "createClientErrorConstructor");
    function createIsHttpErrorFunction(HttpError) {
      return /* @__PURE__ */ __name(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;
      }, "isHttpError");
    }
    __name(createIsHttpErrorFunction, "createIsHttpErrorFunction");
    function createServerErrorConstructor(HttpError, name, code) {
      var className = toClassName(name);
      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;
      }
      __name(ServerError, "ServerError");
      inherits(ServerError, HttpError);
      nameFunc(ServerError, className);
      ServerError.prototype.status = code;
      ServerError.prototype.statusCode = code;
      ServerError.prototype.expose = false;
      return ServerError;
    }
    __name(createServerErrorConstructor, "createServerErrorConstructor");
    function nameFunc(func, name) {
      var desc = Object.getOwnPropertyDescriptor(func, "name");
      if (desc && desc.configurable) {
        desc.value = name;
        Object.defineProperty(func, "name", desc);
      }
    }
    __name(nameFunc, "nameFunc");
    function populateConstructorExports(exports3, codes, HttpError) {
      codes.forEach(/* @__PURE__ */ __name(function forEachCode(code) {
        var CodeError;
        var name = toIdentifier(statuses.message[code]);
        switch (codeClass(code)) {
          case 400:
            CodeError = createClientErrorConstructor(HttpError, name, code);
            break;
          case 500:
            CodeError = createServerErrorConstructor(HttpError, name, code);
            break;
        }
        if (CodeError) {
          exports3[code] = CodeError;
          exports3[name] = CodeError;
        }
      }, "forEachCode"));
    }
    __name(populateConstructorExports, "populateConstructorExports");
    function toClassName(name) {
      return name.substr(-5) !== "Error" ? name + "Error" : name;
    }
    __name(toClassName, "toClassName");
  }
});

// ../../node_modules/.pnpm/ms@2.0.0/node_modules/ms/index.js
var require_ms = __commonJS({
  "../../node_modules/.pnpm/ms@2.0.0/node_modules/ms/index.js"(exports2, module3) {
    init_import_meta_url();
    var s = 1e3;
    var m2 = s * 60;
    var h2 = m2 * 60;
    var d2 = h2 * 24;
    var y2 = d2 * 365.25;
    module3.exports = function(val, options29) {
      options29 = options29 || {};
      var type = typeof val;
      if (type === "string" && val.length > 0) {
        return parse7(val);
      } else if (type === "number" && isNaN(val) === false) {
        return options29.long ? fmtLong(val) : fmtShort(val);
      }
      throw new Error(
        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
      );
    };
    function parse7(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 n2 = parseFloat(match[1]);
      var type = (match[2] || "ms").toLowerCase();
      switch (type) {
        case "years":
        case "year":
        case "yrs":
        case "yr":
        case "y":
          return n2 * y2;
        case "days":
        case "day":
        case "d":
          return n2 * d2;
        case "hours":
        case "hour":
        case "hrs":
        case "hr":
        case "h":
          return n2 * h2;
        case "minutes":
        case "minute":
        case "mins":
        case "min":
        case "m":
          return n2 * m2;
        case "seconds":
        case "second":
        case "secs":
        case "sec":
        case "s":
          return n2 * s;
        case "milliseconds":
        case "millisecond":
        case "msecs":
        case "msec":
        case "ms":
          return n2;
        default:
          return void 0;
      }
    }
    __name(parse7, "parse");
    function fmtShort(ms) {
      if (ms >= d2) {
        return Math.round(ms / d2) + "d";
      }
      if (ms >= h2) {
        return Math.round(ms / h2) + "h";
      }
      if (ms >= m2) {
        return Math.round(ms / m2) + "m";
      }
      if (ms >= s) {
        return Math.round(ms / s) + "s";
      }
      return ms + "ms";
    }
    __name(fmtShort, "fmtShort");
    function fmtLong(ms) {
      return plural2(ms, d2, "day") || plural2(ms, h2, "hour") || plural2(ms, m2, "minute") || plural2(ms, s, "second") || ms + " ms";
    }
    __name(fmtLong, "fmtLong");
    function plural2(ms, n2, name) {
      if (ms < n2) {
        return;
      }
      if (ms < n2 * 1.5) {
        return Math.floor(ms / n2) + " " + name;
      }
      return Math.ceil(ms / n2) + " " + name + "s";
    }
    __name(plural2, "plural");
  }
});

// ../../node_modules/.pnpm/debug@2.6.9_supports-color@9.2.2/node_modules/debug/src/debug.js
var require_debug2 = __commonJS({
  "../../node_modules/.pnpm/debug@2.6.9_supports-color@9.2.2/node_modules/debug/src/debug.js"(exports2, module3) {
    init_import_meta_url();
    exports2 = module3.exports = createDebug.debug = createDebug["default"] = createDebug;
    exports2.coerce = coerce;
    exports2.disable = disable;
    exports2.enable = enable;
    exports2.enabled = enabled;
    exports2.humanize = require_ms();
    exports2.names = [];
    exports2.skips = [];
    exports2.formatters = {};
    var prevTime;
    function selectColor(namespace) {
      var hash = 0, i;
      for (i in namespace) {
        hash = (hash << 5) - hash + namespace.charCodeAt(i);
        hash |= 0;
      }
      return exports2.colors[Math.abs(hash) % exports2.colors.length];
    }
    __name(selectColor, "selectColor");
    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, format10) {
          if (match === "%%")
            return match;
          index++;
          var formatter = exports2.formatters[format10];
          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);
      }
      __name(debug, "debug");
      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;
    }
    __name(createDebug, "createDebug");
    function enable(namespaces) {
      exports2.save(namespaces);
      exports2.names = [];
      exports2.skips = [];
      var split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
      var len = split.length;
      for (var i = 0; i < len; i++) {
        if (!split[i])
          continue;
        namespaces = split[i].replace(/\*/g, ".*?");
        if (namespaces[0] === "-") {
          exports2.skips.push(new RegExp("^" + namespaces.substr(1) + "$"));
        } else {
          exports2.names.push(new RegExp("^" + namespaces + "$"));
        }
      }
    }
    __name(enable, "enable");
    function disable() {
      exports2.enable("");
    }
    __name(disable, "disable");
    function enabled(name) {
      var i, len;
      for (i = 0, len = exports2.skips.length; i < len; i++) {
        if (exports2.skips[i].test(name)) {
          return false;
        }
      }
      for (i = 0, len = exports2.names.length; i < len; i++) {
        if (exports2.names[i].test(name)) {
          return true;
        }
      }
      return false;
    }
    __name(enabled, "enabled");
    function coerce(val) {
      if (val instanceof Error)
        return val.stack || val.message;
      return val;
    }
    __name(coerce, "coerce");
  }
});

// ../../node_modules/.pnpm/debug@2.6.9_supports-color@9.2.2/node_modules/debug/src/browser.js
var require_browser = __commonJS({
  "../../node_modules/.pnpm/debug@2.6.9_supports-color@9.2.2/node_modules/debug/src/browser.js"(exports2, module3) {
    init_import_meta_url();
    exports2 = module3.exports = require_debug2();
    exports2.log = log2;
    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+)/);
    }
    __name(useColors, "useColors");
    exports2.formatters.j = function(v2) {
      try {
        return JSON.stringify(v2);
      } 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 c2 = "color: " + this.color;
      args.splice(1, 0, c2, "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, c2);
    }
    __name(formatArgs, "formatArgs");
    function log2() {
      return "object" === typeof console && console.log && Function.prototype.apply.call(console.log, console, arguments);
    }
    __name(log2, "log");
    function save(namespaces) {
      try {
        if (null == namespaces) {
          exports2.storage.removeItem("debug");
        } else {
          exports2.storage.debug = namespaces;
        }
      } catch (e3) {
      }
    }
    __name(save, "save");
    function load() {
      var r3;
      try {
        r3 = exports2.storage.debug;
      } catch (e3) {
      }
      if (!r3 && typeof process !== "undefined" && "env" in process) {
        r3 = process.env.DEBUG;
      }
      return r3;
    }
    __name(load, "load");
    exports2.enable(load());
    function localstorage() {
      try {
        return window.localStorage;
      } catch (e3) {
      }
    }
    __name(localstorage, "localstorage");
  }
});

// ../../node_modules/.pnpm/debug@2.6.9_supports-color@9.2.2/node_modules/debug/src/node.js
var require_node4 = __commonJS({
  "../../node_modules/.pnpm/debug@2.6.9_supports-color@9.2.2/node_modules/debug/src/node.js"(exports2, module3) {
    init_import_meta_url();
    var tty2 = require("tty");
    var util4 = require("util");
    exports2 = module3.exports = require_debug2();
    exports2.init = init3;
    exports2.log = log2;
    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(_3, k2) {
        return k2.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 stream2 = 1 === fd ? process.stdout : 2 === fd ? process.stderr : createWritableStdioStream(fd);
    function useColors() {
      return "colors" in exports2.inspectOpts ? Boolean(exports2.inspectOpts.colors) : tty2.isatty(fd);
    }
    __name(useColors, "useColors");
    exports2.formatters.o = function(v2) {
      this.inspectOpts.colors = this.useColors;
      return util4.inspect(v2, this.inspectOpts).split("\n").map(function(str) {
        return str.trim();
      }).join(" ");
    };
    exports2.formatters.O = function(v2) {
      this.inspectOpts.colors = this.useColors;
      return util4.inspect(v2, this.inspectOpts);
    };
    function formatArgs(args) {
      var name = this.namespace;
      var useColors2 = this.useColors;
      if (useColors2) {
        var c2 = this.color;
        var prefix = "  \x1B[3" + c2 + ";1m" + name + " \x1B[0m";
        args[0] = prefix + args[0].split("\n").join("\n" + prefix);
        args.push("\x1B[3" + c2 + "m+" + exports2.humanize(this.diff) + "\x1B[0m");
      } else {
        args[0] = (/* @__PURE__ */ new Date()).toUTCString() + " " + name + " " + args[0];
      }
    }
    __name(formatArgs, "formatArgs");
    function log2() {
      return stream2.write(util4.format.apply(util4, arguments) + "\n");
    }
    __name(log2, "log");
    function save(namespaces) {
      if (null == namespaces) {
        delete process.env.DEBUG;
      } else {
        process.env.DEBUG = namespaces;
      }
    }
    __name(save, "save");
    function load() {
      return process.env.DEBUG;
    }
    __name(load, "load");
    function createWritableStdioStream(fd2) {
      var stream3;
      var tty_wrap = process.binding("tty_wrap");
      switch (tty_wrap.guessHandleType(fd2)) {
        case "TTY":
          stream3 = new tty2.WriteStream(fd2);
          stream3._type = "tty";
          if (stream3._handle && stream3._handle.unref) {
            stream3._handle.unref();
          }
          break;
        case "FILE":
          var fs26 = require("fs");
          stream3 = new fs26.SyncWriteStream(fd2, { autoClose: false });
          stream3._type = "fs";
          break;
        case "PIPE":
        case "TCP":
          var net3 = require("net");
          stream3 = new net3.Socket({
            fd: fd2,
            readable: false,
            writable: true
          });
          stream3.readable = false;
          stream3.read = null;
          stream3._type = "pipe";
          if (stream3._handle && stream3._handle.unref) {
            stream3._handle.unref();
          }
          break;
        default:
          throw new Error("Implement me. Unknown stream file type!");
      }
      stream3.fd = fd2;
      stream3._isStdio = true;
      return stream3;
    }
    __name(createWritableStdioStream, "createWritableStdioStream");
    function init3(debug) {
      debug.inspectOpts = {};
      var keys = Object.keys(exports2.inspectOpts);
      for (var i = 0; i < keys.length; i++) {
        debug.inspectOpts[keys[i]] = exports2.inspectOpts[keys[i]];
      }
    }
    __name(init3, "init");
    exports2.enable(load());
  }
});

// ../../node_modules/.pnpm/debug@2.6.9_supports-color@9.2.2/node_modules/debug/src/index.js
var require_src3 = __commonJS({
  "../../node_modules/.pnpm/debug@2.6.9_supports-color@9.2.2/node_modules/debug/src/index.js"(exports2, module3) {
    init_import_meta_url();
    if (typeof process !== "undefined" && process.type === "renderer") {
      module3.exports = require_browser();
    } else {
      module3.exports = require_node4();
    }
  }
});

// ../../node_modules/.pnpm/destroy@1.2.0/node_modules/destroy/index.js
var require_destroy = __commonJS({
  "../../node_modules/.pnpm/destroy@1.2.0/node_modules/destroy/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var EventEmitter7 = require("events").EventEmitter;
    var ReadStream = require("fs").ReadStream;
    var Stream = require("stream");
    var Zlib = require("zlib");
    module3.exports = destroy;
    function destroy(stream2, suppress) {
      if (isFsReadStream(stream2)) {
        destroyReadStream(stream2);
      } else if (isZlibStream(stream2)) {
        destroyZlibStream(stream2);
      } else if (hasDestroy(stream2)) {
        stream2.destroy();
      }
      if (isEventEmitter(stream2) && suppress) {
        stream2.removeAllListeners("error");
        stream2.addListener("error", noop);
      }
      return stream2;
    }
    __name(destroy, "destroy");
    function destroyReadStream(stream2) {
      stream2.destroy();
      if (typeof stream2.close === "function") {
        stream2.on("open", onOpenClose);
      }
    }
    __name(destroyReadStream, "destroyReadStream");
    function closeZlibStream(stream2) {
      if (stream2._hadError === true) {
        var prop = stream2._binding === null ? "_binding" : "_handle";
        stream2[prop] = {
          close: function() {
            this[prop] = null;
          }
        };
      }
      stream2.close();
    }
    __name(closeZlibStream, "closeZlibStream");
    function destroyZlibStream(stream2) {
      if (typeof stream2.destroy === "function") {
        if (stream2._binding) {
          stream2.destroy();
          if (stream2._processing) {
            stream2._needDrain = true;
            stream2.once("drain", onDrainClearBinding);
          } else {
            stream2._binding.clear();
          }
        } else if (stream2._destroy && stream2._destroy !== Stream.Transform.prototype._destroy) {
          stream2.destroy();
        } else if (stream2._destroy && typeof stream2.close === "function") {
          stream2.destroyed = true;
          stream2.close();
        } else {
          stream2.destroy();
        }
      } else if (typeof stream2.close === "function") {
        closeZlibStream(stream2);
      }
    }
    __name(destroyZlibStream, "destroyZlibStream");
    function hasDestroy(stream2) {
      return stream2 instanceof Stream && typeof stream2.destroy === "function";
    }
    __name(hasDestroy, "hasDestroy");
    function isEventEmitter(val) {
      return val instanceof EventEmitter7;
    }
    __name(isEventEmitter, "isEventEmitter");
    function isFsReadStream(stream2) {
      return stream2 instanceof ReadStream;
    }
    __name(isFsReadStream, "isFsReadStream");
    function isZlibStream(stream2) {
      return stream2 instanceof Zlib.Gzip || stream2 instanceof Zlib.Gunzip || stream2 instanceof Zlib.Deflate || stream2 instanceof Zlib.DeflateRaw || stream2 instanceof Zlib.Inflate || stream2 instanceof Zlib.InflateRaw || stream2 instanceof Zlib.Unzip;
    }
    __name(isZlibStream, "isZlibStream");
    function noop() {
    }
    __name(noop, "noop");
    function onDrainClearBinding() {
      this._binding.clear();
    }
    __name(onDrainClearBinding, "onDrainClearBinding");
    function onOpenClose() {
      if (typeof this.fd === "number") {
        this.close();
      }
    }
    __name(onOpenClose, "onOpenClose");
  }
});

// ../../node_modules/.pnpm/safer-buffer@2.1.2/node_modules/safer-buffer/safer.js
var require_safer = __commonJS({
  "../../node_modules/.pnpm/safer-buffer@2.1.2/node_modules/safer-buffer/safer.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    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, fill2, 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 (!fill2 || fill2.length === 0) {
          buf.fill(0);
        } else if (typeof encoding === "string") {
          buf.fill(fill2, encoding);
        } else {
          buf.fill(fill2);
        }
        return buf;
      };
    }
    if (!safer.kStringMaxLength) {
      try {
        safer.kStringMaxLength = process.binding("buffer").kStringMaxLength;
      } catch (e3) {
      }
    }
    if (!safer.constants) {
      safer.constants = {
        MAX_LENGTH: safer.kMaxLength
      };
      if (safer.kStringMaxLength) {
        safer.constants.MAX_STRING_LENGTH = safer.kStringMaxLength;
      }
    }
    module3.exports = safer;
  }
});

// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/lib/bom-handling.js
var require_bom_handling = __commonJS({
  "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/lib/bom-handling.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var BOMChar = "\uFEFF";
    exports2.PrependBOM = PrependBOMWrapper;
    function PrependBOMWrapper(encoder, options29) {
      this.encoder = encoder;
      this.addBOM = true;
    }
    __name(PrependBOMWrapper, "PrependBOMWrapper");
    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, options29) {
      this.decoder = decoder;
      this.pass = false;
      this.options = options29 || {};
    }
    __name(StripBOMWrapper, "StripBOMWrapper");
    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/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/internal.js
var require_internal = __commonJS({
  "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/internal.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var Buffer3 = require_safer().Buffer;
    module3.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;
        }
      }
    }
    __name(InternalCodec, "InternalCodec");
    InternalCodec.prototype.encoder = InternalEncoder;
    InternalCodec.prototype.decoder = InternalDecoder;
    var StringDecoder2 = require("string_decoder").StringDecoder;
    if (!StringDecoder2.prototype.end)
      StringDecoder2.prototype.end = function() {
      };
    function InternalDecoder(options29, codec) {
      StringDecoder2.call(this, codec.enc);
    }
    __name(InternalDecoder, "InternalDecoder");
    InternalDecoder.prototype = StringDecoder2.prototype;
    function InternalEncoder(options29, codec) {
      this.enc = codec.enc;
    }
    __name(InternalEncoder, "InternalEncoder");
    InternalEncoder.prototype.write = function(str) {
      return Buffer3.from(str, this.enc);
    };
    InternalEncoder.prototype.end = function() {
    };
    function InternalEncoderBase64(options29, codec) {
      this.prevStr = "";
    }
    __name(InternalEncoderBase64, "InternalEncoderBase64");
    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(options29, codec) {
    }
    __name(InternalEncoderCesu8, "InternalEncoderCesu8");
    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(options29, codec) {
      this.acc = 0;
      this.contBytes = 0;
      this.accBytes = 0;
      this.defaultCharUnicode = codec.defaultCharUnicode;
    }
    __name(InternalDecoderCesu8, "InternalDecoderCesu8");
    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/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/utf16.js
var require_utf16 = __commonJS({
  "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/utf16.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var Buffer3 = require_safer().Buffer;
    exports2.utf16be = Utf16BECodec;
    function Utf16BECodec() {
    }
    __name(Utf16BECodec, "Utf16BECodec");
    Utf16BECodec.prototype.encoder = Utf16BEEncoder;
    Utf16BECodec.prototype.decoder = Utf16BEDecoder;
    Utf16BECodec.prototype.bomAware = true;
    function Utf16BEEncoder() {
    }
    __name(Utf16BEEncoder, "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;
    }
    __name(Utf16BEDecoder, "Utf16BEDecoder");
    Utf16BEDecoder.prototype.write = function(buf) {
      if (buf.length == 0)
        return "";
      var buf2 = Buffer3.alloc(buf.length + 1), i = 0, j2 = 0;
      if (this.overflowByte !== -1) {
        buf2[0] = buf[0];
        buf2[1] = this.overflowByte;
        i = 1;
        j2 = 2;
      }
      for (; i < buf.length - 1; i += 2, j2 += 2) {
        buf2[j2] = buf[i + 1];
        buf2[j2 + 1] = buf[i];
      }
      this.overflowByte = i == buf.length - 1 ? buf[buf.length - 1] : -1;
      return buf2.slice(0, j2).toString("ucs2");
    };
    Utf16BEDecoder.prototype.end = function() {
    };
    exports2.utf16 = Utf16Codec;
    function Utf16Codec(codecOptions, iconv) {
      this.iconv = iconv;
    }
    __name(Utf16Codec, "Utf16Codec");
    Utf16Codec.prototype.encoder = Utf16Encoder;
    Utf16Codec.prototype.decoder = Utf16Decoder;
    function Utf16Encoder(options29, codec) {
      options29 = options29 || {};
      if (options29.addBOM === void 0)
        options29.addBOM = true;
      this.encoder = codec.iconv.getEncoder("utf-16le", options29);
    }
    __name(Utf16Encoder, "Utf16Encoder");
    Utf16Encoder.prototype.write = function(str) {
      return this.encoder.write(str);
    };
    Utf16Encoder.prototype.end = function() {
      return this.encoder.end();
    };
    function Utf16Decoder(options29, codec) {
      this.decoder = null;
      this.initialBytes = [];
      this.initialBytesLen = 0;
      this.options = options29 || {};
      this.iconv = codec.iconv;
    }
    __name(Utf16Decoder, "Utf16Decoder");
    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;
    }
    __name(detectEncoding, "detectEncoding");
  }
});

// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/utf7.js
var require_utf7 = __commonJS({
  "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/utf7.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var Buffer3 = require_safer().Buffer;
    exports2.utf7 = Utf7Codec;
    exports2.unicode11utf7 = "utf7";
    function Utf7Codec(codecOptions, iconv) {
      this.iconv = iconv;
    }
    __name(Utf7Codec, "Utf7Codec");
    Utf7Codec.prototype.encoder = Utf7Encoder;
    Utf7Codec.prototype.decoder = Utf7Decoder;
    Utf7Codec.prototype.bomAware = true;
    var nonDirectChars = /[^A-Za-z0-9'\(\),-\.\/:\? \n\r\t]+/g;
    function Utf7Encoder(options29, codec) {
      this.iconv = codec.iconv;
    }
    __name(Utf7Encoder, "Utf7Encoder");
    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(options29, codec) {
      this.iconv = codec.iconv;
      this.inBase64 = false;
      this.base64Accum = "";
    }
    __name(Utf7Decoder, "Utf7Decoder");
    var base64Regex = /[A-Za-z0-9\/+]/;
    var base64Chars = [];
    for (i = 0; i < 256; i++)
      base64Chars[i] = base64Regex.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;
    }
    __name(Utf7IMAPCodec, "Utf7IMAPCodec");
    Utf7IMAPCodec.prototype.encoder = Utf7IMAPEncoder;
    Utf7IMAPCodec.prototype.decoder = Utf7IMAPDecoder;
    Utf7IMAPCodec.prototype.bomAware = true;
    function Utf7IMAPEncoder(options29, codec) {
      this.iconv = codec.iconv;
      this.inBase64 = false;
      this.base64Accum = Buffer3.alloc(6);
      this.base64AccumIdx = 0;
    }
    __name(Utf7IMAPEncoder, "Utf7IMAPEncoder");
    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(options29, codec) {
      this.iconv = codec.iconv;
      this.inBase64 = false;
      this.base64Accum = "";
    }
    __name(Utf7IMAPDecoder, "Utf7IMAPDecoder");
    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/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/sbcs-codec.js
var require_sbcs_codec = __commonJS({
  "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/sbcs-codec.js"(exports2) {
    "use strict";
    init_import_meta_url();
    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;
    }
    __name(SBCSCodec, "SBCSCodec");
    SBCSCodec.prototype.encoder = SBCSEncoder;
    SBCSCodec.prototype.decoder = SBCSDecoder;
    function SBCSEncoder(options29, codec) {
      this.encodeBuf = codec.encodeBuf;
    }
    __name(SBCSEncoder, "SBCSEncoder");
    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(options29, codec) {
      this.decodeBuf = codec.decodeBuf;
    }
    __name(SBCSDecoder, "SBCSDecoder");
    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/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/sbcs-data.js
var require_sbcs_data = __commonJS({
  "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/sbcs-data.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.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"
      },
      // 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/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/sbcs-data-generated.js
var require_sbcs_data_generated = __commonJS({
  "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/sbcs-data-generated.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.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/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/dbcs-codec.js
var require_dbcs_codec = __commonJS({
  "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/dbcs-codec.js"(exports2) {
    "use strict";
    init_import_meta_url();
    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 j2 = val.from; j2 <= val.to; j2++)
              skipEncodeChars[j2] = 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 j2 = 48; j2 <= 57; j2++)
            secondByteNode[j2] = 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;
      }
    }
    __name(DBCSCodec, "DBCSCodec");
    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 node2 = this.decodeTables[0];
      for (var i2 = bytes.length - 1; i2 > 0; i2--) {
        var val = node2[bytes[i2]];
        if (val == UNASSIGNED) {
          node2[bytes[i2]] = NODE_START - this.decodeTables.length;
          this.decodeTables.push(node2 = UNASSIGNED_NODE.slice(0));
        } else if (val <= NODE_START) {
          node2 = this.decodeTables[NODE_START - val];
        } else
          throw new Error("Overwrite byte in " + this.encodingName + ", addr: " + addr.toString(16));
      }
      return node2;
    };
    DBCSCodec.prototype._addDecodeChunk = function(chunk) {
      var curAddr = parseInt(chunk[0], 16);
      var writeTable = this._getDecodeTrieNode(curAddr);
      curAddr = curAddr & 255;
      for (var k2 = 1; k2 < chunk.length; k2++) {
        var part = chunk[k2];
        if (typeof part === "string") {
          for (var l2 = 0; l2 < part.length; ) {
            var code = part.charCodeAt(l2++);
            if (55296 <= code && code < 56320) {
              var codeTrail = part.charCodeAt(l2++);
              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 m2 = 0; m2 < len; m2++)
                seq.push(part.charCodeAt(l2++));
              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 l2 = 0; l2 < part; l2++)
            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 node2;
      if (bucket[low] <= SEQ_START) {
        node2 = this.encodeTableSeq[SEQ_START - bucket[low]];
      } else {
        node2 = {};
        if (bucket[low] !== UNASSIGNED)
          node2[DEF_CHAR] = bucket[low];
        bucket[low] = SEQ_START - this.encodeTableSeq.length;
        this.encodeTableSeq.push(node2);
      }
      for (var j2 = 1; j2 < seq.length - 1; j2++) {
        var oldVal = node2[uCode];
        if (typeof oldVal === "object")
          node2 = oldVal;
        else {
          node2 = node2[uCode] = {};
          if (oldVal !== void 0)
            node2[DEF_CHAR] = oldVal;
        }
      }
      uCode = seq[seq.length - 1];
      node2[uCode] = dbcsCode;
    };
    DBCSCodec.prototype._fillEncodeTable = function(nodeIdx, prefix, skipEncodeChars) {
      var node2 = this.decodeTables[nodeIdx];
      for (var i2 = 0; i2 < 256; i2++) {
        var uCode = node2[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(options29, codec) {
      this.leadSurrogate = -1;
      this.seqObj = void 0;
      this.encodeTable = codec.encodeTable;
      this.encodeTableSeq = codec.encodeTableSeq;
      this.defaultCharSingleByte = codec.defCharSB;
      this.gb18030 = codec.gb18030;
    }
    __name(DBCSEncoder, "DBCSEncoder");
    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, j2 = 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[j2++] = 129 + Math.floor(dbcsCode / 12600);
              dbcsCode = dbcsCode % 12600;
              newBuf[j2++] = 48 + Math.floor(dbcsCode / 1260);
              dbcsCode = dbcsCode % 1260;
              newBuf[j2++] = 129 + Math.floor(dbcsCode / 10);
              dbcsCode = dbcsCode % 10;
              newBuf[j2++] = 48 + dbcsCode;
              continue;
            }
          }
        }
        if (dbcsCode === UNASSIGNED)
          dbcsCode = this.defaultCharSingleByte;
        if (dbcsCode < 256) {
          newBuf[j2++] = dbcsCode;
        } else if (dbcsCode < 65536) {
          newBuf[j2++] = dbcsCode >> 8;
          newBuf[j2++] = dbcsCode & 255;
        } else {
          newBuf[j2++] = dbcsCode >> 16;
          newBuf[j2++] = dbcsCode >> 8 & 255;
          newBuf[j2++] = dbcsCode & 255;
        }
      }
      this.seqObj = seqObj;
      this.leadSurrogate = leadSurrogate;
      return newBuf.slice(0, j2);
    };
    DBCSEncoder.prototype.end = function() {
      if (this.leadSurrogate === -1 && this.seqObj === void 0)
        return;
      var newBuf = Buffer3.alloc(10), j2 = 0;
      if (this.seqObj) {
        var dbcsCode = this.seqObj[DEF_CHAR];
        if (dbcsCode !== void 0) {
          if (dbcsCode < 256) {
            newBuf[j2++] = dbcsCode;
          } else {
            newBuf[j2++] = dbcsCode >> 8;
            newBuf[j2++] = dbcsCode & 255;
          }
        } else {
        }
        this.seqObj = void 0;
      }
      if (this.leadSurrogate !== -1) {
        newBuf[j2++] = this.defaultCharSingleByte;
        this.leadSurrogate = -1;
      }
      return newBuf.slice(0, j2);
    };
    DBCSEncoder.prototype.findIdx = findIdx;
    function DBCSDecoder(options29, codec) {
      this.nodeIdx = 0;
      this.prevBuf = Buffer3.alloc(0);
      this.decodeTables = codec.decodeTables;
      this.decodeTableSeq = codec.decodeTableSeq;
      this.defaultCharUnicode = codec.defaultCharUnicode;
      this.gb18030 = codec.gb18030;
    }
    __name(DBCSDecoder, "DBCSDecoder");
    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, j2 = 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 k2 = 0; k2 < seq.length - 1; k2++) {
            uCode = seq[k2];
            newBuf[j2++] = uCode & 255;
            newBuf[j2++] = 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[j2++] = uCodeLead & 255;
          newBuf[j2++] = uCodeLead >> 8;
          uCode = 56320 + uCode % 1024;
        }
        newBuf[j2++] = uCode & 255;
        newBuf[j2++] = 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, j2).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 l2 = 0, r3 = table.length;
      while (l2 < r3 - 1) {
        var mid = l2 + Math.floor((r3 - l2 + 1) / 2);
        if (table[mid] <= val)
          l2 = mid;
        else
          r3 = mid;
      }
      return l2;
    }
    __name(findIdx, "findIdx");
  }
});

// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/shiftjis.json
var require_shiftjis = __commonJS({
  "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/shiftjis.json"(exports2, module3) {
    module3.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/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/eucjp.json
var require_eucjp = __commonJS({
  "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/eucjp.json"(exports2, module3) {
    module3.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/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/cp936.json
var require_cp936 = __commonJS({
  "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/cp936.json"(exports2, module3) {
    module3.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/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/gbk-added.json
var require_gbk_added = __commonJS({
  "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/gbk-added.json"(exports2, module3) {
    module3.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/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/gb18030-ranges.json
var require_gb18030_ranges = __commonJS({
  "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/gb18030-ranges.json"(exports2, module3) {
    module3.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/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/cp949.json
var require_cp949 = __commonJS({
  "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/cp949.json"(exports2, module3) {
    module3.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/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/cp950.json
var require_cp950 = __commonJS({
  "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/cp950.json"(exports2, module3) {
    module3.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/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/big5-added.json
var require_big5_added = __commonJS({
  "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/tables/big5-added.json"(exports2, module3) {
    module3.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/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/dbcs-data.js
var require_dbcs_data = __commonJS({
  "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/dbcs-data.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.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: [41676]
      },
      "cnbig5": "big5hkscs",
      "csbig5": "big5hkscs",
      "xxbig5": "big5hkscs"
    };
  }
});

// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/index.js
var require_encodings = __commonJS({
  "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var modules = [
      require_internal(),
      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++) {
      module3 = modules[i];
      for (enc in module3)
        if (Object.prototype.hasOwnProperty.call(module3, enc))
          exports2[enc] = module3[enc];
    }
    var module3;
    var enc;
    var i;
  }
});

// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/lib/streams.js
var require_streams = __commonJS({
  "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/lib/streams.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var Buffer3 = require("buffer").Buffer;
    var Transform = require("stream").Transform;
    module3.exports = function(iconv) {
      iconv.encodeStream = /* @__PURE__ */ __name(function encodeStream(encoding, options29) {
        return new IconvLiteEncoderStream(iconv.getEncoder(encoding, options29), options29);
      }, "encodeStream");
      iconv.decodeStream = /* @__PURE__ */ __name(function decodeStream(encoding, options29) {
        return new IconvLiteDecoderStream(iconv.getDecoder(encoding, options29), options29);
      }, "decodeStream");
      iconv.supportsStreams = true;
      iconv.IconvLiteEncoderStream = IconvLiteEncoderStream;
      iconv.IconvLiteDecoderStream = IconvLiteDecoderStream;
      iconv._collect = IconvLiteDecoderStream.prototype.collect;
    };
    function IconvLiteEncoderStream(conv, options29) {
      this.conv = conv;
      options29 = options29 || {};
      options29.decodeStrings = false;
      Transform.call(this, options29);
    }
    __name(IconvLiteEncoderStream, "IconvLiteEncoderStream");
    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 (e3) {
        done(e3);
      }
    };
    IconvLiteEncoderStream.prototype._flush = function(done) {
      try {
        var res = this.conv.end();
        if (res && res.length)
          this.push(res);
        done();
      } catch (e3) {
        done(e3);
      }
    };
    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, options29) {
      this.conv = conv;
      options29 = options29 || {};
      options29.encoding = this.encoding = "utf8";
      Transform.call(this, options29);
    }
    __name(IconvLiteDecoderStream, "IconvLiteDecoderStream");
    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 (e3) {
        done(e3);
      }
    };
    IconvLiteDecoderStream.prototype._flush = function(done) {
      try {
        var res = this.conv.end();
        if (res && res.length)
          this.push(res, this.encoding);
        done();
      } catch (e3) {
        done(e3);
      }
    };
    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/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/lib/extend-node.js
var require_extend_node = __commonJS({
  "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/lib/extend-node.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var Buffer3 = require("buffer").Buffer;
    module3.exports = function(iconv) {
      var original = void 0;
      iconv.supportsNodeEncodingsExtension = !(Buffer3.from || new Buffer3(0) instanceof Uint8Array);
      iconv.extendNodeEncodings = /* @__PURE__ */ __name(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(string, 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, string, offset, length, encoding);
          if (string.length > 0 && (length < 0 || offset < 0))
            throw new RangeError("attempt to write beyond buffer bounds");
          var buf = iconv.encode(string, 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(string, offset, length, encoding) {
          var _offset = offset, _length = 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, string, _offset, _length, _encoding);
          offset = +offset || 0;
          var remaining = this.length - offset;
          if (!length) {
            length = remaining;
          } else {
            length = +length;
            if (length > remaining) {
              length = remaining;
            }
          }
          if (string.length > 0 && (length < 0 || offset < 0))
            throw new RangeError("attempt to write beyond buffer bounds");
          var buf = iconv.encode(string, 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 = /* @__PURE__ */ __name(function setEncoding(enc, options29) {
            this._readableState.decoder = iconv.getDecoder(enc, options29);
            this._readableState.encoding = enc;
          }, "setEncoding");
          Readable2.prototype.collect = iconv._collect;
        }
      }, "extendNodeEncodings");
      iconv.undoExtendNodeEncodings = /* @__PURE__ */ __name(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;
      }, "undoExtendNodeEncodings");
    };
  }
});

// ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/lib/index.js
var require_lib2 = __commonJS({
  "../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/lib/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var Buffer3 = require_safer().Buffer;
    var bomHandling = require_bom_handling();
    var iconv = module3.exports;
    iconv.encodings = null;
    iconv.defaultCharUnicode = "\uFFFD";
    iconv.defaultCharSingleByte = "?";
    iconv.encode = /* @__PURE__ */ __name(function encode(str, encoding, options29) {
      str = "" + (str || "");
      var encoder = iconv.getEncoder(encoding, options29);
      var res = encoder.write(str);
      var trail = encoder.end();
      return trail && trail.length > 0 ? Buffer3.concat([res, trail]) : res;
    }, "encode");
    iconv.decode = /* @__PURE__ */ __name(function decode(buf, encoding, options29) {
      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, options29);
      var res = decoder.write(buf);
      var trail = decoder.end();
      return trail ? res + trail : res;
    }, "decode");
    iconv.encodingExists = /* @__PURE__ */ __name(function encodingExists(enc) {
      try {
        iconv.getCodec(enc);
        return true;
      } catch (e3) {
        return false;
      }
    }, "encodingExists");
    iconv.toEncoding = iconv.encode;
    iconv.fromEncoding = iconv.decode;
    iconv._codecDataCache = {};
    iconv.getCodec = /* @__PURE__ */ __name(function getCodec(encoding) {
      if (!iconv.encodings)
        iconv.encodings = require_encodings();
      var enc = iconv._canonicalizeEncoding(encoding);
      var codecOptions = {};
      while (true) {
        var codec = iconv._codecDataCache[enc];
        if (codec)
          return codec;
        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;
            codec = new codecDef(codecOptions, iconv);
            iconv._codecDataCache[codecOptions.encodingName] = codec;
            return codec;
          default:
            throw new Error("Encoding not recognized: '" + encoding + "' (searched as: '" + enc + "')");
        }
      }
    }, "getCodec");
    iconv._canonicalizeEncoding = function(encoding) {
      return ("" + encoding).toLowerCase().replace(/:\d{4}$|[^0-9a-z]/g, "");
    };
    iconv.getEncoder = /* @__PURE__ */ __name(function getEncoder(encoding, options29) {
      var codec = iconv.getCodec(encoding), encoder = new codec.encoder(options29, codec);
      if (codec.bomAware && options29 && options29.addBOM)
        encoder = new bomHandling.PrependBOM(encoder, options29);
      return encoder;
    }, "getEncoder");
    iconv.getDecoder = /* @__PURE__ */ __name(function getDecoder(encoding, options29) {
      var codec = iconv.getCodec(encoding), decoder = new codec.decoder(options29, codec);
      if (codec.bomAware && !(options29 && options29.stripBOM === false))
        decoder = new bomHandling.StripBOM(decoder, options29);
      return decoder;
    }, "getDecoder");
    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_streams()(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/.pnpm/unpipe@1.0.0/node_modules/unpipe/index.js
var require_unpipe = __commonJS({
  "../../node_modules/.pnpm/unpipe@1.0.0/node_modules/unpipe/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = unpipe;
    function hasPipeDataListeners(stream2) {
      var listeners = stream2.listeners("data");
      for (var i = 0; i < listeners.length; i++) {
        if (listeners[i].name === "ondata") {
          return true;
        }
      }
      return false;
    }
    __name(hasPipeDataListeners, "hasPipeDataListeners");
    function unpipe(stream2) {
      if (!stream2) {
        throw new TypeError("argument stream is required");
      }
      if (typeof stream2.unpipe === "function") {
        stream2.unpipe();
        return;
      }
      if (!hasPipeDataListeners(stream2)) {
        return;
      }
      var listener;
      var listeners = stream2.listeners("close");
      for (var i = 0; i < listeners.length; i++) {
        listener = listeners[i];
        if (listener.name !== "cleanup" && listener.name !== "onclose") {
          continue;
        }
        listener.call(stream2);
      }
    }
    __name(unpipe, "unpipe");
  }
});

// ../../node_modules/.pnpm/raw-body@2.5.1/node_modules/raw-body/index.js
var require_raw_body = __commonJS({
  "../../node_modules/.pnpm/raw-body@2.5.1/node_modules/raw-body/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var asyncHooks = tryRequireAsyncHooks();
    var bytes = require_bytes();
    var createError = require_http_errors();
    var iconv = require_lib2();
    var unpipe = require_unpipe();
    module3.exports = getRawBody;
    var ICONV_ENCODING_MESSAGE_REGEXP = /^Encoding not recognized: /;
    function getDecoder(encoding) {
      if (!encoding)
        return null;
      try {
        return iconv.getDecoder(encoding);
      } catch (e3) {
        if (!ICONV_ENCODING_MESSAGE_REGEXP.test(e3.message))
          throw e3;
        throw createError(415, "specified encoding unsupported", {
          encoding,
          type: "encoding.unsupported"
        });
      }
    }
    __name(getDecoder, "getDecoder");
    function getRawBody(stream2, options29, callback) {
      var done = callback;
      var opts = options29 || {};
      if (options29 === true || typeof options29 === "string") {
        opts = {
          encoding: options29
        };
      }
      if (typeof options29 === "function") {
        done = options29;
        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 readStream(stream2, encoding, length, limit, wrap4(done));
      }
      return new Promise(/* @__PURE__ */ __name(function executor(resolve19, reject) {
        readStream(stream2, encoding, length, limit, /* @__PURE__ */ __name(function onRead(err, buf) {
          if (err)
            return reject(err);
          resolve19(buf);
        }, "onRead"));
      }, "executor"));
    }
    __name(getRawBody, "getRawBody");
    function halt(stream2) {
      unpipe(stream2);
      if (typeof stream2.pause === "function") {
        stream2.pause();
      }
    }
    __name(halt, "halt");
    function readStream(stream2, 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 = stream2._readableState;
      if (stream2._decoder || state && (state.encoding || state.decoder)) {
        return done(createError(500, "stream encoding should not be set", {
          type: "stream.encoding.set"
        }));
      }
      if (typeof stream2.readable !== "undefined" && !stream2.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 ? "" : [];
      stream2.on("aborted", onAborted);
      stream2.on("close", cleanup);
      stream2.on("data", onData);
      stream2.on("end", onEnd);
      stream2.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(stream2);
          }
          callback.apply(null, args);
        }
        __name(invokeCallback, "invokeCallback");
      }
      __name(done, "done");
      function onAborted() {
        if (complete)
          return;
        done(createError(400, "request aborted", {
          code: "ECONNABORTED",
          expected: length,
          length,
          received,
          type: "request.aborted"
        }));
      }
      __name(onAborted, "onAborted");
      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);
        }
      }
      __name(onData, "onData");
      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 string = decoder ? buffer + (decoder.end() || "") : Buffer.concat(buffer);
          done(null, string);
        }
      }
      __name(onEnd, "onEnd");
      function cleanup() {
        buffer = null;
        stream2.removeListener("aborted", onAborted);
        stream2.removeListener("data", onData);
        stream2.removeListener("end", onEnd);
        stream2.removeListener("error", onEnd);
        stream2.removeListener("close", cleanup);
      }
      __name(cleanup, "cleanup");
    }
    __name(readStream, "readStream");
    function tryRequireAsyncHooks() {
      try {
        return require("async_hooks");
      } catch (e3) {
        return {};
      }
    }
    __name(tryRequireAsyncHooks, "tryRequireAsyncHooks");
    function wrap4(fn2) {
      var res;
      if (asyncHooks.AsyncResource) {
        res = new asyncHooks.AsyncResource(fn2.name || "bound-anonymous-fn");
      }
      if (!res || !res.runInAsyncScope) {
        return fn2;
      }
      return res.runInAsyncScope.bind(res, fn2, null);
    }
    __name(wrap4, "wrap");
  }
});

// ../../node_modules/.pnpm/ee-first@1.1.1/node_modules/ee-first/index.js
var require_ee_first = __commonJS({
  "../../node_modules/.pnpm/ee-first@1.1.1/node_modules/ee-first/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.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 j2 = 1; j2 < arr.length; j2++) {
          var event = arr[j2];
          var fn2 = listener(event, callback);
          ee.on(event, fn2);
          cleanups.push({
            ee,
            event,
            fn: fn2
          });
        }
      }
      function callback() {
        cleanup();
        done.apply(null, arguments);
      }
      __name(callback, "callback");
      function cleanup() {
        var x2;
        for (var i2 = 0; i2 < cleanups.length; i2++) {
          x2 = cleanups[i2];
          x2.ee.removeListener(x2.event, x2.fn);
        }
      }
      __name(cleanup, "cleanup");
      function thunk(fn3) {
        done = fn3;
      }
      __name(thunk, "thunk");
      thunk.cancel = cleanup;
      return thunk;
    }
    __name(first, "first");
    function listener(event, done) {
      return /* @__PURE__ */ __name(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);
      }, "onevent");
    }
    __name(listener, "listener");
  }
});

// ../../node_modules/.pnpm/on-finished@2.4.1/node_modules/on-finished/index.js
var require_on_finished = __commonJS({
  "../../node_modules/.pnpm/on-finished@2.4.1/node_modules/on-finished/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = onFinished;
    module3.exports.isFinished = isFinished;
    var asyncHooks = tryRequireAsyncHooks();
    var first = require_ee_first();
    var defer = typeof setImmediate === "function" ? setImmediate : function(fn2) {
      process.nextTick(fn2.bind.apply(fn2, arguments));
    };
    function onFinished(msg, listener) {
      if (isFinished(msg) !== false) {
        defer(listener, null, msg);
        return msg;
      }
      attachListener(msg, wrap4(listener));
      return msg;
    }
    __name(onFinished, "onFinished");
    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;
    }
    __name(isFinished, "isFinished");
    function attachFinishedListener(msg, callback) {
      var eeMsg;
      var eeSocket;
      var finished = false;
      function onFinish(error2) {
        eeMsg.cancel();
        eeSocket.cancel();
        finished = true;
        callback(error2);
      }
      __name(onFinish, "onFinish");
      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);
      }
      __name(onSocket, "onSocket");
      if (msg.socket) {
        onSocket(msg.socket);
        return;
      }
      msg.on("socket", onSocket);
      if (msg.socket === void 0) {
        patchAssignSocket(msg, onSocket);
      }
    }
    __name(attachFinishedListener, "attachFinishedListener");
    function attachListener(msg, listener) {
      var attached = msg.__onFinished;
      if (!attached || !attached.queue) {
        attached = msg.__onFinished = createListener(msg);
        attachFinishedListener(msg, attached);
      }
      attached.queue.push(listener);
    }
    __name(attachListener, "attachListener");
    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);
        }
      }
      __name(listener, "listener");
      listener.queue = [];
      return listener;
    }
    __name(createListener, "createListener");
    function patchAssignSocket(res, callback) {
      var assignSocket = res.assignSocket;
      if (typeof assignSocket !== "function")
        return;
      res.assignSocket = /* @__PURE__ */ __name(function _assignSocket(socket) {
        assignSocket.call(this, socket);
        callback(socket);
      }, "_assignSocket");
    }
    __name(patchAssignSocket, "patchAssignSocket");
    function tryRequireAsyncHooks() {
      try {
        return require("async_hooks");
      } catch (e3) {
        return {};
      }
    }
    __name(tryRequireAsyncHooks, "tryRequireAsyncHooks");
    function wrap4(fn2) {
      var res;
      if (asyncHooks.AsyncResource) {
        res = new asyncHooks.AsyncResource(fn2.name || "bound-anonymous-fn");
      }
      if (!res || !res.runInAsyncScope) {
        return fn2;
      }
      return res.runInAsyncScope.bind(res, fn2, null);
    }
    __name(wrap4, "wrap");
  }
});

// ../../node_modules/.pnpm/body-parser@1.20.0_supports-color@9.2.2/node_modules/body-parser/lib/read.js
var require_read = __commonJS({
  "../../node_modules/.pnpm/body-parser@1.20.0_supports-color@9.2.2/node_modules/body-parser/lib/read.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var createError = require_http_errors();
    var destroy = require_destroy();
    var getBody = require_raw_body();
    var iconv = require_lib2();
    var onFinished = require_on_finished();
    var unpipe = require_unpipe();
    var zlib = require("zlib");
    module3.exports = read;
    function read(req, res, next, parse7, debug, options29) {
      var length;
      var opts = options29;
      var stream2;
      req._body = true;
      var encoding = opts.encoding !== null ? opts.encoding : null;
      var verify = opts.verify;
      try {
        stream2 = contentstream(req, debug, opts.inflate);
        length = stream2.length;
        stream2.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(stream2, opts, function(error2, body) {
        if (error2) {
          var _error;
          if (error2.type === "encoding.unsupported") {
            _error = createError(415, 'unsupported charset "' + encoding.toUpperCase() + '"', {
              charset: encoding.toLowerCase(),
              type: "charset.unsupported"
            });
          } else {
            _error = createError(400, error2);
          }
          if (stream2 !== req) {
            unpipe(req);
            destroy(stream2, true);
          }
          dump(req, /* @__PURE__ */ __name(function onfinished() {
            next(createError(400, _error));
          }, "onfinished"));
          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 = parse7(str);
        } catch (err) {
          next(createError(400, err, {
            body: str,
            type: err.type || "entity.parse.failed"
          }));
          return;
        }
        next();
      });
    }
    __name(read, "read");
    function contentstream(req, debug, inflate) {
      var encoding = (req.headers["content-encoding"] || "identity").toLowerCase();
      var length = req.headers["content-length"];
      var stream2;
      debug('content-encoding "%s"', encoding);
      if (inflate === false && encoding !== "identity") {
        throw createError(415, "content encoding unsupported", {
          encoding,
          type: "encoding.unsupported"
        });
      }
      switch (encoding) {
        case "deflate":
          stream2 = zlib.createInflate();
          debug("inflate body");
          req.pipe(stream2);
          break;
        case "gzip":
          stream2 = zlib.createGunzip();
          debug("gunzip body");
          req.pipe(stream2);
          break;
        case "identity":
          stream2 = req;
          stream2.length = length;
          break;
        default:
          throw createError(415, 'unsupported content encoding "' + encoding + '"', {
            encoding,
            type: "encoding.unsupported"
          });
      }
      return stream2;
    }
    __name(contentstream, "contentstream");
    function dump(req, callback) {
      if (onFinished.isFinished(req)) {
        callback(null);
      } else {
        onFinished(req, callback);
        req.resume();
      }
    }
    __name(dump, "dump");
  }
});

// ../../node_modules/.pnpm/media-typer@0.3.0/node_modules/media-typer/index.js
var require_media_typer = __commonJS({
  "../../node_modules/.pnpm/media-typer@0.3.0/node_modules/media-typer/index.js"(exports2) {
    init_import_meta_url();
    var paramRegExp = /; *([!#$%&'\*\+\-\.0-9A-Z\^_`a-z\|~]+) *= *("(?:[ !\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u0020-\u007e])*"|[!#$%&'\*\+\-\.0-9A-Z\^_`a-z\|~]+) */g;
    var textRegExp = /^[\u0020-\u007e\u0080-\u00ff]+$/;
    var tokenRegExp = /^[!#$%&'\*\+\-\.0-9A-Z\^_`a-z\|~]+$/;
    var qescRegExp = /\\([\u0000-\u007f])/g;
    var quoteRegExp = /([\\"])/g;
    var subtypeNameRegExp = /^[A-Za-z0-9][A-Za-z0-9!#$&^_.-]{0,126}$/;
    var typeNameRegExp = /^[A-Za-z0-9][A-Za-z0-9!#$&^_-]{0,126}$/;
    var typeRegExp = /^ *([A-Za-z0-9][A-Za-z0-9!#$&^_-]{0,126})\/([A-Za-z0-9][A-Za-z0-9!#$&^_.+-]{0,126}) *$/;
    exports2.format = format10;
    exports2.parse = parse7;
    function format10(obj) {
      if (!obj || typeof obj !== "object") {
        throw new TypeError("argument obj is required");
      }
      var parameters = obj.parameters;
      var subtype = obj.subtype;
      var suffix = obj.suffix;
      var type = obj.type;
      if (!type || !typeNameRegExp.test(type)) {
        throw new TypeError("invalid type");
      }
      if (!subtype || !subtypeNameRegExp.test(subtype)) {
        throw new TypeError("invalid subtype");
      }
      var string = type + "/" + subtype;
      if (suffix) {
        if (!typeNameRegExp.test(suffix)) {
          throw new TypeError("invalid suffix");
        }
        string += "+" + suffix;
      }
      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 (!tokenRegExp.test(param)) {
            throw new TypeError("invalid parameter name");
          }
          string += "; " + param + "=" + qstring(parameters[param]);
        }
      }
      return string;
    }
    __name(format10, "format");
    function parse7(string) {
      if (!string) {
        throw new TypeError("argument string is required");
      }
      if (typeof string === "object") {
        string = getcontenttype(string);
      }
      if (typeof string !== "string") {
        throw new TypeError("argument string is required to be a string");
      }
      var index = string.indexOf(";");
      var type = index !== -1 ? string.substr(0, index) : string;
      var key;
      var match;
      var obj = splitType(type);
      var params = {};
      var value;
      paramRegExp.lastIndex = index;
      while (match = paramRegExp.exec(string)) {
        if (match.index !== index) {
          throw new TypeError("invalid parameter format");
        }
        index += match[0].length;
        key = match[1].toLowerCase();
        value = match[2];
        if (value[0] === '"') {
          value = value.substr(1, value.length - 2).replace(qescRegExp, "$1");
        }
        params[key] = value;
      }
      if (index !== -1 && index !== string.length) {
        throw new TypeError("invalid parameter format");
      }
      obj.parameters = params;
      return obj;
    }
    __name(parse7, "parse");
    function getcontenttype(obj) {
      if (typeof obj.getHeader === "function") {
        return obj.getHeader("content-type");
      }
      if (typeof obj.headers === "object") {
        return obj.headers && obj.headers["content-type"];
      }
    }
    __name(getcontenttype, "getcontenttype");
    function qstring(val) {
      var str = String(val);
      if (tokenRegExp.test(str)) {
        return str;
      }
      if (str.length > 0 && !textRegExp.test(str)) {
        throw new TypeError("invalid parameter value");
      }
      return '"' + str.replace(quoteRegExp, "\\$1") + '"';
    }
    __name(qstring, "qstring");
    function splitType(string) {
      var match = typeRegExp.exec(string.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);
      }
      var obj = {
        type,
        subtype,
        suffix
      };
      return obj;
    }
    __name(splitType, "splitType");
  }
});

// ../../node_modules/.pnpm/mime-db@1.52.0/node_modules/mime-db/db.json
var require_db = __commonJS({
  "../../node_modules/.pnpm/mime-db@1.52.0/node_modules/mime-db/db.json"(exports2, module3) {
    module3.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/.pnpm/mime-db@1.52.0/node_modules/mime-db/index.js
var require_mime_db = __commonJS({
  "../../node_modules/.pnpm/mime-db@1.52.0/node_modules/mime-db/index.js"(exports2, module3) {
    init_import_meta_url();
    module3.exports = require_db();
  }
});

// ../../node_modules/.pnpm/mime-types@2.1.35/node_modules/mime-types/index.js
var require_mime_types = __commonJS({
  "../../node_modules/.pnpm/mime-types@2.1.35/node_modules/mime-types/index.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var db = require_mime_db();
    var extname4 = 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 && db[match[1].toLowerCase()];
      if (mime && mime.charset) {
        return mime.charset;
      }
      if (match && TEXT_TYPE_REGEXP.test(match[1])) {
        return "UTF-8";
      }
      return false;
    }
    __name(charset, "charset");
    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;
    }
    __name(contentType, "contentType");
    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];
    }
    __name(extension, "extension");
    function lookup(path67) {
      if (!path67 || typeof path67 !== "string") {
        return false;
      }
      var extension2 = extname4("x." + path67).toLowerCase().substr(1);
      if (!extension2) {
        return false;
      }
      return exports2.types[extension2] || false;
    }
    __name(lookup, "lookup");
    function populateMaps(extensions, types) {
      var preference = ["nginx", "apache", void 0, "iana"];
      Object.keys(db).forEach(/* @__PURE__ */ __name(function forEachMimeType(type) {
        var mime = db[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(db[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;
        }
      }, "forEachMimeType"));
    }
    __name(populateMaps, "populateMaps");
  }
});

// ../../node_modules/.pnpm/type-is@1.6.18/node_modules/type-is/index.js
var require_type_is = __commonJS({
  "../../node_modules/.pnpm/type-is@1.6.18/node_modules/type-is/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var typer = require_media_typer();
    var mime = require_mime_types();
    module3.exports = typeofrequest;
    module3.exports.is = typeis;
    module3.exports.hasBody = hasbody;
    module3.exports.normalize = normalize3;
    module3.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(normalize3(type = types[i]), val)) {
          return type[0] === "+" || type.indexOf("*") !== -1 ? val : type;
        }
      }
      return false;
    }
    __name(typeis, "typeis");
    function hasbody(req) {
      return req.headers["transfer-encoding"] !== void 0 || !isNaN(req.headers["content-length"]);
    }
    __name(hasbody, "hasbody");
    function typeofrequest(req, types_) {
      var types = types_;
      if (!hasbody(req)) {
        return null;
      }
      if (arguments.length > 2) {
        types = new Array(arguments.length - 1);
        for (var i = 0; i < types.length; i++) {
          types[i] = arguments[i + 1];
        }
      }
      var value = req.headers["content-type"];
      return typeis(value, types);
    }
    __name(typeofrequest, "typeofrequest");
    function normalize3(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;
    }
    __name(normalize3, "normalize");
    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].substr(0, 2) === "*+") {
        return expectedParts[1].length <= actualParts[1].length + 1 && expectedParts[1].substr(1) === actualParts[1].substr(1 - expectedParts[1].length);
      }
      if (expectedParts[1] !== "*" && expectedParts[1] !== actualParts[1]) {
        return false;
      }
      return true;
    }
    __name(mimeMatch, "mimeMatch");
    function normalizeType(value) {
      var type = typer.parse(value);
      type.parameters = void 0;
      return typer.format(type);
    }
    __name(normalizeType, "normalizeType");
    function tryNormalizeType(value) {
      if (!value) {
        return null;
      }
      try {
        return normalizeType(value);
      } catch (err) {
        return null;
      }
    }
    __name(tryNormalizeType, "tryNormalizeType");
  }
});

// ../../node_modules/.pnpm/body-parser@1.20.0_supports-color@9.2.2/node_modules/body-parser/lib/types/json.js
var require_json = __commonJS({
  "../../node_modules/.pnpm/body-parser@1.20.0_supports-color@9.2.2/node_modules/body-parser/lib/types/json.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var bytes = require_bytes();
    var contentType = require_content_type();
    var createError = require_http_errors();
    var debug = require_src3()("body-parser:json");
    var read = require_read();
    var typeis = require_type_is();
    module3.exports = json;
    var FIRST_CHAR_REGEXP = /^[\x20\x09\x0a\x0d]*([^\x20\x09\x0a\x0d])/;
    function json(options29) {
      var opts = options29 || {};
      var limit = typeof opts.limit !== "number" ? bytes.parse(opts.limit || "100kb") : opts.limit;
      var inflate = opts.inflate !== false;
      var reviver = opts.reviver;
      var strict = opts.strict !== false;
      var type = opts.type || "application/json";
      var verify = opts.verify || false;
      if (verify !== false && typeof verify !== "function") {
        throw new TypeError("option verify must be function");
      }
      var shouldParse = typeof type !== "function" ? typeChecker(type) : type;
      function parse7(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 (e3) {
          throw normalizeJsonSyntaxError(e3, {
            message: e3.message,
            stack: e3.stack
          });
        }
      }
      __name(parse7, "parse");
      return /* @__PURE__ */ __name(function jsonParser(req, res, next) {
        if (req._body) {
          debug("body already parsed");
          next();
          return;
        }
        req.body = req.body || {};
        if (!typeis.hasBody(req)) {
          debug("skip empty body");
          next();
          return;
        }
        debug("content-type %j", req.headers["content-type"]);
        if (!shouldParse(req)) {
          debug("skip parsing");
          next();
          return;
        }
        var charset = getCharset(req) || "utf-8";
        if (charset.slice(0, 4) !== "utf-") {
          debug("invalid charset");
          next(createError(415, 'unsupported charset "' + charset.toUpperCase() + '"', {
            charset,
            type: "charset.unsupported"
          }));
          return;
        }
        read(req, res, next, parse7, debug, {
          encoding: charset,
          inflate,
          limit,
          verify
        });
      }, "jsonParser");
    }
    __name(json, "json");
    function createStrictSyntaxError(str, char) {
      var index = str.indexOf(char);
      var partial = index !== -1 ? str.substring(0, index) + "#" : "";
      try {
        JSON.parse(partial);
        throw new SyntaxError("strict violation");
      } catch (e3) {
        return normalizeJsonSyntaxError(e3, {
          message: e3.message.replace("#", char),
          stack: e3.stack
        });
      }
    }
    __name(createStrictSyntaxError, "createStrictSyntaxError");
    function firstchar(str) {
      var match = FIRST_CHAR_REGEXP.exec(str);
      return match ? match[1] : void 0;
    }
    __name(firstchar, "firstchar");
    function getCharset(req) {
      try {
        return (contentType.parse(req).parameters.charset || "").toLowerCase();
      } catch (e3) {
        return void 0;
      }
    }
    __name(getCharset, "getCharset");
    function normalizeJsonSyntaxError(error2, obj) {
      var keys = Object.getOwnPropertyNames(error2);
      for (var i = 0; i < keys.length; i++) {
        var key = keys[i];
        if (key !== "stack" && key !== "message") {
          delete error2[key];
        }
      }
      error2.stack = obj.stack.replace(error2.message, obj.message);
      error2.message = obj.message;
      return error2;
    }
    __name(normalizeJsonSyntaxError, "normalizeJsonSyntaxError");
    function typeChecker(type) {
      return /* @__PURE__ */ __name(function checkType2(req) {
        return Boolean(typeis(req, type));
      }, "checkType");
    }
    __name(typeChecker, "typeChecker");
  }
});

// ../../node_modules/.pnpm/body-parser@1.20.0_supports-color@9.2.2/node_modules/body-parser/lib/types/raw.js
var require_raw = __commonJS({
  "../../node_modules/.pnpm/body-parser@1.20.0_supports-color@9.2.2/node_modules/body-parser/lib/types/raw.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var bytes = require_bytes();
    var debug = require_src3()("body-parser:raw");
    var read = require_read();
    var typeis = require_type_is();
    module3.exports = raw;
    function raw(options29) {
      var opts = options29 || {};
      var inflate = opts.inflate !== false;
      var limit = typeof opts.limit !== "number" ? bytes.parse(opts.limit || "100kb") : opts.limit;
      var type = opts.type || "application/octet-stream";
      var verify = opts.verify || false;
      if (verify !== false && typeof verify !== "function") {
        throw new TypeError("option verify must be function");
      }
      var shouldParse = typeof type !== "function" ? typeChecker(type) : type;
      function parse7(buf) {
        return buf;
      }
      __name(parse7, "parse");
      return /* @__PURE__ */ __name(function rawParser(req, res, next) {
        if (req._body) {
          debug("body already parsed");
          next();
          return;
        }
        req.body = req.body || {};
        if (!typeis.hasBody(req)) {
          debug("skip empty body");
          next();
          return;
        }
        debug("content-type %j", req.headers["content-type"]);
        if (!shouldParse(req)) {
          debug("skip parsing");
          next();
          return;
        }
        read(req, res, next, parse7, debug, {
          encoding: null,
          inflate,
          limit,
          verify
        });
      }, "rawParser");
    }
    __name(raw, "raw");
    function typeChecker(type) {
      return /* @__PURE__ */ __name(function checkType2(req) {
        return Boolean(typeis(req, type));
      }, "checkType");
    }
    __name(typeChecker, "typeChecker");
  }
});

// ../../node_modules/.pnpm/body-parser@1.20.0_supports-color@9.2.2/node_modules/body-parser/lib/types/text.js
var require_text3 = __commonJS({
  "../../node_modules/.pnpm/body-parser@1.20.0_supports-color@9.2.2/node_modules/body-parser/lib/types/text.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var bytes = require_bytes();
    var contentType = require_content_type();
    var debug = require_src3()("body-parser:text");
    var read = require_read();
    var typeis = require_type_is();
    module3.exports = text;
    function text(options29) {
      var opts = options29 || {};
      var defaultCharset = opts.defaultCharset || "utf-8";
      var inflate = opts.inflate !== false;
      var limit = typeof opts.limit !== "number" ? bytes.parse(opts.limit || "100kb") : opts.limit;
      var type = opts.type || "text/plain";
      var verify = opts.verify || false;
      if (verify !== false && typeof verify !== "function") {
        throw new TypeError("option verify must be function");
      }
      var shouldParse = typeof type !== "function" ? typeChecker(type) : type;
      function parse7(buf) {
        return buf;
      }
      __name(parse7, "parse");
      return /* @__PURE__ */ __name(function textParser(req, res, next) {
        if (req._body) {
          debug("body already parsed");
          next();
          return;
        }
        req.body = req.body || {};
        if (!typeis.hasBody(req)) {
          debug("skip empty body");
          next();
          return;
        }
        debug("content-type %j", req.headers["content-type"]);
        if (!shouldParse(req)) {
          debug("skip parsing");
          next();
          return;
        }
        var charset = getCharset(req) || defaultCharset;
        read(req, res, next, parse7, debug, {
          encoding: charset,
          inflate,
          limit,
          verify
        });
      }, "textParser");
    }
    __name(text, "text");
    function getCharset(req) {
      try {
        return (contentType.parse(req).parameters.charset || "").toLowerCase();
      } catch (e3) {
        return void 0;
      }
    }
    __name(getCharset, "getCharset");
    function typeChecker(type) {
      return /* @__PURE__ */ __name(function checkType2(req) {
        return Boolean(typeis(req, type));
      }, "checkType");
    }
    __name(typeChecker, "typeChecker");
  }
});

// ../../node_modules/.pnpm/has-symbols@1.0.3/node_modules/has-symbols/shams.js
var require_shams = __commonJS({
  "../../node_modules/.pnpm/has-symbols@1.0.3/node_modules/has-symbols/shams.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function hasSymbols() {
      if (typeof Symbol !== "function" || typeof Object.getOwnPropertySymbols !== "function") {
        return false;
      }
      if (typeof Symbol.iterator === "symbol") {
        return true;
      }
      var obj = {};
      var sym = 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 (sym 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 descriptor2 = Object.getOwnPropertyDescriptor(obj, sym);
        if (descriptor2.value !== symVal || descriptor2.enumerable !== true) {
          return false;
        }
      }
      return true;
    }, "hasSymbols");
  }
});

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

// ../../node_modules/.pnpm/has-proto@1.0.1/node_modules/has-proto/index.js
var require_has_proto = __commonJS({
  "../../node_modules/.pnpm/has-proto@1.0.1/node_modules/has-proto/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var test = {
      foo: {}
    };
    var $Object = Object;
    module3.exports = /* @__PURE__ */ __name(function hasProto() {
      return { __proto__: test }.foo === test.foo && !({ __proto__: null } instanceof $Object);
    }, "hasProto");
  }
});

// ../../node_modules/.pnpm/get-intrinsic@1.2.1/node_modules/get-intrinsic/index.js
var require_get_intrinsic = __commonJS({
  "../../node_modules/.pnpm/get-intrinsic@1.2.1/node_modules/get-intrinsic/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var undefined2;
    var $SyntaxError = SyntaxError;
    var $Function = Function;
    var $TypeError = TypeError;
    var getEvalledConstructor = /* @__PURE__ */ __name(function(expressionSyntax) {
      try {
        return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")();
      } catch (e3) {
      }
    }, "getEvalledConstructor");
    var $gOPD = Object.getOwnPropertyDescriptor;
    if ($gOPD) {
      try {
        $gOPD({}, "");
      } catch (e3) {
        $gOPD = null;
      }
    }
    var throwTypeError = /* @__PURE__ */ __name(function() {
      throw new $TypeError();
    }, "throwTypeError");
    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 hasProto = require_has_proto()();
    var getProto = Object.getPrototypeOf || (hasProto ? function(x2) {
      return x2.__proto__;
    } : null);
    var needsEval = {};
    var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined2 : getProto(Uint8Array);
    var INTRINSICS = {
      "%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,
      "%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,
      "%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
    };
    if (getProto) {
      try {
        null.error;
      } catch (e3) {
        errorProto = getProto(getProto(e3));
        INTRINSICS["%Error.prototype%"] = errorProto;
      }
    }
    var errorProto;
    var doEval = /* @__PURE__ */ __name(function doEval2(name) {
      var value;
      if (name === "%AsyncFunction%") {
        value = getEvalledConstructor("async function () {}");
      } else if (name === "%GeneratorFunction%") {
        value = getEvalledConstructor("function* () {}");
      } else if (name === "%AsyncGeneratorFunction%") {
        value = getEvalledConstructor("async function* () {}");
      } else if (name === "%AsyncGenerator%") {
        var fn2 = doEval2("%AsyncGeneratorFunction%");
        if (fn2) {
          value = fn2.prototype;
        }
      } else if (name === "%AsyncIteratorPrototype%") {
        var gen = doEval2("%AsyncGenerator%");
        if (gen && getProto) {
          value = getProto(gen.prototype);
        }
      }
      INTRINSICS[name] = value;
      return value;
    }, "doEval");
    var LEGACY_ALIASES = {
      "%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 bind = require_function_bind();
    var hasOwn = require_src2();
    var $concat = bind.call(Function.call, Array.prototype.concat);
    var $spliceApply = bind.call(Function.apply, Array.prototype.splice);
    var $replace = bind.call(Function.call, String.prototype.replace);
    var $strSlice = bind.call(Function.call, String.prototype.slice);
    var $exec = bind.call(Function.call, RegExp.prototype.exec);
    var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
    var reEscapeChar = /\\(\\)?/g;
    var stringToPath = /* @__PURE__ */ __name(function stringToPath2(string) {
      var first = $strSlice(string, 0, 1);
      var last = $strSlice(string, -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(string, rePropName, function(match, number, quote2, subString) {
        result[result.length] = quote2 ? $replace(subString, reEscapeChar, "$1") : number || match;
      });
      return result;
    }, "stringToPath");
    var getBaseIntrinsic = /* @__PURE__ */ __name(function getBaseIntrinsic2(name, allowMissing) {
      var intrinsicName = name;
      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 " + name + " exists, but is not available. Please file an issue!");
        }
        return {
          alias,
          name: intrinsicName,
          value
        };
      }
      throw new $SyntaxError("intrinsic " + name + " does not exist!");
    }, "getBaseIntrinsic");
    module3.exports = /* @__PURE__ */ __name(function GetIntrinsic(name, allowMissing) {
      if (typeof name !== "string" || name.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(/^%?[^%]*%?$/, name) === null) {
        throw new $SyntaxError("`%` may not be present anywhere but at the beginning and end of the intrinsic name");
      }
      var parts = stringToPath(name);
      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 " + name + " exists, but the property is not available.");
            }
            return void 0;
          }
          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;
    }, "GetIntrinsic");
  }
});

// ../../node_modules/.pnpm/call-bind@1.0.2/node_modules/call-bind/index.js
var require_call_bind = __commonJS({
  "../../node_modules/.pnpm/call-bind@1.0.2/node_modules/call-bind/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var bind = require_function_bind();
    var GetIntrinsic = require_get_intrinsic();
    var $apply = GetIntrinsic("%Function.prototype.apply%");
    var $call = GetIntrinsic("%Function.prototype.call%");
    var $reflectApply = GetIntrinsic("%Reflect.apply%", true) || bind.call($call, $apply);
    var $gOPD = GetIntrinsic("%Object.getOwnPropertyDescriptor%", true);
    var $defineProperty = GetIntrinsic("%Object.defineProperty%", true);
    var $max = GetIntrinsic("%Math.max%");
    if ($defineProperty) {
      try {
        $defineProperty({}, "a", { value: 1 });
      } catch (e3) {
        $defineProperty = null;
      }
    }
    module3.exports = /* @__PURE__ */ __name(function callBind(originalFunction) {
      var func = $reflectApply(bind, $call, arguments);
      if ($gOPD && $defineProperty) {
        var desc = $gOPD(func, "length");
        if (desc.configurable) {
          $defineProperty(
            func,
            "length",
            { value: 1 + $max(0, originalFunction.length - (arguments.length - 1)) }
          );
        }
      }
      return func;
    }, "callBind");
    var applyBind = /* @__PURE__ */ __name(function applyBind2() {
      return $reflectApply(bind, $apply, arguments);
    }, "applyBind");
    if ($defineProperty) {
      $defineProperty(module3.exports, "apply", { value: applyBind });
    } else {
      module3.exports.apply = applyBind;
    }
  }
});

// ../../node_modules/.pnpm/call-bind@1.0.2/node_modules/call-bind/callBound.js
var require_callBound = __commonJS({
  "../../node_modules/.pnpm/call-bind@1.0.2/node_modules/call-bind/callBound.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var GetIntrinsic = require_get_intrinsic();
    var callBind = require_call_bind();
    var $indexOf = callBind(GetIntrinsic("String.prototype.indexOf"));
    module3.exports = /* @__PURE__ */ __name(function callBoundIntrinsic(name, allowMissing) {
      var intrinsic = GetIntrinsic(name, !!allowMissing);
      if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) {
        return callBind(intrinsic);
      }
      return intrinsic;
    }, "callBoundIntrinsic");
  }
});

// ../../node_modules/.pnpm/object-inspect@1.12.3/node_modules/object-inspect/util.inspect.js
var require_util_inspect = __commonJS({
  "../../node_modules/.pnpm/object-inspect@1.12.3/node_modules/object-inspect/util.inspect.js"(exports2, module3) {
    init_import_meta_url();
    module3.exports = require("util").inspect;
  }
});

// ../../node_modules/.pnpm/object-inspect@1.12.3/node_modules/object-inspect/index.js
var require_object_inspect = __commonJS({
  "../../node_modules/.pnpm/object-inspect@1.12.3/node_modules/object-inspect/index.js"(exports2, module3) {
    init_import_meta_url();
    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 toStringTag = 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(O2) {
      return O2.__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 int = num < 0 ? -$floor(-num) : $floor(num);
        if (int !== num) {
          var intStr = String(int);
          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, "$&_");
    }
    __name(addNumericSeparator, "addNumericSeparator");
    var utilInspect2 = require_util_inspect();
    var inspectCustom = utilInspect2.custom;
    var inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null;
    module3.exports = /* @__PURE__ */ __name(function inspect_(obj, options29, depth, seen) {
      var opts = options29 || {};
      if (has(opts, "quoteStyle") && (opts.quoteStyle !== "single" && opts.quoteStyle !== "double")) {
        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 isArray(obj) ? "[Array]" : "[Object]";
      }
      var indent = getIndent(opts, depth);
      if (typeof seen === "undefined") {
        seen = [];
      } else if (indexOf(seen, obj) >= 0) {
        return "[Circular]";
      }
      function inspect2(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);
      }
      __name(inspect2, "inspect");
      if (typeof obj === "function" && !isRegExp2(obj)) {
        var name = nameOf(obj);
        var keys = arrObjKeys(obj, inspect2);
        return "[Function" + (name ? ": " + name : " (anonymous)") + "]" + (keys.length > 0 ? " { " + $join.call(keys, ", ") + " }" : "");
      }
      if (isSymbol(obj)) {
        var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\(.*\))_[^)]*$/, "$1") : symToString.call(obj);
        return typeof obj === "object" && !hasShammedSymbols ? markBoxed(symString) : symString;
      }
      if (isElement2(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(quote2(attrs[i].value), "double", opts);
        }
        s += ">";
        if (obj.childNodes && obj.childNodes.length) {
          s += "...";
        }
        s += "</" + $toLowerCase.call(String(obj.nodeName)) + ">";
        return s;
      }
      if (isArray(obj)) {
        if (obj.length === 0) {
          return "[]";
        }
        var xs = arrObjKeys(obj, inspect2);
        if (indent && !singleLineValues(xs)) {
          return "[" + indentedJoin(xs, indent) + "]";
        }
        return "[ " + $join.call(xs, ", ") + " ]";
      }
      if (isError2(obj)) {
        var parts = arrObjKeys(obj, inspect2);
        if (!("cause" in Error.prototype) && "cause" in obj && !isEnumerable.call(obj, "cause")) {
          return "{ [" + String(obj) + "] " + $join.call($concat.call("[cause]: " + inspect2(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" && utilInspect2) {
          return utilInspect2(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(inspect2(key, obj, true) + " => " + inspect2(value, obj));
          });
        }
        return collectionOf("Map", mapSize.call(obj), mapParts, indent);
      }
      if (isSet(obj)) {
        var setParts = [];
        if (setForEach) {
          setForEach.call(obj, function(value) {
            setParts.push(inspect2(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 (isNumber(obj)) {
        return markBoxed(inspect2(Number(obj)));
      }
      if (isBigInt(obj)) {
        return markBoxed(inspect2(bigIntValueOf.call(obj)));
      }
      if (isBoolean3(obj)) {
        return markBoxed(booleanValueOf.call(obj));
      }
      if (isString4(obj)) {
        return markBoxed(inspect2(String(obj)));
      }
      if (!isDate(obj) && !isRegExp2(obj)) {
        var ys = arrObjKeys(obj, inspect2);
        var isPlainObject2 = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;
        var protoTag = obj instanceof Object ? "" : "null prototype";
        var stringTag = !isPlainObject2 && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? "Object" : "";
        var constructorTag = isPlainObject2 || typeof obj.constructor !== "function" ? "" : obj.constructor.name ? obj.constructor.name + " " : "";
        var tag = constructorTag + (stringTag || protoTag ? "[" + $join.call($concat.call([], stringTag || [], protoTag || []), ": ") + "] " : "");
        if (ys.length === 0) {
          return tag + "{}";
        }
        if (indent) {
          return tag + "{" + indentedJoin(ys, indent) + "}";
        }
        return tag + "{ " + $join.call(ys, ", ") + " }";
      }
      return String(obj);
    }, "inspect_");
    function wrapQuotes(s, defaultStyle, opts) {
      var quoteChar = (opts.quoteStyle || defaultStyle) === "double" ? '"' : "'";
      return quoteChar + s + quoteChar;
    }
    __name(wrapQuotes, "wrapQuotes");
    function quote2(s) {
      return $replace.call(String(s), /"/g, "&quot;");
    }
    __name(quote2, "quote");
    function isArray(obj) {
      return toStr(obj) === "[object Array]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
    }
    __name(isArray, "isArray");
    function isDate(obj) {
      return toStr(obj) === "[object Date]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
    }
    __name(isDate, "isDate");
    function isRegExp2(obj) {
      return toStr(obj) === "[object RegExp]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
    }
    __name(isRegExp2, "isRegExp");
    function isError2(obj) {
      return toStr(obj) === "[object Error]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
    }
    __name(isError2, "isError");
    function isString4(obj) {
      return toStr(obj) === "[object String]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
    }
    __name(isString4, "isString");
    function isNumber(obj) {
      return toStr(obj) === "[object Number]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
    }
    __name(isNumber, "isNumber");
    function isBoolean3(obj) {
      return toStr(obj) === "[object Boolean]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
    }
    __name(isBoolean3, "isBoolean");
    function isSymbol(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 (e3) {
      }
      return false;
    }
    __name(isSymbol, "isSymbol");
    function isBigInt(obj) {
      if (!obj || typeof obj !== "object" || !bigIntValueOf) {
        return false;
      }
      try {
        bigIntValueOf.call(obj);
        return true;
      } catch (e3) {
      }
      return false;
    }
    __name(isBigInt, "isBigInt");
    var hasOwn = Object.prototype.hasOwnProperty || function(key) {
      return key in this;
    };
    function has(obj, key) {
      return hasOwn.call(obj, key);
    }
    __name(has, "has");
    function toStr(obj) {
      return objectToString2.call(obj);
    }
    __name(toStr, "toStr");
    function nameOf(f) {
      if (f.name) {
        return f.name;
      }
      var m2 = $match.call(functionToString.call(f), /^function\s*([\w$]+)/);
      if (m2) {
        return m2[1];
      }
      return null;
    }
    __name(nameOf, "nameOf");
    function indexOf(xs, x2) {
      if (xs.indexOf) {
        return xs.indexOf(x2);
      }
      for (var i = 0, l2 = xs.length; i < l2; i++) {
        if (xs[i] === x2) {
          return i;
        }
      }
      return -1;
    }
    __name(indexOf, "indexOf");
    function isMap(x2) {
      if (!mapSize || !x2 || typeof x2 !== "object") {
        return false;
      }
      try {
        mapSize.call(x2);
        try {
          setSize.call(x2);
        } catch (s) {
          return true;
        }
        return x2 instanceof Map;
      } catch (e3) {
      }
      return false;
    }
    __name(isMap, "isMap");
    function isWeakMap(x2) {
      if (!weakMapHas || !x2 || typeof x2 !== "object") {
        return false;
      }
      try {
        weakMapHas.call(x2, weakMapHas);
        try {
          weakSetHas.call(x2, weakSetHas);
        } catch (s) {
          return true;
        }
        return x2 instanceof WeakMap;
      } catch (e3) {
      }
      return false;
    }
    __name(isWeakMap, "isWeakMap");
    function isWeakRef(x2) {
      if (!weakRefDeref || !x2 || typeof x2 !== "object") {
        return false;
      }
      try {
        weakRefDeref.call(x2);
        return true;
      } catch (e3) {
      }
      return false;
    }
    __name(isWeakRef, "isWeakRef");
    function isSet(x2) {
      if (!setSize || !x2 || typeof x2 !== "object") {
        return false;
      }
      try {
        setSize.call(x2);
        try {
          mapSize.call(x2);
        } catch (m2) {
          return true;
        }
        return x2 instanceof Set;
      } catch (e3) {
      }
      return false;
    }
    __name(isSet, "isSet");
    function isWeakSet(x2) {
      if (!weakSetHas || !x2 || typeof x2 !== "object") {
        return false;
      }
      try {
        weakSetHas.call(x2, weakSetHas);
        try {
          weakMapHas.call(x2, weakMapHas);
        } catch (s) {
          return true;
        }
        return x2 instanceof WeakSet;
      } catch (e3) {
      }
      return false;
    }
    __name(isWeakSet, "isWeakSet");
    function isElement2(x2) {
      if (!x2 || typeof x2 !== "object") {
        return false;
      }
      if (typeof HTMLElement !== "undefined" && x2 instanceof HTMLElement) {
        return true;
      }
      return typeof x2.nodeName === "string" && typeof x2.getAttribute === "function";
    }
    __name(isElement2, "isElement");
    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 s = $replace.call($replace.call(str, /(['\\])/g, "\\$1"), /[\x00-\x1f]/g, lowbyte);
      return wrapQuotes(s, "single", opts);
    }
    __name(inspectString, "inspectString");
    function lowbyte(c2) {
      var n2 = c2.charCodeAt(0);
      var x2 = {
        8: "b",
        9: "t",
        10: "n",
        12: "f",
        13: "r"
      }[n2];
      if (x2) {
        return "\\" + x2;
      }
      return "\\x" + (n2 < 16 ? "0" : "") + $toUpperCase.call(n2.toString(16));
    }
    __name(lowbyte, "lowbyte");
    function markBoxed(str) {
      return "Object(" + str + ")";
    }
    __name(markBoxed, "markBoxed");
    function weakCollectionOf(type) {
      return type + " { ? }";
    }
    __name(weakCollectionOf, "weakCollectionOf");
    function collectionOf(type, size, entries, indent) {
      var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, ", ");
      return type + " (" + size + ") {" + joinedEntries + "}";
    }
    __name(collectionOf, "collectionOf");
    function singleLineValues(xs) {
      for (var i = 0; i < xs.length; i++) {
        if (indexOf(xs[i], "\n") >= 0) {
          return false;
        }
      }
      return true;
    }
    __name(singleLineValues, "singleLineValues");
    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)
      };
    }
    __name(getIndent, "getIndent");
    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;
    }
    __name(indentedJoin, "indentedJoin");
    function arrObjKeys(obj, inspect2) {
      var isArr = isArray(obj);
      var xs = [];
      if (isArr) {
        xs.length = obj.length;
        for (var i = 0; i < obj.length; i++) {
          xs[i] = has(obj, i) ? inspect2(obj[i], obj) : "";
        }
      }
      var syms = typeof gOPS === "function" ? gOPS(obj) : [];
      var symMap;
      if (hasShammedSymbols) {
        symMap = {};
        for (var k2 = 0; k2 < syms.length; k2++) {
          symMap["$" + syms[k2]] = syms[k2];
        }
      }
      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(inspect2(key, obj) + ": " + inspect2(obj[key], obj));
        } else {
          xs.push(key + ": " + inspect2(obj[key], obj));
        }
      }
      if (typeof gOPS === "function") {
        for (var j2 = 0; j2 < syms.length; j2++) {
          if (isEnumerable.call(obj, syms[j2])) {
            xs.push("[" + inspect2(syms[j2]) + "]: " + inspect2(obj[syms[j2]], obj));
          }
        }
      }
      return xs;
    }
    __name(arrObjKeys, "arrObjKeys");
  }
});

// ../../node_modules/.pnpm/side-channel@1.0.4/node_modules/side-channel/index.js
var require_side_channel = __commonJS({
  "../../node_modules/.pnpm/side-channel@1.0.4/node_modules/side-channel/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var GetIntrinsic = require_get_intrinsic();
    var callBound = require_callBound();
    var inspect2 = require_object_inspect();
    var $TypeError = GetIntrinsic("%TypeError%");
    var $WeakMap = GetIntrinsic("%WeakMap%", true);
    var $Map = GetIntrinsic("%Map%", true);
    var $weakMapGet = callBound("WeakMap.prototype.get", true);
    var $weakMapSet = callBound("WeakMap.prototype.set", true);
    var $weakMapHas = callBound("WeakMap.prototype.has", true);
    var $mapGet = callBound("Map.prototype.get", true);
    var $mapSet = callBound("Map.prototype.set", true);
    var $mapHas = callBound("Map.prototype.has", true);
    var listGetNode = /* @__PURE__ */ __name(function(list, key) {
      for (var prev = list, curr; (curr = prev.next) !== null; prev = curr) {
        if (curr.key === key) {
          prev.next = curr.next;
          curr.next = list.next;
          list.next = curr;
          return curr;
        }
      }
    }, "listGetNode");
    var listGet = /* @__PURE__ */ __name(function(objects, key) {
      var node2 = listGetNode(objects, key);
      return node2 && node2.value;
    }, "listGet");
    var listSet = /* @__PURE__ */ __name(function(objects, key, value) {
      var node2 = listGetNode(objects, key);
      if (node2) {
        node2.value = value;
      } else {
        objects.next = {
          // eslint-disable-line no-param-reassign
          key,
          next: objects.next,
          value
        };
      }
    }, "listSet");
    var listHas = /* @__PURE__ */ __name(function(objects, key) {
      return !!listGetNode(objects, key);
    }, "listHas");
    module3.exports = /* @__PURE__ */ __name(function getSideChannel() {
      var $wm;
      var $m;
      var $o;
      var channel = {
        assert: function(key) {
          if (!channel.has(key)) {
            throw new $TypeError("Side channel does not contain " + inspect2(key));
          }
        },
        get: function(key) {
          if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
            if ($wm) {
              return $weakMapGet($wm, key);
            }
          } else if ($Map) {
            if ($m) {
              return $mapGet($m, key);
            }
          } else {
            if ($o) {
              return listGet($o, key);
            }
          }
        },
        has: function(key) {
          if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
            if ($wm) {
              return $weakMapHas($wm, key);
            }
          } else if ($Map) {
            if ($m) {
              return $mapHas($m, key);
            }
          } else {
            if ($o) {
              return listHas($o, key);
            }
          }
          return false;
        },
        set: function(key, value) {
          if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
            if (!$wm) {
              $wm = new $WeakMap();
            }
            $weakMapSet($wm, key, value);
          } else if ($Map) {
            if (!$m) {
              $m = new $Map();
            }
            $mapSet($m, key, value);
          } else {
            if (!$o) {
              $o = { key: {}, next: null };
            }
            listSet($o, key, value);
          }
        }
      };
      return channel;
    }, "getSideChannel");
  }
});

// ../../node_modules/.pnpm/qs@6.10.3/node_modules/qs/lib/formats.js
var require_formats = __commonJS({
  "../../node_modules/.pnpm/qs@6.10.3/node_modules/qs/lib/formats.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var replace = String.prototype.replace;
    var percentTwenties = /%20/g;
    var Format = {
      RFC1738: "RFC1738",
      RFC3986: "RFC3986"
    };
    module3.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/.pnpm/qs@6.10.3/node_modules/qs/lib/utils.js
var require_utils3 = __commonJS({
  "../../node_modules/.pnpm/qs@6.10.3/node_modules/qs/lib/utils.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var formats = require_formats();
    var has = Object.prototype.hasOwnProperty;
    var isArray = Array.isArray;
    var hexTable = function() {
      var array = [];
      for (var i = 0; i < 256; ++i) {
        array.push("%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase());
      }
      return array;
    }();
    var compactQueue = /* @__PURE__ */ __name(function compactQueue2(queue) {
      while (queue.length > 1) {
        var item = queue.pop();
        var obj = item.obj[item.prop];
        if (isArray(obj)) {
          var compacted = [];
          for (var j2 = 0; j2 < obj.length; ++j2) {
            if (typeof obj[j2] !== "undefined") {
              compacted.push(obj[j2]);
            }
          }
          item.obj[item.prop] = compacted;
        }
      }
    }, "compactQueue");
    var arrayToObject = /* @__PURE__ */ __name(function arrayToObject2(source, options29) {
      var obj = options29 && options29.plainObjects ? /* @__PURE__ */ Object.create(null) : {};
      for (var i = 0; i < source.length; ++i) {
        if (typeof source[i] !== "undefined") {
          obj[i] = source[i];
        }
      }
      return obj;
    }, "arrayToObject");
    var merge = /* @__PURE__ */ __name(function merge2(target, source, options29) {
      if (!source) {
        return target;
      }
      if (typeof source !== "object") {
        if (isArray(target)) {
          target.push(source);
        } else if (target && typeof target === "object") {
          if (options29 && (options29.plainObjects || options29.allowPrototypes) || !has.call(Object.prototype, source)) {
            target[source] = true;
          }
        } else {
          return [target, source];
        }
        return target;
      }
      if (!target || typeof target !== "object") {
        return [target].concat(source);
      }
      var mergeTarget = target;
      if (isArray(target) && !isArray(source)) {
        mergeTarget = arrayToObject(target, options29);
      }
      if (isArray(target) && isArray(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] = merge2(targetItem, item, options29);
            } else {
              target.push(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] = merge2(acc[key], value, options29);
        } else {
          acc[key] = value;
        }
        return acc;
      }, mergeTarget);
    }, "merge");
    var assign = /* @__PURE__ */ __name(function assignSingleSource(target, source) {
      return Object.keys(source).reduce(function(acc, key) {
        acc[key] = source[key];
        return acc;
      }, target);
    }, "assignSingleSource");
    var decode = /* @__PURE__ */ __name(function(str, decoder, 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 (e3) {
        return strWithoutPlus;
      }
    }, "decode");
    var encode = /* @__PURE__ */ __name(function encode2(str, defaultEncoder, charset, kind, format10) {
      if (str.length === 0) {
        return str;
      }
      var string = str;
      if (typeof str === "symbol") {
        string = Symbol.prototype.toString.call(str);
      } else if (typeof str !== "string") {
        string = String(str);
      }
      if (charset === "iso-8859-1") {
        return escape(string).replace(/%u[0-9a-f]{4}/gi, function($0) {
          return "%26%23" + parseInt($0.slice(2), 16) + "%3B";
        });
      }
      var out = "";
      for (var i = 0; i < string.length; ++i) {
        var c2 = string.charCodeAt(i);
        if (c2 === 45 || c2 === 46 || c2 === 95 || c2 === 126 || c2 >= 48 && c2 <= 57 || c2 >= 65 && c2 <= 90 || c2 >= 97 && c2 <= 122 || format10 === formats.RFC1738 && (c2 === 40 || c2 === 41)) {
          out += string.charAt(i);
          continue;
        }
        if (c2 < 128) {
          out = out + hexTable[c2];
          continue;
        }
        if (c2 < 2048) {
          out = out + (hexTable[192 | c2 >> 6] + hexTable[128 | c2 & 63]);
          continue;
        }
        if (c2 < 55296 || c2 >= 57344) {
          out = out + (hexTable[224 | c2 >> 12] + hexTable[128 | c2 >> 6 & 63] + hexTable[128 | c2 & 63]);
          continue;
        }
        i += 1;
        c2 = 65536 + ((c2 & 1023) << 10 | string.charCodeAt(i) & 1023);
        out += hexTable[240 | c2 >> 18] + hexTable[128 | c2 >> 12 & 63] + hexTable[128 | c2 >> 6 & 63] + hexTable[128 | c2 & 63];
      }
      return out;
    }, "encode");
    var compact = /* @__PURE__ */ __name(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 keys = Object.keys(obj);
        for (var j2 = 0; j2 < keys.length; ++j2) {
          var key = keys[j2];
          var val = obj[key];
          if (typeof val === "object" && val !== null && refs.indexOf(val) === -1) {
            queue.push({ obj, prop: key });
            refs.push(val);
          }
        }
      }
      compactQueue(queue);
      return value;
    }, "compact");
    var isRegExp2 = /* @__PURE__ */ __name(function isRegExp3(obj) {
      return Object.prototype.toString.call(obj) === "[object RegExp]";
    }, "isRegExp");
    var isBuffer = /* @__PURE__ */ __name(function isBuffer2(obj) {
      if (!obj || typeof obj !== "object") {
        return false;
      }
      return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
    }, "isBuffer");
    var combine = /* @__PURE__ */ __name(function combine2(a, b2) {
      return [].concat(a, b2);
    }, "combine");
    var maybeMap = /* @__PURE__ */ __name(function maybeMap2(val, fn2) {
      if (isArray(val)) {
        var mapped = [];
        for (var i = 0; i < val.length; i += 1) {
          mapped.push(fn2(val[i]));
        }
        return mapped;
      }
      return fn2(val);
    }, "maybeMap");
    module3.exports = {
      arrayToObject,
      assign,
      combine,
      compact,
      decode,
      encode,
      isBuffer,
      isRegExp: isRegExp2,
      maybeMap,
      merge
    };
  }
});

// ../../node_modules/.pnpm/qs@6.10.3/node_modules/qs/lib/stringify.js
var require_stringify2 = __commonJS({
  "../../node_modules/.pnpm/qs@6.10.3/node_modules/qs/lib/stringify.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var getSideChannel = require_side_channel();
    var utils = require_utils3();
    var formats = require_formats();
    var has = Object.prototype.hasOwnProperty;
    var arrayPrefixGenerators = {
      brackets: /* @__PURE__ */ __name(function brackets(prefix) {
        return prefix + "[]";
      }, "brackets"),
      comma: "comma",
      indices: /* @__PURE__ */ __name(function indices(prefix, key) {
        return prefix + "[" + key + "]";
      }, "indices"),
      repeat: /* @__PURE__ */ __name(function repeat(prefix) {
        return prefix;
      }, "repeat")
    };
    var isArray = Array.isArray;
    var split = String.prototype.split;
    var push = Array.prototype.push;
    var pushToArray = /* @__PURE__ */ __name(function(arr, valueOrArray) {
      push.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);
    }, "pushToArray");
    var toISO = Date.prototype.toISOString;
    var defaultFormat = formats["default"];
    var defaults = {
      addQueryPrefix: false,
      allowDots: false,
      charset: "utf-8",
      charsetSentinel: false,
      delimiter: "&",
      encode: true,
      encoder: utils.encode,
      encodeValuesOnly: false,
      format: defaultFormat,
      formatter: formats.formatters[defaultFormat],
      // deprecated
      indices: false,
      serializeDate: /* @__PURE__ */ __name(function serializeDate(date) {
        return toISO.call(date);
      }, "serializeDate"),
      skipNulls: false,
      strictNullHandling: false
    };
    var isNonNullishPrimitive = /* @__PURE__ */ __name(function isNonNullishPrimitive2(v2) {
      return typeof v2 === "string" || typeof v2 === "number" || typeof v2 === "boolean" || typeof v2 === "symbol" || typeof v2 === "bigint";
    }, "isNonNullishPrimitive");
    var sentinel = {};
    var stringify = /* @__PURE__ */ __name(function stringify2(object, prefix, generateArrayPrefix, strictNullHandling, skipNulls, encoder, filter, sort, allowDots, serializeDate, format10, formatter, encodeValuesOnly, charset, sideChannel) {
      var obj = object;
      var tmpSc = sideChannel;
      var step = 0;
      var findFlag = false;
      while ((tmpSc = tmpSc.get(sentinel)) !== void 0 && !findFlag) {
        var pos = tmpSc.get(object);
        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 filter === "function") {
        obj = filter(prefix, obj);
      } else if (obj instanceof Date) {
        obj = serializeDate(obj);
      } else if (generateArrayPrefix === "comma" && isArray(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, defaults.encoder, charset, "key", format10) : prefix;
        }
        obj = "";
      }
      if (isNonNullishPrimitive(obj) || utils.isBuffer(obj)) {
        if (encoder) {
          var keyValue = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, "key", format10);
          if (generateArrayPrefix === "comma" && encodeValuesOnly) {
            var valuesArray = split.call(String(obj), ",");
            var valuesJoined = "";
            for (var i = 0; i < valuesArray.length; ++i) {
              valuesJoined += (i === 0 ? "" : ",") + formatter(encoder(valuesArray[i], defaults.encoder, charset, "value", format10));
            }
            return [formatter(keyValue) + "=" + valuesJoined];
          }
          return [formatter(keyValue) + "=" + formatter(encoder(obj, defaults.encoder, charset, "value", format10))];
        }
        return [formatter(prefix) + "=" + formatter(String(obj))];
      }
      var values = [];
      if (typeof obj === "undefined") {
        return values;
      }
      var objKeys;
      if (generateArrayPrefix === "comma" && isArray(obj)) {
        objKeys = [{ value: obj.length > 0 ? obj.join(",") || null : void 0 }];
      } else if (isArray(filter)) {
        objKeys = filter;
      } else {
        var keys = Object.keys(obj);
        objKeys = sort ? keys.sort(sort) : keys;
      }
      for (var j2 = 0; j2 < objKeys.length; ++j2) {
        var key = objKeys[j2];
        var value = typeof key === "object" && typeof key.value !== "undefined" ? key.value : obj[key];
        if (skipNulls && value === null) {
          continue;
        }
        var keyPrefix = isArray(obj) ? typeof generateArrayPrefix === "function" ? generateArrayPrefix(prefix, key) : prefix : prefix + (allowDots ? "." + key : "[" + key + "]");
        sideChannel.set(object, step);
        var valueSideChannel = getSideChannel();
        valueSideChannel.set(sentinel, sideChannel);
        pushToArray(values, stringify2(
          value,
          keyPrefix,
          generateArrayPrefix,
          strictNullHandling,
          skipNulls,
          encoder,
          filter,
          sort,
          allowDots,
          serializeDate,
          format10,
          formatter,
          encodeValuesOnly,
          charset,
          valueSideChannel
        ));
      }
      return values;
    }, "stringify");
    var normalizeStringifyOptions = /* @__PURE__ */ __name(function normalizeStringifyOptions2(opts) {
      if (!opts) {
        return defaults;
      }
      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 || defaults.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 format10 = formats["default"];
      if (typeof opts.format !== "undefined") {
        if (!has.call(formats.formatters, opts.format)) {
          throw new TypeError("Unknown format option provided.");
        }
        format10 = opts.format;
      }
      var formatter = formats.formatters[format10];
      var filter = defaults.filter;
      if (typeof opts.filter === "function" || isArray(opts.filter)) {
        filter = opts.filter;
      }
      return {
        addQueryPrefix: typeof opts.addQueryPrefix === "boolean" ? opts.addQueryPrefix : defaults.addQueryPrefix,
        allowDots: typeof opts.allowDots === "undefined" ? defaults.allowDots : !!opts.allowDots,
        charset,
        charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults.charsetSentinel,
        delimiter: typeof opts.delimiter === "undefined" ? defaults.delimiter : opts.delimiter,
        encode: typeof opts.encode === "boolean" ? opts.encode : defaults.encode,
        encoder: typeof opts.encoder === "function" ? opts.encoder : defaults.encoder,
        encodeValuesOnly: typeof opts.encodeValuesOnly === "boolean" ? opts.encodeValuesOnly : defaults.encodeValuesOnly,
        filter,
        format: format10,
        formatter,
        serializeDate: typeof opts.serializeDate === "function" ? opts.serializeDate : defaults.serializeDate,
        skipNulls: typeof opts.skipNulls === "boolean" ? opts.skipNulls : defaults.skipNulls,
        sort: typeof opts.sort === "function" ? opts.sort : null,
        strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults.strictNullHandling
      };
    }, "normalizeStringifyOptions");
    module3.exports = function(object, opts) {
      var obj = object;
      var options29 = normalizeStringifyOptions(opts);
      var objKeys;
      var filter;
      if (typeof options29.filter === "function") {
        filter = options29.filter;
        obj = filter("", obj);
      } else if (isArray(options29.filter)) {
        filter = options29.filter;
        objKeys = filter;
      }
      var keys = [];
      if (typeof obj !== "object" || obj === null) {
        return "";
      }
      var arrayFormat;
      if (opts && opts.arrayFormat in arrayPrefixGenerators) {
        arrayFormat = opts.arrayFormat;
      } else if (opts && "indices" in opts) {
        arrayFormat = opts.indices ? "indices" : "repeat";
      } else {
        arrayFormat = "indices";
      }
      var generateArrayPrefix = arrayPrefixGenerators[arrayFormat];
      if (!objKeys) {
        objKeys = Object.keys(obj);
      }
      if (options29.sort) {
        objKeys.sort(options29.sort);
      }
      var sideChannel = getSideChannel();
      for (var i = 0; i < objKeys.length; ++i) {
        var key = objKeys[i];
        if (options29.skipNulls && obj[key] === null) {
          continue;
        }
        pushToArray(keys, stringify(
          obj[key],
          key,
          generateArrayPrefix,
          options29.strictNullHandling,
          options29.skipNulls,
          options29.encode ? options29.encoder : null,
          options29.filter,
          options29.sort,
          options29.allowDots,
          options29.serializeDate,
          options29.format,
          options29.formatter,
          options29.encodeValuesOnly,
          options29.charset,
          sideChannel
        ));
      }
      var joined = keys.join(options29.delimiter);
      var prefix = options29.addQueryPrefix === true ? "?" : "";
      if (options29.charsetSentinel) {
        if (options29.charset === "iso-8859-1") {
          prefix += "utf8=%26%2310003%3B&";
        } else {
          prefix += "utf8=%E2%9C%93&";
        }
      }
      return joined.length > 0 ? prefix + joined : "";
    };
  }
});

// ../../node_modules/.pnpm/qs@6.10.3/node_modules/qs/lib/parse.js
var require_parse4 = __commonJS({
  "../../node_modules/.pnpm/qs@6.10.3/node_modules/qs/lib/parse.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var utils = require_utils3();
    var has = Object.prototype.hasOwnProperty;
    var isArray = Array.isArray;
    var defaults = {
      allowDots: false,
      allowPrototypes: false,
      allowSparse: false,
      arrayLimit: 20,
      charset: "utf-8",
      charsetSentinel: false,
      comma: false,
      decoder: utils.decode,
      delimiter: "&",
      depth: 5,
      ignoreQueryPrefix: false,
      interpretNumericEntities: false,
      parameterLimit: 1e3,
      parseArrays: true,
      plainObjects: false,
      strictNullHandling: false
    };
    var interpretNumericEntities = /* @__PURE__ */ __name(function(str) {
      return str.replace(/&#(\d+);/g, function($0, numberStr) {
        return String.fromCharCode(parseInt(numberStr, 10));
      });
    }, "interpretNumericEntities");
    var parseArrayValue = /* @__PURE__ */ __name(function(val, options29) {
      if (val && typeof val === "string" && options29.comma && val.indexOf(",") > -1) {
        return val.split(",");
      }
      return val;
    }, "parseArrayValue");
    var isoSentinel = "utf8=%26%2310003%3B";
    var charsetSentinel = "utf8=%E2%9C%93";
    var parseValues = /* @__PURE__ */ __name(function parseQueryStringValues(str, options29) {
      var obj = {};
      var cleanStr = options29.ignoreQueryPrefix ? str.replace(/^\?/, "") : str;
      var limit = options29.parameterLimit === Infinity ? void 0 : options29.parameterLimit;
      var parts = cleanStr.split(options29.delimiter, limit);
      var skipIndex = -1;
      var i;
      var charset = options29.charset;
      if (options29.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, val;
        if (pos === -1) {
          key = options29.decoder(part, defaults.decoder, charset, "key");
          val = options29.strictNullHandling ? null : "";
        } else {
          key = options29.decoder(part.slice(0, pos), defaults.decoder, charset, "key");
          val = utils.maybeMap(
            parseArrayValue(part.slice(pos + 1), options29),
            function(encodedVal) {
              return options29.decoder(encodedVal, defaults.decoder, charset, "value");
            }
          );
        }
        if (val && options29.interpretNumericEntities && charset === "iso-8859-1") {
          val = interpretNumericEntities(val);
        }
        if (part.indexOf("[]=") > -1) {
          val = isArray(val) ? [val] : val;
        }
        if (has.call(obj, key)) {
          obj[key] = utils.combine(obj[key], val);
        } else {
          obj[key] = val;
        }
      }
      return obj;
    }, "parseQueryStringValues");
    var parseObject = /* @__PURE__ */ __name(function(chain, val, options29, valuesParsed) {
      var leaf = valuesParsed ? val : parseArrayValue(val, options29);
      for (var i = chain.length - 1; i >= 0; --i) {
        var obj;
        var root = chain[i];
        if (root === "[]" && options29.parseArrays) {
          obj = [].concat(leaf);
        } else {
          obj = options29.plainObjects ? /* @__PURE__ */ Object.create(null) : {};
          var cleanRoot = root.charAt(0) === "[" && root.charAt(root.length - 1) === "]" ? root.slice(1, -1) : root;
          var index = parseInt(cleanRoot, 10);
          if (!options29.parseArrays && cleanRoot === "") {
            obj = { 0: leaf };
          } else if (!isNaN(index) && root !== cleanRoot && String(index) === cleanRoot && index >= 0 && (options29.parseArrays && index <= options29.arrayLimit)) {
            obj = [];
            obj[index] = leaf;
          } else if (cleanRoot !== "__proto__") {
            obj[cleanRoot] = leaf;
          }
        }
        leaf = obj;
      }
      return leaf;
    }, "parseObject");
    var parseKeys = /* @__PURE__ */ __name(function parseQueryStringKeys(givenKey, val, options29, valuesParsed) {
      if (!givenKey) {
        return;
      }
      var key = options29.allowDots ? givenKey.replace(/\.([^.[]+)/g, "[$1]") : givenKey;
      var brackets = /(\[[^[\]]*])/;
      var child = /(\[[^[\]]*])/g;
      var segment = options29.depth > 0 && brackets.exec(key);
      var parent = segment ? key.slice(0, segment.index) : key;
      var keys = [];
      if (parent) {
        if (!options29.plainObjects && has.call(Object.prototype, parent)) {
          if (!options29.allowPrototypes) {
            return;
          }
        }
        keys.push(parent);
      }
      var i = 0;
      while (options29.depth > 0 && (segment = child.exec(key)) !== null && i < options29.depth) {
        i += 1;
        if (!options29.plainObjects && has.call(Object.prototype, segment[1].slice(1, -1))) {
          if (!options29.allowPrototypes) {
            return;
          }
        }
        keys.push(segment[1]);
      }
      if (segment) {
        keys.push("[" + key.slice(segment.index) + "]");
      }
      return parseObject(keys, val, options29, valuesParsed);
    }, "parseQueryStringKeys");
    var normalizeParseOptions = /* @__PURE__ */ __name(function normalizeParseOptions2(opts) {
      if (!opts) {
        return defaults;
      }
      if (opts.decoder !== null && opts.decoder !== void 0 && 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");
      }
      var charset = typeof opts.charset === "undefined" ? defaults.charset : opts.charset;
      return {
        allowDots: typeof opts.allowDots === "undefined" ? defaults.allowDots : !!opts.allowDots,
        allowPrototypes: typeof opts.allowPrototypes === "boolean" ? opts.allowPrototypes : defaults.allowPrototypes,
        allowSparse: typeof opts.allowSparse === "boolean" ? opts.allowSparse : defaults.allowSparse,
        arrayLimit: typeof opts.arrayLimit === "number" ? opts.arrayLimit : defaults.arrayLimit,
        charset,
        charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults.charsetSentinel,
        comma: typeof opts.comma === "boolean" ? opts.comma : defaults.comma,
        decoder: typeof opts.decoder === "function" ? opts.decoder : defaults.decoder,
        delimiter: typeof opts.delimiter === "string" || utils.isRegExp(opts.delimiter) ? opts.delimiter : defaults.delimiter,
        // eslint-disable-next-line no-implicit-coercion, no-extra-parens
        depth: typeof opts.depth === "number" || opts.depth === false ? +opts.depth : defaults.depth,
        ignoreQueryPrefix: opts.ignoreQueryPrefix === true,
        interpretNumericEntities: typeof opts.interpretNumericEntities === "boolean" ? opts.interpretNumericEntities : defaults.interpretNumericEntities,
        parameterLimit: typeof opts.parameterLimit === "number" ? opts.parameterLimit : defaults.parameterLimit,
        parseArrays: opts.parseArrays !== false,
        plainObjects: typeof opts.plainObjects === "boolean" ? opts.plainObjects : defaults.plainObjects,
        strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults.strictNullHandling
      };
    }, "normalizeParseOptions");
    module3.exports = function(str, opts) {
      var options29 = normalizeParseOptions(opts);
      if (str === "" || str === null || typeof str === "undefined") {
        return options29.plainObjects ? /* @__PURE__ */ Object.create(null) : {};
      }
      var tempObj = typeof str === "string" ? parseValues(str, options29) : str;
      var obj = options29.plainObjects ? /* @__PURE__ */ Object.create(null) : {};
      var keys = Object.keys(tempObj);
      for (var i = 0; i < keys.length; ++i) {
        var key = keys[i];
        var newObj = parseKeys(key, tempObj[key], options29, typeof str === "string");
        obj = utils.merge(obj, newObj, options29);
      }
      if (options29.allowSparse === true) {
        return obj;
      }
      return utils.compact(obj);
    };
  }
});

// ../../node_modules/.pnpm/qs@6.10.3/node_modules/qs/lib/index.js
var require_lib3 = __commonJS({
  "../../node_modules/.pnpm/qs@6.10.3/node_modules/qs/lib/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var stringify = require_stringify2();
    var parse7 = require_parse4();
    var formats = require_formats();
    module3.exports = {
      formats,
      parse: parse7,
      stringify
    };
  }
});

// ../../node_modules/.pnpm/body-parser@1.20.0_supports-color@9.2.2/node_modules/body-parser/lib/types/urlencoded.js
var require_urlencoded2 = __commonJS({
  "../../node_modules/.pnpm/body-parser@1.20.0_supports-color@9.2.2/node_modules/body-parser/lib/types/urlencoded.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var bytes = require_bytes();
    var contentType = require_content_type();
    var createError = require_http_errors();
    var debug = require_src3()("body-parser:urlencoded");
    var deprecate = require_depd()("body-parser");
    var read = require_read();
    var typeis = require_type_is();
    module3.exports = urlencoded;
    var parsers = /* @__PURE__ */ Object.create(null);
    function urlencoded(options29) {
      var opts = options29 || {};
      if (opts.extended === void 0) {
        deprecate("undefined extended: provide extended option");
      }
      var extended = opts.extended !== false;
      var inflate = opts.inflate !== false;
      var limit = typeof opts.limit !== "number" ? bytes.parse(opts.limit || "100kb") : opts.limit;
      var type = opts.type || "application/x-www-form-urlencoded";
      var verify = opts.verify || false;
      if (verify !== false && typeof verify !== "function") {
        throw new TypeError("option verify must be function");
      }
      var queryparse = extended ? extendedparser(opts) : simpleparser(opts);
      var shouldParse = typeof type !== "function" ? typeChecker(type) : type;
      function parse7(body) {
        return body.length ? queryparse(body) : {};
      }
      __name(parse7, "parse");
      return /* @__PURE__ */ __name(function urlencodedParser(req, res, next) {
        if (req._body) {
          debug("body already parsed");
          next();
          return;
        }
        req.body = req.body || {};
        if (!typeis.hasBody(req)) {
          debug("skip empty body");
          next();
          return;
        }
        debug("content-type %j", req.headers["content-type"]);
        if (!shouldParse(req)) {
          debug("skip parsing");
          next();
          return;
        }
        var charset = getCharset(req) || "utf-8";
        if (charset !== "utf-8") {
          debug("invalid charset");
          next(createError(415, 'unsupported charset "' + charset.toUpperCase() + '"', {
            charset,
            type: "charset.unsupported"
          }));
          return;
        }
        read(req, res, next, parse7, debug, {
          debug,
          encoding: charset,
          inflate,
          limit,
          verify
        });
      }, "urlencodedParser");
    }
    __name(urlencoded, "urlencoded");
    function extendedparser(options29) {
      var parameterLimit = options29.parameterLimit !== void 0 ? options29.parameterLimit : 1e3;
      var parse7 = parser2("qs");
      if (isNaN(parameterLimit) || parameterLimit < 1) {
        throw new TypeError("option parameterLimit must be a positive number");
      }
      if (isFinite(parameterLimit)) {
        parameterLimit = parameterLimit | 0;
      }
      return /* @__PURE__ */ __name(function queryparse(body) {
        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 = Math.max(100, paramCount);
        debug("parse extended urlencoding");
        return parse7(body, {
          allowPrototypes: true,
          arrayLimit,
          depth: Infinity,
          parameterLimit
        });
      }, "queryparse");
    }
    __name(extendedparser, "extendedparser");
    function getCharset(req) {
      try {
        return (contentType.parse(req).parameters.charset || "").toLowerCase();
      } catch (e3) {
        return void 0;
      }
    }
    __name(getCharset, "getCharset");
    function parameterCount(body, limit) {
      var count = 0;
      var index = 0;
      while ((index = body.indexOf("&", index)) !== -1) {
        count++;
        index++;
        if (count === limit) {
          return void 0;
        }
      }
      return count;
    }
    __name(parameterCount, "parameterCount");
    function parser2(name) {
      var mod = parsers[name];
      if (mod !== void 0) {
        return mod.parse;
      }
      switch (name) {
        case "qs":
          mod = require_lib3();
          break;
        case "querystring":
          mod = require("querystring");
          break;
      }
      parsers[name] = mod;
      return mod.parse;
    }
    __name(parser2, "parser");
    function simpleparser(options29) {
      var parameterLimit = options29.parameterLimit !== void 0 ? options29.parameterLimit : 1e3;
      var parse7 = parser2("querystring");
      if (isNaN(parameterLimit) || parameterLimit < 1) {
        throw new TypeError("option parameterLimit must be a positive number");
      }
      if (isFinite(parameterLimit)) {
        parameterLimit = parameterLimit | 0;
      }
      return /* @__PURE__ */ __name(function queryparse(body) {
        var paramCount = parameterCount(body, parameterLimit);
        if (paramCount === void 0) {
          debug("too many parameters");
          throw createError(413, "too many parameters", {
            type: "parameters.too.many"
          });
        }
        debug("parse urlencoding");
        return parse7(body, void 0, void 0, { maxKeys: parameterLimit });
      }, "queryparse");
    }
    __name(simpleparser, "simpleparser");
    function typeChecker(type) {
      return /* @__PURE__ */ __name(function checkType2(req) {
        return Boolean(typeis(req, type));
      }, "checkType");
    }
    __name(typeChecker, "typeChecker");
  }
});

// ../../node_modules/.pnpm/body-parser@1.20.0_supports-color@9.2.2/node_modules/body-parser/index.js
var require_body_parser = __commonJS({
  "../../node_modules/.pnpm/body-parser@1.20.0_supports-color@9.2.2/node_modules/body-parser/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var deprecate = require_depd()("body-parser");
    var parsers = /* @__PURE__ */ Object.create(null);
    exports2 = module3.exports = deprecate.function(
      bodyParser2,
      "bodyParser: use individual json/urlencoded middlewares"
    );
    Object.defineProperty(exports2, "json", {
      configurable: true,
      enumerable: true,
      get: createParserGetter("json")
    });
    Object.defineProperty(exports2, "raw", {
      configurable: true,
      enumerable: true,
      get: createParserGetter("raw")
    });
    Object.defineProperty(exports2, "text", {
      configurable: true,
      enumerable: true,
      get: createParserGetter("text")
    });
    Object.defineProperty(exports2, "urlencoded", {
      configurable: true,
      enumerable: true,
      get: createParserGetter("urlencoded")
    });
    function bodyParser2(options29) {
      var opts = {};
      if (options29) {
        for (var prop in options29) {
          if (prop !== "type") {
            opts[prop] = options29[prop];
          }
        }
      }
      var _urlencoded = exports2.urlencoded(opts);
      var _json = exports2.json(opts);
      return /* @__PURE__ */ __name(function bodyParser3(req, res, next) {
        _json(req, res, function(err) {
          if (err)
            return next(err);
          _urlencoded(req, res, next);
        });
      }, "bodyParser");
    }
    __name(bodyParser2, "bodyParser");
    function createParserGetter(name) {
      return /* @__PURE__ */ __name(function get() {
        return loadParser(name);
      }, "get");
    }
    __name(createParserGetter, "createParserGetter");
    function loadParser(parserName) {
      var parser2 = parsers[parserName];
      if (parser2 !== void 0) {
        return parser2;
      }
      switch (parserName) {
        case "json":
          parser2 = require_json();
          break;
        case "raw":
          parser2 = require_raw();
          break;
        case "text":
          parser2 = require_text3();
          break;
        case "urlencoded":
          parser2 = require_urlencoded2();
          break;
      }
      return parsers[parserName] = parser2;
    }
    __name(loadParser, "loadParser");
  }
});

// ../../node_modules/.pnpm/merge-descriptors@1.0.1/node_modules/merge-descriptors/index.js
var require_merge_descriptors = __commonJS({
  "../../node_modules/.pnpm/merge-descriptors@1.0.1/node_modules/merge-descriptors/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = merge;
    var hasOwnProperty2 = Object.prototype.hasOwnProperty;
    function merge(dest, src, redefine) {
      if (!dest) {
        throw new TypeError("argument dest is required");
      }
      if (!src) {
        throw new TypeError("argument src is required");
      }
      if (redefine === void 0) {
        redefine = true;
      }
      Object.getOwnPropertyNames(src).forEach(/* @__PURE__ */ __name(function forEachOwnPropertyName(name) {
        if (!redefine && hasOwnProperty2.call(dest, name)) {
          return;
        }
        var descriptor2 = Object.getOwnPropertyDescriptor(src, name);
        Object.defineProperty(dest, name, descriptor2);
      }, "forEachOwnPropertyName"));
      return dest;
    }
    __name(merge, "merge");
  }
});

// ../../node_modules/.pnpm/encodeurl@1.0.2/node_modules/encodeurl/index.js
var require_encodeurl = __commonJS({
  "../../node_modules/.pnpm/encodeurl@1.0.2/node_modules/encodeurl/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = encodeUrl;
    var ENCODE_CHARS_REGEXP = /(?:[^\x21\x25\x26-\x3B\x3D\x3F-\x5B\x5D\x5F\x61-\x7A\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);
    }
    __name(encodeUrl, "encodeUrl");
  }
});

// ../../node_modules/.pnpm/escape-html@1.0.3/node_modules/escape-html/index.js
var require_escape_html = __commonJS({
  "../../node_modules/.pnpm/escape-html@1.0.3/node_modules/escape-html/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var matchHtmlRegExp = /["'&<>]/;
    module3.exports = escapeHtml;
    function escapeHtml(string) {
      var str = "" + string;
      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;
    }
    __name(escapeHtml, "escapeHtml");
  }
});

// ../../node_modules/.pnpm/parseurl@1.3.3/node_modules/parseurl/index.js
var require_parseurl = __commonJS({
  "../../node_modules/.pnpm/parseurl@1.3.3/node_modules/parseurl/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var url4 = require("url");
    var parse7 = url4.parse;
    var Url = url4.Url;
    module3.exports = parseurl;
    module3.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;
    }
    __name(parseurl, "parseurl");
    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;
    }
    __name(originalurl, "originalurl");
    function fastparse(str) {
      if (typeof str !== "string" || str.charCodeAt(0) !== 47) {
        return parse7(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:
          case 10:
          case 12:
          case 13:
          case 32:
          case 35:
          case 160:
          case 65279:
            return parse7(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;
    }
    __name(fastparse, "fastparse");
    function fresh(url5, parsedUrl) {
      return typeof parsedUrl === "object" && parsedUrl !== null && (Url === void 0 || parsedUrl instanceof Url) && parsedUrl._raw === url5;
    }
    __name(fresh, "fresh");
  }
});

// ../../node_modules/.pnpm/finalhandler@1.2.0_supports-color@9.2.2/node_modules/finalhandler/index.js
var require_finalhandler = __commonJS({
  "../../node_modules/.pnpm/finalhandler@1.2.0_supports-color@9.2.2/node_modules/finalhandler/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var debug = require_src3()("finalhandler");
    var encodeUrl = require_encodeurl();
    var escapeHtml = require_escape_html();
    var onFinished = require_on_finished();
    var parseUrl2 = require_parseurl();
    var statuses = require_statuses();
    var unpipe = require_unpipe();
    var DOUBLE_SPACE_REGEXP = /\x20{2}/g;
    var NEWLINE_REGEXP = /\n/g;
    var defer = typeof setImmediate === "function" ? setImmediate : function(fn2) {
      process.nextTick(fn2.bind.apply(fn2, arguments));
    };
    var isFinished = onFinished.isFinished;
    function createHtmlDocument(message) {
      var body = escapeHtml(message).replace(NEWLINE_REGEXP, "<br>").replace(DOUBLE_SPACE_REGEXP, " &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";
    }
    __name(createHtmlDocument, "createHtmlDocument");
    module3.exports = finalhandler;
    function finalhandler(req, res, options29) {
      var opts = options29 || {};
      var env5 = opts.env || "production";
      var onerror = opts.onerror;
      return function(err) {
        var headers;
        var msg;
        var status2;
        if (!err && headersSent(res)) {
          debug("cannot 404 after headers sent");
          return;
        }
        if (err) {
          status2 = getErrorStatusCode(err);
          if (status2 === void 0) {
            status2 = getResponseStatusCode(res);
          } else {
            headers = getErrorHeaders(err);
          }
          msg = getErrorMessage2(err, status2, env5);
        } else {
          status2 = 404;
          msg = "Cannot " + req.method + " " + encodeUrl(getResourceName(req));
        }
        debug("default %s", status2);
        if (err && onerror) {
          defer(onerror, err, req, res);
        }
        if (headersSent(res)) {
          debug("cannot %d after headers sent", status2);
          req.socket.destroy();
          return;
        }
        send(req, res, status2, headers, msg);
      };
    }
    __name(finalhandler, "finalhandler");
    function getErrorHeaders(err) {
      if (!err.headers || typeof err.headers !== "object") {
        return void 0;
      }
      var headers = /* @__PURE__ */ Object.create(null);
      var keys = Object.keys(err.headers);
      for (var i = 0; i < keys.length; i++) {
        var key = keys[i];
        headers[key] = err.headers[key];
      }
      return headers;
    }
    __name(getErrorHeaders, "getErrorHeaders");
    function getErrorMessage2(err, status2, env5) {
      var msg;
      if (env5 !== "production") {
        msg = err.stack;
        if (!msg && typeof err.toString === "function") {
          msg = err.toString();
        }
      }
      return msg || statuses.message[status2];
    }
    __name(getErrorMessage2, "getErrorMessage");
    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;
    }
    __name(getErrorStatusCode, "getErrorStatusCode");
    function getResourceName(req) {
      try {
        return parseUrl2.original(req).pathname;
      } catch (e3) {
        return "resource";
      }
    }
    __name(getResourceName, "getResourceName");
    function getResponseStatusCode(res) {
      var status2 = res.statusCode;
      if (typeof status2 !== "number" || status2 < 400 || status2 > 599) {
        status2 = 500;
      }
      return status2;
    }
    __name(getResponseStatusCode, "getResponseStatusCode");
    function headersSent(res) {
      return typeof res.headersSent !== "boolean" ? Boolean(res._header) : res.headersSent;
    }
    __name(headersSent, "headersSent");
    function send(req, res, status2, headers, message) {
      function write() {
        var body = createHtmlDocument(message);
        res.statusCode = status2;
        res.statusMessage = statuses.message[status2];
        res.removeHeader("Content-Encoding");
        res.removeHeader("Content-Language");
        res.removeHeader("Content-Range");
        setHeaders(res, headers);
        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");
      }
      __name(write, "write");
      if (isFinished(req)) {
        write();
        return;
      }
      unpipe(req);
      onFinished(req, write);
      req.resume();
    }
    __name(send, "send");
    function setHeaders(res, headers) {
      if (!headers) {
        return;
      }
      var keys = Object.keys(headers);
      for (var i = 0; i < keys.length; i++) {
        var key = keys[i];
        res.setHeader(key, headers[key]);
      }
    }
    __name(setHeaders, "setHeaders");
  }
});

// ../../node_modules/.pnpm/array-flatten@1.1.1/node_modules/array-flatten/array-flatten.js
var require_array_flatten = __commonJS({
  "../../node_modules/.pnpm/array-flatten@1.1.1/node_modules/array-flatten/array-flatten.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = arrayFlatten;
    function flattenWithDepth(array, result, depth) {
      for (var i = 0; i < array.length; i++) {
        var value = array[i];
        if (depth > 0 && Array.isArray(value)) {
          flattenWithDepth(value, result, depth - 1);
        } else {
          result.push(value);
        }
      }
      return result;
    }
    __name(flattenWithDepth, "flattenWithDepth");
    function flattenForever(array, result) {
      for (var i = 0; i < array.length; i++) {
        var value = array[i];
        if (Array.isArray(value)) {
          flattenForever(value, result);
        } else {
          result.push(value);
        }
      }
      return result;
    }
    __name(flattenForever, "flattenForever");
    function arrayFlatten(array, depth) {
      if (depth == null) {
        return flattenForever(array, []);
      }
      return flattenWithDepth(array, [], depth);
    }
    __name(arrayFlatten, "arrayFlatten");
  }
});

// ../../node_modules/.pnpm/path-to-regexp@0.1.7/node_modules/path-to-regexp/index.js
var require_path_to_regexp = __commonJS({
  "../../node_modules/.pnpm/path-to-regexp@0.1.7/node_modules/path-to-regexp/index.js"(exports2, module3) {
    init_import_meta_url();
    module3.exports = pathtoRegexp;
    var MATCHING_GROUP_REGEXP = /\((?!\?)/g;
    function pathtoRegexp(path67, keys, options29) {
      options29 = options29 || {};
      keys = keys || [];
      var strict = options29.strict;
      var end = options29.end !== false;
      var flags = options29.sensitive ? "" : "i";
      var extraOffset = 0;
      var keysOffset = keys.length;
      var i = 0;
      var name = 0;
      var m2;
      if (path67 instanceof RegExp) {
        while (m2 = MATCHING_GROUP_REGEXP.exec(path67.source)) {
          keys.push({
            name: name++,
            optional: false,
            offset: m2.index
          });
        }
        return path67;
      }
      if (Array.isArray(path67)) {
        path67 = path67.map(function(value) {
          return pathtoRegexp(value, keys, options29).source;
        });
        return new RegExp("(?:" + path67.join("|") + ")", flags);
      }
      path67 = ("^" + path67 + (strict ? "" : path67[path67.length - 1] === "/" ? "?" : "/?")).replace(/\/\(/g, "/(?:").replace(/([\/\.])/g, "\\$1").replace(/(\\\/)?(\\\.)?:(\w+)(\(.*?\))?(\*)?(\?)?/g, function(match, slash, format10, key, capture, star, optional, offset) {
        slash = slash || "";
        format10 = format10 || "";
        capture = capture || "([^\\/" + format10 + "]+?)";
        optional = optional || "";
        keys.push({
          name: key,
          optional: !!optional,
          offset: offset + extraOffset
        });
        var result = "" + (optional ? "" : slash) + "(?:" + format10 + (optional ? slash : "") + capture + (star ? "((?:[\\/" + format10 + "].+?)?)" : "") + ")" + optional;
        extraOffset += result.length - match.length;
        return result;
      }).replace(/\*/g, function(star, index2) {
        var len = keys.length;
        while (len-- > keysOffset && keys[len].offset > index2) {
          keys[len].offset += 3;
        }
        return "(.*)";
      });
      while (m2 = MATCHING_GROUP_REGEXP.exec(path67)) {
        var escapeCount = 0;
        var index = m2.index;
        while (path67.charAt(--index) === "\\") {
          escapeCount++;
        }
        if (escapeCount % 2 === 1) {
          continue;
        }
        if (keysOffset + i === keys.length || keys[keysOffset + i].offset > m2.index) {
          keys.splice(keysOffset + i, 0, {
            name: name++,
            // Unnamed matching groups must be consistently linear.
            optional: false,
            offset: m2.index
          });
        }
        i++;
      }
      path67 += end ? "$" : path67[path67.length - 1] === "/" ? "" : "(?=\\/|$)";
      return new RegExp(path67, flags);
    }
    __name(pathtoRegexp, "pathtoRegexp");
  }
});

// ../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/router/layer.js
var require_layer = __commonJS({
  "../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/router/layer.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var pathRegexp = require_path_to_regexp();
    var debug = require_src3()("express:router:layer");
    var hasOwnProperty2 = Object.prototype.hasOwnProperty;
    module3.exports = Layer;
    function Layer(path67, options29, fn2) {
      if (!(this instanceof Layer)) {
        return new Layer(path67, options29, fn2);
      }
      debug("new %o", path67);
      var opts = options29 || {};
      this.handle = fn2;
      this.name = fn2.name || "<anonymous>";
      this.params = void 0;
      this.path = void 0;
      this.regexp = pathRegexp(path67, this.keys = [], opts);
      this.regexp.fast_star = path67 === "*";
      this.regexp.fast_slash = path67 === "/" && opts.end === false;
    }
    __name(Layer, "Layer");
    Layer.prototype.handle_error = /* @__PURE__ */ __name(function handle_error(error2, req, res, next) {
      var fn2 = this.handle;
      if (fn2.length !== 4) {
        return next(error2);
      }
      try {
        fn2(error2, req, res, next);
      } catch (err) {
        next(err);
      }
    }, "handle_error");
    Layer.prototype.handle_request = /* @__PURE__ */ __name(function handle(req, res, next) {
      var fn2 = this.handle;
      if (fn2.length > 3) {
        return next();
      }
      try {
        fn2(req, res, next);
      } catch (err) {
        next(err);
      }
    }, "handle");
    Layer.prototype.match = /* @__PURE__ */ __name(function match(path67) {
      var match2;
      if (path67 != null) {
        if (this.regexp.fast_slash) {
          this.params = {};
          this.path = "";
          return true;
        }
        if (this.regexp.fast_star) {
          this.params = { "0": decode_param(path67) };
          this.path = path67;
          return true;
        }
        match2 = this.regexp.exec(path67);
      }
      if (!match2) {
        this.params = void 0;
        this.path = void 0;
        return false;
      }
      this.params = {};
      this.path = match2[0];
      var keys = this.keys;
      var params = this.params;
      for (var i = 1; i < match2.length; i++) {
        var key = keys[i - 1];
        var prop = key.name;
        var val = decode_param(match2[i]);
        if (val !== void 0 || !hasOwnProperty2.call(params, prop)) {
          params[prop] = val;
        }
      }
      return true;
    }, "match");
    function decode_param(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 = err.statusCode = 400;
        }
        throw err;
      }
    }
    __name(decode_param, "decode_param");
  }
});

// ../../node_modules/.pnpm/methods@1.1.2/node_modules/methods/index.js
var require_methods = __commonJS({
  "../../node_modules/.pnpm/methods@1.1.2/node_modules/methods/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var http4 = require("http");
    module3.exports = getCurrentNodeMethods() || getBasicNodeMethods();
    function getCurrentNodeMethods() {
      return http4.METHODS && http4.METHODS.map(/* @__PURE__ */ __name(function lowerCaseMethod(method) {
        return method.toLowerCase();
      }, "lowerCaseMethod"));
    }
    __name(getCurrentNodeMethods, "getCurrentNodeMethods");
    function getBasicNodeMethods() {
      return [
        "get",
        "post",
        "put",
        "head",
        "delete",
        "options",
        "trace",
        "copy",
        "lock",
        "mkcol",
        "move",
        "purge",
        "propfind",
        "proppatch",
        "unlock",
        "report",
        "mkactivity",
        "checkout",
        "merge",
        "m-search",
        "notify",
        "subscribe",
        "unsubscribe",
        "patch",
        "search",
        "connect"
      ];
    }
    __name(getBasicNodeMethods, "getBasicNodeMethods");
  }
});

// ../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/router/route.js
var require_route3 = __commonJS({
  "../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/router/route.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var debug = require_src3()("express:router:route");
    var flatten = require_array_flatten();
    var Layer = require_layer();
    var methods = require_methods();
    var slice = Array.prototype.slice;
    var toString2 = Object.prototype.toString;
    module3.exports = Route;
    function Route(path67) {
      this.path = path67;
      this.stack = [];
      debug("new %o", path67);
      this.methods = {};
    }
    __name(Route, "Route");
    Route.prototype._handles_method = /* @__PURE__ */ __name(function _handles_method(method) {
      if (this.methods._all) {
        return true;
      }
      var name = method.toLowerCase();
      if (name === "head" && !this.methods["head"]) {
        name = "get";
      }
      return Boolean(this.methods[name]);
    }, "_handles_method");
    Route.prototype._options = /* @__PURE__ */ __name(function _options() {
      var methods2 = Object.keys(this.methods);
      if (this.methods.get && !this.methods.head) {
        methods2.push("head");
      }
      for (var i = 0; i < methods2.length; i++) {
        methods2[i] = methods2[i].toUpperCase();
      }
      return methods2;
    }, "_options");
    Route.prototype.dispatch = /* @__PURE__ */ __name(function dispatch(req, res, done) {
      var idx = 0;
      var stack = this.stack;
      var sync = 0;
      if (stack.length === 0) {
        return done();
      }
      var method = req.method.toLowerCase();
      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);
        }
        var layer = stack[idx++];
        if (!layer) {
          return done(err);
        }
        if (++sync > 100) {
          return setImmediate(next, err);
        }
        if (layer.method && layer.method !== method) {
          return next(err);
        }
        if (err) {
          layer.handle_error(err, req, res, next);
        } else {
          layer.handle_request(req, res, next);
        }
        sync = 0;
      }
      __name(next, "next");
    }, "dispatch");
    Route.prototype.all = /* @__PURE__ */ __name(function all2() {
      var handles = flatten(slice.call(arguments));
      for (var i = 0; i < handles.length; i++) {
        var handle = handles[i];
        if (typeof handle !== "function") {
          var type = toString2.call(handle);
          var msg = "Route.all() requires a callback function but got a " + type;
          throw new TypeError(msg);
        }
        var layer = Layer("/", {}, handle);
        layer.method = void 0;
        this.methods._all = true;
        this.stack.push(layer);
      }
      return this;
    }, "all");
    methods.forEach(function(method) {
      Route.prototype[method] = function() {
        var handles = flatten(slice.call(arguments));
        for (var i = 0; i < handles.length; i++) {
          var handle = handles[i];
          if (typeof handle !== "function") {
            var type = toString2.call(handle);
            var msg = "Route." + method + "() requires a callback function but got a " + type;
            throw new Error(msg);
          }
          debug("%s %o", method, this.path);
          var layer = Layer("/", {}, handle);
          layer.method = method;
          this.methods[method] = true;
          this.stack.push(layer);
        }
        return this;
      };
    });
  }
});

// ../../node_modules/.pnpm/utils-merge@1.0.1/node_modules/utils-merge/index.js
var require_utils_merge = __commonJS({
  "../../node_modules/.pnpm/utils-merge@1.0.1/node_modules/utils-merge/index.js"(exports2, module3) {
    init_import_meta_url();
    exports2 = module3.exports = function(a, b2) {
      if (a && b2) {
        for (var key in b2) {
          a[key] = b2[key];
        }
      }
      return a;
    };
  }
});

// ../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/router/index.js
var require_router = __commonJS({
  "../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/router/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var Route = require_route3();
    var Layer = require_layer();
    var methods = require_methods();
    var mixin3 = require_utils_merge();
    var debug = require_src3()("express:router");
    var deprecate = require_depd()("express");
    var flatten = require_array_flatten();
    var parseUrl2 = require_parseurl();
    var setPrototypeOf = require_setprototypeof();
    var objectRegExp = /^\[object (\S+)\]$/;
    var slice = Array.prototype.slice;
    var toString2 = Object.prototype.toString;
    var proto = module3.exports = function(options29) {
      var opts = options29 || {};
      function router(req, res, next) {
        router.handle(req, res, next);
      }
      __name(router, "router");
      setPrototypeOf(router, proto);
      router.params = {};
      router._params = [];
      router.caseSensitive = opts.caseSensitive;
      router.mergeParams = opts.mergeParams;
      router.strict = opts.strict;
      router.stack = [];
      return router;
    };
    proto.param = /* @__PURE__ */ __name(function param(name, fn2) {
      if (typeof name === "function") {
        deprecate("router.param(fn): Refactor to use path params");
        this._params.push(name);
        return;
      }
      var params = this._params;
      var len = params.length;
      var ret;
      if (name[0] === ":") {
        deprecate("router.param(" + JSON.stringify(name) + ", fn): Use router.param(" + JSON.stringify(name.slice(1)) + ", fn) instead");
        name = name.slice(1);
      }
      for (var i = 0; i < len; ++i) {
        if (ret = params[i](name, fn2)) {
          fn2 = ret;
        }
      }
      if ("function" !== typeof fn2) {
        throw new Error("invalid param() call for " + name + ", got " + fn2);
      }
      (this.params[name] = this.params[name] || []).push(fn2);
      return this;
    }, "param");
    proto.handle = /* @__PURE__ */ __name(function handle(req, res, out) {
      var self2 = this;
      debug("dispatching %s %s", req.method, req.url);
      var idx = 0;
      var protohost = getProtohost(req.url) || "";
      var removed = "";
      var slashAdded = false;
      var sync = 0;
      var paramcalled = {};
      var options29 = [];
      var stack = self2.stack;
      var parentParams = req.params;
      var parentUrl = req.baseUrl || "";
      var done = restore(out, req, "baseUrl", "next", "params");
      req.next = next;
      if (req.method === "OPTIONS") {
        done = wrap4(done, function(old, err) {
          if (err || options29.length === 0)
            return old(err);
          sendOptionsResponse(res, options29, old);
        });
      }
      req.baseUrl = parentUrl;
      req.originalUrl = req.originalUrl || req.url;
      next();
      function next(err) {
        var 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);
        }
        var path67 = getPathname(req);
        if (path67 == null) {
          return done(layerError);
        }
        var layer;
        var match;
        var route2;
        while (match !== true && idx < stack.length) {
          layer = stack[idx++];
          match = matchLayer(layer, path67);
          route2 = layer.route;
          if (typeof match !== "boolean") {
            layerError = layerError || match;
          }
          if (match !== true) {
            continue;
          }
          if (!route2) {
            continue;
          }
          if (layerError) {
            match = false;
            continue;
          }
          var method = req.method;
          var has_method = route2._handles_method(method);
          if (!has_method && method === "OPTIONS") {
            appendMethods(options29, route2._options());
          }
          if (!has_method && method !== "HEAD") {
            match = false;
          }
        }
        if (match !== true) {
          return done(layerError);
        }
        if (route2) {
          req.route = route2;
        }
        req.params = self2.mergeParams ? mergeParams(layer.params, parentParams) : layer.params;
        var layerPath = layer.path;
        self2.process_params(layer, paramcalled, req, res, function(err2) {
          if (err2) {
            next(layerError || err2);
          } else if (route2) {
            layer.handle_request(req, res, next);
          } else {
            trim_prefix(layer, layerError, layerPath, path67);
          }
          sync = 0;
        });
      }
      __name(next, "next");
      function trim_prefix(layer, layerError, layerPath, path67) {
        if (layerPath.length !== 0) {
          if (layerPath !== path67.slice(0, layerPath.length)) {
            next(layerError);
            return;
          }
          var c2 = path67[layerPath.length];
          if (c2 && c2 !== "/" && c2 !== ".")
            return next(layerError);
          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.handle_error(layerError, req, res, next);
        } else {
          layer.handle_request(req, res, next);
        }
      }
      __name(trim_prefix, "trim_prefix");
    }, "handle");
    proto.process_params = /* @__PURE__ */ __name(function process_params(layer, called, req, res, done) {
      var params = this.params;
      var keys = layer.keys;
      if (!keys || keys.length === 0) {
        return done();
      }
      var i = 0;
      var name;
      var paramIndex = 0;
      var key;
      var paramVal;
      var paramCallbacks;
      var paramCalled;
      function param(err) {
        if (err) {
          return done(err);
        }
        if (i >= keys.length) {
          return done();
        }
        paramIndex = 0;
        key = keys[i++];
        name = key.name;
        paramVal = req.params[name];
        paramCallbacks = params[name];
        paramCalled = called[name];
        if (paramVal === void 0 || !paramCallbacks) {
          return param();
        }
        if (paramCalled && (paramCalled.match === paramVal || paramCalled.error && paramCalled.error !== "route")) {
          req.params[name] = paramCalled.value;
          return param(paramCalled.error);
        }
        called[name] = paramCalled = {
          error: null,
          match: paramVal,
          value: paramVal
        };
        paramCallback();
      }
      __name(param, "param");
      function paramCallback(err) {
        var fn2 = paramCallbacks[paramIndex++];
        paramCalled.value = req.params[key.name];
        if (err) {
          paramCalled.error = err;
          param(err);
          return;
        }
        if (!fn2)
          return param();
        try {
          fn2(req, res, paramCallback, paramVal, key.name);
        } catch (e3) {
          paramCallback(e3);
        }
      }
      __name(paramCallback, "paramCallback");
      param();
    }, "process_params");
    proto.use = /* @__PURE__ */ __name(function use(fn2) {
      var offset = 0;
      var path67 = "/";
      if (typeof fn2 !== "function") {
        var arg = fn2;
        while (Array.isArray(arg) && arg.length !== 0) {
          arg = arg[0];
        }
        if (typeof arg !== "function") {
          offset = 1;
          path67 = fn2;
        }
      }
      var callbacks = flatten(slice.call(arguments, offset));
      if (callbacks.length === 0) {
        throw new TypeError("Router.use() requires a middleware function");
      }
      for (var i = 0; i < callbacks.length; i++) {
        var fn2 = callbacks[i];
        if (typeof fn2 !== "function") {
          throw new TypeError("Router.use() requires a middleware function but got a " + gettype(fn2));
        }
        debug("use %o %s", path67, fn2.name || "<anonymous>");
        var layer = new Layer(path67, {
          sensitive: this.caseSensitive,
          strict: false,
          end: false
        }, fn2);
        layer.route = void 0;
        this.stack.push(layer);
      }
      return this;
    }, "use");
    proto.route = /* @__PURE__ */ __name(function route2(path67) {
      var route3 = new Route(path67);
      var layer = new Layer(path67, {
        sensitive: this.caseSensitive,
        strict: this.strict,
        end: true
      }, route3.dispatch.bind(route3));
      layer.route = route3;
      this.stack.push(layer);
      return route3;
    }, "route");
    methods.concat("all").forEach(function(method) {
      proto[method] = function(path67) {
        var route2 = this.route(path67);
        route2[method].apply(route2, slice.call(arguments, 1));
        return this;
      };
    });
    function appendMethods(list, addition) {
      for (var i = 0; i < addition.length; i++) {
        var method = addition[i];
        if (list.indexOf(method) === -1) {
          list.push(method);
        }
      }
    }
    __name(appendMethods, "appendMethods");
    function getPathname(req) {
      try {
        return parseUrl2(req).pathname;
      } catch (err) {
        return void 0;
      }
    }
    __name(getPathname, "getPathname");
    function getProtohost(url4) {
      if (typeof url4 !== "string" || url4.length === 0 || url4[0] === "/") {
        return void 0;
      }
      var searchIndex = url4.indexOf("?");
      var pathLength = searchIndex !== -1 ? searchIndex : url4.length;
      var fqdnIndex = url4.slice(0, pathLength).indexOf("://");
      return fqdnIndex !== -1 ? url4.substring(0, url4.indexOf("/", 3 + fqdnIndex)) : void 0;
    }
    __name(getProtohost, "getProtohost");
    function gettype(obj) {
      var type = typeof obj;
      if (type !== "object") {
        return type;
      }
      return toString2.call(obj).replace(objectRegExp, "$1");
    }
    __name(gettype, "gettype");
    function matchLayer(layer, path67) {
      try {
        return layer.match(path67);
      } catch (err) {
        return err;
      }
    }
    __name(matchLayer, "matchLayer");
    function mergeParams(params, parent) {
      if (typeof parent !== "object" || !parent) {
        return params;
      }
      var obj = mixin3({}, parent);
      if (!(0 in params) || !(0 in parent)) {
        return mixin3(obj, params);
      }
      var i = 0;
      var o2 = 0;
      while (i in params) {
        i++;
      }
      while (o2 in parent) {
        o2++;
      }
      for (i--; i >= 0; i--) {
        params[i + o2] = params[i];
        if (i < o2) {
          delete params[i];
        }
      }
      return mixin3(obj, params);
    }
    __name(mergeParams, "mergeParams");
    function restore(fn2, obj) {
      var props = new Array(arguments.length - 2);
      var vals = new Array(arguments.length - 2);
      for (var i = 0; i < props.length; i++) {
        props[i] = arguments[i + 2];
        vals[i] = obj[props[i]];
      }
      return function() {
        for (var i2 = 0; i2 < props.length; i2++) {
          obj[props[i2]] = vals[i2];
        }
        return fn2.apply(this, arguments);
      };
    }
    __name(restore, "restore");
    function sendOptionsResponse(res, options29, next) {
      try {
        var body = options29.join(",");
        res.set("Allow", body);
        res.send(body);
      } catch (err) {
        next(err);
      }
    }
    __name(sendOptionsResponse, "sendOptionsResponse");
    function wrap4(old, fn2) {
      return /* @__PURE__ */ __name(function proxy2() {
        var args = new Array(arguments.length + 1);
        args[0] = old;
        for (var i = 0, len = arguments.length; i < len; i++) {
          args[i + 1] = arguments[i];
        }
        fn2.apply(this, args);
      }, "proxy");
    }
    __name(wrap4, "wrap");
  }
});

// ../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/middleware/init.js
var require_init = __commonJS({
  "../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/middleware/init.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var setPrototypeOf = require_setprototypeof();
    exports2.init = function(app) {
      return /* @__PURE__ */ __name(function expressInit(req, res, next) {
        if (app.enabled("x-powered-by"))
          res.setHeader("X-Powered-By", "Express");
        req.res = res;
        res.req = req;
        req.next = next;
        setPrototypeOf(req, app.request);
        setPrototypeOf(res, app.response);
        res.locals = res.locals || /* @__PURE__ */ Object.create(null);
        next();
      }, "expressInit");
    };
  }
});

// ../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/middleware/query.js
var require_query = __commonJS({
  "../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/middleware/query.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var merge = require_utils_merge();
    var parseUrl2 = require_parseurl();
    var qs = require_lib3();
    module3.exports = /* @__PURE__ */ __name(function query(options29) {
      var opts = merge({}, options29);
      var queryparse = qs.parse;
      if (typeof options29 === "function") {
        queryparse = options29;
        opts = void 0;
      }
      if (opts !== void 0 && opts.allowPrototypes === void 0) {
        opts.allowPrototypes = true;
      }
      return /* @__PURE__ */ __name(function query2(req, res, next) {
        if (!req.query) {
          var val = parseUrl2(req).query;
          req.query = queryparse(val, opts);
        }
        next();
      }, "query");
    }, "query");
  }
});

// ../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/view.js
var require_view = __commonJS({
  "../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/view.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var debug = require_src3()("express:view");
    var path67 = require("path");
    var fs26 = require("fs");
    var dirname13 = path67.dirname;
    var basename4 = path67.basename;
    var extname4 = path67.extname;
    var join15 = path67.join;
    var resolve19 = path67.resolve;
    module3.exports = View;
    function View(name, options29) {
      var opts = options29 || {};
      this.defaultEngine = opts.defaultEngine;
      this.ext = extname4(name);
      this.name = name;
      this.root = opts.root;
      if (!this.ext && !this.defaultEngine) {
        throw new Error("No default engine was specified and no extension was provided.");
      }
      var fileName = name;
      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 fn2 = require(mod).__express;
        if (typeof fn2 !== "function") {
          throw new Error('Module "' + mod + '" does not provide a view engine.');
        }
        opts.engines[this.ext] = fn2;
      }
      this.engine = opts.engines[this.ext];
      this.path = this.lookup(fileName);
    }
    __name(View, "View");
    View.prototype.lookup = /* @__PURE__ */ __name(function lookup(name) {
      var path68;
      var roots = [].concat(this.root);
      debug('lookup "%s"', name);
      for (var i = 0; i < roots.length && !path68; i++) {
        var root = roots[i];
        var loc = resolve19(root, name);
        var dir = dirname13(loc);
        var file = basename4(loc);
        path68 = this.resolve(dir, file);
      }
      return path68;
    }, "lookup");
    View.prototype.render = /* @__PURE__ */ __name(function render7(options29, callback) {
      debug('render "%s"', this.path);
      this.engine(this.path, options29, callback);
    }, "render");
    View.prototype.resolve = /* @__PURE__ */ __name(function resolve20(dir, file) {
      var ext = this.ext;
      var path68 = join15(dir, file);
      var stat4 = tryStat(path68);
      if (stat4 && stat4.isFile()) {
        return path68;
      }
      path68 = join15(dir, basename4(file, ext), "index" + ext);
      stat4 = tryStat(path68);
      if (stat4 && stat4.isFile()) {
        return path68;
      }
    }, "resolve");
    function tryStat(path68) {
      debug('stat "%s"', path68);
      try {
        return fs26.statSync(path68);
      } catch (e3) {
        return void 0;
      }
    }
    __name(tryStat, "tryStat");
  }
});

// ../../node_modules/.pnpm/safe-buffer@5.2.1/node_modules/safe-buffer/index.js
var require_safe_buffer = __commonJS({
  "../../node_modules/.pnpm/safe-buffer@5.2.1/node_modules/safe-buffer/index.js"(exports2, module3) {
    init_import_meta_url();
    var buffer = require("buffer");
    var Buffer3 = buffer.Buffer;
    function copyProps(src, dst) {
      for (var key in src) {
        dst[key] = src[key];
      }
    }
    __name(copyProps, "copyProps");
    if (Buffer3.from && Buffer3.alloc && Buffer3.allocUnsafe && Buffer3.allocUnsafeSlow) {
      module3.exports = buffer;
    } else {
      copyProps(buffer, exports2);
      exports2.Buffer = SafeBuffer;
    }
    function SafeBuffer(arg, encodingOrOffset, length) {
      return Buffer3(arg, encodingOrOffset, length);
    }
    __name(SafeBuffer, "SafeBuffer");
    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, fill2, encoding) {
      if (typeof size !== "number") {
        throw new TypeError("Argument must be a number");
      }
      var buf = Buffer3(size);
      if (fill2 !== void 0) {
        if (typeof encoding === "string") {
          buf.fill(fill2, encoding);
        } else {
          buf.fill(fill2);
        }
      } 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/.pnpm/content-disposition@0.5.4/node_modules/content-disposition/index.js
var require_content_disposition = __commonJS({
  "../../node_modules/.pnpm/content-disposition@0.5.4/node_modules/content-disposition/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = contentDisposition;
    module3.exports.parse = parse7;
    var basename4 = require("path").basename;
    var Buffer3 = require_safe_buffer().Buffer;
    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, options29) {
      var opts = options29 || {};
      var type = opts.type || "attachment";
      var params = createparams(filename, opts.fallback);
      return format10(new ContentDisposition(type, params));
    }
    __name(contentDisposition, "contentDisposition");
    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 name = basename4(filename);
      var isQuotedString = TEXT_REGEXP.test(name);
      var fallbackName = typeof fallback !== "string" ? fallback && getlatin1(name) : basename4(fallback);
      var hasFallback = typeof fallbackName === "string" && fallbackName !== name;
      if (hasFallback || !isQuotedString || HEX_ESCAPE_REGEXP.test(name)) {
        params["filename*"] = name;
      }
      if (isQuotedString || hasFallback) {
        params.filename = hasFallback ? fallbackName : name;
      }
      return params;
    }
    __name(createparams, "createparams");
    function format10(obj) {
      var parameters = obj.parameters;
      var type = obj.type;
      if (!type || typeof type !== "string" || !TOKEN_REGEXP.test(type)) {
        throw new TypeError("invalid type");
      }
      var string = 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.substr(-1) === "*" ? ustring(parameters[param]) : qstring(parameters[param]);
          string += "; " + param + "=" + val;
        }
      }
      return string;
    }
    __name(format10, "format");
    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":
          value = Buffer3.from(binary, "binary").toString("utf8");
          break;
        default:
          throw new TypeError("unsupported charset in extended field");
      }
      return value;
    }
    __name(decodefield, "decodefield");
    function getlatin1(val) {
      return String(val).replace(NON_LATIN1_REGEXP, "?");
    }
    __name(getlatin1, "getlatin1");
    function parse7(string) {
      if (!string || typeof string !== "string") {
        throw new TypeError("argument string is required");
      }
      var match = DISPOSITION_TYPE_REGEXP.exec(string);
      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].substr(-1) === ";" ? index - 1 : index;
      while (match = PARAM_REGEXP.exec(string)) {
        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.substr(1, value.length - 2).replace(QESC_REGEXP, "$1");
        }
        params[key] = value;
      }
      if (index !== -1 && index !== string.length) {
        throw new TypeError("invalid parameter format");
      }
      return new ContentDisposition(type, params);
    }
    __name(parse7, "parse");
    function pdecode(str, hex) {
      return String.fromCharCode(parseInt(hex, 16));
    }
    __name(pdecode, "pdecode");
    function pencode(char) {
      return "%" + String(char).charCodeAt(0).toString(16).toUpperCase();
    }
    __name(pencode, "pencode");
    function qstring(val) {
      var str = String(val);
      return '"' + str.replace(QUOTE_REGEXP, "\\$1") + '"';
    }
    __name(qstring, "qstring");
    function ustring(val) {
      var str = String(val);
      var encoded = encodeURIComponent(str).replace(ENCODE_URL_ATTR_CHAR_REGEXP, pencode);
      return "UTF-8''" + encoded;
    }
    __name(ustring, "ustring");
    function ContentDisposition(type, parameters) {
      this.type = type;
      this.parameters = parameters;
    }
    __name(ContentDisposition, "ContentDisposition");
  }
});

// ../../node_modules/.pnpm/etag@1.8.1/node_modules/etag/index.js
var require_etag = __commonJS({
  "../../node_modules/.pnpm/etag@1.8.1/node_modules/etag/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = etag;
    var crypto5 = require("crypto");
    var Stats = require("fs").Stats;
    var toString2 = Object.prototype.toString;
    function entitytag(entity) {
      if (entity.length === 0) {
        return '"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk"';
      }
      var hash = crypto5.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) + "-" + hash + '"';
    }
    __name(entitytag, "entitytag");
    function etag(entity, options29) {
      if (entity == null) {
        throw new TypeError("argument entity is required");
      }
      var isStats = isstats(entity);
      var weak = options29 && typeof options29.weak === "boolean" ? options29.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;
    }
    __name(etag, "etag");
    function isstats(obj) {
      if (typeof Stats === "function" && obj instanceof Stats) {
        return true;
      }
      return obj && typeof obj === "object" && "ctime" in obj && toString2.call(obj.ctime) === "[object Date]" && "mtime" in obj && toString2.call(obj.mtime) === "[object Date]" && "ino" in obj && typeof obj.ino === "number" && "size" in obj && typeof obj.size === "number";
    }
    __name(isstats, "isstats");
    function stattag(stat4) {
      var mtime = stat4.mtime.getTime().toString(16);
      var size = stat4.size.toString(16);
      return '"' + size + "-" + mtime + '"';
    }
    __name(stattag, "stattag");
  }
});

// ../../node_modules/.pnpm/fresh@0.5.2/node_modules/fresh/index.js
var require_fresh = __commonJS({
  "../../node_modules/.pnpm/fresh@0.5.2/node_modules/fresh/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var CACHE_CONTROL_NO_CACHE_REGEXP = /(?:^|,)\s*?no-cache\s*?(?:,|$)/;
    module3.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 && noneMatch !== "*") {
        var etag = resHeaders["etag"];
        if (!etag) {
          return false;
        }
        var etagStale = true;
        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) {
            etagStale = false;
            break;
          }
        }
        if (etagStale) {
          return false;
        }
      }
      if (modifiedSince) {
        var lastModified = resHeaders["last-modified"];
        var modifiedStale = !lastModified || !(parseHttpDate(lastModified) <= parseHttpDate(modifiedSince));
        if (modifiedStale) {
          return false;
        }
      }
      return true;
    }
    __name(fresh, "fresh");
    function parseHttpDate(date) {
      var timestamp = date && Date.parse(date);
      return typeof timestamp === "number" ? timestamp : NaN;
    }
    __name(parseHttpDate, "parseHttpDate");
    function parseTokenList(str) {
      var end = 0;
      var list = [];
      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:
            list.push(str.substring(start, end));
            start = end = i + 1;
            break;
          default:
            end = i + 1;
            break;
        }
      }
      list.push(str.substring(start, end));
      return list;
    }
    __name(parseTokenList, "parseTokenList");
  }
});

// ../../node_modules/.pnpm/mime@1.6.0/node_modules/mime/types.json
var require_types = __commonJS({
  "../../node_modules/.pnpm/mime@1.6.0/node_modules/mime/types.json"(exports2, module3) {
    module3.exports = { "application/andrew-inset": ["ez"], "application/applixware": ["aw"], "application/atom+xml": ["atom"], "application/atomcat+xml": ["atomcat"], "application/atomsvc+xml": ["atomsvc"], "application/bdoc": ["bdoc"], "application/ccxml+xml": ["ccxml"], "application/cdmi-capability": ["cdmia"], "application/cdmi-container": ["cdmic"], "application/cdmi-domain": ["cdmid"], "application/cdmi-object": ["cdmio"], "application/cdmi-queue": ["cdmiq"], "application/cu-seeme": ["cu"], "application/dash+xml": ["mpd"], "application/davmount+xml": ["davmount"], "application/docbook+xml": ["dbk"], "application/dssc+der": ["dssc"], "application/dssc+xml": ["xdssc"], "application/ecmascript": ["ecma"], "application/emma+xml": ["emma"], "application/epub+zip": ["epub"], "application/exi": ["exi"], "application/font-tdpfr": ["pfr"], "application/font-woff": [], "application/font-woff2": [], "application/geo+json": ["geojson"], "application/gml+xml": ["gml"], "application/gpx+xml": ["gpx"], "application/gxf": ["gxf"], "application/gzip": ["gz"], "application/hyperstudio": ["stk"], "application/inkml+xml": ["ink", "inkml"], "application/ipfix": ["ipfix"], "application/java-archive": ["jar", "war", "ear"], "application/java-serialized-object": ["ser"], "application/java-vm": ["class"], "application/javascript": ["js", "mjs"], "application/json": ["json", "map"], "application/json5": ["json5"], "application/jsonml+json": ["jsonml"], "application/ld+json": ["jsonld"], "application/lost+xml": ["lostxml"], "application/mac-binhex40": ["hqx"], "application/mac-compactpro": ["cpt"], "application/mads+xml": ["mads"], "application/manifest+json": ["webmanifest"], "application/marc": ["mrc"], "application/marcxml+xml": ["mrcx"], "application/mathematica": ["ma", "nb", "mb"], "application/mathml+xml": ["mathml"], "application/mbox": ["mbox"], "application/mediaservercontrol+xml": ["mscml"], "application/metalink+xml": ["metalink"], "application/metalink4+xml": ["meta4"], "application/mets+xml": ["mets"], "application/mods+xml": ["mods"], "application/mp21": ["m21", "mp21"], "application/mp4": ["mp4s", "m4p"], "application/msword": ["doc", "dot"], "application/mxf": ["mxf"], "application/octet-stream": ["bin", "dms", "lrf", "mar", "so", "dist", "distz", "pkg", "bpk", "dump", "elc", "deploy", "exe", "dll", "deb", "dmg", "iso", "img", "msi", "msp", "msm", "buffer"], "application/oda": ["oda"], "application/oebps-package+xml": ["opf"], "application/ogg": ["ogx"], "application/omdoc+xml": ["omdoc"], "application/onenote": ["onetoc", "onetoc2", "onetmp", "onepkg"], "application/oxps": ["oxps"], "application/patch-ops-error+xml": ["xer"], "application/pdf": ["pdf"], "application/pgp-encrypted": ["pgp"], "application/pgp-signature": ["asc", "sig"], "application/pics-rules": ["prf"], "application/pkcs10": ["p10"], "application/pkcs7-mime": ["p7m", "p7c"], "application/pkcs7-signature": ["p7s"], "application/pkcs8": ["p8"], "application/pkix-attr-cert": ["ac"], "application/pkix-cert": ["cer"], "application/pkix-crl": ["crl"], "application/pkix-pkipath": ["pkipath"], "application/pkixcmp": ["pki"], "application/pls+xml": ["pls"], "application/postscript": ["ai", "eps", "ps"], "application/prs.cww": ["cww"], "application/pskc+xml": ["pskcxml"], "application/raml+yaml": ["raml"], "application/rdf+xml": ["rdf"], "application/reginfo+xml": ["rif"], "application/relax-ng-compact-syntax": ["rnc"], "application/resource-lists+xml": ["rl"], "application/resource-lists-diff+xml": ["rld"], "application/rls-services+xml": ["rs"], "application/rpki-ghostbusters": ["gbr"], "application/rpki-manifest": ["mft"], "application/rpki-roa": ["roa"], "application/rsd+xml": ["rsd"], "application/rss+xml": ["rss"], "application/rtf": ["rtf"], "application/sbml+xml": ["sbml"], "application/scvp-cv-request": ["scq"], "application/scvp-cv-response": ["scs"], "application/scvp-vp-request": ["spq"], "application/scvp-vp-response": ["spp"], "application/sdp": ["sdp"], "application/set-payment-initiation": ["setpay"], "application/set-registration-initiation": ["setreg"], "application/shf+xml": ["shf"], "application/smil+xml": ["smi", "smil"], "application/sparql-query": ["rq"], "application/sparql-results+xml": ["srx"], "application/srgs": ["gram"], "application/srgs+xml": ["grxml"], "application/sru+xml": ["sru"], "application/ssdl+xml": ["ssdl"], "application/ssml+xml": ["ssml"], "application/tei+xml": ["tei", "teicorpus"], "application/thraud+xml": ["tfi"], "application/timestamped-data": ["tsd"], "application/vnd.3gpp.pic-bw-large": ["plb"], "application/vnd.3gpp.pic-bw-small": ["psb"], "application/vnd.3gpp.pic-bw-var": ["pvb"], "application/vnd.3gpp2.tcap": ["tcap"], "application/vnd.3m.post-it-notes": ["pwn"], "application/vnd.accpac.simply.aso": ["aso"], "application/vnd.accpac.simply.imp": ["imp"], "application/vnd.acucobol": ["acu"], "application/vnd.acucorp": ["atc", "acutc"], "application/vnd.adobe.air-application-installer-package+zip": ["air"], "application/vnd.adobe.formscentral.fcdt": ["fcdt"], "application/vnd.adobe.fxp": ["fxp", "fxpl"], "application/vnd.adobe.xdp+xml": ["xdp"], "application/vnd.adobe.xfdf": ["xfdf"], "application/vnd.ahead.space": ["ahead"], "application/vnd.airzip.filesecure.azf": ["azf"], "application/vnd.airzip.filesecure.azs": ["azs"], "application/vnd.amazon.ebook": ["azw"], "application/vnd.americandynamics.acc": ["acc"], "application/vnd.amiga.ami": ["ami"], "application/vnd.android.package-archive": ["apk"], "application/vnd.anser-web-certificate-issue-initiation": ["cii"], "application/vnd.anser-web-funds-transfer-initiation": ["fti"], "application/vnd.antix.game-component": ["atx"], "application/vnd.apple.installer+xml": ["mpkg"], "application/vnd.apple.mpegurl": ["m3u8"], "application/vnd.apple.pkpass": ["pkpass"], "application/vnd.aristanetworks.swi": ["swi"], "application/vnd.astraea-software.iota": ["iota"], "application/vnd.audiograph": ["aep"], "application/vnd.blueice.multipass": ["mpm"], "application/vnd.bmi": ["bmi"], "application/vnd.businessobjects": ["rep"], "application/vnd.chemdraw+xml": ["cdxml"], "application/vnd.chipnuts.karaoke-mmd": ["mmd"], "application/vnd.cinderella": ["cdy"], "application/vnd.claymore": ["cla"], "application/vnd.cloanto.rp9": ["rp9"], "application/vnd.clonk.c4group": ["c4g", "c4d", "c4f", "c4p", "c4u"], "application/vnd.cluetrust.cartomobile-config": ["c11amc"], "application/vnd.cluetrust.cartomobile-config-pkg": ["c11amz"], "application/vnd.commonspace": ["csp"], "application/vnd.contact.cmsg": ["cdbcmsg"], "application/vnd.cosmocaller": ["cmc"], "application/vnd.crick.clicker": ["clkx"], "application/vnd.crick.clicker.keyboard": ["clkk"], "application/vnd.crick.clicker.palette": ["clkp"], "application/vnd.crick.clicker.template": ["clkt"], "application/vnd.crick.clicker.wordbank": ["clkw"], "application/vnd.criticaltools.wbs+xml": ["wbs"], "application/vnd.ctc-posml": ["pml"], "application/vnd.cups-ppd": ["ppd"], "application/vnd.curl.car": ["car"], "application/vnd.curl.pcurl": ["pcurl"], "application/vnd.dart": ["dart"], "application/vnd.data-vision.rdz": ["rdz"], "application/vnd.dece.data": ["uvf", "uvvf", "uvd", "uvvd"], "application/vnd.dece.ttml+xml": ["uvt", "uvvt"], "application/vnd.dece.unspecified": ["uvx", "uvvx"], "application/vnd.dece.zip": ["uvz", "uvvz"], "application/vnd.denovo.fcselayout-link": ["fe_launch"], "application/vnd.dna": ["dna"], "application/vnd.dolby.mlp": ["mlp"], "application/vnd.dpgraph": ["dpg"], "application/vnd.dreamfactory": ["dfac"], "application/vnd.ds-keypoint": ["kpxx"], "application/vnd.dvb.ait": ["ait"], "application/vnd.dvb.service": ["svc"], "application/vnd.dynageo": ["geo"], "application/vnd.ecowin.chart": ["mag"], "application/vnd.enliven": ["nml"], "application/vnd.epson.esf": ["esf"], "application/vnd.epson.msf": ["msf"], "application/vnd.epson.quickanime": ["qam"], "application/vnd.epson.salt": ["slt"], "application/vnd.epson.ssf": ["ssf"], "application/vnd.eszigno3+xml": ["es3", "et3"], "application/vnd.ezpix-album": ["ez2"], "application/vnd.ezpix-package": ["ez3"], "application/vnd.fdf": ["fdf"], "application/vnd.fdsn.mseed": ["mseed"], "application/vnd.fdsn.seed": ["seed", "dataless"], "application/vnd.flographit": ["gph"], "application/vnd.fluxtime.clip": ["ftc"], "application/vnd.framemaker": ["fm", "frame", "maker", "book"], "application/vnd.frogans.fnc": ["fnc"], "application/vnd.frogans.ltf": ["ltf"], "application/vnd.fsc.weblaunch": ["fsc"], "application/vnd.fujitsu.oasys": ["oas"], "application/vnd.fujitsu.oasys2": ["oa2"], "application/vnd.fujitsu.oasys3": ["oa3"], "application/vnd.fujitsu.oasysgp": ["fg5"], "application/vnd.fujitsu.oasysprs": ["bh2"], "application/vnd.fujixerox.ddd": ["ddd"], "application/vnd.fujixerox.docuworks": ["xdw"], "application/vnd.fujixerox.docuworks.binder": ["xbd"], "application/vnd.fuzzysheet": ["fzs"], "application/vnd.genomatix.tuxedo": ["txd"], "application/vnd.geogebra.file": ["ggb"], "application/vnd.geogebra.tool": ["ggt"], "application/vnd.geometry-explorer": ["gex", "gre"], "application/vnd.geonext": ["gxt"], "application/vnd.geoplan": ["g2w"], "application/vnd.geospace": ["g3w"], "application/vnd.gmx": ["gmx"], "application/vnd.google-apps.document": ["gdoc"], "application/vnd.google-apps.presentation": ["gslides"], "application/vnd.google-apps.spreadsheet": ["gsheet"], "application/vnd.google-earth.kml+xml": ["kml"], "application/vnd.google-earth.kmz": ["kmz"], "application/vnd.grafeq": ["gqf", "gqs"], "application/vnd.groove-account": ["gac"], "application/vnd.groove-help": ["ghf"], "application/vnd.groove-identity-message": ["gim"], "application/vnd.groove-injector": ["grv"], "application/vnd.groove-tool-message": ["gtm"], "application/vnd.groove-tool-template": ["tpl"], "application/vnd.groove-vcard": ["vcg"], "application/vnd.hal+xml": ["hal"], "application/vnd.handheld-entertainment+xml": ["zmm"], "application/vnd.hbci": ["hbci"], "application/vnd.hhe.lesson-player": ["les"], "application/vnd.hp-hpgl": ["hpgl"], "application/vnd.hp-hpid": ["hpid"], "application/vnd.hp-hps": ["hps"], "application/vnd.hp-jlyt": ["jlt"], "application/vnd.hp-pcl": ["pcl"], "application/vnd.hp-pclxl": ["pclxl"], "application/vnd.hydrostatix.sof-data": ["sfd-hdstx"], "application/vnd.ibm.minipay": ["mpy"], "application/vnd.ibm.modcap": ["afp", "listafp", "list3820"], "application/vnd.ibm.rights-management": ["irm"], "application/vnd.ibm.secure-container": ["sc"], "application/vnd.iccprofile": ["icc", "icm"], "application/vnd.igloader": ["igl"], "application/vnd.immervision-ivp": ["ivp"], "application/vnd.immervision-ivu": ["ivu"], "application/vnd.insors.igm": ["igm"], "application/vnd.intercon.formnet": ["xpw", "xpx"], "application/vnd.intergeo": ["i2g"], "application/vnd.intu.qbo": ["qbo"], "application/vnd.intu.qfx": ["qfx"], "application/vnd.ipunplugged.rcprofile": ["rcprofile"], "application/vnd.irepository.package+xml": ["irp"], "application/vnd.is-xpr": ["xpr"], "application/vnd.isac.fcs": ["fcs"], "application/vnd.jam": ["jam"], "application/vnd.jcp.javame.midlet-rms": ["rms"], "application/vnd.jisp": ["jisp"], "application/vnd.joost.joda-archive": ["joda"], "application/vnd.kahootz": ["ktz", "ktr"], "application/vnd.kde.karbon": ["karbon"], "application/vnd.kde.kchart": ["chrt"], "application/vnd.kde.kformula": ["kfo"], "application/vnd.kde.kivio": ["flw"], "application/vnd.kde.kontour": ["kon"], "application/vnd.kde.kpresenter": ["kpr", "kpt"], "application/vnd.kde.kspread": ["ksp"], "application/vnd.kde.kword": ["kwd", "kwt"], "application/vnd.kenameaapp": ["htke"], "application/vnd.kidspiration": ["kia"], "application/vnd.kinar": ["kne", "knp"], "application/vnd.koan": ["skp", "skd", "skt", "skm"], "application/vnd.kodak-descriptor": ["sse"], "application/vnd.las.las+xml": ["lasxml"], "application/vnd.llamagraphics.life-balance.desktop": ["lbd"], "application/vnd.llamagraphics.life-balance.exchange+xml": ["lbe"], "application/vnd.lotus-1-2-3": ["123"], "application/vnd.lotus-approach": ["apr"], "application/vnd.lotus-freelance": ["pre"], "application/vnd.lotus-notes": ["nsf"], "application/vnd.lotus-organizer": ["org"], "application/vnd.lotus-screencam": ["scm"], "application/vnd.lotus-wordpro": ["lwp"], "application/vnd.macports.portpkg": ["portpkg"], "application/vnd.mcd": ["mcd"], "application/vnd.medcalcdata": ["mc1"], "application/vnd.mediastation.cdkey": ["cdkey"], "application/vnd.mfer": ["mwf"], "application/vnd.mfmp": ["mfm"], "application/vnd.micrografx.flo": ["flo"], "application/vnd.micrografx.igx": ["igx"], "application/vnd.mif": ["mif"], "application/vnd.mobius.daf": ["daf"], "application/vnd.mobius.dis": ["dis"], "application/vnd.mobius.mbk": ["mbk"], "application/vnd.mobius.mqy": ["mqy"], "application/vnd.mobius.msl": ["msl"], "application/vnd.mobius.plc": ["plc"], "application/vnd.mobius.txf": ["txf"], "application/vnd.mophun.application": ["mpn"], "application/vnd.mophun.certificate": ["mpc"], "application/vnd.mozilla.xul+xml": ["xul"], "application/vnd.ms-artgalry": ["cil"], "application/vnd.ms-cab-compressed": ["cab"], "application/vnd.ms-excel": ["xls", "xlm", "xla", "xlc", "xlt", "xlw"], "application/vnd.ms-excel.addin.macroenabled.12": ["xlam"], "application/vnd.ms-excel.sheet.binary.macroenabled.12": ["xlsb"], "application/vnd.ms-excel.sheet.macroenabled.12": ["xlsm"], "application/vnd.ms-excel.template.macroenabled.12": ["xltm"], "application/vnd.ms-fontobject": ["eot"], "application/vnd.ms-htmlhelp": ["chm"], "application/vnd.ms-ims": ["ims"], "application/vnd.ms-lrm": ["lrm"], "application/vnd.ms-officetheme": ["thmx"], "application/vnd.ms-outlook": ["msg"], "application/vnd.ms-pki.seccat": ["cat"], "application/vnd.ms-pki.stl": ["stl"], "application/vnd.ms-powerpoint": ["ppt", "pps", "pot"], "application/vnd.ms-powerpoint.addin.macroenabled.12": ["ppam"], "application/vnd.ms-powerpoint.presentation.macroenabled.12": ["pptm"], "application/vnd.ms-powerpoint.slide.macroenabled.12": ["sldm"], "application/vnd.ms-powerpoint.slideshow.macroenabled.12": ["ppsm"], "application/vnd.ms-powerpoint.template.macroenabled.12": ["potm"], "application/vnd.ms-project": ["mpp", "mpt"], "application/vnd.ms-word.document.macroenabled.12": ["docm"], "application/vnd.ms-word.template.macroenabled.12": ["dotm"], "application/vnd.ms-works": ["wps", "wks", "wcm", "wdb"], "application/vnd.ms-wpl": ["wpl"], "application/vnd.ms-xpsdocument": ["xps"], "application/vnd.mseq": ["mseq"], "application/vnd.musician": ["mus"], "application/vnd.muvee.style": ["msty"], "application/vnd.mynfc": ["taglet"], "application/vnd.neurolanguage.nlu": ["nlu"], "application/vnd.nitf": ["ntf", "nitf"], "application/vnd.noblenet-directory": ["nnd"], "application/vnd.noblenet-sealer": ["nns"], "application/vnd.noblenet-web": ["nnw"], "application/vnd.nokia.n-gage.data": ["ngdat"], "application/vnd.nokia.n-gage.symbian.install": ["n-gage"], "application/vnd.nokia.radio-preset": ["rpst"], "application/vnd.nokia.radio-presets": ["rpss"], "application/vnd.novadigm.edm": ["edm"], "application/vnd.novadigm.edx": ["edx"], "application/vnd.novadigm.ext": ["ext"], "application/vnd.oasis.opendocument.chart": ["odc"], "application/vnd.oasis.opendocument.chart-template": ["otc"], "application/vnd.oasis.opendocument.database": ["odb"], "application/vnd.oasis.opendocument.formula": ["odf"], "application/vnd.oasis.opendocument.formula-template": ["odft"], "application/vnd.oasis.opendocument.graphics": ["odg"], "application/vnd.oasis.opendocument.graphics-template": ["otg"], "application/vnd.oasis.opendocument.image": ["odi"], "application/vnd.oasis.opendocument.image-template": ["oti"], "application/vnd.oasis.opendocument.presentation": ["odp"], "application/vnd.oasis.opendocument.presentation-template": ["otp"], "application/vnd.oasis.opendocument.spreadsheet": ["ods"], "application/vnd.oasis.opendocument.spreadsheet-template": ["ots"], "application/vnd.oasis.opendocument.text": ["odt"], "application/vnd.oasis.opendocument.text-master": ["odm"], "application/vnd.oasis.opendocument.text-template": ["ott"], "application/vnd.oasis.opendocument.text-web": ["oth"], "application/vnd.olpc-sugar": ["xo"], "application/vnd.oma.dd2+xml": ["dd2"], "application/vnd.openofficeorg.extension": ["oxt"], "application/vnd.openxmlformats-officedocument.presentationml.presentation": ["pptx"], "application/vnd.openxmlformats-officedocument.presentationml.slide": ["sldx"], "application/vnd.openxmlformats-officedocument.presentationml.slideshow": ["ppsx"], "application/vnd.openxmlformats-officedocument.presentationml.template": ["potx"], "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ["xlsx"], "application/vnd.openxmlformats-officedocument.spreadsheetml.template": ["xltx"], "application/vnd.openxmlformats-officedocument.wordprocessingml.document": ["docx"], "application/vnd.openxmlformats-officedocument.wordprocessingml.template": ["dotx"], "application/vnd.osgeo.mapguide.package": ["mgp"], "application/vnd.osgi.dp": ["dp"], "application/vnd.osgi.subsystem": ["esa"], "application/vnd.palm": ["pdb", "pqa", "oprc"], "application/vnd.pawaafile": ["paw"], "application/vnd.pg.format": ["str"], "application/vnd.pg.osasli": ["ei6"], "application/vnd.picsel": ["efif"], "application/vnd.pmi.widget": ["wg"], "application/vnd.pocketlearn": ["plf"], "application/vnd.powerbuilder6": ["pbd"], "application/vnd.previewsystems.box": ["box"], "application/vnd.proteus.magazine": ["mgz"], "application/vnd.publishare-delta-tree": ["qps"], "application/vnd.pvi.ptid1": ["ptid"], "application/vnd.quark.quarkxpress": ["qxd", "qxt", "qwd", "qwt", "qxl", "qxb"], "application/vnd.realvnc.bed": ["bed"], "application/vnd.recordare.musicxml": ["mxl"], "application/vnd.recordare.musicxml+xml": ["musicxml"], "application/vnd.rig.cryptonote": ["cryptonote"], "application/vnd.rim.cod": ["cod"], "application/vnd.rn-realmedia": ["rm"], "application/vnd.rn-realmedia-vbr": ["rmvb"], "application/vnd.route66.link66+xml": ["link66"], "application/vnd.sailingtracker.track": ["st"], "application/vnd.seemail": ["see"], "application/vnd.sema": ["sema"], "application/vnd.semd": ["semd"], "application/vnd.semf": ["semf"], "application/vnd.shana.informed.formdata": ["ifm"], "application/vnd.shana.informed.formtemplate": ["itp"], "application/vnd.shana.informed.interchange": ["iif"], "application/vnd.shana.informed.package": ["ipk"], "application/vnd.simtech-mindmapper": ["twd", "twds"], "application/vnd.smaf": ["mmf"], "application/vnd.smart.teacher": ["teacher"], "application/vnd.solent.sdkm+xml": ["sdkm", "sdkd"], "application/vnd.spotfire.dxp": ["dxp"], "application/vnd.spotfire.sfs": ["sfs"], "application/vnd.stardivision.calc": ["sdc"], "application/vnd.stardivision.draw": ["sda"], "application/vnd.stardivision.impress": ["sdd"], "application/vnd.stardivision.math": ["smf"], "application/vnd.stardivision.writer": ["sdw", "vor"], "application/vnd.stardivision.writer-global": ["sgl"], "application/vnd.stepmania.package": ["smzip"], "application/vnd.stepmania.stepchart": ["sm"], "application/vnd.sun.wadl+xml": ["wadl"], "application/vnd.sun.xml.calc": ["sxc"], "application/vnd.sun.xml.calc.template": ["stc"], "application/vnd.sun.xml.draw": ["sxd"], "application/vnd.sun.xml.draw.template": ["std"], "application/vnd.sun.xml.impress": ["sxi"], "application/vnd.sun.xml.impress.template": ["sti"], "application/vnd.sun.xml.math": ["sxm"], "application/vnd.sun.xml.writer": ["sxw"], "application/vnd.sun.xml.writer.global": ["sxg"], "application/vnd.sun.xml.writer.template": ["stw"], "application/vnd.sus-calendar": ["sus", "susp"], "application/vnd.svd": ["svd"], "application/vnd.symbian.install": ["sis", "sisx"], "application/vnd.syncml+xml": ["xsm"], "application/vnd.syncml.dm+wbxml": ["bdm"], "application/vnd.syncml.dm+xml": ["xdm"], "application/vnd.tao.intent-module-archive": ["tao"], "application/vnd.tcpdump.pcap": ["pcap", "cap", "dmp"], "application/vnd.tmobile-livetv": ["tmo"], "application/vnd.trid.tpt": ["tpt"], "application/vnd.triscape.mxs": ["mxs"], "application/vnd.trueapp": ["tra"], "application/vnd.ufdl": ["ufd", "ufdl"], "application/vnd.uiq.theme": ["utz"], "application/vnd.umajin": ["umj"], "application/vnd.unity": ["unityweb"], "application/vnd.uoml+xml": ["uoml"], "application/vnd.vcx": ["vcx"], "application/vnd.visio": ["vsd", "vst", "vss", "vsw"], "application/vnd.visionary": ["vis"], "application/vnd.vsf": ["vsf"], "application/vnd.wap.wbxml": ["wbxml"], "application/vnd.wap.wmlc": ["wmlc"], "application/vnd.wap.wmlscriptc": ["wmlsc"], "application/vnd.webturbo": ["wtb"], "application/vnd.wolfram.player": ["nbp"], "application/vnd.wordperfect": ["wpd"], "application/vnd.wqd": ["wqd"], "application/vnd.wt.stf": ["stf"], "application/vnd.xara": ["xar"], "application/vnd.xfdl": ["xfdl"], "application/vnd.yamaha.hv-dic": ["hvd"], "application/vnd.yamaha.hv-script": ["hvs"], "application/vnd.yamaha.hv-voice": ["hvp"], "application/vnd.yamaha.openscoreformat": ["osf"], "application/vnd.yamaha.openscoreformat.osfpvg+xml": ["osfpvg"], "application/vnd.yamaha.smaf-audio": ["saf"], "application/vnd.yamaha.smaf-phrase": ["spf"], "application/vnd.yellowriver-custom-menu": ["cmp"], "application/vnd.zul": ["zir", "zirz"], "application/vnd.zzazz.deck+xml": ["zaz"], "application/voicexml+xml": ["vxml"], "application/wasm": ["wasm"], "application/widget": ["wgt"], "application/winhlp": ["hlp"], "application/wsdl+xml": ["wsdl"], "application/wspolicy+xml": ["wspolicy"], "application/x-7z-compressed": ["7z"], "application/x-abiword": ["abw"], "application/x-ace-compressed": ["ace"], "application/x-apple-diskimage": [], "application/x-arj": ["arj"], "application/x-authorware-bin": ["aab", "x32", "u32", "vox"], "application/x-authorware-map": ["aam"], "application/x-authorware-seg": ["aas"], "application/x-bcpio": ["bcpio"], "application/x-bdoc": [], "application/x-bittorrent": ["torrent"], "application/x-blorb": ["blb", "blorb"], "application/x-bzip": ["bz"], "application/x-bzip2": ["bz2", "boz"], "application/x-cbr": ["cbr", "cba", "cbt", "cbz", "cb7"], "application/x-cdlink": ["vcd"], "application/x-cfs-compressed": ["cfs"], "application/x-chat": ["chat"], "application/x-chess-pgn": ["pgn"], "application/x-chrome-extension": ["crx"], "application/x-cocoa": ["cco"], "application/x-conference": ["nsc"], "application/x-cpio": ["cpio"], "application/x-csh": ["csh"], "application/x-debian-package": ["udeb"], "application/x-dgc-compressed": ["dgc"], "application/x-director": ["dir", "dcr", "dxr", "cst", "cct", "cxt", "w3d", "fgd", "swa"], "application/x-doom": ["wad"], "application/x-dtbncx+xml": ["ncx"], "application/x-dtbook+xml": ["dtb"], "application/x-dtbresource+xml": ["res"], "application/x-dvi": ["dvi"], "application/x-envoy": ["evy"], "application/x-eva": ["eva"], "application/x-font-bdf": ["bdf"], "application/x-font-ghostscript": ["gsf"], "application/x-font-linux-psf": ["psf"], "application/x-font-pcf": ["pcf"], "application/x-font-snf": ["snf"], "application/x-font-type1": ["pfa", "pfb", "pfm", "afm"], "application/x-freearc": ["arc"], "application/x-futuresplash": ["spl"], "application/x-gca-compressed": ["gca"], "application/x-glulx": ["ulx"], "application/x-gnumeric": ["gnumeric"], "application/x-gramps-xml": ["gramps"], "application/x-gtar": ["gtar"], "application/x-hdf": ["hdf"], "application/x-httpd-php": ["php"], "application/x-install-instructions": ["install"], "application/x-iso9660-image": [], "application/x-java-archive-diff": ["jardiff"], "application/x-java-jnlp-file": ["jnlp"], "application/x-latex": ["latex"], "application/x-lua-bytecode": ["luac"], "application/x-lzh-compressed": ["lzh", "lha"], "application/x-makeself": ["run"], "application/x-mie": ["mie"], "application/x-mobipocket-ebook": ["prc", "mobi"], "application/x-ms-application": ["application"], "application/x-ms-shortcut": ["lnk"], "application/x-ms-wmd": ["wmd"], "application/x-ms-wmz": ["wmz"], "application/x-ms-xbap": ["xbap"], "application/x-msaccess": ["mdb"], "application/x-msbinder": ["obd"], "application/x-mscardfile": ["crd"], "application/x-msclip": ["clp"], "application/x-msdos-program": [], "application/x-msdownload": ["com", "bat"], "application/x-msmediaview": ["mvb", "m13", "m14"], "application/x-msmetafile": ["wmf", "emf", "emz"], "application/x-msmoney": ["mny"], "application/x-mspublisher": ["pub"], "application/x-msschedule": ["scd"], "application/x-msterminal": ["trm"], "application/x-mswrite": ["wri"], "application/x-netcdf": ["nc", "cdf"], "application/x-ns-proxy-autoconfig": ["pac"], "application/x-nzb": ["nzb"], "application/x-perl": ["pl", "pm"], "application/x-pilot": [], "application/x-pkcs12": ["p12", "pfx"], "application/x-pkcs7-certificates": ["p7b", "spc"], "application/x-pkcs7-certreqresp": ["p7r"], "application/x-rar-compressed": ["rar"], "application/x-redhat-package-manager": ["rpm"], "application/x-research-info-systems": ["ris"], "application/x-sea": ["sea"], "application/x-sh": ["sh"], "application/x-shar": ["shar"], "application/x-shockwave-flash": ["swf"], "application/x-silverlight-app": ["xap"], "application/x-sql": ["sql"], "application/x-stuffit": ["sit"], "application/x-stuffitx": ["sitx"], "application/x-subrip": ["srt"], "application/x-sv4cpio": ["sv4cpio"], "application/x-sv4crc": ["sv4crc"], "application/x-t3vm-image": ["t3"], "application/x-tads": ["gam"], "application/x-tar": ["tar"], "application/x-tcl": ["tcl", "tk"], "application/x-tex": ["tex"], "application/x-tex-tfm": ["tfm"], "application/x-texinfo": ["texinfo", "texi"], "application/x-tgif": ["obj"], "application/x-ustar": ["ustar"], "application/x-virtualbox-hdd": ["hdd"], "application/x-virtualbox-ova": ["ova"], "application/x-virtualbox-ovf": ["ovf"], "application/x-virtualbox-vbox": ["vbox"], "application/x-virtualbox-vbox-extpack": ["vbox-extpack"], "application/x-virtualbox-vdi": ["vdi"], "application/x-virtualbox-vhd": ["vhd"], "application/x-virtualbox-vmdk": ["vmdk"], "application/x-wais-source": ["src"], "application/x-web-app-manifest+json": ["webapp"], "application/x-x509-ca-cert": ["der", "crt", "pem"], "application/x-xfig": ["fig"], "application/x-xliff+xml": ["xlf"], "application/x-xpinstall": ["xpi"], "application/x-xz": ["xz"], "application/x-zmachine": ["z1", "z2", "z3", "z4", "z5", "z6", "z7", "z8"], "application/xaml+xml": ["xaml"], "application/xcap-diff+xml": ["xdf"], "application/xenc+xml": ["xenc"], "application/xhtml+xml": ["xhtml", "xht"], "application/xml": ["xml", "xsl", "xsd", "rng"], "application/xml-dtd": ["dtd"], "application/xop+xml": ["xop"], "application/xproc+xml": ["xpl"], "application/xslt+xml": ["xslt"], "application/xspf+xml": ["xspf"], "application/xv+xml": ["mxml", "xhvml", "xvml", "xvm"], "application/yang": ["yang"], "application/yin+xml": ["yin"], "application/zip": ["zip"], "audio/3gpp": [], "audio/adpcm": ["adp"], "audio/basic": ["au", "snd"], "audio/midi": ["mid", "midi", "kar", "rmi"], "audio/mp3": [], "audio/mp4": ["m4a", "mp4a"], "audio/mpeg": ["mpga", "mp2", "mp2a", "mp3", "m2a", "m3a"], "audio/ogg": ["oga", "ogg", "spx"], "audio/s3m": ["s3m"], "audio/silk": ["sil"], "audio/vnd.dece.audio": ["uva", "uvva"], "audio/vnd.digital-winds": ["eol"], "audio/vnd.dra": ["dra"], "audio/vnd.dts": ["dts"], "audio/vnd.dts.hd": ["dtshd"], "audio/vnd.lucent.voice": ["lvp"], "audio/vnd.ms-playready.media.pya": ["pya"], "audio/vnd.nuera.ecelp4800": ["ecelp4800"], "audio/vnd.nuera.ecelp7470": ["ecelp7470"], "audio/vnd.nuera.ecelp9600": ["ecelp9600"], "audio/vnd.rip": ["rip"], "audio/wav": ["wav"], "audio/wave": [], "audio/webm": ["weba"], "audio/x-aac": ["aac"], "audio/x-aiff": ["aif", "aiff", "aifc"], "audio/x-caf": ["caf"], "audio/x-flac": ["flac"], "audio/x-m4a": [], "audio/x-matroska": ["mka"], "audio/x-mpegurl": ["m3u"], "audio/x-ms-wax": ["wax"], "audio/x-ms-wma": ["wma"], "audio/x-pn-realaudio": ["ram", "ra"], "audio/x-pn-realaudio-plugin": ["rmp"], "audio/x-realaudio": [], "audio/x-wav": [], "audio/xm": ["xm"], "chemical/x-cdx": ["cdx"], "chemical/x-cif": ["cif"], "chemical/x-cmdf": ["cmdf"], "chemical/x-cml": ["cml"], "chemical/x-csml": ["csml"], "chemical/x-xyz": ["xyz"], "font/collection": ["ttc"], "font/otf": ["otf"], "font/ttf": ["ttf"], "font/woff": ["woff"], "font/woff2": ["woff2"], "image/apng": ["apng"], "image/bmp": ["bmp"], "image/cgm": ["cgm"], "image/g3fax": ["g3"], "image/gif": ["gif"], "image/ief": ["ief"], "image/jp2": ["jp2", "jpg2"], "image/jpeg": ["jpeg", "jpg", "jpe"], "image/jpm": ["jpm"], "image/jpx": ["jpx", "jpf"], "image/ktx": ["ktx"], "image/png": ["png"], "image/prs.btif": ["btif"], "image/sgi": ["sgi"], "image/svg+xml": ["svg", "svgz"], "image/tiff": ["tiff", "tif"], "image/vnd.adobe.photoshop": ["psd"], "image/vnd.dece.graphic": ["uvi", "uvvi", "uvg", "uvvg"], "image/vnd.djvu": ["djvu", "djv"], "image/vnd.dvb.subtitle": [], "image/vnd.dwg": ["dwg"], "image/vnd.dxf": ["dxf"], "image/vnd.fastbidsheet": ["fbs"], "image/vnd.fpx": ["fpx"], "image/vnd.fst": ["fst"], "image/vnd.fujixerox.edmics-mmr": ["mmr"], "image/vnd.fujixerox.edmics-rlc": ["rlc"], "image/vnd.ms-modi": ["mdi"], "image/vnd.ms-photo": ["wdp"], "image/vnd.net-fpx": ["npx"], "image/vnd.wap.wbmp": ["wbmp"], "image/vnd.xiff": ["xif"], "image/webp": ["webp"], "image/x-3ds": ["3ds"], "image/x-cmu-raster": ["ras"], "image/x-cmx": ["cmx"], "image/x-freehand": ["fh", "fhc", "fh4", "fh5", "fh7"], "image/x-icon": ["ico"], "image/x-jng": ["jng"], "image/x-mrsid-image": ["sid"], "image/x-ms-bmp": [], "image/x-pcx": ["pcx"], "image/x-pict": ["pic", "pct"], "image/x-portable-anymap": ["pnm"], "image/x-portable-bitmap": ["pbm"], "image/x-portable-graymap": ["pgm"], "image/x-portable-pixmap": ["ppm"], "image/x-rgb": ["rgb"], "image/x-tga": ["tga"], "image/x-xbitmap": ["xbm"], "image/x-xpixmap": ["xpm"], "image/x-xwindowdump": ["xwd"], "message/rfc822": ["eml", "mime"], "model/gltf+json": ["gltf"], "model/gltf-binary": ["glb"], "model/iges": ["igs", "iges"], "model/mesh": ["msh", "mesh", "silo"], "model/vnd.collada+xml": ["dae"], "model/vnd.dwf": ["dwf"], "model/vnd.gdl": ["gdl"], "model/vnd.gtw": ["gtw"], "model/vnd.mts": ["mts"], "model/vnd.vtu": ["vtu"], "model/vrml": ["wrl", "vrml"], "model/x3d+binary": ["x3db", "x3dbz"], "model/x3d+vrml": ["x3dv", "x3dvz"], "model/x3d+xml": ["x3d", "x3dz"], "text/cache-manifest": ["appcache", "manifest"], "text/calendar": ["ics", "ifb"], "text/coffeescript": ["coffee", "litcoffee"], "text/css": ["css"], "text/csv": ["csv"], "text/hjson": ["hjson"], "text/html": ["html", "htm", "shtml"], "text/jade": ["jade"], "text/jsx": ["jsx"], "text/less": ["less"], "text/markdown": ["markdown", "md"], "text/mathml": ["mml"], "text/n3": ["n3"], "text/plain": ["txt", "text", "conf", "def", "list", "log", "in", "ini"], "text/prs.lines.tag": ["dsc"], "text/richtext": ["rtx"], "text/rtf": [], "text/sgml": ["sgml", "sgm"], "text/slim": ["slim", "slm"], "text/stylus": ["stylus", "styl"], "text/tab-separated-values": ["tsv"], "text/troff": ["t", "tr", "roff", "man", "me", "ms"], "text/turtle": ["ttl"], "text/uri-list": ["uri", "uris", "urls"], "text/vcard": ["vcard"], "text/vnd.curl": ["curl"], "text/vnd.curl.dcurl": ["dcurl"], "text/vnd.curl.mcurl": ["mcurl"], "text/vnd.curl.scurl": ["scurl"], "text/vnd.dvb.subtitle": ["sub"], "text/vnd.fly": ["fly"], "text/vnd.fmi.flexstor": ["flx"], "text/vnd.graphviz": ["gv"], "text/vnd.in3d.3dml": ["3dml"], "text/vnd.in3d.spot": ["spot"], "text/vnd.sun.j2me.app-descriptor": ["jad"], "text/vnd.wap.wml": ["wml"], "text/vnd.wap.wmlscript": ["wmls"], "text/vtt": ["vtt"], "text/x-asm": ["s", "asm"], "text/x-c": ["c", "cc", "cxx", "cpp", "h", "hh", "dic"], "text/x-component": ["htc"], "text/x-fortran": ["f", "for", "f77", "f90"], "text/x-handlebars-template": ["hbs"], "text/x-java-source": ["java"], "text/x-lua": ["lua"], "text/x-markdown": ["mkd"], "text/x-nfo": ["nfo"], "text/x-opml": ["opml"], "text/x-org": [], "text/x-pascal": ["p", "pas"], "text/x-processing": ["pde"], "text/x-sass": ["sass"], "text/x-scss": ["scss"], "text/x-setext": ["etx"], "text/x-sfv": ["sfv"], "text/x-suse-ymp": ["ymp"], "text/x-uuencode": ["uu"], "text/x-vcalendar": ["vcs"], "text/x-vcard": ["vcf"], "text/xml": [], "text/yaml": ["yaml", "yml"], "video/3gpp": ["3gp", "3gpp"], "video/3gpp2": ["3g2"], "video/h261": ["h261"], "video/h263": ["h263"], "video/h264": ["h264"], "video/jpeg": ["jpgv"], "video/jpm": ["jpgm"], "video/mj2": ["mj2", "mjp2"], "video/mp2t": ["ts"], "video/mp4": ["mp4", "mp4v", "mpg4"], "video/mpeg": ["mpeg", "mpg", "mpe", "m1v", "m2v"], "video/ogg": ["ogv"], "video/quicktime": ["qt", "mov"], "video/vnd.dece.hd": ["uvh", "uvvh"], "video/vnd.dece.mobile": ["uvm", "uvvm"], "video/vnd.dece.pd": ["uvp", "uvvp"], "video/vnd.dece.sd": ["uvs", "uvvs"], "video/vnd.dece.video": ["uvv", "uvvv"], "video/vnd.dvb.file": ["dvb"], "video/vnd.fvt": ["fvt"], "video/vnd.mpegurl": ["mxu", "m4u"], "video/vnd.ms-playready.media.pyv": ["pyv"], "video/vnd.uvvu.mp4": ["uvu", "uvvu"], "video/vnd.vivo": ["viv"], "video/webm": ["webm"], "video/x-f4v": ["f4v"], "video/x-fli": ["fli"], "video/x-flv": ["flv"], "video/x-m4v": ["m4v"], "video/x-matroska": ["mkv", "mk3d", "mks"], "video/x-mng": ["mng"], "video/x-ms-asf": ["asf", "asx"], "video/x-ms-vob": ["vob"], "video/x-ms-wm": ["wm"], "video/x-ms-wmv": ["wmv"], "video/x-ms-wmx": ["wmx"], "video/x-ms-wvx": ["wvx"], "video/x-msvideo": ["avi"], "video/x-sgi-movie": ["movie"], "video/x-smv": ["smv"], "x-conference/x-cooltalk": ["ice"] };
  }
});

// ../../node_modules/.pnpm/mime@1.6.0/node_modules/mime/mime.js
var require_mime = __commonJS({
  "../../node_modules/.pnpm/mime@1.6.0/node_modules/mime/mime.js"(exports2, module3) {
    init_import_meta_url();
    var path67 = require("path");
    var fs26 = require("fs");
    function Mime() {
      this.types = /* @__PURE__ */ Object.create(null);
      this.extensions = /* @__PURE__ */ Object.create(null);
    }
    __name(Mime, "Mime");
    Mime.prototype.define = function(map) {
      for (var type in map) {
        var exts = map[type];
        for (var i = 0; i < exts.length; i++) {
          if (process.env.DEBUG_MIME && this.types[exts[i]]) {
            console.warn((this._loading || "define()").replace(/.*\//, ""), 'changes "' + exts[i] + '" extension type from ' + this.types[exts[i]] + " to " + type);
          }
          this.types[exts[i]] = type;
        }
        if (!this.extensions[type]) {
          this.extensions[type] = exts[0];
        }
      }
    };
    Mime.prototype.load = function(file) {
      this._loading = file;
      var map = {}, content = fs26.readFileSync(file, "ascii"), lines = content.split(/[\r\n]+/);
      lines.forEach(function(line) {
        var fields = line.replace(/\s*#.*|^\s*|\s*$/g, "").split(/\s+/);
        map[fields.shift()] = fields;
      });
      this.define(map);
      this._loading = null;
    };
    Mime.prototype.lookup = function(path68, fallback) {
      var ext = path68.replace(/^.*[\.\/\\]/, "").toLowerCase();
      return this.types[ext] || fallback || this.default_type;
    };
    Mime.prototype.extension = function(mimeType) {
      var type = mimeType.match(/^\s*([^;\s]*)(?:;|\s|$)/)[1].toLowerCase();
      return this.extensions[type];
    };
    var mime = new Mime();
    mime.define(require_types());
    mime.default_type = mime.lookup("bin");
    mime.Mime = Mime;
    mime.charsets = {
      lookup: function(mimeType, fallback) {
        return /^text\/|^application\/(javascript|json)/.test(mimeType) ? "UTF-8" : fallback;
      }
    };
    module3.exports = mime;
  }
});

// ../../node_modules/.pnpm/ms@2.1.3/node_modules/ms/index.js
var require_ms2 = __commonJS({
  "../../node_modules/.pnpm/ms@2.1.3/node_modules/ms/index.js"(exports2, module3) {
    init_import_meta_url();
    var s = 1e3;
    var m2 = s * 60;
    var h2 = m2 * 60;
    var d2 = h2 * 24;
    var w2 = d2 * 7;
    var y2 = d2 * 365.25;
    module3.exports = function(val, options29) {
      options29 = options29 || {};
      var type = typeof val;
      if (type === "string" && val.length > 0) {
        return parse7(val);
      } else if (type === "number" && isFinite(val)) {
        return options29.long ? fmtLong(val) : fmtShort(val);
      }
      throw new Error(
        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
      );
    };
    function parse7(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 n2 = parseFloat(match[1]);
      var type = (match[2] || "ms").toLowerCase();
      switch (type) {
        case "years":
        case "year":
        case "yrs":
        case "yr":
        case "y":
          return n2 * y2;
        case "weeks":
        case "week":
        case "w":
          return n2 * w2;
        case "days":
        case "day":
        case "d":
          return n2 * d2;
        case "hours":
        case "hour":
        case "hrs":
        case "hr":
        case "h":
          return n2 * h2;
        case "minutes":
        case "minute":
        case "mins":
        case "min":
        case "m":
          return n2 * m2;
        case "seconds":
        case "second":
        case "secs":
        case "sec":
        case "s":
          return n2 * s;
        case "milliseconds":
        case "millisecond":
        case "msecs":
        case "msec":
        case "ms":
          return n2;
        default:
          return void 0;
      }
    }
    __name(parse7, "parse");
    function fmtShort(ms) {
      var msAbs = Math.abs(ms);
      if (msAbs >= d2) {
        return Math.round(ms / d2) + "d";
      }
      if (msAbs >= h2) {
        return Math.round(ms / h2) + "h";
      }
      if (msAbs >= m2) {
        return Math.round(ms / m2) + "m";
      }
      if (msAbs >= s) {
        return Math.round(ms / s) + "s";
      }
      return ms + "ms";
    }
    __name(fmtShort, "fmtShort");
    function fmtLong(ms) {
      var msAbs = Math.abs(ms);
      if (msAbs >= d2) {
        return plural2(ms, msAbs, d2, "day");
      }
      if (msAbs >= h2) {
        return plural2(ms, msAbs, h2, "hour");
      }
      if (msAbs >= m2) {
        return plural2(ms, msAbs, m2, "minute");
      }
      if (msAbs >= s) {
        return plural2(ms, msAbs, s, "second");
      }
      return ms + " ms";
    }
    __name(fmtLong, "fmtLong");
    function plural2(ms, msAbs, n2, name) {
      var isPlural = msAbs >= n2 * 1.5;
      return Math.round(ms / n2) + " " + name + (isPlural ? "s" : "");
    }
    __name(plural2, "plural");
  }
});

// ../../node_modules/.pnpm/range-parser@1.2.1/node_modules/range-parser/index.js
var require_range_parser = __commonJS({
  "../../node_modules/.pnpm/range-parser@1.2.1/node_modules/range-parser/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = rangeParser;
    function rangeParser(size, str, options29) {
      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 options29 && options29.combine ? combineRanges(ranges) : ranges;
    }
    __name(rangeParser, "rangeParser");
    function combineRanges(ranges) {
      var ordered = ranges.map(mapWithIndex).sort(sortByRangeStart);
      for (var j2 = 0, i = 1; i < ordered.length; i++) {
        var range = ordered[i];
        var current = ordered[j2];
        if (range.start > current.end + 1) {
          ordered[++j2] = range;
        } else if (range.end > current.end) {
          current.end = range.end;
          current.index = Math.min(current.index, range.index);
        }
      }
      ordered.length = j2 + 1;
      var combined = ordered.sort(sortByRangeIndex).map(mapWithoutIndex);
      combined.type = ranges.type;
      return combined;
    }
    __name(combineRanges, "combineRanges");
    function mapWithIndex(range, index) {
      return {
        start: range.start,
        end: range.end,
        index
      };
    }
    __name(mapWithIndex, "mapWithIndex");
    function mapWithoutIndex(range) {
      return {
        start: range.start,
        end: range.end
      };
    }
    __name(mapWithoutIndex, "mapWithoutIndex");
    function sortByRangeIndex(a, b2) {
      return a.index - b2.index;
    }
    __name(sortByRangeIndex, "sortByRangeIndex");
    function sortByRangeStart(a, b2) {
      return a.start - b2.start;
    }
    __name(sortByRangeStart, "sortByRangeStart");
  }
});

// ../../node_modules/.pnpm/send@0.18.0_supports-color@9.2.2/node_modules/send/index.js
var require_send = __commonJS({
  "../../node_modules/.pnpm/send@0.18.0_supports-color@9.2.2/node_modules/send/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var createError = require_http_errors();
    var debug = require_src3()("send");
    var deprecate = require_depd()("send");
    var destroy = require_destroy();
    var encodeUrl = require_encodeurl();
    var escapeHtml = require_escape_html();
    var etag = require_etag();
    var fresh = require_fresh();
    var fs26 = require("fs");
    var mime = require_mime();
    var ms = require_ms2();
    var onFinished = require_on_finished();
    var parseRange = require_range_parser();
    var path67 = require("path");
    var statuses = require_statuses();
    var Stream = require("stream");
    var util4 = require("util");
    var extname4 = path67.extname;
    var join15 = path67.join;
    var normalize3 = path67.normalize;
    var resolve19 = path67.resolve;
    var sep3 = path67.sep;
    var BYTES_RANGE_REGEXP = /^ *bytes=/;
    var MAX_MAXAGE = 60 * 60 * 24 * 365 * 1e3;
    var UP_PATH_REGEXP = /(?:^|[\\/])\.\.(?:[\\/]|$)/;
    module3.exports = send;
    module3.exports.mime = mime;
    function send(req, path68, options29) {
      return new SendStream(req, path68, options29);
    }
    __name(send, "send");
    function SendStream(req, path68, options29) {
      Stream.call(this);
      var opts = options29 || {};
      this.options = opts;
      this.path = path68;
      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._hidden = Boolean(opts.hidden);
      if (opts.hidden !== void 0) {
        deprecate("hidden: use dotfiles: '" + (this._hidden ? "allow" : "ignore") + "' instead");
      }
      if (opts.dotfiles === void 0) {
        this._dotfiles = void 0;
      }
      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 ? resolve19(opts.root) : null;
      if (!this._root && opts.from) {
        this.from(opts.from);
      }
    }
    __name(SendStream, "SendStream");
    util4.inherits(SendStream, Stream);
    SendStream.prototype.etag = deprecate.function(/* @__PURE__ */ __name(function etag2(val) {
      this._etag = Boolean(val);
      debug("etag %s", this._etag);
      return this;
    }, "etag"), "send.etag: pass etag as option");
    SendStream.prototype.hidden = deprecate.function(/* @__PURE__ */ __name(function hidden2(val) {
      this._hidden = Boolean(val);
      this._dotfiles = void 0;
      debug("hidden %s", this._hidden);
      return this;
    }, "hidden"), "send.hidden: use dotfiles option");
    SendStream.prototype.index = deprecate.function(/* @__PURE__ */ __name(function index(paths) {
      var index2 = !paths ? [] : normalizeList(paths, "paths argument");
      debug("index %o", paths);
      this._index = index2;
      return this;
    }, "index"), "send.index: pass index as option");
    SendStream.prototype.root = /* @__PURE__ */ __name(function root(path68) {
      this._root = resolve19(String(path68));
      debug("root %s", this._root);
      return this;
    }, "root");
    SendStream.prototype.from = deprecate.function(
      SendStream.prototype.root,
      "send.from: pass root as option"
    );
    SendStream.prototype.root = deprecate.function(
      SendStream.prototype.root,
      "send.root: pass root as option"
    );
    SendStream.prototype.maxage = deprecate.function(/* @__PURE__ */ __name(function maxage(maxAge) {
      this._maxage = typeof maxAge === "string" ? ms(maxAge) : Number(maxAge);
      this._maxage = !isNaN(this._maxage) ? Math.min(Math.max(0, this._maxage), MAX_MAXAGE) : 0;
      debug("max-age %d", this._maxage);
      return this;
    }, "maxage"), "send.maxage: pass maxAge as option");
    SendStream.prototype.error = /* @__PURE__ */ __name(function error2(status2, err) {
      if (hasListeners(this, "error")) {
        return this.emit("error", createHttpError(status2, err));
      }
      var res = this.res;
      var msg = statuses.message[status2] || String(status2);
      var doc = createHtmlDocument("Error", escapeHtml(msg));
      clearHeaders(res);
      if (err && err.headers) {
        setHeaders(res, err.headers);
      }
      res.statusCode = status2;
      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);
    }, "error");
    SendStream.prototype.hasTrailingSlash = /* @__PURE__ */ __name(function hasTrailingSlash() {
      return this.path[this.path.length - 1] === "/";
    }, "hasTrailingSlash");
    SendStream.prototype.isConditionalGET = /* @__PURE__ */ __name(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"];
    }, "isConditionalGET");
    SendStream.prototype.isPreconditionFailure = /* @__PURE__ */ __name(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;
    }, "isPreconditionFailure");
    SendStream.prototype.removeContentHeaderFields = /* @__PURE__ */ __name(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");
    }, "removeContentHeaderFields");
    SendStream.prototype.notModified = /* @__PURE__ */ __name(function notModified() {
      var res = this.res;
      debug("not modified");
      this.removeContentHeaderFields();
      res.statusCode = 304;
      res.end();
    }, "notModified");
    SendStream.prototype.headersAlreadySent = /* @__PURE__ */ __name(function headersAlreadySent() {
      var err = new Error("Can't set headers after they are sent.");
      debug("headers already sent");
      this.error(500, err);
    }, "headersAlreadySent");
    SendStream.prototype.isCachable = /* @__PURE__ */ __name(function isCachable() {
      var statusCode = this.res.statusCode;
      return statusCode >= 200 && statusCode < 300 || statusCode === 304;
    }, "isCachable");
    SendStream.prototype.onStatError = /* @__PURE__ */ __name(function onStatError(error2) {
      switch (error2.code) {
        case "ENAMETOOLONG":
        case "ENOENT":
        case "ENOTDIR":
          this.error(404, error2);
          break;
        default:
          this.error(500, error2);
          break;
      }
    }, "onStatError");
    SendStream.prototype.isFresh = /* @__PURE__ */ __name(function isFresh() {
      return fresh(this.req.headers, {
        etag: this.res.getHeader("ETag"),
        "last-modified": this.res.getHeader("Last-Modified")
      });
    }, "isFresh");
    SendStream.prototype.isRangeFresh = /* @__PURE__ */ __name(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);
    }, "isRangeFresh");
    SendStream.prototype.redirect = /* @__PURE__ */ __name(function redirect(path68) {
      var res = this.res;
      if (hasListeners(this, "directory")) {
        this.emit("directory", res, path68);
        return;
      }
      if (this.hasTrailingSlash()) {
        this.error(403);
        return;
      }
      var loc = encodeUrl(collapseLeadingSlashes(this.path + "/"));
      var doc = createHtmlDocument("Redirecting", 'Redirecting to <a href="' + escapeHtml(loc) + '">' + escapeHtml(loc) + "</a>");
      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);
    }, "redirect");
    SendStream.prototype.pipe = /* @__PURE__ */ __name(function pipe(res) {
      var root = this._root;
      this.res = res;
      var path68 = decode(this.path);
      if (path68 === -1) {
        this.error(400);
        return res;
      }
      if (~path68.indexOf("\0")) {
        this.error(400);
        return res;
      }
      var parts;
      if (root !== null) {
        if (path68) {
          path68 = normalize3("." + sep3 + path68);
        }
        if (UP_PATH_REGEXP.test(path68)) {
          debug('malicious path "%s"', path68);
          this.error(403);
          return res;
        }
        parts = path68.split(sep3);
        path68 = normalize3(join15(root, path68));
      } else {
        if (UP_PATH_REGEXP.test(path68)) {
          debug('malicious path "%s"', path68);
          this.error(403);
          return res;
        }
        parts = normalize3(path68).split(sep3);
        path68 = resolve19(path68);
      }
      if (containsDotFile(parts)) {
        var access3 = this._dotfiles;
        if (access3 === void 0) {
          access3 = parts[parts.length - 1][0] === "." ? this._hidden ? "allow" : "ignore" : "allow";
        }
        debug('%s dotfile "%s"', access3, path68);
        switch (access3) {
          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(path68);
        return res;
      }
      this.sendFile(path68);
      return res;
    }, "pipe");
    SendStream.prototype.send = /* @__PURE__ */ __name(function send2(path68, stat4) {
      var len = stat4.size;
      var options29 = this.options;
      var opts = {};
      var res = this.res;
      var req = this.req;
      var ranges = req.headers.range;
      var offset = options29.start || 0;
      if (headersSent(res)) {
        this.headersAlreadySent();
        return;
      }
      debug('pipe "%s"', path68);
      this.setHeader(path68, stat4);
      this.type(path68);
      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 (options29.end !== void 0) {
        var bytes = options29.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 options29) {
        opts[prop] = options29[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(path68, opts);
    }, "send");
    SendStream.prototype.sendFile = /* @__PURE__ */ __name(function sendFile(path68) {
      var i = 0;
      var self2 = this;
      debug('stat "%s"', path68);
      fs26.stat(path68, /* @__PURE__ */ __name(function onstat(err, stat4) {
        if (err && err.code === "ENOENT" && !extname4(path68) && path68[path68.length - 1] !== sep3) {
          return next(err);
        }
        if (err)
          return self2.onStatError(err);
        if (stat4.isDirectory())
          return self2.redirect(path68);
        self2.emit("file", path68, stat4);
        self2.send(path68, stat4);
      }, "onstat"));
      function next(err) {
        if (self2._extensions.length <= i) {
          return err ? self2.onStatError(err) : self2.error(404);
        }
        var p2 = path68 + "." + self2._extensions[i++];
        debug('stat "%s"', p2);
        fs26.stat(p2, function(err2, stat4) {
          if (err2)
            return next(err2);
          if (stat4.isDirectory())
            return next();
          self2.emit("file", p2, stat4);
          self2.send(p2, stat4);
        });
      }
      __name(next, "next");
    }, "sendFile");
    SendStream.prototype.sendIndex = /* @__PURE__ */ __name(function sendIndex(path68) {
      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 p2 = join15(path68, self2._index[i]);
        debug('stat "%s"', p2);
        fs26.stat(p2, function(err2, stat4) {
          if (err2)
            return next(err2);
          if (stat4.isDirectory())
            return next();
          self2.emit("file", p2, stat4);
          self2.send(p2, stat4);
        });
      }
      __name(next, "next");
      next();
    }, "sendIndex");
    SendStream.prototype.stream = /* @__PURE__ */ __name(function stream2(path68, options29) {
      var self2 = this;
      var res = this.res;
      var stream3 = fs26.createReadStream(path68, options29);
      this.emit("stream", stream3);
      stream3.pipe(res);
      function cleanup() {
        destroy(stream3, true);
      }
      __name(cleanup, "cleanup");
      onFinished(res, cleanup);
      stream3.on("error", /* @__PURE__ */ __name(function onerror(err) {
        cleanup();
        self2.onStatError(err);
      }, "onerror"));
      stream3.on("end", /* @__PURE__ */ __name(function onend() {
        self2.emit("end");
      }, "onend"));
    }, "stream");
    SendStream.prototype.type = /* @__PURE__ */ __name(function type(path68) {
      var res = this.res;
      if (res.getHeader("Content-Type"))
        return;
      var type2 = mime.lookup(path68);
      if (!type2) {
        debug("no content-type");
        return;
      }
      var charset = mime.charsets.lookup(type2);
      debug("content-type %s", type2);
      res.setHeader("Content-Type", type2 + (charset ? "; charset=" + charset : ""));
    }, "type");
    SendStream.prototype.setHeader = /* @__PURE__ */ __name(function setHeader(path68, stat4) {
      var res = this.res;
      this.emit("headers", res, path68, stat4);
      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 = stat4.mtime.toUTCString();
        debug("modified %s", modified);
        res.setHeader("Last-Modified", modified);
      }
      if (this._etag && !res.getHeader("ETag")) {
        var val = etag(stat4);
        debug("etag %s", val);
        res.setHeader("ETag", val);
      }
    }, "setHeader");
    function clearHeaders(res) {
      var headers = getHeaderNames(res);
      for (var i = 0; i < headers.length; i++) {
        res.removeHeader(headers[i]);
      }
    }
    __name(clearHeaders, "clearHeaders");
    function collapseLeadingSlashes(str) {
      for (var i = 0; i < str.length; i++) {
        if (str[i] !== "/") {
          break;
        }
      }
      return i > 1 ? "/" + str.substr(i) : str;
    }
    __name(collapseLeadingSlashes, "collapseLeadingSlashes");
    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;
    }
    __name(containsDotFile, "containsDotFile");
    function contentRange(type, size, range) {
      return type + " " + (range ? range.start + "-" + range.end : "*") + "/" + size;
    }
    __name(contentRange, "contentRange");
    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";
    }
    __name(createHtmlDocument, "createHtmlDocument");
    function createHttpError(status2, err) {
      if (!err) {
        return createError(status2);
      }
      return err instanceof Error ? createError(status2, err, { expose: false }) : createError(status2, err);
    }
    __name(createHttpError, "createHttpError");
    function decode(path68) {
      try {
        return decodeURIComponent(path68);
      } catch (err) {
        return -1;
      }
    }
    __name(decode, "decode");
    function getHeaderNames(res) {
      return typeof res.getHeaderNames !== "function" ? Object.keys(res._headers || {}) : res.getHeaderNames();
    }
    __name(getHeaderNames, "getHeaderNames");
    function hasListeners(emitter, type) {
      var count = typeof emitter.listenerCount !== "function" ? emitter.listeners(type).length : emitter.listenerCount(type);
      return count > 0;
    }
    __name(hasListeners, "hasListeners");
    function headersSent(res) {
      return typeof res.headersSent !== "boolean" ? Boolean(res._header) : res.headersSent;
    }
    __name(headersSent, "headersSent");
    function normalizeList(val, name) {
      var list = [].concat(val || []);
      for (var i = 0; i < list.length; i++) {
        if (typeof list[i] !== "string") {
          throw new TypeError(name + " must be array of strings or false");
        }
      }
      return list;
    }
    __name(normalizeList, "normalizeList");
    function parseHttpDate(date) {
      var timestamp = date && Date.parse(date);
      return typeof timestamp === "number" ? timestamp : NaN;
    }
    __name(parseHttpDate, "parseHttpDate");
    function parseTokenList(str) {
      var end = 0;
      var list = [];
      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) {
              list.push(str.substring(start, end));
            }
            start = end = i + 1;
            break;
          default:
            end = i + 1;
            break;
        }
      }
      if (start !== end) {
        list.push(str.substring(start, end));
      }
      return list;
    }
    __name(parseTokenList, "parseTokenList");
    function setHeaders(res, headers) {
      var keys = Object.keys(headers);
      for (var i = 0; i < keys.length; i++) {
        var key = keys[i];
        res.setHeader(key, headers[key]);
      }
    }
    __name(setHeaders, "setHeaders");
  }
});

// ../../node_modules/.pnpm/forwarded@0.2.0/node_modules/forwarded/index.js
var require_forwarded = __commonJS({
  "../../node_modules/.pnpm/forwarded@0.2.0/node_modules/forwarded/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = forwarded;
    function forwarded(req) {
      if (!req) {
        throw new TypeError("argument req is required");
      }
      var proxyAddrs = parse7(req.headers["x-forwarded-for"] || "");
      var socketAddr = getSocketAddr(req);
      var addrs = [socketAddr].concat(proxyAddrs);
      return addrs;
    }
    __name(forwarded, "forwarded");
    function getSocketAddr(req) {
      return req.socket ? req.socket.remoteAddress : req.connection.remoteAddress;
    }
    __name(getSocketAddr, "getSocketAddr");
    function parse7(header) {
      var end = header.length;
      var list = [];
      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) {
              list.push(header.substring(start, end));
            }
            start = end = i;
            break;
          default:
            start = i;
            break;
        }
      }
      if (start !== end) {
        list.push(header.substring(start, end));
      }
      return list;
    }
    __name(parse7, "parse");
  }
});

// ../../node_modules/.pnpm/ipaddr.js@1.9.1/node_modules/ipaddr.js/lib/ipaddr.js
var require_ipaddr = __commonJS({
  "../../node_modules/.pnpm/ipaddr.js@1.9.1/node_modules/ipaddr.js/lib/ipaddr.js"(exports2, module3) {
    init_import_meta_url();
    (function() {
      var expandIPv6, ipaddr, ipv4Part, ipv4Regexes, ipv6Part, ipv6Regexes, matchCIDR, root, zoneIndex;
      ipaddr = {};
      root = this;
      if (typeof module3 !== "undefined" && module3 !== null && module3.exports) {
        module3.exports = ipaddr;
      } else {
        root["ipaddr"] = ipaddr;
      }
      matchCIDR = /* @__PURE__ */ __name(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;
      }, "matchCIDR");
      ipaddr.subnetMatch = function(address, rangeList, defaultName) {
        var k2, 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 (k2 = 0, len = rangeSubnets.length; k2 < len; k2++) {
            subnet = rangeSubnets[k2];
            if (address.kind() === subnet[0].kind()) {
              if (address.match.apply(address, subnet)) {
                return rangeName;
              }
            }
          }
        }
        return defaultName;
      };
      ipaddr.IPv4 = function() {
        function IPv4(octets) {
          var k2, len, octet;
          if (octets.length !== 4) {
            throw new Error("ipaddr: ipv4 octet count should be 4");
          }
          for (k2 = 0, len = octets.length; k2 < len; k2++) {
            octet = octets[k2];
            if (!(0 <= octet && octet <= 255)) {
              throw new Error("ipaddr: ipv4 octet should fit in 8 bits");
            }
          }
          this.octets = octets;
        }
        __name(IPv4, "IPv4");
        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, k2, 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 = k2 = 3; k2 >= 0; i = k2 += -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(string) {
        var match, parseIntAuto, part, shift, value;
        parseIntAuto = /* @__PURE__ */ __name(function(string2) {
          if (string2[0] === "0" && string2[1] !== "x") {
            return parseInt(string2, 8);
          } else {
            return parseInt(string2);
          }
        }, "parseIntAuto");
        if (match = string.match(ipv4Regexes.fourOctet)) {
          return function() {
            var k2, len, ref, results;
            ref = match.slice(1, 6);
            results = [];
            for (k2 = 0, len = ref.length; k2 < len; k2++) {
              part = ref[k2];
              results.push(parseIntAuto(part));
            }
            return results;
          }();
        } else if (match = string.match(ipv4Regexes.longValue)) {
          value = parseIntAuto(match[1]);
          if (value > 4294967295 || value < 0) {
            throw new Error("ipaddr: address outside defined range");
          }
          return function() {
            var k2, results;
            results = [];
            for (shift = k2 = 0; k2 <= 24; shift = k2 += 8) {
              results.push(value >> shift & 255);
            }
            return results;
          }().reverse();
        } else {
          return null;
        }
      };
      ipaddr.IPv6 = function() {
        function IPv6(parts, zoneId) {
          var i, k2, l2, len, part, ref;
          if (parts.length === 16) {
            this.parts = [];
            for (i = k2 = 0; k2 <= 14; i = k2 += 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 (l2 = 0, len = ref.length; l2 < len; l2++) {
            part = ref[l2];
            if (!(0 <= part && part <= 65535)) {
              throw new Error("ipaddr: ipv6 part should fit in 16 bits");
            }
          }
          if (zoneId) {
            this.zoneId = zoneId;
          }
        }
        __name(IPv6, "IPv6");
        IPv6.prototype.kind = function() {
          return "ipv6";
        };
        IPv6.prototype.toString = function() {
          return this.toNormalizedString().replace(/((^|:)(0(:|$))+)/, "::");
        };
        IPv6.prototype.toRFC5952String = function() {
          var bestMatchIndex, bestMatchLength, match, regex2, string;
          regex2 = /((^|:)(0(:|$)){2,})/g;
          string = this.toNormalizedString();
          bestMatchIndex = 0;
          bestMatchLength = -1;
          while (match = regex2.exec(string)) {
            if (match[0].length > bestMatchLength) {
              bestMatchIndex = match.index;
              bestMatchLength = match[0].length;
            }
          }
          if (bestMatchLength < 0) {
            return string;
          }
          return string.substring(0, bestMatchIndex) + "::" + string.substring(bestMatchIndex + bestMatchLength);
        };
        IPv6.prototype.toByteArray = function() {
          var bytes, k2, len, part, ref;
          bytes = [];
          ref = this.parts;
          for (k2 = 0, len = ref.length; k2 < len; k2++) {
            part = ref[k2];
            bytes.push(part >> 8);
            bytes.push(part & 255);
          }
          return bytes;
        };
        IPv6.prototype.toNormalizedString = function() {
          var addr, part, suffix;
          addr = function() {
            var k2, len, ref, results;
            ref = this.parts;
            results = [];
            for (k2 = 0, len = ref.length; k2 < len; k2++) {
              part = ref[k2];
              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 k2, len, ref, results;
            ref = this.parts;
            results = [];
            for (k2 = 0, len = ref.length; k2 < len; k2++) {
              part = ref[k2];
              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, k2, 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 = k2 = 7; k2 >= 0; i = k2 += -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 = /* @__PURE__ */ __name(function(string, parts) {
        var colonCount, lastColon, part, replacement, replacementCount, zoneId;
        if (string.indexOf("::") !== string.lastIndexOf("::")) {
          return null;
        }
        zoneId = (string.match(ipv6Regexes["zoneIndex"]) || [])[0];
        if (zoneId) {
          zoneId = zoneId.substring(1);
          string = string.replace(/%.+$/, "");
        }
        colonCount = 0;
        lastColon = -1;
        while ((lastColon = string.indexOf(":", lastColon + 1)) >= 0) {
          colonCount++;
        }
        if (string.substr(0, 2) === "::") {
          colonCount--;
        }
        if (string.substr(-2, 2) === "::") {
          colonCount--;
        }
        if (colonCount > parts) {
          return null;
        }
        replacementCount = parts - colonCount;
        replacement = ":";
        while (replacementCount--) {
          replacement += "0:";
        }
        string = string.replace("::", replacement);
        if (string[0] === ":") {
          string = string.slice(1);
        }
        if (string[string.length - 1] === ":") {
          string = string.slice(0, -1);
        }
        parts = function() {
          var k2, len, ref, results;
          ref = string.split(":");
          results = [];
          for (k2 = 0, len = ref.length; k2 < len; k2++) {
            part = ref[k2];
            results.push(parseInt(part, 16));
          }
          return results;
        }();
        return {
          parts,
          zoneId
        };
      }, "expandIPv6");
      ipaddr.IPv6.parser = function(string) {
        var addr, k2, len, match, octet, octets, zoneId;
        if (ipv6Regexes["native"].test(string)) {
          return expandIPv6(string, 8);
        } else if (match = string.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 (k2 = 0, len = octets.length; k2 < len; k2++) {
              octet = octets[k2];
              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(string) {
        return this.parser(string) !== null;
      };
      ipaddr.IPv4.isValid = function(string) {
        var e3;
        try {
          new this(this.parser(string));
          return true;
        } catch (error1) {
          e3 = error1;
          return false;
        }
      };
      ipaddr.IPv4.isValidFourPartDecimal = function(string) {
        if (ipaddr.IPv4.isValid(string) && string.match(/^(0|[1-9]\d*)(\.(0|[1-9]\d*)){3}$/)) {
          return true;
        } else {
          return false;
        }
      };
      ipaddr.IPv6.isValid = function(string) {
        var addr, e3;
        if (typeof string === "string" && string.indexOf(":") === -1) {
          return false;
        }
        try {
          addr = this.parser(string);
          new this(addr.parts, addr.zoneId);
          return true;
        } catch (error1) {
          e3 = error1;
          return false;
        }
      };
      ipaddr.IPv4.parse = function(string) {
        var parts;
        parts = this.parser(string);
        if (parts === null) {
          throw new Error("ipaddr: string is not formatted like ip address");
        }
        return new this(parts);
      };
      ipaddr.IPv6.parse = function(string) {
        var addr;
        addr = this.parser(string);
        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(string) {
        var maskLength, match, parsed;
        if (match = string.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, j2, octets;
        prefix = parseInt(prefix);
        if (prefix < 0 || prefix > 32) {
          throw new Error("ipaddr: invalid IPv4 prefix length");
        }
        octets = [0, 0, 0, 0];
        j2 = 0;
        filledOctetCount = Math.floor(prefix / 8);
        while (j2 < filledOctetCount) {
          octets[j2] = 255;
          j2++;
        }
        if (filledOctetCount < 4) {
          octets[filledOctetCount] = Math.pow(2, prefix % 8) - 1 << 8 - prefix % 8;
        }
        return new this(octets);
      };
      ipaddr.IPv4.broadcastAddressFromCIDR = function(string) {
        var cidr, error2, i, ipInterfaceOctets, octets, subnetMaskOctets;
        try {
          cidr = this.parseCIDR(string);
          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) {
          error2 = error1;
          throw new Error("ipaddr: the address does not have IPv4 CIDR format");
        }
      };
      ipaddr.IPv4.networkAddressFromCIDR = function(string) {
        var cidr, error2, i, ipInterfaceOctets, octets, subnetMaskOctets;
        try {
          cidr = this.parseCIDR(string);
          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) {
          error2 = error1;
          throw new Error("ipaddr: the address does not have IPv4 CIDR format");
        }
      };
      ipaddr.IPv6.parseCIDR = function(string) {
        var maskLength, match, parsed;
        if (match = string.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(string) {
        return ipaddr.IPv6.isValid(string) || ipaddr.IPv4.isValid(string);
      };
      ipaddr.parse = function(string) {
        if (ipaddr.IPv6.isValid(string)) {
          return ipaddr.IPv6.parse(string);
        } else if (ipaddr.IPv4.isValid(string)) {
          return ipaddr.IPv4.parse(string);
        } else {
          throw new Error("ipaddr: the address has neither IPv6 nor IPv4 format");
        }
      };
      ipaddr.parseCIDR = function(string) {
        var e3;
        try {
          return ipaddr.IPv6.parseCIDR(string);
        } catch (error1) {
          e3 = error1;
          try {
            return ipaddr.IPv4.parseCIDR(string);
          } catch (error12) {
            e3 = error12;
            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(string) {
        var addr;
        addr = this.parse(string);
        if (addr.kind() === "ipv6" && addr.isIPv4MappedAddress()) {
          return addr.toIPv4Address();
        } else {
          return addr;
        }
      };
    }).call(exports2);
  }
});

// ../../node_modules/.pnpm/proxy-addr@2.0.7/node_modules/proxy-addr/index.js
var require_proxy_addr = __commonJS({
  "../../node_modules/.pnpm/proxy-addr@2.0.7/node_modules/proxy-addr/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = proxyaddr;
    module3.exports.all = alladdrs;
    module3.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;
    }
    __name(alladdrs, "alladdrs");
    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));
    }
    __name(compile, "compile");
    function compileRangeSubnets(arr) {
      var rangeSubnets = new Array(arr.length);
      for (var i = 0; i < arr.length; i++) {
        rangeSubnets[i] = parseipNotation(arr[i]);
      }
      return rangeSubnets;
    }
    __name(compileRangeSubnets, "compileRangeSubnets");
    function compileTrust(rangeSubnets) {
      var len = rangeSubnets.length;
      return len === 0 ? trustNone : len === 1 ? trustSingle(rangeSubnets[0]) : trustMulti(rangeSubnets);
    }
    __name(compileTrust, "compileTrust");
    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 ip2 = parseip(str);
      if (pos === -1 && ip2.kind() === "ipv6" && ip2.isIPv4MappedAddress()) {
        ip2 = ip2.toIPv4Address();
      }
      var max = ip2.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 (ip2.kind() === "ipv4" && isip(range)) {
        range = parseNetmask(range);
      } else {
        range = null;
      }
      if (range <= 0 || range > max) {
        throw new TypeError("invalid range on address: " + note);
      }
      return [ip2, range];
    }
    __name(parseipNotation, "parseipNotation");
    function parseNetmask(netmask) {
      var ip2 = parseip(netmask);
      var kind = ip2.kind();
      return kind === "ipv4" ? ip2.prefixLengthFromSubnetMask() : null;
    }
    __name(parseNetmask, "parseNetmask");
    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;
    }
    __name(proxyaddr, "proxyaddr");
    function trustNone() {
      return false;
    }
    __name(trustNone, "trustNone");
    function trustMulti(subnets) {
      return /* @__PURE__ */ __name(function trust(addr) {
        if (!isip(addr))
          return false;
        var ip2 = parseip(addr);
        var ipconv;
        var kind = ip2.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 = ip2;
          if (kind !== subnetkind) {
            if (subnetkind === "ipv4" && !ip2.isIPv4MappedAddress()) {
              continue;
            }
            if (!ipconv) {
              ipconv = subnetkind === "ipv4" ? ip2.toIPv4Address() : ip2.toIPv4MappedAddress();
            }
            trusted = ipconv;
          }
          if (trusted.match(subnetip, subnetrange)) {
            return true;
          }
        }
        return false;
      }, "trust");
    }
    __name(trustMulti, "trustMulti");
    function trustSingle(subnet) {
      var subnetip = subnet[0];
      var subnetkind = subnetip.kind();
      var subnetisipv4 = subnetkind === "ipv4";
      var subnetrange = subnet[1];
      return /* @__PURE__ */ __name(function trust(addr) {
        if (!isip(addr))
          return false;
        var ip2 = parseip(addr);
        var kind = ip2.kind();
        if (kind !== subnetkind) {
          if (subnetisipv4 && !ip2.isIPv4MappedAddress()) {
            return false;
          }
          ip2 = subnetisipv4 ? ip2.toIPv4Address() : ip2.toIPv4MappedAddress();
        }
        return ip2.match(subnetip, subnetrange);
      }, "trust");
    }
    __name(trustSingle, "trustSingle");
  }
});

// ../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/utils.js
var require_utils4 = __commonJS({
  "../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/utils.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var Buffer3 = require_safe_buffer().Buffer;
    var contentDisposition = require_content_disposition();
    var contentType = require_content_type();
    var deprecate = require_depd()("express");
    var flatten = require_array_flatten();
    var mime = require_send().mime;
    var etag = require_etag();
    var proxyaddr = require_proxy_addr();
    var qs = require_lib3();
    var querystring = require("querystring");
    exports2.etag = createETagGenerator({ weak: false });
    exports2.wetag = createETagGenerator({ weak: true });
    exports2.isAbsolute = function(path67) {
      if ("/" === path67[0])
        return true;
      if (":" === path67[1] && ("\\" === path67[2] || "/" === path67[2]))
        return true;
      if ("\\\\" === path67.substring(0, 2))
        return true;
    };
    exports2.flatten = deprecate.function(
      flatten,
      "utils.flatten: use array-flatten npm module instead"
    );
    exports2.normalizeType = function(type) {
      return ~type.indexOf("/") ? acceptParams(type) : { value: mime.lookup(type), params: {} };
    };
    exports2.normalizeTypes = function(types) {
      var ret = [];
      for (var i = 0; i < types.length; ++i) {
        ret.push(exports2.normalizeType(types[i]));
      }
      return ret;
    };
    exports2.contentDisposition = deprecate.function(
      contentDisposition,
      "utils.contentDisposition: use content-disposition npm module instead"
    );
    function acceptParams(str, index) {
      var parts = str.split(/ *; */);
      var ret = { value: parts[0], quality: 1, params: {}, originalIndex: index };
      for (var i = 1; i < parts.length; ++i) {
        var pms = parts[i].split(/ *= */);
        if ("q" === pms[0]) {
          ret.quality = parseFloat(pms[1]);
        } else {
          ret.params[pms[0]] = pms[1];
        }
      }
      return ret;
    }
    __name(acceptParams, "acceptParams");
    exports2.compileETag = function(val) {
      var fn2;
      if (typeof val === "function") {
        return val;
      }
      switch (val) {
        case true:
        case "weak":
          fn2 = exports2.wetag;
          break;
        case false:
          break;
        case "strong":
          fn2 = exports2.etag;
          break;
        default:
          throw new TypeError("unknown value for etag function: " + val);
      }
      return fn2;
    };
    exports2.compileQueryParser = /* @__PURE__ */ __name(function compileQueryParser(val) {
      var fn2;
      if (typeof val === "function") {
        return val;
      }
      switch (val) {
        case true:
        case "simple":
          fn2 = querystring.parse;
          break;
        case false:
          fn2 = newObject;
          break;
        case "extended":
          fn2 = parseExtendedQueryString;
          break;
        default:
          throw new TypeError("unknown value for query parser function: " + val);
      }
      return fn2;
    }, "compileQueryParser");
    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(v2) {
          return v2.trim();
        });
      }
      return proxyaddr.compile(val || []);
    };
    exports2.setCharset = /* @__PURE__ */ __name(function setCharset(type, charset) {
      if (!type || !charset) {
        return type;
      }
      var parsed = contentType.parse(type);
      parsed.parameters.charset = charset;
      return contentType.format(parsed);
    }, "setCharset");
    function createETagGenerator(options29) {
      return /* @__PURE__ */ __name(function generateETag(body, encoding) {
        var buf = !Buffer3.isBuffer(body) ? Buffer3.from(body, encoding) : body;
        return etag(buf, options29);
      }, "generateETag");
    }
    __name(createETagGenerator, "createETagGenerator");
    function parseExtendedQueryString(str) {
      return qs.parse(str, {
        allowPrototypes: true
      });
    }
    __name(parseExtendedQueryString, "parseExtendedQueryString");
    function newObject() {
      return {};
    }
    __name(newObject, "newObject");
  }
});

// ../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/application.js
var require_application = __commonJS({
  "../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/application.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var finalhandler = require_finalhandler();
    var Router = require_router();
    var methods = require_methods();
    var middleware = require_init();
    var query = require_query();
    var debug = require_src3()("express:application");
    var View = require_view();
    var http4 = require("http");
    var compileETag = require_utils4().compileETag;
    var compileQueryParser = require_utils4().compileQueryParser;
    var compileTrust = require_utils4().compileTrust;
    var deprecate = require_depd()("express");
    var flatten = require_array_flatten();
    var merge = require_utils_merge();
    var resolve19 = require("path").resolve;
    var setPrototypeOf = require_setprototypeof();
    var hasOwnProperty2 = Object.prototype.hasOwnProperty;
    var slice = Array.prototype.slice;
    var app = exports2 = module3.exports = {};
    var trustProxyDefaultSymbol = "@@symbol:trust_proxy_default";
    app.init = /* @__PURE__ */ __name(function init3() {
      this.cache = {};
      this.engines = {};
      this.settings = {};
      this.defaultConfiguration();
    }, "init");
    app.defaultConfiguration = /* @__PURE__ */ __name(function defaultConfiguration() {
      var env5 = "production";
      this.enable("x-powered-by");
      this.set("etag", "weak");
      this.set("env", env5);
      this.set("query parser", "extended");
      this.set("subdomain offset", 2);
      this.set("trust proxy", false);
      Object.defineProperty(this.settings, trustProxyDefaultSymbol, {
        configurable: true,
        value: true
      });
      debug("booting in %s mode", env5);
      this.on("mount", /* @__PURE__ */ __name(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"];
        }
        setPrototypeOf(this.request, parent.request);
        setPrototypeOf(this.response, parent.response);
        setPrototypeOf(this.engines, parent.engines);
        setPrototypeOf(this.settings, parent.settings);
      }, "onmount"));
      this.locals = /* @__PURE__ */ Object.create(null);
      this.mountpath = "/";
      this.locals.settings = this.settings;
      this.set("view", View);
      this.set("views", resolve19("views"));
      this.set("jsonp callback name", "callback");
      if (env5 === "production") {
        this.enable("view cache");
      }
      Object.defineProperty(this, "router", {
        get: function() {
          throw new Error("'app.router' is deprecated!\nPlease see the 3.x to 4.x migration guide for details on how to update your app.");
        }
      });
    }, "defaultConfiguration");
    app.lazyrouter = /* @__PURE__ */ __name(function lazyrouter() {
      if (!this._router) {
        this._router = new Router({
          caseSensitive: this.enabled("case sensitive routing"),
          strict: this.enabled("strict routing")
        });
        this._router.use(query(this.get("query parser fn")));
        this._router.use(middleware.init(this));
      }
    }, "lazyrouter");
    app.handle = /* @__PURE__ */ __name(function handle(req, res, callback) {
      var router = this._router;
      var done = callback || finalhandler(req, res, {
        env: this.get("env"),
        onerror: logerror.bind(this)
      });
      if (!router) {
        debug("no routes defined on app");
        done();
        return;
      }
      router.handle(req, res, done);
    }, "handle");
    app.use = /* @__PURE__ */ __name(function use(fn2) {
      var offset = 0;
      var path67 = "/";
      if (typeof fn2 !== "function") {
        var arg = fn2;
        while (Array.isArray(arg) && arg.length !== 0) {
          arg = arg[0];
        }
        if (typeof arg !== "function") {
          offset = 1;
          path67 = fn2;
        }
      }
      var fns = flatten(slice.call(arguments, offset));
      if (fns.length === 0) {
        throw new TypeError("app.use() requires a middleware function");
      }
      this.lazyrouter();
      var router = this._router;
      fns.forEach(function(fn3) {
        if (!fn3 || !fn3.handle || !fn3.set) {
          return router.use(path67, fn3);
        }
        debug(".use app under %s", path67);
        fn3.mountpath = path67;
        fn3.parent = this;
        router.use(path67, /* @__PURE__ */ __name(function mounted_app(req, res, next) {
          var orig = req.app;
          fn3.handle(req, res, function(err) {
            setPrototypeOf(req, orig.request);
            setPrototypeOf(res, orig.response);
            next(err);
          });
        }, "mounted_app"));
        fn3.emit("mount", this);
      }, this);
      return this;
    }, "use");
    app.route = /* @__PURE__ */ __name(function route2(path67) {
      this.lazyrouter();
      return this._router.route(path67);
    }, "route");
    app.engine = /* @__PURE__ */ __name(function engine(ext, fn2) {
      if (typeof fn2 !== "function") {
        throw new Error("callback function required");
      }
      var extension = ext[0] !== "." ? "." + ext : ext;
      this.engines[extension] = fn2;
      return this;
    }, "engine");
    app.param = /* @__PURE__ */ __name(function param(name, fn2) {
      this.lazyrouter();
      if (Array.isArray(name)) {
        for (var i = 0; i < name.length; i++) {
          this.param(name[i], fn2);
        }
        return this;
      }
      this._router.param(name, fn2);
      return this;
    }, "param");
    app.set = /* @__PURE__ */ __name(function set(setting, val) {
      if (arguments.length === 1) {
        var settings = this.settings;
        while (settings && settings !== Object.prototype) {
          if (hasOwnProperty2.call(settings, setting)) {
            return settings[setting];
          }
          settings = Object.getPrototypeOf(settings);
        }
        return void 0;
      }
      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;
    }, "set");
    app.path = /* @__PURE__ */ __name(function path67() {
      return this.parent ? this.parent.path() + this.mountpath : "";
    }, "path");
    app.enabled = /* @__PURE__ */ __name(function enabled(setting) {
      return Boolean(this.set(setting));
    }, "enabled");
    app.disabled = /* @__PURE__ */ __name(function disabled(setting) {
      return !this.set(setting);
    }, "disabled");
    app.enable = /* @__PURE__ */ __name(function enable(setting) {
      return this.set(setting, true);
    }, "enable");
    app.disable = /* @__PURE__ */ __name(function disable(setting) {
      return this.set(setting, false);
    }, "disable");
    methods.forEach(function(method) {
      app[method] = function(path67) {
        if (method === "get" && arguments.length === 1) {
          return this.set(path67);
        }
        this.lazyrouter();
        var route2 = this._router.route(path67);
        route2[method].apply(route2, slice.call(arguments, 1));
        return this;
      };
    });
    app.all = /* @__PURE__ */ __name(function all2(path67) {
      this.lazyrouter();
      var route2 = this._router.route(path67);
      var args = slice.call(arguments, 1);
      for (var i = 0; i < methods.length; i++) {
        route2[methods[i]].apply(route2, args);
      }
      return this;
    }, "all");
    app.del = deprecate.function(app.delete, "app.del: Use app.delete instead");
    app.render = /* @__PURE__ */ __name(function render7(name, options29, callback) {
      var cache2 = this.cache;
      var done = callback;
      var engines = this.engines;
      var opts = options29;
      var renderOptions = {};
      var view;
      if (typeof options29 === "function") {
        done = options29;
        opts = {};
      }
      merge(renderOptions, this.locals);
      if (opts._locals) {
        merge(renderOptions, opts._locals);
      }
      merge(renderOptions, opts);
      if (renderOptions.cache == null) {
        renderOptions.cache = this.enabled("view cache");
      }
      if (renderOptions.cache) {
        view = cache2[name];
      }
      if (!view) {
        var View2 = this.get("view");
        view = new View2(name, {
          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 "' + name + '" in views ' + dirs);
          err.view = view;
          return done(err);
        }
        if (renderOptions.cache) {
          cache2[name] = view;
        }
      }
      tryRender(view, renderOptions, done);
    }, "render");
    app.listen = /* @__PURE__ */ __name(function listen() {
      var server = http4.createServer(this);
      return server.listen.apply(server, arguments);
    }, "listen");
    function logerror(err) {
      if (this.get("env") !== "test")
        console.error(err.stack || err.toString());
    }
    __name(logerror, "logerror");
    function tryRender(view, options29, callback) {
      try {
        view.render(options29, callback);
      } catch (err) {
        callback(err);
      }
    }
    __name(tryRender, "tryRender");
  }
});

// ../../node_modules/.pnpm/negotiator@0.6.3/node_modules/negotiator/lib/charset.js
var require_charset = __commonJS({
  "../../node_modules/.pnpm/negotiator@0.6.3/node_modules/negotiator/lib/charset.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = preferredCharsets;
    module3.exports.preferredCharsets = preferredCharsets;
    var simpleCharsetRegExp = /^\s*([^\s;]+)\s*(?:;(.*))?$/;
    function parseAcceptCharset(accept) {
      var accepts = accept.split(",");
      for (var i = 0, j2 = 0; i < accepts.length; i++) {
        var charset = parseCharset(accepts[i].trim(), i);
        if (charset) {
          accepts[j2++] = charset;
        }
      }
      accepts.length = j2;
      return accepts;
    }
    __name(parseAcceptCharset, "parseAcceptCharset");
    function parseCharset(str, i) {
      var match = simpleCharsetRegExp.exec(str);
      if (!match)
        return null;
      var charset = match[1];
      var q2 = 1;
      if (match[2]) {
        var params = match[2].split(";");
        for (var j2 = 0; j2 < params.length; j2++) {
          var p2 = params[j2].trim().split("=");
          if (p2[0] === "q") {
            q2 = parseFloat(p2[1]);
            break;
          }
        }
      }
      return {
        charset,
        q: q2,
        i
      };
    }
    __name(parseCharset, "parseCharset");
    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;
    }
    __name(getCharsetPriority, "getCharsetPriority");
    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
      };
    }
    __name(specify, "specify");
    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(/* @__PURE__ */ __name(function getPriority(type, index) {
        return getCharsetPriority(type, accepts, index);
      }, "getPriority"));
      return priorities.filter(isQuality).sort(compareSpecs).map(/* @__PURE__ */ __name(function getCharset(priority) {
        return provided[priorities.indexOf(priority)];
      }, "getCharset"));
    }
    __name(preferredCharsets, "preferredCharsets");
    function compareSpecs(a, b2) {
      return b2.q - a.q || b2.s - a.s || a.o - b2.o || a.i - b2.i || 0;
    }
    __name(compareSpecs, "compareSpecs");
    function getFullCharset(spec) {
      return spec.charset;
    }
    __name(getFullCharset, "getFullCharset");
    function isQuality(spec) {
      return spec.q > 0;
    }
    __name(isQuality, "isQuality");
  }
});

// ../../node_modules/.pnpm/negotiator@0.6.3/node_modules/negotiator/lib/encoding.js
var require_encoding2 = __commonJS({
  "../../node_modules/.pnpm/negotiator@0.6.3/node_modules/negotiator/lib/encoding.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = preferredEncodings;
    module3.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, j2 = 0; i < accepts.length; i++) {
        var encoding = parseEncoding(accepts[i].trim(), i);
        if (encoding) {
          accepts[j2++] = encoding;
          hasIdentity = hasIdentity || specify("identity", encoding);
          minQuality = Math.min(minQuality, encoding.q || 1);
        }
      }
      if (!hasIdentity) {
        accepts[j2++] = {
          encoding: "identity",
          q: minQuality,
          i
        };
      }
      accepts.length = j2;
      return accepts;
    }
    __name(parseAcceptEncoding, "parseAcceptEncoding");
    function parseEncoding(str, i) {
      var match = simpleEncodingRegExp.exec(str);
      if (!match)
        return null;
      var encoding = match[1];
      var q2 = 1;
      if (match[2]) {
        var params = match[2].split(";");
        for (var j2 = 0; j2 < params.length; j2++) {
          var p2 = params[j2].trim().split("=");
          if (p2[0] === "q") {
            q2 = parseFloat(p2[1]);
            break;
          }
        }
      }
      return {
        encoding,
        q: q2,
        i
      };
    }
    __name(parseEncoding, "parseEncoding");
    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;
    }
    __name(getEncodingPriority, "getEncodingPriority");
    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
      };
    }
    __name(specify, "specify");
    function preferredEncodings(accept, provided) {
      var accepts = parseAcceptEncoding(accept || "");
      if (!provided) {
        return accepts.filter(isQuality).sort(compareSpecs).map(getFullEncoding);
      }
      var priorities = provided.map(/* @__PURE__ */ __name(function getPriority(type, index) {
        return getEncodingPriority(type, accepts, index);
      }, "getPriority"));
      return priorities.filter(isQuality).sort(compareSpecs).map(/* @__PURE__ */ __name(function getEncoding(priority) {
        return provided[priorities.indexOf(priority)];
      }, "getEncoding"));
    }
    __name(preferredEncodings, "preferredEncodings");
    function compareSpecs(a, b2) {
      return b2.q - a.q || b2.s - a.s || a.o - b2.o || a.i - b2.i || 0;
    }
    __name(compareSpecs, "compareSpecs");
    function getFullEncoding(spec) {
      return spec.encoding;
    }
    __name(getFullEncoding, "getFullEncoding");
    function isQuality(spec) {
      return spec.q > 0;
    }
    __name(isQuality, "isQuality");
  }
});

// ../../node_modules/.pnpm/negotiator@0.6.3/node_modules/negotiator/lib/language.js
var require_language = __commonJS({
  "../../node_modules/.pnpm/negotiator@0.6.3/node_modules/negotiator/lib/language.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = preferredLanguages;
    module3.exports.preferredLanguages = preferredLanguages;
    var simpleLanguageRegExp = /^\s*([^\s\-;]+)(?:-([^\s;]+))?\s*(?:;(.*))?$/;
    function parseAcceptLanguage(accept) {
      var accepts = accept.split(",");
      for (var i = 0, j2 = 0; i < accepts.length; i++) {
        var language = parseLanguage(accepts[i].trim(), i);
        if (language) {
          accepts[j2++] = language;
        }
      }
      accepts.length = j2;
      return accepts;
    }
    __name(parseAcceptLanguage, "parseAcceptLanguage");
    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 q2 = 1;
      if (match[3]) {
        var params = match[3].split(";");
        for (var j2 = 0; j2 < params.length; j2++) {
          var p2 = params[j2].split("=");
          if (p2[0] === "q")
            q2 = parseFloat(p2[1]);
        }
      }
      return {
        prefix,
        suffix,
        q: q2,
        i,
        full
      };
    }
    __name(parseLanguage, "parseLanguage");
    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;
    }
    __name(getLanguagePriority, "getLanguagePriority");
    function specify(language, spec, index) {
      var p2 = parseLanguage(language);
      if (!p2)
        return null;
      var s = 0;
      if (spec.full.toLowerCase() === p2.full.toLowerCase()) {
        s |= 4;
      } else if (spec.prefix.toLowerCase() === p2.full.toLowerCase()) {
        s |= 2;
      } else if (spec.full.toLowerCase() === p2.prefix.toLowerCase()) {
        s |= 1;
      } else if (spec.full !== "*") {
        return null;
      }
      return {
        i: index,
        o: spec.i,
        q: spec.q,
        s
      };
    }
    __name(specify, "specify");
    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(/* @__PURE__ */ __name(function getPriority(type, index) {
        return getLanguagePriority(type, accepts, index);
      }, "getPriority"));
      return priorities.filter(isQuality).sort(compareSpecs).map(/* @__PURE__ */ __name(function getLanguage(priority) {
        return provided[priorities.indexOf(priority)];
      }, "getLanguage"));
    }
    __name(preferredLanguages, "preferredLanguages");
    function compareSpecs(a, b2) {
      return b2.q - a.q || b2.s - a.s || a.o - b2.o || a.i - b2.i || 0;
    }
    __name(compareSpecs, "compareSpecs");
    function getFullLanguage(spec) {
      return spec.full;
    }
    __name(getFullLanguage, "getFullLanguage");
    function isQuality(spec) {
      return spec.q > 0;
    }
    __name(isQuality, "isQuality");
  }
});

// ../../node_modules/.pnpm/negotiator@0.6.3/node_modules/negotiator/lib/mediaType.js
var require_mediaType = __commonJS({
  "../../node_modules/.pnpm/negotiator@0.6.3/node_modules/negotiator/lib/mediaType.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = preferredMediaTypes;
    module3.exports.preferredMediaTypes = preferredMediaTypes;
    var simpleMediaTypeRegExp = /^\s*([^\s\/;]+)\/([^;\s]+)\s*(?:;(.*))?$/;
    function parseAccept(accept) {
      var accepts = splitMediaTypes(accept);
      for (var i = 0, j2 = 0; i < accepts.length; i++) {
        var mediaType = parseMediaType(accepts[i].trim(), i);
        if (mediaType) {
          accepts[j2++] = mediaType;
        }
      }
      accepts.length = j2;
      return accepts;
    }
    __name(parseAccept, "parseAccept");
    function parseMediaType(str, i) {
      var match = simpleMediaTypeRegExp.exec(str);
      if (!match)
        return null;
      var params = /* @__PURE__ */ Object.create(null);
      var q2 = 1;
      var subtype = match[2];
      var type = match[1];
      if (match[3]) {
        var kvps = splitParameters(match[3]).map(splitKeyValuePair);
        for (var j2 = 0; j2 < kvps.length; j2++) {
          var pair = kvps[j2];
          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") {
            q2 = parseFloat(value);
            break;
          }
          params[key] = value;
        }
      }
      return {
        type,
        subtype,
        params,
        q: q2,
        i
      };
    }
    __name(parseMediaType, "parseMediaType");
    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;
    }
    __name(getMediaTypePriority, "getMediaTypePriority");
    function specify(type, spec, index) {
      var p2 = parseMediaType(type);
      var s = 0;
      if (!p2) {
        return null;
      }
      if (spec.type.toLowerCase() == p2.type.toLowerCase()) {
        s |= 4;
      } else if (spec.type != "*") {
        return null;
      }
      if (spec.subtype.toLowerCase() == p2.subtype.toLowerCase()) {
        s |= 2;
      } else if (spec.subtype != "*") {
        return null;
      }
      var keys = Object.keys(spec.params);
      if (keys.length > 0) {
        if (keys.every(function(k2) {
          return spec.params[k2] == "*" || (spec.params[k2] || "").toLowerCase() == (p2.params[k2] || "").toLowerCase();
        })) {
          s |= 1;
        } else {
          return null;
        }
      }
      return {
        i: index,
        o: spec.i,
        q: spec.q,
        s
      };
    }
    __name(specify, "specify");
    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(/* @__PURE__ */ __name(function getPriority(type, index) {
        return getMediaTypePriority(type, accepts, index);
      }, "getPriority"));
      return priorities.filter(isQuality).sort(compareSpecs).map(/* @__PURE__ */ __name(function getType3(priority) {
        return provided[priorities.indexOf(priority)];
      }, "getType"));
    }
    __name(preferredMediaTypes, "preferredMediaTypes");
    function compareSpecs(a, b2) {
      return b2.q - a.q || b2.s - a.s || a.o - b2.o || a.i - b2.i || 0;
    }
    __name(compareSpecs, "compareSpecs");
    function getFullType(spec) {
      return spec.type + "/" + spec.subtype;
    }
    __name(getFullType, "getFullType");
    function isQuality(spec) {
      return spec.q > 0;
    }
    __name(isQuality, "isQuality");
    function quoteCount(string) {
      var count = 0;
      var index = 0;
      while ((index = string.indexOf('"', index)) !== -1) {
        count++;
        index++;
      }
      return count;
    }
    __name(quoteCount, "quoteCount");
    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];
    }
    __name(splitKeyValuePair, "splitKeyValuePair");
    function splitMediaTypes(accept) {
      var accepts = accept.split(",");
      for (var i = 1, j2 = 0; i < accepts.length; i++) {
        if (quoteCount(accepts[j2]) % 2 == 0) {
          accepts[++j2] = accepts[i];
        } else {
          accepts[j2] += "," + accepts[i];
        }
      }
      accepts.length = j2 + 1;
      return accepts;
    }
    __name(splitMediaTypes, "splitMediaTypes");
    function splitParameters(str) {
      var parameters = str.split(";");
      for (var i = 1, j2 = 0; i < parameters.length; i++) {
        if (quoteCount(parameters[j2]) % 2 == 0) {
          parameters[++j2] = parameters[i];
        } else {
          parameters[j2] += ";" + parameters[i];
        }
      }
      parameters.length = j2 + 1;
      for (var i = 0; i < parameters.length; i++) {
        parameters[i] = parameters[i].trim();
      }
      return parameters;
    }
    __name(splitParameters, "splitParameters");
  }
});

// ../../node_modules/.pnpm/negotiator@0.6.3/node_modules/negotiator/index.js
var require_negotiator = __commonJS({
  "../../node_modules/.pnpm/negotiator@0.6.3/node_modules/negotiator/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var preferredCharsets = require_charset();
    var preferredEncodings = require_encoding2();
    var preferredLanguages = require_language();
    var preferredMediaTypes = require_mediaType();
    module3.exports = Negotiator;
    module3.exports.Negotiator = Negotiator;
    function Negotiator(request3) {
      if (!(this instanceof Negotiator)) {
        return new Negotiator(request3);
      }
      this.request = request3;
    }
    __name(Negotiator, "Negotiator");
    Negotiator.prototype.charset = /* @__PURE__ */ __name(function charset(available) {
      var set = this.charsets(available);
      return set && set[0];
    }, "charset");
    Negotiator.prototype.charsets = /* @__PURE__ */ __name(function charsets(available) {
      return preferredCharsets(this.request.headers["accept-charset"], available);
    }, "charsets");
    Negotiator.prototype.encoding = /* @__PURE__ */ __name(function encoding(available) {
      var set = this.encodings(available);
      return set && set[0];
    }, "encoding");
    Negotiator.prototype.encodings = /* @__PURE__ */ __name(function encodings(available) {
      return preferredEncodings(this.request.headers["accept-encoding"], available);
    }, "encodings");
    Negotiator.prototype.language = /* @__PURE__ */ __name(function language(available) {
      var set = this.languages(available);
      return set && set[0];
    }, "language");
    Negotiator.prototype.languages = /* @__PURE__ */ __name(function languages(available) {
      return preferredLanguages(this.request.headers["accept-language"], available);
    }, "languages");
    Negotiator.prototype.mediaType = /* @__PURE__ */ __name(function mediaType(available) {
      var set = this.mediaTypes(available);
      return set && set[0];
    }, "mediaType");
    Negotiator.prototype.mediaTypes = /* @__PURE__ */ __name(function mediaTypes(available) {
      return preferredMediaTypes(this.request.headers.accept, available);
    }, "mediaTypes");
    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/.pnpm/accepts@1.3.8/node_modules/accepts/index.js
var require_accepts = __commonJS({
  "../../node_modules/.pnpm/accepts@1.3.8/node_modules/accepts/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var Negotiator = require_negotiator();
    var mime = require_mime_types();
    module3.exports = Accepts;
    function Accepts(req) {
      if (!(this instanceof Accepts)) {
        return new Accepts(req);
      }
      this.headers = req.headers;
      this.negotiator = new Negotiator(req);
    }
    __name(Accepts, "Accepts");
    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;
    }
    __name(extToMime, "extToMime");
    function validMime(type) {
      return typeof type === "string";
    }
    __name(validMime, "validMime");
  }
});

// ../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/request.js
var require_request3 = __commonJS({
  "../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/request.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var accepts = require_accepts();
    var deprecate = require_depd()("express");
    var isIP = require("net").isIP;
    var typeis = require_type_is();
    var http4 = require("http");
    var fresh = require_fresh();
    var parseRange = require_range_parser();
    var parse7 = require_parseurl();
    var proxyaddr = require_proxy_addr();
    var req = Object.create(http4.IncomingMessage.prototype);
    module3.exports = req;
    req.get = req.header = /* @__PURE__ */ __name(function header(name) {
      if (!name) {
        throw new TypeError("name argument is required to req.get");
      }
      if (typeof name !== "string") {
        throw new TypeError("name must be a string to req.get");
      }
      var lc = name.toLowerCase();
      switch (lc) {
        case "referer":
        case "referrer":
          return this.headers.referrer || this.headers.referer;
        default:
          return this.headers[lc];
      }
    }, "header");
    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.acceptsEncoding = deprecate.function(
      req.acceptsEncodings,
      "req.acceptsEncoding: Use acceptsEncodings instead"
    );
    req.acceptsCharsets = function() {
      var accept = accepts(this);
      return accept.charsets.apply(accept, arguments);
    };
    req.acceptsCharset = deprecate.function(
      req.acceptsCharsets,
      "req.acceptsCharset: Use acceptsCharsets instead"
    );
    req.acceptsLanguages = function() {
      var accept = accepts(this);
      return accept.languages.apply(accept, arguments);
    };
    req.acceptsLanguage = deprecate.function(
      req.acceptsLanguages,
      "req.acceptsLanguage: Use acceptsLanguages instead"
    );
    req.range = /* @__PURE__ */ __name(function range(size, options29) {
      var range2 = this.get("Range");
      if (!range2)
        return;
      return parseRange(size, range2, options29);
    }, "range");
    req.param = /* @__PURE__ */ __name(function param(name, defaultValue) {
      var params = this.params || {};
      var body = this.body || {};
      var query = this.query || {};
      var args = arguments.length === 1 ? "name" : "name, default";
      deprecate("req.param(" + args + "): Use req.params, req.body, or req.query instead");
      if (null != params[name] && params.hasOwnProperty(name))
        return params[name];
      if (null != body[name])
        return body[name];
      if (null != query[name])
        return query[name];
      return defaultValue;
    }, "param");
    req.is = /* @__PURE__ */ __name(function is2(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);
    }, "is");
    defineGetter(req, "protocol", /* @__PURE__ */ __name(function protocol() {
      var proto = this.connection.encrypted ? "https" : "http";
      var trust = this.app.get("trust proxy fn");
      if (!trust(this.connection.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();
    }, "protocol"));
    defineGetter(req, "secure", /* @__PURE__ */ __name(function secure() {
      return this.protocol === "https";
    }, "secure"));
    defineGetter(req, "ip", /* @__PURE__ */ __name(function ip2() {
      var trust = this.app.get("trust proxy fn");
      return proxyaddr(this, trust);
    }, "ip"));
    defineGetter(req, "ips", /* @__PURE__ */ __name(function ips() {
      var trust = this.app.get("trust proxy fn");
      var addrs = proxyaddr.all(this, trust);
      addrs.reverse().pop();
      return addrs;
    }, "ips"));
    defineGetter(req, "subdomains", /* @__PURE__ */ __name(function subdomains() {
      var hostname2 = this.hostname;
      if (!hostname2)
        return [];
      var offset = this.app.get("subdomain offset");
      var subdomains2 = !isIP(hostname2) ? hostname2.split(".").reverse() : [hostname2];
      return subdomains2.slice(offset);
    }, "subdomains"));
    defineGetter(req, "path", /* @__PURE__ */ __name(function path67() {
      return parse7(this).pathname;
    }, "path"));
    defineGetter(req, "hostname", /* @__PURE__ */ __name(function hostname2() {
      var trust = this.app.get("trust proxy fn");
      var host = this.get("X-Forwarded-Host");
      if (!host || !trust(this.connection.remoteAddress, 0)) {
        host = this.get("Host");
      } else if (host.indexOf(",") !== -1) {
        host = host.substring(0, host.indexOf(",")).trimRight();
      }
      if (!host)
        return;
      var offset = host[0] === "[" ? host.indexOf("]") + 1 : 0;
      var index = host.indexOf(":", offset);
      return index !== -1 ? host.substring(0, index) : host;
    }, "hostname"));
    defineGetter(req, "host", deprecate.function(/* @__PURE__ */ __name(function host() {
      return this.hostname;
    }, "host"), "req.host: Use req.hostname instead"));
    defineGetter(req, "fresh", function() {
      var method = this.method;
      var res = this.res;
      var status2 = res.statusCode;
      if ("GET" !== method && "HEAD" !== method)
        return false;
      if (status2 >= 200 && status2 < 300 || 304 === status2) {
        return fresh(this.headers, {
          "etag": res.get("ETag"),
          "last-modified": res.get("Last-Modified")
        });
      }
      return false;
    });
    defineGetter(req, "stale", /* @__PURE__ */ __name(function stale() {
      return !this.fresh;
    }, "stale"));
    defineGetter(req, "xhr", /* @__PURE__ */ __name(function xhr() {
      var val = this.get("X-Requested-With") || "";
      return val.toLowerCase() === "xmlhttprequest";
    }, "xhr"));
    function defineGetter(obj, name, getter) {
      Object.defineProperty(obj, name, {
        configurable: true,
        enumerable: true,
        get: getter
      });
    }
    __name(defineGetter, "defineGetter");
  }
});

// ../../node_modules/.pnpm/cookie-signature@1.0.6/node_modules/cookie-signature/index.js
var require_cookie_signature = __commonJS({
  "../../node_modules/.pnpm/cookie-signature@1.0.6/node_modules/cookie-signature/index.js"(exports2) {
    init_import_meta_url();
    var crypto5 = require("crypto");
    exports2.sign = function(val, secret3) {
      if ("string" != typeof val)
        throw new TypeError("Cookie value must be provided as a string.");
      if ("string" != typeof secret3)
        throw new TypeError("Secret string must be provided.");
      return val + "." + crypto5.createHmac("sha256", secret3).update(val).digest("base64").replace(/\=+$/, "");
    };
    exports2.unsign = function(val, secret3) {
      if ("string" != typeof val)
        throw new TypeError("Signed cookie string must be provided.");
      if ("string" != typeof secret3)
        throw new TypeError("Secret string must be provided.");
      var str = val.slice(0, val.lastIndexOf(".")), mac = exports2.sign(str, secret3);
      return sha1(mac) == sha1(val) ? str : false;
    };
    function sha1(str) {
      return crypto5.createHash("sha1").update(str).digest("hex");
    }
    __name(sha1, "sha1");
  }
});

// ../../node_modules/.pnpm/cookie@0.5.0/node_modules/cookie/index.js
var require_cookie = __commonJS({
  "../../node_modules/.pnpm/cookie@0.5.0/node_modules/cookie/index.js"(exports2) {
    "use strict";
    init_import_meta_url();
    exports2.parse = parse7;
    exports2.serialize = serialize;
    var __toString = Object.prototype.toString;
    var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
    function parse7(str, options29) {
      if (typeof str !== "string") {
        throw new TypeError("argument str must be a string");
      }
      var obj = {};
      var opt = options29 || {};
      var dec = opt.decode || decode;
      var index = 0;
      while (index < str.length) {
        var eqIdx = str.indexOf("=", index);
        if (eqIdx === -1) {
          break;
        }
        var endIdx = str.indexOf(";", index);
        if (endIdx === -1) {
          endIdx = str.length;
        } else if (endIdx < eqIdx) {
          index = str.lastIndexOf(";", eqIdx - 1) + 1;
          continue;
        }
        var key = str.slice(index, eqIdx).trim();
        if (void 0 === obj[key]) {
          var val = str.slice(eqIdx + 1, endIdx).trim();
          if (val.charCodeAt(0) === 34) {
            val = val.slice(1, -1);
          }
          obj[key] = tryDecode(val, dec);
        }
        index = endIdx + 1;
      }
      return obj;
    }
    __name(parse7, "parse");
    function serialize(name, val, options29) {
      var opt = options29 || {};
      var enc = opt.encode || encode;
      if (typeof enc !== "function") {
        throw new TypeError("option encode is invalid");
      }
      if (!fieldContentRegExp.test(name)) {
        throw new TypeError("argument name is invalid");
      }
      var value = enc(val);
      if (value && !fieldContentRegExp.test(value)) {
        throw new TypeError("argument val is invalid");
      }
      var str = name + "=" + value;
      if (null != opt.maxAge) {
        var maxAge = opt.maxAge - 0;
        if (isNaN(maxAge) || !isFinite(maxAge)) {
          throw new TypeError("option maxAge is invalid");
        }
        str += "; Max-Age=" + Math.floor(maxAge);
      }
      if (opt.domain) {
        if (!fieldContentRegExp.test(opt.domain)) {
          throw new TypeError("option domain is invalid");
        }
        str += "; Domain=" + opt.domain;
      }
      if (opt.path) {
        if (!fieldContentRegExp.test(opt.path)) {
          throw new TypeError("option path is invalid");
        }
        str += "; Path=" + opt.path;
      }
      if (opt.expires) {
        var expires = opt.expires;
        if (!isDate(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.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;
    }
    __name(serialize, "serialize");
    function decode(str) {
      return str.indexOf("%") !== -1 ? decodeURIComponent(str) : str;
    }
    __name(decode, "decode");
    function encode(val) {
      return encodeURIComponent(val);
    }
    __name(encode, "encode");
    function isDate(val) {
      return __toString.call(val) === "[object Date]" || val instanceof Date;
    }
    __name(isDate, "isDate");
    function tryDecode(str, decode2) {
      try {
        return decode2(str);
      } catch (e3) {
        return str;
      }
    }
    __name(tryDecode, "tryDecode");
  }
});

// ../../node_modules/.pnpm/vary@1.1.2/node_modules/vary/index.js
var require_vary = __commonJS({
  "../../node_modules/.pnpm/vary@1.1.2/node_modules/vary/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = vary;
    module3.exports.append = append;
    var FIELD_NAME_REGEXP = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
    function append(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) ? parse7(String(field)) : field;
      for (var j2 = 0; j2 < fields.length; j2++) {
        if (!FIELD_NAME_REGEXP.test(fields[j2])) {
          throw new TypeError("field argument contains an invalid header name");
        }
      }
      if (header === "*") {
        return header;
      }
      var val = header;
      var vals = parse7(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;
    }
    __name(append, "append");
    function parse7(header) {
      var end = 0;
      var list = [];
      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:
            list.push(header.substring(start, end));
            start = end = i + 1;
            break;
          default:
            end = i + 1;
            break;
        }
      }
      list.push(header.substring(start, end));
      return list;
    }
    __name(parse7, "parse");
    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 = append(header, field)) {
        res.setHeader("Vary", val);
      }
    }
    __name(vary, "vary");
  }
});

// ../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/response.js
var require_response2 = __commonJS({
  "../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/response.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var Buffer3 = require_safe_buffer().Buffer;
    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("http");
    var isAbsolute = require_utils4().isAbsolute;
    var onFinished = require_on_finished();
    var path67 = require("path");
    var statuses = require_statuses();
    var merge = require_utils_merge();
    var sign = require_cookie_signature().sign;
    var normalizeType = require_utils4().normalizeType;
    var normalizeTypes = require_utils4().normalizeTypes;
    var setCharset = require_utils4().setCharset;
    var cookie = require_cookie();
    var send = require_send();
    var extname4 = path67.extname;
    var mime = send.mime;
    var resolve19 = path67.resolve;
    var vary = require_vary();
    var res = Object.create(http4.ServerResponse.prototype);
    module3.exports = res;
    var charsetRegExp = /;\s*charset\s*=/;
    res.status = /* @__PURE__ */ __name(function status2(code) {
      if ((typeof code === "string" || Math.floor(code) !== code) && code > 99 && code < 1e3) {
        deprecate("res.status(" + JSON.stringify(code) + "): use res.status(" + Math.floor(code) + ") instead");
      }
      this.statusCode = code;
      return this;
    }, "status");
    res.links = function(links) {
      var link = this.get("Link") || "";
      if (link)
        link += ", ";
      return this.set("Link", link + Object.keys(links).map(function(rel) {
        return "<" + links[rel] + '>; rel="' + rel + '"';
      }).join(", "));
    };
    res.send = /* @__PURE__ */ __name(function send2(body) {
      var chunk = body;
      var encoding;
      var req = this.req;
      var type;
      var app = this.app;
      if (arguments.length === 2) {
        if (typeof arguments[0] !== "number" && typeof arguments[1] === "number") {
          deprecate("res.send(body, status): Use res.status(status).send(body) instead");
          this.statusCode = arguments[1];
        } else {
          deprecate("res.send(status, body): Use res.status(status).send(body) instead");
          this.statusCode = arguments[0];
          chunk = arguments[1];
        }
      }
      if (typeof chunk === "number" && arguments.length === 1) {
        if (!this.get("Content-Type")) {
          this.type("txt");
        }
        deprecate("res.send(status): Use res.sendStatus(status) instead");
        this.statusCode = chunk;
        chunk = statuses.message[chunk];
      }
      switch (typeof chunk) {
        case "string":
          if (!this.get("Content-Type")) {
            this.type("html");
          }
          break;
        case "boolean":
        case "number":
        case "object":
          if (chunk === null) {
            chunk = "";
          } else if (Buffer3.isBuffer(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 = app.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.statusCode = 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;
    }, "send");
    res.json = /* @__PURE__ */ __name(function json(obj) {
      var val = obj;
      if (arguments.length === 2) {
        if (typeof arguments[1] === "number") {
          deprecate("res.json(obj, status): Use res.status(status).json(obj) instead");
          this.statusCode = arguments[1];
        } else {
          deprecate("res.json(status, obj): Use res.status(status).json(obj) instead");
          this.statusCode = arguments[0];
          val = arguments[1];
        }
      }
      var app = this.app;
      var escape2 = app.get("json escape");
      var replacer2 = app.get("json replacer");
      var spaces = app.get("json spaces");
      var body = stringify(val, replacer2, spaces, escape2);
      if (!this.get("Content-Type")) {
        this.set("Content-Type", "application/json");
      }
      return this.send(body);
    }, "json");
    res.jsonp = /* @__PURE__ */ __name(function jsonp(obj) {
      var val = obj;
      if (arguments.length === 2) {
        if (typeof arguments[1] === "number") {
          deprecate("res.jsonp(obj, status): Use res.status(status).jsonp(obj) instead");
          this.statusCode = arguments[1];
        } else {
          deprecate("res.jsonp(status, obj): Use res.status(status).jsonp(obj) instead");
          this.statusCode = arguments[0];
          val = arguments[1];
        }
      }
      var app = this.app;
      var escape2 = app.get("json escape");
      var replacer2 = app.get("json replacer");
      var spaces = app.get("json spaces");
      var body = stringify(val, replacer2, spaces, escape2);
      var callback = this.req.query[app.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);
    }, "jsonp");
    res.sendStatus = /* @__PURE__ */ __name(function sendStatus(statusCode) {
      var body = statuses.message[statusCode] || String(statusCode);
      this.statusCode = statusCode;
      this.type("txt");
      return this.send(body);
    }, "sendStatus");
    res.sendFile = /* @__PURE__ */ __name(function sendFile(path68, options29, callback) {
      var done = callback;
      var req = this.req;
      var res2 = this;
      var next = req.next;
      var opts = options29 || {};
      if (!path68) {
        throw new TypeError("path argument is required to res.sendFile");
      }
      if (typeof path68 !== "string") {
        throw new TypeError("path must be a string to res.sendFile");
      }
      if (typeof options29 === "function") {
        done = options29;
        opts = {};
      }
      if (!opts.root && !isAbsolute(path68)) {
        throw new TypeError("path must be absolute or specify root to res.sendFile");
      }
      var pathname = encodeURI(path68);
      var file = send(req, pathname, opts);
      sendfile(res2, file, 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);
        }
      });
    }, "sendFile");
    res.sendfile = function(path68, options29, callback) {
      var done = callback;
      var req = this.req;
      var res2 = this;
      var next = req.next;
      var opts = options29 || {};
      if (typeof options29 === "function") {
        done = options29;
        opts = {};
      }
      var file = send(req, path68, opts);
      sendfile(res2, file, 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.sendfile = deprecate.function(
      res.sendfile,
      "res.sendfile: Use res.sendFile instead"
    );
    res.download = /* @__PURE__ */ __name(function download(path68, filename, options29, callback) {
      var done = callback;
      var name = filename;
      var opts = options29 || null;
      if (typeof filename === "function") {
        done = filename;
        name = null;
        opts = null;
      } else if (typeof options29 === "function") {
        done = options29;
        opts = null;
      }
      if (typeof filename === "object" && (typeof options29 === "function" || options29 === void 0)) {
        name = null;
        opts = filename;
      }
      var headers = {
        "Content-Disposition": contentDisposition(name || path68)
      };
      if (opts && opts.headers) {
        var keys = Object.keys(opts.headers);
        for (var i = 0; i < keys.length; i++) {
          var key = keys[i];
          if (key.toLowerCase() !== "content-disposition") {
            headers[key] = opts.headers[key];
          }
        }
      }
      opts = Object.create(opts);
      opts.headers = headers;
      var fullPath = !opts.root ? resolve19(path68) : path68;
      return this.sendFile(fullPath, opts, done);
    }, "download");
    res.contentType = res.type = /* @__PURE__ */ __name(function contentType(type) {
      var ct = type.indexOf("/") === -1 ? mime.lookup(type) : type;
      return this.set("Content-Type", ct);
    }, "contentType");
    res.format = function(obj) {
      var req = this.req;
      var next = req.next;
      var keys = Object.keys(obj).filter(function(v2) {
        return v2 !== "default";
      });
      var key = keys.length > 0 ? req.accepts(keys) : 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(keys).map(function(o2) {
            return o2.value;
          })
        }));
      }
      return this;
    };
    res.attachment = /* @__PURE__ */ __name(function attachment(filename) {
      if (filename) {
        this.type(extname4(filename));
      }
      this.set("Content-Disposition", contentDisposition(filename));
      return this;
    }, "attachment");
    res.append = /* @__PURE__ */ __name(function append(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);
    }, "append");
    res.set = res.header = /* @__PURE__ */ __name(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");
          }
          if (!charsetRegExp.test(value)) {
            var charset = mime.charsets.lookup(value.split(";")[0]);
            if (charset)
              value += "; charset=" + charset.toLowerCase();
          }
        }
        this.setHeader(field, value);
      } else {
        for (var key in field) {
          this.set(key, field[key]);
        }
      }
      return this;
    }, "header");
    res.get = function(field) {
      return this.getHeader(field);
    };
    res.clearCookie = /* @__PURE__ */ __name(function clearCookie(name, options29) {
      var opts = merge({ expires: /* @__PURE__ */ new Date(1), path: "/" }, options29);
      return this.cookie(name, "", opts);
    }, "clearCookie");
    res.cookie = function(name, value, options29) {
      var opts = merge({}, options29);
      var secret3 = this.req.secret;
      var signed = opts.signed;
      if (signed && !secret3) {
        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, secret3);
      }
      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(name, String(val), opts));
      return this;
    };
    res.location = /* @__PURE__ */ __name(function location(url4) {
      var loc = url4;
      if (url4 === "back") {
        loc = this.req.get("Referrer") || "/";
      }
      return this.set("Location", encodeUrl(loc));
    }, "location");
    res.redirect = /* @__PURE__ */ __name(function redirect(url4) {
      var address = url4;
      var body;
      var status2 = 302;
      if (arguments.length === 2) {
        if (typeof arguments[0] === "number") {
          status2 = arguments[0];
          address = arguments[1];
        } else {
          deprecate("res.redirect(url, status): Use res.redirect(status, url) instead");
          status2 = arguments[1];
        }
      }
      address = this.location(address).get("Location");
      this.format({
        text: function() {
          body = statuses.message[status2] + ". Redirecting to " + address;
        },
        html: function() {
          var u = escapeHtml(address);
          body = "<p>" + statuses.message[status2] + '. Redirecting to <a href="' + u + '">' + u + "</a></p>";
        },
        default: function() {
          body = "";
        }
      });
      this.statusCode = status2;
      this.set("Content-Length", Buffer3.byteLength(body));
      if (this.req.method === "HEAD") {
        this.end();
      } else {
        this.end(body);
      }
    }, "redirect");
    res.vary = function(field) {
      if (!field || Array.isArray(field) && !field.length) {
        deprecate("res.vary(): Provide a field name");
        return this;
      }
      vary(this, field);
      return this;
    };
    res.render = /* @__PURE__ */ __name(function render7(view, options29, callback) {
      var app = this.req.app;
      var done = callback;
      var opts = options29 || {};
      var req = this.req;
      var self2 = this;
      if (typeof options29 === "function") {
        done = options29;
        opts = {};
      }
      opts._locals = self2.locals;
      done = done || function(err, str) {
        if (err)
          return req.next(err);
        self2.send(str);
      };
      app.render(view, opts, done);
    }, "render");
    function sendfile(res2, file, options29, callback) {
      var done = false;
      var streaming;
      function onaborted() {
        if (done)
          return;
        done = true;
        var err = new Error("Request aborted");
        err.code = "ECONNABORTED";
        callback(err);
      }
      __name(onaborted, "onaborted");
      function ondirectory() {
        if (done)
          return;
        done = true;
        var err = new Error("EISDIR, read");
        err.code = "EISDIR";
        callback(err);
      }
      __name(ondirectory, "ondirectory");
      function onerror(err) {
        if (done)
          return;
        done = true;
        callback(err);
      }
      __name(onerror, "onerror");
      function onend() {
        if (done)
          return;
        done = true;
        callback();
      }
      __name(onend, "onend");
      function onfile() {
        streaming = false;
      }
      __name(onfile, "onfile");
      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();
        });
      }
      __name(onfinish, "onfinish");
      function onstream() {
        streaming = true;
      }
      __name(onstream, "onstream");
      file.on("directory", ondirectory);
      file.on("end", onend);
      file.on("error", onerror);
      file.on("file", onfile);
      file.on("stream", onstream);
      onFinished(res2, onfinish);
      if (options29.headers) {
        file.on("headers", /* @__PURE__ */ __name(function headers(res3) {
          var obj = options29.headers;
          var keys = Object.keys(obj);
          for (var i = 0; i < keys.length; i++) {
            var k2 = keys[i];
            res3.setHeader(k2, obj[k2]);
          }
        }, "headers"));
      }
      file.pipe(res2);
    }
    __name(sendfile, "sendfile");
    function stringify(value, replacer2, spaces, escape2) {
      var json = replacer2 || spaces ? JSON.stringify(value, replacer2, spaces) : JSON.stringify(value);
      if (escape2 && typeof json === "string") {
        json = json.replace(/[<>&]/g, function(c2) {
          switch (c2.charCodeAt(0)) {
            case 60:
              return "\\u003c";
            case 62:
              return "\\u003e";
            case 38:
              return "\\u0026";
            default:
              return c2;
          }
        });
      }
      return json;
    }
    __name(stringify, "stringify");
  }
});

// ../../node_modules/.pnpm/serve-static@1.15.0_supports-color@9.2.2/node_modules/serve-static/index.js
var require_serve_static = __commonJS({
  "../../node_modules/.pnpm/serve-static@1.15.0_supports-color@9.2.2/node_modules/serve-static/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var encodeUrl = require_encodeurl();
    var escapeHtml = require_escape_html();
    var parseUrl2 = require_parseurl();
    var resolve19 = require("path").resolve;
    var send = require_send();
    var url4 = require("url");
    module3.exports = serveStatic2;
    module3.exports.mime = send.mime;
    function serveStatic2(root, options29) {
      if (!root) {
        throw new TypeError("root path required");
      }
      if (typeof root !== "string") {
        throw new TypeError("root path must be a string");
      }
      var opts = Object.create(options29 || 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 = resolve19(root);
      var onDirectory = redirect ? createRedirectDirectoryListener() : createNotFoundDirectoryListener();
      return /* @__PURE__ */ __name(function serveStatic3(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 path67 = parseUrl2(req).pathname;
        if (path67 === "/" && originalUrl.pathname.substr(-1) !== "/") {
          path67 = "";
        }
        var stream2 = send(req, path67, opts);
        stream2.on("directory", onDirectory);
        if (setHeaders) {
          stream2.on("headers", setHeaders);
        }
        if (fallthrough) {
          stream2.on("file", /* @__PURE__ */ __name(function onFile() {
            forwardError = true;
          }, "onFile"));
        }
        stream2.on("error", /* @__PURE__ */ __name(function error2(err) {
          if (forwardError || !(err.statusCode < 500)) {
            next(err);
            return;
          }
          next();
        }, "error"));
        stream2.pipe(res);
      }, "serveStatic");
    }
    __name(serveStatic2, "serveStatic");
    function collapseLeadingSlashes(str) {
      for (var i = 0; i < str.length; i++) {
        if (str.charCodeAt(i) !== 47) {
          break;
        }
      }
      return i > 1 ? "/" + str.substr(i) : str;
    }
    __name(collapseLeadingSlashes, "collapseLeadingSlashes");
    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";
    }
    __name(createHtmlDocument, "createHtmlDocument");
    function createNotFoundDirectoryListener() {
      return /* @__PURE__ */ __name(function notFound() {
        this.error(404);
      }, "notFound");
    }
    __name(createNotFoundDirectoryListener, "createNotFoundDirectoryListener");
    function createRedirectDirectoryListener() {
      return /* @__PURE__ */ __name(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 <a href="' + escapeHtml(loc) + '">' + escapeHtml(loc) + "</a>");
        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);
      }, "redirect");
    }
    __name(createRedirectDirectoryListener, "createRedirectDirectoryListener");
  }
});

// ../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/express.js
var require_express = __commonJS({
  "../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/lib/express.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var bodyParser2 = require_body_parser();
    var EventEmitter7 = require("events").EventEmitter;
    var mixin3 = require_merge_descriptors();
    var proto = require_application();
    var Route = require_route3();
    var Router = require_router();
    var req = require_request3();
    var res = require_response2();
    exports2 = module3.exports = createApplication;
    function createApplication() {
      var app = /* @__PURE__ */ __name(function(req2, res2, next) {
        app.handle(req2, res2, next);
      }, "app");
      mixin3(app, EventEmitter7.prototype, false);
      mixin3(app, proto, false);
      app.request = Object.create(req, {
        app: { configurable: true, enumerable: true, writable: true, value: app }
      });
      app.response = Object.create(res, {
        app: { configurable: true, enumerable: true, writable: true, value: app }
      });
      app.init();
      return app;
    }
    __name(createApplication, "createApplication");
    exports2.application = proto;
    exports2.request = req;
    exports2.response = res;
    exports2.Route = Route;
    exports2.Router = Router;
    exports2.json = bodyParser2.json;
    exports2.query = require_query();
    exports2.raw = bodyParser2.raw;
    exports2.static = require_serve_static();
    exports2.text = bodyParser2.text;
    exports2.urlencoded = bodyParser2.urlencoded;
    var removedMiddlewares = [
      "bodyParser",
      "compress",
      "cookieSession",
      "session",
      "logger",
      "cookieParser",
      "favicon",
      "responseTime",
      "errorHandler",
      "timeout",
      "methodOverride",
      "vhost",
      "csrf",
      "directory",
      "limit",
      "multipart",
      "staticCache"
    ];
    removedMiddlewares.forEach(function(name) {
      Object.defineProperty(exports2, name, {
        get: function() {
          throw new Error("Most middleware (like " + name + ") is no longer bundled with Express and must be installed separately. Please see https://github.com/senchalabs/connect#middleware.");
        },
        configurable: true
      });
    });
  }
});

// ../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/index.js
var require_express2 = __commonJS({
  "../../node_modules/.pnpm/express@4.18.1_supports-color@9.2.2/node_modules/express/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = require_express();
  }
});

// ../../node_modules/.pnpm/p-finally@1.0.0/node_modules/p-finally/index.js
var require_p_finally = __commonJS({
  "../../node_modules/.pnpm/p-finally@1.0.0/node_modules/p-finally/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = (promise, onFinally) => {
      onFinally = onFinally || (() => {
      });
      return promise.then(
        (val) => new Promise((resolve19) => {
          resolve19(onFinally());
        }).then(() => val),
        (err) => new Promise((resolve19) => {
          resolve19(onFinally());
        }).then(() => {
          throw err;
        })
      );
    };
  }
});

// ../../node_modules/.pnpm/p-timeout@3.2.0/node_modules/p-timeout/index.js
var require_p_timeout = __commonJS({
  "../../node_modules/.pnpm/p-timeout@3.2.0/node_modules/p-timeout/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var pFinally = require_p_finally();
    var TimeoutError2 = class extends Error {
      constructor(message) {
        super(message);
        this.name = "TimeoutError";
      }
    };
    __name(TimeoutError2, "TimeoutError");
    var pTimeout2 = /* @__PURE__ */ __name((promise, milliseconds, fallback) => new Promise((resolve19, reject) => {
      if (typeof milliseconds !== "number" || milliseconds < 0) {
        throw new TypeError("Expected `milliseconds` to be a positive number");
      }
      if (milliseconds === Infinity) {
        resolve19(promise);
        return;
      }
      const timer = setTimeout(() => {
        if (typeof fallback === "function") {
          try {
            resolve19(fallback());
          } catch (error2) {
            reject(error2);
          }
          return;
        }
        const message = typeof fallback === "string" ? fallback : `Promise timed out after ${milliseconds} milliseconds`;
        const timeoutError2 = fallback instanceof Error ? fallback : new TimeoutError2(message);
        if (typeof promise.cancel === "function") {
          promise.cancel();
        }
        reject(timeoutError2);
      }, milliseconds);
      pFinally(
        // eslint-disable-next-line promise/prefer-await-to-then
        promise.then(resolve19, reject),
        () => {
          clearTimeout(timer);
        }
      );
    }), "pTimeout");
    module3.exports = pTimeout2;
    module3.exports.default = pTimeout2;
    module3.exports.TimeoutError = TimeoutError2;
  }
});

// ../../node_modules/.pnpm/p-wait-for@3.2.0/node_modules/p-wait-for/index.js
var require_p_wait_for = __commonJS({
  "../../node_modules/.pnpm/p-wait-for@3.2.0/node_modules/p-wait-for/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var pTimeout2 = require_p_timeout();
    var pWaitFor = /* @__PURE__ */ __name(async (condition, options29) => {
      options29 = {
        interval: 20,
        timeout: Infinity,
        leadingCheck: true,
        ...options29
      };
      let retryTimeout;
      const promise = new Promise((resolve19, reject) => {
        const check = /* @__PURE__ */ __name(async () => {
          try {
            const value = await condition();
            if (typeof value !== "boolean") {
              throw new TypeError("Expected condition to return a boolean");
            }
            if (value === true) {
              resolve19();
            } else {
              retryTimeout = setTimeout(check, options29.interval);
            }
          } catch (error2) {
            reject(error2);
          }
        }, "check");
        if (options29.leadingCheck) {
          check();
        } else {
          retryTimeout = setTimeout(check, options29.interval);
        }
      });
      if (options29.timeout !== Infinity) {
        try {
          return await pTimeout2(promise, options29.timeout);
        } catch (error2) {
          if (retryTimeout) {
            clearTimeout(retryTimeout);
          }
          throw error2;
        }
      }
      return promise;
    }, "pWaitFor");
    module3.exports = pWaitFor;
    module3.exports.default = pWaitFor;
  }
});

// ../../node_modules/.pnpm/boolean@3.2.0/node_modules/boolean/build/lib/boolean.js
var require_boolean = __commonJS({
  "../../node_modules/.pnpm/boolean@3.2.0/node_modules/boolean/build/lib/boolean.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.boolean = void 0;
    var boolean = /* @__PURE__ */ __name(function(value) {
      switch (Object.prototype.toString.call(value)) {
        case "[object String]":
          return ["true", "t", "yes", "y", "on", "1"].includes(value.trim().toLowerCase());
        case "[object Number]":
          return value.valueOf() === 1;
        case "[object Boolean]":
          return value.valueOf();
        default:
          return false;
      }
    }, "boolean");
    exports2.boolean = boolean;
  }
});

// ../../node_modules/.pnpm/boolean@3.2.0/node_modules/boolean/build/lib/isBooleanable.js
var require_isBooleanable = __commonJS({
  "../../node_modules/.pnpm/boolean@3.2.0/node_modules/boolean/build/lib/isBooleanable.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.isBooleanable = void 0;
    var isBooleanable = /* @__PURE__ */ __name(function(value) {
      switch (Object.prototype.toString.call(value)) {
        case "[object String]":
          return [
            "true",
            "t",
            "yes",
            "y",
            "on",
            "1",
            "false",
            "f",
            "no",
            "n",
            "off",
            "0"
          ].includes(value.trim().toLowerCase());
        case "[object Number]":
          return [0, 1].includes(value.valueOf());
        case "[object Boolean]":
          return true;
        default:
          return false;
      }
    }, "isBooleanable");
    exports2.isBooleanable = isBooleanable;
  }
});

// ../../node_modules/.pnpm/boolean@3.2.0/node_modules/boolean/build/lib/index.js
var require_lib4 = __commonJS({
  "../../node_modules/.pnpm/boolean@3.2.0/node_modules/boolean/build/lib/index.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.isBooleanable = exports2.boolean = void 0;
    var boolean_1 = require_boolean();
    Object.defineProperty(exports2, "boolean", { enumerable: true, get: function() {
      return boolean_1.boolean;
    } });
    var isBooleanable_1 = require_isBooleanable();
    Object.defineProperty(exports2, "isBooleanable", { enumerable: true, get: function() {
      return isBooleanable_1.isBooleanable;
    } });
  }
});

// ../../node_modules/.pnpm/uri-js@4.4.1/node_modules/uri-js/dist/es5/uri.all.js
var require_uri_all = __commonJS({
  "../../node_modules/.pnpm/uri-js@4.4.1/node_modules/uri-js/dist/es5/uri.all.js"(exports2, module3) {
    init_import_meta_url();
    (function(global2, factory) {
      typeof exports2 === "object" && typeof module3 !== "undefined" ? factory(exports2) : typeof define === "function" && define.amd ? define(["exports"], factory) : factory(global2.URI = global2.URI || {});
    })(exports2, function(exports3) {
      "use strict";
      function merge() {
        for (var _len = arguments.length, sets = Array(_len), _key = 0; _key < _len; _key++) {
          sets[_key] = arguments[_key];
        }
        if (sets.length > 1) {
          sets[0] = sets[0].slice(0, -1);
          var xl = sets.length - 1;
          for (var x2 = 1; x2 < xl; ++x2) {
            sets[x2] = sets[x2].slice(1, -1);
          }
          sets[xl] = sets[xl].slice(1);
          return sets.join("");
        } else {
          return sets[0];
        }
      }
      __name(merge, "merge");
      function subexp(str) {
        return "(?:" + str + ")";
      }
      __name(subexp, "subexp");
      function typeOf(o2) {
        return o2 === void 0 ? "undefined" : o2 === null ? "null" : Object.prototype.toString.call(o2).split(" ").pop().split("]").shift().toLowerCase();
      }
      __name(typeOf, "typeOf");
      function toUpperCase(str) {
        return str.toUpperCase();
      }
      __name(toUpperCase, "toUpperCase");
      function toArray(obj) {
        return obj !== void 0 && obj !== null ? obj instanceof Array ? obj : typeof obj.length !== "number" || obj.split || obj.setInterval || obj.call ? [obj] : Array.prototype.slice.call(obj) : [];
      }
      __name(toArray, "toArray");
      function assign(target, source) {
        var obj = target;
        if (source) {
          for (var key in source) {
            obj[key] = source[key];
          }
        }
        return obj;
      }
      __name(assign, "assign");
      function buildExps(isIRI2) {
        var ALPHA$$ = "[A-Za-z]", CR$ = "[\\x0D]", DIGIT$$ = "[0-9]", DQUOTE$$ = "[\\x22]", HEXDIG$$2 = merge(DIGIT$$, "[A-Fa-f]"), LF$$ = "[\\x0A]", SP$$ = "[\\x20]", PCT_ENCODED$2 = subexp(subexp("%[EFef]" + HEXDIG$$2 + "%" + HEXDIG$$2 + HEXDIG$$2 + "%" + HEXDIG$$2 + HEXDIG$$2) + "|" + subexp("%[89A-Fa-f]" + HEXDIG$$2 + "%" + HEXDIG$$2 + HEXDIG$$2) + "|" + subexp("%" + HEXDIG$$2 + HEXDIG$$2)), GEN_DELIMS$$ = "[\\:\\/\\?\\#\\[\\]\\@]", SUB_DELIMS$$ = "[\\!\\$\\&\\'\\(\\)\\*\\+\\,\\;\\=]", RESERVED$$ = merge(GEN_DELIMS$$, SUB_DELIMS$$), UCSCHAR$$ = isIRI2 ? "[\\xA0-\\u200D\\u2010-\\u2029\\u202F-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF]" : "[]", IPRIVATE$$ = isIRI2 ? "[\\uE000-\\uF8FF]" : "[]", UNRESERVED$$2 = merge(ALPHA$$, DIGIT$$, "[\\-\\.\\_\\~]", UCSCHAR$$), SCHEME$ = subexp(ALPHA$$ + merge(ALPHA$$, DIGIT$$, "[\\+\\-\\.]") + "*"), USERINFO$ = subexp(subexp(PCT_ENCODED$2 + "|" + merge(UNRESERVED$$2, SUB_DELIMS$$, "[\\:]")) + "*"), DEC_OCTET$ = subexp(subexp("25[0-5]") + "|" + subexp("2[0-4]" + DIGIT$$) + "|" + subexp("1" + DIGIT$$ + DIGIT$$) + "|" + subexp("[1-9]" + DIGIT$$) + "|" + DIGIT$$), DEC_OCTET_RELAXED$ = subexp(subexp("25[0-5]") + "|" + subexp("2[0-4]" + DIGIT$$) + "|" + subexp("1" + DIGIT$$ + DIGIT$$) + "|" + subexp("0?[1-9]" + DIGIT$$) + "|0?0?" + DIGIT$$), IPV4ADDRESS$ = subexp(DEC_OCTET_RELAXED$ + "\\." + DEC_OCTET_RELAXED$ + "\\." + DEC_OCTET_RELAXED$ + "\\." + DEC_OCTET_RELAXED$), H16$ = subexp(HEXDIG$$2 + "{1,4}"), LS32$ = subexp(subexp(H16$ + "\\:" + H16$) + "|" + IPV4ADDRESS$), IPV6ADDRESS1$ = subexp(subexp(H16$ + "\\:") + "{6}" + LS32$), IPV6ADDRESS2$ = subexp("\\:\\:" + subexp(H16$ + "\\:") + "{5}" + LS32$), IPV6ADDRESS3$ = subexp(subexp(H16$) + "?\\:\\:" + subexp(H16$ + "\\:") + "{4}" + LS32$), IPV6ADDRESS4$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,1}" + H16$) + "?\\:\\:" + subexp(H16$ + "\\:") + "{3}" + LS32$), IPV6ADDRESS5$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,2}" + H16$) + "?\\:\\:" + subexp(H16$ + "\\:") + "{2}" + LS32$), IPV6ADDRESS6$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,3}" + H16$) + "?\\:\\:" + H16$ + "\\:" + LS32$), IPV6ADDRESS7$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,4}" + H16$) + "?\\:\\:" + LS32$), IPV6ADDRESS8$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,5}" + H16$) + "?\\:\\:" + H16$), IPV6ADDRESS9$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,6}" + H16$) + "?\\:\\:"), IPV6ADDRESS$ = subexp([IPV6ADDRESS1$, IPV6ADDRESS2$, IPV6ADDRESS3$, IPV6ADDRESS4$, IPV6ADDRESS5$, IPV6ADDRESS6$, IPV6ADDRESS7$, IPV6ADDRESS8$, IPV6ADDRESS9$].join("|")), ZONEID$ = subexp(subexp(UNRESERVED$$2 + "|" + PCT_ENCODED$2) + "+"), IPV6ADDRZ$ = subexp(IPV6ADDRESS$ + "\\%25" + ZONEID$), IPV6ADDRZ_RELAXED$ = subexp(IPV6ADDRESS$ + subexp("\\%25|\\%(?!" + HEXDIG$$2 + "{2})") + ZONEID$), IPVFUTURE$ = subexp("[vV]" + HEXDIG$$2 + "+\\." + merge(UNRESERVED$$2, SUB_DELIMS$$, "[\\:]") + "+"), IP_LITERAL$ = subexp("\\[" + subexp(IPV6ADDRZ_RELAXED$ + "|" + IPV6ADDRESS$ + "|" + IPVFUTURE$) + "\\]"), REG_NAME$ = subexp(subexp(PCT_ENCODED$2 + "|" + merge(UNRESERVED$$2, SUB_DELIMS$$)) + "*"), HOST$ = subexp(IP_LITERAL$ + "|" + IPV4ADDRESS$ + "(?!" + REG_NAME$ + ")|" + REG_NAME$), PORT$ = subexp(DIGIT$$ + "*"), AUTHORITY$ = subexp(subexp(USERINFO$ + "@") + "?" + HOST$ + subexp("\\:" + PORT$) + "?"), PCHAR$ = subexp(PCT_ENCODED$2 + "|" + merge(UNRESERVED$$2, SUB_DELIMS$$, "[\\:\\@]")), SEGMENT$ = subexp(PCHAR$ + "*"), SEGMENT_NZ$ = subexp(PCHAR$ + "+"), SEGMENT_NZ_NC$ = subexp(subexp(PCT_ENCODED$2 + "|" + merge(UNRESERVED$$2, SUB_DELIMS$$, "[\\@]")) + "+"), PATH_ABEMPTY$ = subexp(subexp("\\/" + SEGMENT$) + "*"), PATH_ABSOLUTE$ = subexp("\\/" + subexp(SEGMENT_NZ$ + PATH_ABEMPTY$) + "?"), PATH_NOSCHEME$ = subexp(SEGMENT_NZ_NC$ + PATH_ABEMPTY$), PATH_ROOTLESS$ = subexp(SEGMENT_NZ$ + PATH_ABEMPTY$), PATH_EMPTY$ = "(?!" + PCHAR$ + ")", PATH$ = subexp(PATH_ABEMPTY$ + "|" + PATH_ABSOLUTE$ + "|" + PATH_NOSCHEME$ + "|" + PATH_ROOTLESS$ + "|" + PATH_EMPTY$), QUERY$ = subexp(subexp(PCHAR$ + "|" + merge("[\\/\\?]", IPRIVATE$$)) + "*"), FRAGMENT$ = subexp(subexp(PCHAR$ + "|[\\/\\?]") + "*"), HIER_PART$ = subexp(subexp("\\/\\/" + AUTHORITY$ + PATH_ABEMPTY$) + "|" + PATH_ABSOLUTE$ + "|" + PATH_ROOTLESS$ + "|" + PATH_EMPTY$), URI$ = subexp(SCHEME$ + "\\:" + HIER_PART$ + subexp("\\?" + QUERY$) + "?" + subexp("\\#" + FRAGMENT$) + "?"), RELATIVE_PART$ = subexp(subexp("\\/\\/" + AUTHORITY$ + PATH_ABEMPTY$) + "|" + PATH_ABSOLUTE$ + "|" + PATH_NOSCHEME$ + "|" + PATH_EMPTY$), RELATIVE$ = subexp(RELATIVE_PART$ + subexp("\\?" + QUERY$) + "?" + subexp("\\#" + FRAGMENT$) + "?"), URI_REFERENCE$ = subexp(URI$ + "|" + RELATIVE$), ABSOLUTE_URI$ = subexp(SCHEME$ + "\\:" + HIER_PART$ + subexp("\\?" + QUERY$) + "?"), GENERIC_REF$ = "^(" + SCHEME$ + ")\\:" + subexp(subexp("\\/\\/(" + subexp("(" + USERINFO$ + ")@") + "?(" + HOST$ + ")" + subexp("\\:(" + PORT$ + ")") + "?)") + "?(" + PATH_ABEMPTY$ + "|" + PATH_ABSOLUTE$ + "|" + PATH_ROOTLESS$ + "|" + PATH_EMPTY$ + ")") + subexp("\\?(" + QUERY$ + ")") + "?" + subexp("\\#(" + FRAGMENT$ + ")") + "?$", RELATIVE_REF$ = "^(){0}" + subexp(subexp("\\/\\/(" + subexp("(" + USERINFO$ + ")@") + "?(" + HOST$ + ")" + subexp("\\:(" + PORT$ + ")") + "?)") + "?(" + PATH_ABEMPTY$ + "|" + PATH_ABSOLUTE$ + "|" + PATH_NOSCHEME$ + "|" + PATH_EMPTY$ + ")") + subexp("\\?(" + QUERY$ + ")") + "?" + subexp("\\#(" + FRAGMENT$ + ")") + "?$", ABSOLUTE_REF$ = "^(" + SCHEME$ + ")\\:" + subexp(subexp("\\/\\/(" + subexp("(" + USERINFO$ + ")@") + "?(" + HOST$ + ")" + subexp("\\:(" + PORT$ + ")") + "?)") + "?(" + PATH_ABEMPTY$ + "|" + PATH_ABSOLUTE$ + "|" + PATH_ROOTLESS$ + "|" + PATH_EMPTY$ + ")") + subexp("\\?(" + QUERY$ + ")") + "?$", SAMEDOC_REF$ = "^" + subexp("\\#(" + FRAGMENT$ + ")") + "?$", AUTHORITY_REF$ = "^" + subexp("(" + USERINFO$ + ")@") + "?(" + HOST$ + ")" + subexp("\\:(" + PORT$ + ")") + "?$";
        return {
          NOT_SCHEME: new RegExp(merge("[^]", ALPHA$$, DIGIT$$, "[\\+\\-\\.]"), "g"),
          NOT_USERINFO: new RegExp(merge("[^\\%\\:]", UNRESERVED$$2, SUB_DELIMS$$), "g"),
          NOT_HOST: new RegExp(merge("[^\\%\\[\\]\\:]", UNRESERVED$$2, SUB_DELIMS$$), "g"),
          NOT_PATH: new RegExp(merge("[^\\%\\/\\:\\@]", UNRESERVED$$2, SUB_DELIMS$$), "g"),
          NOT_PATH_NOSCHEME: new RegExp(merge("[^\\%\\/\\@]", UNRESERVED$$2, SUB_DELIMS$$), "g"),
          NOT_QUERY: new RegExp(merge("[^\\%]", UNRESERVED$$2, SUB_DELIMS$$, "[\\:\\@\\/\\?]", IPRIVATE$$), "g"),
          NOT_FRAGMENT: new RegExp(merge("[^\\%]", UNRESERVED$$2, SUB_DELIMS$$, "[\\:\\@\\/\\?]"), "g"),
          ESCAPE: new RegExp(merge("[^]", UNRESERVED$$2, SUB_DELIMS$$), "g"),
          UNRESERVED: new RegExp(UNRESERVED$$2, "g"),
          OTHER_CHARS: new RegExp(merge("[^\\%]", UNRESERVED$$2, RESERVED$$), "g"),
          PCT_ENCODED: new RegExp(PCT_ENCODED$2, "g"),
          IPV4ADDRESS: new RegExp("^(" + IPV4ADDRESS$ + ")$"),
          IPV6ADDRESS: new RegExp("^\\[?(" + IPV6ADDRESS$ + ")" + subexp(subexp("\\%25|\\%(?!" + HEXDIG$$2 + "{2})") + "(" + ZONEID$ + ")") + "?\\]?$")
          //RFC 6874, with relaxed parsing rules
        };
      }
      __name(buildExps, "buildExps");
      var URI_PROTOCOL = buildExps(false);
      var IRI_PROTOCOL = buildExps(true);
      var slicedToArray = 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;
        }
        __name(sliceIterator, "sliceIterator");
        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");
          }
        };
      }();
      var toConsumableArray = /* @__PURE__ */ __name(function(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);
        }
      }, "toConsumableArray");
      var maxInt = 2147483647;
      var base = 36;
      var tMin = 1;
      var tMax = 26;
      var skew = 38;
      var damp = 700;
      var initialBias = 72;
      var initialN = 128;
      var delimiter = "-";
      var regexPunycode = /^xn--/;
      var regexNonASCII = /[^\0-\x7E]/;
      var regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g;
      var errors = {
        "overflow": "Overflow: input needs wider integers to process",
        "not-basic": "Illegal input >= 0x80 (not a basic code point)",
        "invalid-input": "Invalid input"
      };
      var baseMinusTMin = base - tMin;
      var floor = Math.floor;
      var stringFromCharCode = String.fromCharCode;
      function error$1(type) {
        throw new RangeError(errors[type]);
      }
      __name(error$1, "error$1");
      function map(array, fn2) {
        var result = [];
        var length = array.length;
        while (length--) {
          result[length] = fn2(array[length]);
        }
        return result;
      }
      __name(map, "map");
      function mapDomain(string, fn2) {
        var parts = string.split("@");
        var result = "";
        if (parts.length > 1) {
          result = parts[0] + "@";
          string = parts[1];
        }
        string = string.replace(regexSeparators, ".");
        var labels = string.split(".");
        var encoded = map(labels, fn2).join(".");
        return result + encoded;
      }
      __name(mapDomain, "mapDomain");
      function ucs2decode(string) {
        var output = [];
        var counter = 0;
        var length = string.length;
        while (counter < length) {
          var value = string.charCodeAt(counter++);
          if (value >= 55296 && value <= 56319 && counter < length) {
            var extra = string.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;
      }
      __name(ucs2decode, "ucs2decode");
      var ucs2encode = /* @__PURE__ */ __name(function ucs2encode2(array) {
        return String.fromCodePoint.apply(String, toConsumableArray(array));
      }, "ucs2encode");
      var basicToDigit = /* @__PURE__ */ __name(function basicToDigit2(codePoint) {
        if (codePoint - 48 < 10) {
          return codePoint - 22;
        }
        if (codePoint - 65 < 26) {
          return codePoint - 65;
        }
        if (codePoint - 97 < 26) {
          return codePoint - 97;
        }
        return base;
      }, "basicToDigit");
      var digitToBasic = /* @__PURE__ */ __name(function digitToBasic2(digit, flag) {
        return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
      }, "digitToBasic");
      var adapt = /* @__PURE__ */ __name(function adapt2(delta, numPoints, firstTime) {
        var k2 = 0;
        delta = firstTime ? floor(delta / damp) : delta >> 1;
        delta += floor(delta / numPoints);
        for (
          ;
          /* no initialization */
          delta > baseMinusTMin * tMax >> 1;
          k2 += base
        ) {
          delta = floor(delta / baseMinusTMin);
        }
        return floor(k2 + (baseMinusTMin + 1) * delta / (delta + skew));
      }, "adapt");
      var decode = /* @__PURE__ */ __name(function decode2(input) {
        var output = [];
        var inputLength = input.length;
        var i = 0;
        var n2 = initialN;
        var bias = initialBias;
        var basic = input.lastIndexOf(delimiter);
        if (basic < 0) {
          basic = 0;
        }
        for (var j2 = 0; j2 < basic; ++j2) {
          if (input.charCodeAt(j2) >= 128) {
            error$1("not-basic");
          }
          output.push(input.charCodeAt(j2));
        }
        for (var index = basic > 0 ? basic + 1 : 0; index < inputLength; ) {
          var oldi = i;
          for (
            var w2 = 1, k2 = base;
            ;
            /* no condition */
            k2 += base
          ) {
            if (index >= inputLength) {
              error$1("invalid-input");
            }
            var digit = basicToDigit(input.charCodeAt(index++));
            if (digit >= base || digit > floor((maxInt - i) / w2)) {
              error$1("overflow");
            }
            i += digit * w2;
            var t3 = k2 <= bias ? tMin : k2 >= bias + tMax ? tMax : k2 - bias;
            if (digit < t3) {
              break;
            }
            var baseMinusT = base - t3;
            if (w2 > floor(maxInt / baseMinusT)) {
              error$1("overflow");
            }
            w2 *= baseMinusT;
          }
          var out = output.length + 1;
          bias = adapt(i - oldi, out, oldi == 0);
          if (floor(i / out) > maxInt - n2) {
            error$1("overflow");
          }
          n2 += floor(i / out);
          i %= out;
          output.splice(i++, 0, n2);
        }
        return String.fromCodePoint.apply(String, output);
      }, "decode");
      var encode = /* @__PURE__ */ __name(function encode2(input) {
        var output = [];
        input = ucs2decode(input);
        var inputLength = input.length;
        var n2 = initialN;
        var delta = 0;
        var bias = initialBias;
        var _iteratorNormalCompletion = true;
        var _didIteratorError = false;
        var _iteratorError = void 0;
        try {
          for (var _iterator = input[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
            var _currentValue2 = _step.value;
            if (_currentValue2 < 128) {
              output.push(stringFromCharCode(_currentValue2));
            }
          }
        } catch (err) {
          _didIteratorError = true;
          _iteratorError = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion && _iterator.return) {
              _iterator.return();
            }
          } finally {
            if (_didIteratorError) {
              throw _iteratorError;
            }
          }
        }
        var basicLength = output.length;
        var handledCPCount = basicLength;
        if (basicLength) {
          output.push(delimiter);
        }
        while (handledCPCount < inputLength) {
          var m2 = maxInt;
          var _iteratorNormalCompletion2 = true;
          var _didIteratorError2 = false;
          var _iteratorError2 = void 0;
          try {
            for (var _iterator2 = input[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
              var currentValue = _step2.value;
              if (currentValue >= n2 && currentValue < m2) {
                m2 = currentValue;
              }
            }
          } catch (err) {
            _didIteratorError2 = true;
            _iteratorError2 = err;
          } finally {
            try {
              if (!_iteratorNormalCompletion2 && _iterator2.return) {
                _iterator2.return();
              }
            } finally {
              if (_didIteratorError2) {
                throw _iteratorError2;
              }
            }
          }
          var handledCPCountPlusOne = handledCPCount + 1;
          if (m2 - n2 > floor((maxInt - delta) / handledCPCountPlusOne)) {
            error$1("overflow");
          }
          delta += (m2 - n2) * handledCPCountPlusOne;
          n2 = m2;
          var _iteratorNormalCompletion3 = true;
          var _didIteratorError3 = false;
          var _iteratorError3 = void 0;
          try {
            for (var _iterator3 = input[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
              var _currentValue = _step3.value;
              if (_currentValue < n2 && ++delta > maxInt) {
                error$1("overflow");
              }
              if (_currentValue == n2) {
                var q2 = delta;
                for (
                  var k2 = base;
                  ;
                  /* no condition */
                  k2 += base
                ) {
                  var t3 = k2 <= bias ? tMin : k2 >= bias + tMax ? tMax : k2 - bias;
                  if (q2 < t3) {
                    break;
                  }
                  var qMinusT = q2 - t3;
                  var baseMinusT = base - t3;
                  output.push(stringFromCharCode(digitToBasic(t3 + qMinusT % baseMinusT, 0)));
                  q2 = floor(qMinusT / baseMinusT);
                }
                output.push(stringFromCharCode(digitToBasic(q2, 0)));
                bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
                delta = 0;
                ++handledCPCount;
              }
            }
          } catch (err) {
            _didIteratorError3 = true;
            _iteratorError3 = err;
          } finally {
            try {
              if (!_iteratorNormalCompletion3 && _iterator3.return) {
                _iterator3.return();
              }
            } finally {
              if (_didIteratorError3) {
                throw _iteratorError3;
              }
            }
          }
          ++delta;
          ++n2;
        }
        return output.join("");
      }, "encode");
      var toUnicode = /* @__PURE__ */ __name(function toUnicode2(input) {
        return mapDomain(input, function(string) {
          return regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string;
        });
      }, "toUnicode");
      var toASCII = /* @__PURE__ */ __name(function toASCII2(input) {
        return mapDomain(input, function(string) {
          return regexNonASCII.test(string) ? "xn--" + encode(string) : string;
        });
      }, "toASCII");
      var punycode = {
        /**
         * A string representing the current Punycode.js version number.
         * @memberOf punycode
         * @type String
         */
        "version": "2.1.0",
        /**
         * An object of methods to convert from JavaScript's internal character
         * representation (UCS-2) to Unicode code points, and back.
         * @see <https://mathiasbynens.be/notes/javascript-encoding>
         * @memberOf punycode
         * @type Object
         */
        "ucs2": {
          "decode": ucs2decode,
          "encode": ucs2encode
        },
        "decode": decode,
        "encode": encode,
        "toASCII": toASCII,
        "toUnicode": toUnicode
      };
      var SCHEMES = {};
      function pctEncChar(chr) {
        var c2 = chr.charCodeAt(0);
        var e3 = void 0;
        if (c2 < 16)
          e3 = "%0" + c2.toString(16).toUpperCase();
        else if (c2 < 128)
          e3 = "%" + c2.toString(16).toUpperCase();
        else if (c2 < 2048)
          e3 = "%" + (c2 >> 6 | 192).toString(16).toUpperCase() + "%" + (c2 & 63 | 128).toString(16).toUpperCase();
        else
          e3 = "%" + (c2 >> 12 | 224).toString(16).toUpperCase() + "%" + (c2 >> 6 & 63 | 128).toString(16).toUpperCase() + "%" + (c2 & 63 | 128).toString(16).toUpperCase();
        return e3;
      }
      __name(pctEncChar, "pctEncChar");
      function pctDecChars(str) {
        var newStr = "";
        var i = 0;
        var il = str.length;
        while (i < il) {
          var c2 = parseInt(str.substr(i + 1, 2), 16);
          if (c2 < 128) {
            newStr += String.fromCharCode(c2);
            i += 3;
          } else if (c2 >= 194 && c2 < 224) {
            if (il - i >= 6) {
              var c22 = parseInt(str.substr(i + 4, 2), 16);
              newStr += String.fromCharCode((c2 & 31) << 6 | c22 & 63);
            } else {
              newStr += str.substr(i, 6);
            }
            i += 6;
          } else if (c2 >= 224) {
            if (il - i >= 9) {
              var _c2 = parseInt(str.substr(i + 4, 2), 16);
              var c3 = parseInt(str.substr(i + 7, 2), 16);
              newStr += String.fromCharCode((c2 & 15) << 12 | (_c2 & 63) << 6 | c3 & 63);
            } else {
              newStr += str.substr(i, 9);
            }
            i += 9;
          } else {
            newStr += str.substr(i, 3);
            i += 3;
          }
        }
        return newStr;
      }
      __name(pctDecChars, "pctDecChars");
      function _normalizeComponentEncoding(components, protocol) {
        function decodeUnreserved2(str) {
          var decStr = pctDecChars(str);
          return !decStr.match(protocol.UNRESERVED) ? str : decStr;
        }
        __name(decodeUnreserved2, "decodeUnreserved");
        if (components.scheme)
          components.scheme = String(components.scheme).replace(protocol.PCT_ENCODED, decodeUnreserved2).toLowerCase().replace(protocol.NOT_SCHEME, "");
        if (components.userinfo !== void 0)
          components.userinfo = String(components.userinfo).replace(protocol.PCT_ENCODED, decodeUnreserved2).replace(protocol.NOT_USERINFO, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);
        if (components.host !== void 0)
          components.host = String(components.host).replace(protocol.PCT_ENCODED, decodeUnreserved2).toLowerCase().replace(protocol.NOT_HOST, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);
        if (components.path !== void 0)
          components.path = String(components.path).replace(protocol.PCT_ENCODED, decodeUnreserved2).replace(components.scheme ? protocol.NOT_PATH : protocol.NOT_PATH_NOSCHEME, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);
        if (components.query !== void 0)
          components.query = String(components.query).replace(protocol.PCT_ENCODED, decodeUnreserved2).replace(protocol.NOT_QUERY, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);
        if (components.fragment !== void 0)
          components.fragment = String(components.fragment).replace(protocol.PCT_ENCODED, decodeUnreserved2).replace(protocol.NOT_FRAGMENT, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);
        return components;
      }
      __name(_normalizeComponentEncoding, "_normalizeComponentEncoding");
      function _stripLeadingZeros(str) {
        return str.replace(/^0*(.*)/, "$1") || "0";
      }
      __name(_stripLeadingZeros, "_stripLeadingZeros");
      function _normalizeIPv4(host, protocol) {
        var matches = host.match(protocol.IPV4ADDRESS) || [];
        var _matches = slicedToArray(matches, 2), address = _matches[1];
        if (address) {
          return address.split(".").map(_stripLeadingZeros).join(".");
        } else {
          return host;
        }
      }
      __name(_normalizeIPv4, "_normalizeIPv4");
      function _normalizeIPv6(host, protocol) {
        var matches = host.match(protocol.IPV6ADDRESS) || [];
        var _matches2 = slicedToArray(matches, 3), address = _matches2[1], zone = _matches2[2];
        if (address) {
          var _address$toLowerCase$ = address.toLowerCase().split("::").reverse(), _address$toLowerCase$2 = slicedToArray(_address$toLowerCase$, 2), last = _address$toLowerCase$2[0], first = _address$toLowerCase$2[1];
          var firstFields = first ? first.split(":").map(_stripLeadingZeros) : [];
          var lastFields = last.split(":").map(_stripLeadingZeros);
          var isLastFieldIPv4Address = protocol.IPV4ADDRESS.test(lastFields[lastFields.length - 1]);
          var fieldCount = isLastFieldIPv4Address ? 7 : 8;
          var lastFieldsStart = lastFields.length - fieldCount;
          var fields = Array(fieldCount);
          for (var x2 = 0; x2 < fieldCount; ++x2) {
            fields[x2] = firstFields[x2] || lastFields[lastFieldsStart + x2] || "";
          }
          if (isLastFieldIPv4Address) {
            fields[fieldCount - 1] = _normalizeIPv4(fields[fieldCount - 1], protocol);
          }
          var allZeroFields = fields.reduce(function(acc, field, index) {
            if (!field || field === "0") {
              var lastLongest = acc[acc.length - 1];
              if (lastLongest && lastLongest.index + lastLongest.length === index) {
                lastLongest.length++;
              } else {
                acc.push({ index, length: 1 });
              }
            }
            return acc;
          }, []);
          var longestZeroFields = allZeroFields.sort(function(a, b2) {
            return b2.length - a.length;
          })[0];
          var newHost = void 0;
          if (longestZeroFields && longestZeroFields.length > 1) {
            var newFirst = fields.slice(0, longestZeroFields.index);
            var newLast = fields.slice(longestZeroFields.index + longestZeroFields.length);
            newHost = newFirst.join(":") + "::" + newLast.join(":");
          } else {
            newHost = fields.join(":");
          }
          if (zone) {
            newHost += "%" + zone;
          }
          return newHost;
        } else {
          return host;
        }
      }
      __name(_normalizeIPv6, "_normalizeIPv6");
      var URI_PARSE = /^(?:([^:\/?#]+):)?(?:\/\/((?:([^\/?#@]*)@)?(\[[^\/?#\]]+\]|[^\/?#:]*)(?:\:(\d*))?))?([^?#]*)(?:\?([^#]*))?(?:#((?:.|\n|\r)*))?/i;
      var NO_MATCH_IS_UNDEFINED = "".match(/(){0}/)[1] === void 0;
      function parse7(uriString) {
        var options29 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
        var components = {};
        var protocol = options29.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL;
        if (options29.reference === "suffix")
          uriString = (options29.scheme ? options29.scheme + ":" : "") + "//" + uriString;
        var matches = uriString.match(URI_PARSE);
        if (matches) {
          if (NO_MATCH_IS_UNDEFINED) {
            components.scheme = matches[1];
            components.userinfo = matches[3];
            components.host = matches[4];
            components.port = parseInt(matches[5], 10);
            components.path = matches[6] || "";
            components.query = matches[7];
            components.fragment = matches[8];
            if (isNaN(components.port)) {
              components.port = matches[5];
            }
          } else {
            components.scheme = matches[1] || void 0;
            components.userinfo = uriString.indexOf("@") !== -1 ? matches[3] : void 0;
            components.host = uriString.indexOf("//") !== -1 ? matches[4] : void 0;
            components.port = parseInt(matches[5], 10);
            components.path = matches[6] || "";
            components.query = uriString.indexOf("?") !== -1 ? matches[7] : void 0;
            components.fragment = uriString.indexOf("#") !== -1 ? matches[8] : void 0;
            if (isNaN(components.port)) {
              components.port = uriString.match(/\/\/(?:.|\n)*\:(?:\/|\?|\#|$)/) ? matches[4] : void 0;
            }
          }
          if (components.host) {
            components.host = _normalizeIPv6(_normalizeIPv4(components.host, protocol), protocol);
          }
          if (components.scheme === void 0 && components.userinfo === void 0 && components.host === void 0 && components.port === void 0 && !components.path && components.query === void 0) {
            components.reference = "same-document";
          } else if (components.scheme === void 0) {
            components.reference = "relative";
          } else if (components.fragment === void 0) {
            components.reference = "absolute";
          } else {
            components.reference = "uri";
          }
          if (options29.reference && options29.reference !== "suffix" && options29.reference !== components.reference) {
            components.error = components.error || "URI is not a " + options29.reference + " reference.";
          }
          var schemeHandler = SCHEMES[(options29.scheme || components.scheme || "").toLowerCase()];
          if (!options29.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
            if (components.host && (options29.domainHost || schemeHandler && schemeHandler.domainHost)) {
              try {
                components.host = punycode.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase());
              } catch (e3) {
                components.error = components.error || "Host's domain name can not be converted to ASCII via punycode: " + e3;
              }
            }
            _normalizeComponentEncoding(components, URI_PROTOCOL);
          } else {
            _normalizeComponentEncoding(components, protocol);
          }
          if (schemeHandler && schemeHandler.parse) {
            schemeHandler.parse(components, options29);
          }
        } else {
          components.error = components.error || "URI can not be parsed.";
        }
        return components;
      }
      __name(parse7, "parse");
      function _recomposeAuthority(components, options29) {
        var protocol = options29.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL;
        var uriTokens = [];
        if (components.userinfo !== void 0) {
          uriTokens.push(components.userinfo);
          uriTokens.push("@");
        }
        if (components.host !== void 0) {
          uriTokens.push(_normalizeIPv6(_normalizeIPv4(String(components.host), protocol), protocol).replace(protocol.IPV6ADDRESS, function(_3, $1, $22) {
            return "[" + $1 + ($22 ? "%25" + $22 : "") + "]";
          }));
        }
        if (typeof components.port === "number" || typeof components.port === "string") {
          uriTokens.push(":");
          uriTokens.push(String(components.port));
        }
        return uriTokens.length ? uriTokens.join("") : void 0;
      }
      __name(_recomposeAuthority, "_recomposeAuthority");
      var RDS1 = /^\.\.?\//;
      var RDS2 = /^\/\.(\/|$)/;
      var RDS3 = /^\/\.\.(\/|$)/;
      var RDS5 = /^\/?(?:.|\n)*?(?=\/|$)/;
      function removeDotSegments(input) {
        var output = [];
        while (input.length) {
          if (input.match(RDS1)) {
            input = input.replace(RDS1, "");
          } else if (input.match(RDS2)) {
            input = input.replace(RDS2, "/");
          } else if (input.match(RDS3)) {
            input = input.replace(RDS3, "/");
            output.pop();
          } else if (input === "." || input === "..") {
            input = "";
          } else {
            var im = input.match(RDS5);
            if (im) {
              var s = im[0];
              input = input.slice(s.length);
              output.push(s);
            } else {
              throw new Error("Unexpected dot segment condition");
            }
          }
        }
        return output.join("");
      }
      __name(removeDotSegments, "removeDotSegments");
      function serialize(components) {
        var options29 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
        var protocol = options29.iri ? IRI_PROTOCOL : URI_PROTOCOL;
        var uriTokens = [];
        var schemeHandler = SCHEMES[(options29.scheme || components.scheme || "").toLowerCase()];
        if (schemeHandler && schemeHandler.serialize)
          schemeHandler.serialize(components, options29);
        if (components.host) {
          if (protocol.IPV6ADDRESS.test(components.host)) {
          } else if (options29.domainHost || schemeHandler && schemeHandler.domainHost) {
            try {
              components.host = !options29.iri ? punycode.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase()) : punycode.toUnicode(components.host);
            } catch (e3) {
              components.error = components.error || "Host's domain name can not be converted to " + (!options29.iri ? "ASCII" : "Unicode") + " via punycode: " + e3;
            }
          }
        }
        _normalizeComponentEncoding(components, protocol);
        if (options29.reference !== "suffix" && components.scheme) {
          uriTokens.push(components.scheme);
          uriTokens.push(":");
        }
        var authority = _recomposeAuthority(components, options29);
        if (authority !== void 0) {
          if (options29.reference !== "suffix") {
            uriTokens.push("//");
          }
          uriTokens.push(authority);
          if (components.path && components.path.charAt(0) !== "/") {
            uriTokens.push("/");
          }
        }
        if (components.path !== void 0) {
          var s = components.path;
          if (!options29.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
            s = removeDotSegments(s);
          }
          if (authority === void 0) {
            s = s.replace(/^\/\//, "/%2F");
          }
          uriTokens.push(s);
        }
        if (components.query !== void 0) {
          uriTokens.push("?");
          uriTokens.push(components.query);
        }
        if (components.fragment !== void 0) {
          uriTokens.push("#");
          uriTokens.push(components.fragment);
        }
        return uriTokens.join("");
      }
      __name(serialize, "serialize");
      function resolveComponents(base2, relative13) {
        var options29 = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
        var skipNormalization = arguments[3];
        var target = {};
        if (!skipNormalization) {
          base2 = parse7(serialize(base2, options29), options29);
          relative13 = parse7(serialize(relative13, options29), options29);
        }
        options29 = options29 || {};
        if (!options29.tolerant && relative13.scheme) {
          target.scheme = relative13.scheme;
          target.userinfo = relative13.userinfo;
          target.host = relative13.host;
          target.port = relative13.port;
          target.path = removeDotSegments(relative13.path || "");
          target.query = relative13.query;
        } else {
          if (relative13.userinfo !== void 0 || relative13.host !== void 0 || relative13.port !== void 0) {
            target.userinfo = relative13.userinfo;
            target.host = relative13.host;
            target.port = relative13.port;
            target.path = removeDotSegments(relative13.path || "");
            target.query = relative13.query;
          } else {
            if (!relative13.path) {
              target.path = base2.path;
              if (relative13.query !== void 0) {
                target.query = relative13.query;
              } else {
                target.query = base2.query;
              }
            } else {
              if (relative13.path.charAt(0) === "/") {
                target.path = removeDotSegments(relative13.path);
              } else {
                if ((base2.userinfo !== void 0 || base2.host !== void 0 || base2.port !== void 0) && !base2.path) {
                  target.path = "/" + relative13.path;
                } else if (!base2.path) {
                  target.path = relative13.path;
                } else {
                  target.path = base2.path.slice(0, base2.path.lastIndexOf("/") + 1) + relative13.path;
                }
                target.path = removeDotSegments(target.path);
              }
              target.query = relative13.query;
            }
            target.userinfo = base2.userinfo;
            target.host = base2.host;
            target.port = base2.port;
          }
          target.scheme = base2.scheme;
        }
        target.fragment = relative13.fragment;
        return target;
      }
      __name(resolveComponents, "resolveComponents");
      function resolve19(baseURI, relativeURI, options29) {
        var schemelessOptions = assign({ scheme: "null" }, options29);
        return serialize(resolveComponents(parse7(baseURI, schemelessOptions), parse7(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions);
      }
      __name(resolve19, "resolve");
      function normalize3(uri, options29) {
        if (typeof uri === "string") {
          uri = serialize(parse7(uri, options29), options29);
        } else if (typeOf(uri) === "object") {
          uri = parse7(serialize(uri, options29), options29);
        }
        return uri;
      }
      __name(normalize3, "normalize");
      function equal(uriA, uriB, options29) {
        if (typeof uriA === "string") {
          uriA = serialize(parse7(uriA, options29), options29);
        } else if (typeOf(uriA) === "object") {
          uriA = serialize(uriA, options29);
        }
        if (typeof uriB === "string") {
          uriB = serialize(parse7(uriB, options29), options29);
        } else if (typeOf(uriB) === "object") {
          uriB = serialize(uriB, options29);
        }
        return uriA === uriB;
      }
      __name(equal, "equal");
      function escapeComponent(str, options29) {
        return str && str.toString().replace(!options29 || !options29.iri ? URI_PROTOCOL.ESCAPE : IRI_PROTOCOL.ESCAPE, pctEncChar);
      }
      __name(escapeComponent, "escapeComponent");
      function unescapeComponent(str, options29) {
        return str && str.toString().replace(!options29 || !options29.iri ? URI_PROTOCOL.PCT_ENCODED : IRI_PROTOCOL.PCT_ENCODED, pctDecChars);
      }
      __name(unescapeComponent, "unescapeComponent");
      var handler30 = {
        scheme: "http",
        domainHost: true,
        parse: /* @__PURE__ */ __name(function parse8(components, options29) {
          if (!components.host) {
            components.error = components.error || "HTTP URIs must have a host.";
          }
          return components;
        }, "parse"),
        serialize: /* @__PURE__ */ __name(function serialize2(components, options29) {
          var secure = String(components.scheme).toLowerCase() === "https";
          if (components.port === (secure ? 443 : 80) || components.port === "") {
            components.port = void 0;
          }
          if (!components.path) {
            components.path = "/";
          }
          return components;
        }, "serialize")
      };
      var handler$1 = {
        scheme: "https",
        domainHost: handler30.domainHost,
        parse: handler30.parse,
        serialize: handler30.serialize
      };
      function isSecure(wsComponents) {
        return typeof wsComponents.secure === "boolean" ? wsComponents.secure : String(wsComponents.scheme).toLowerCase() === "wss";
      }
      __name(isSecure, "isSecure");
      var handler$2 = {
        scheme: "ws",
        domainHost: true,
        parse: /* @__PURE__ */ __name(function parse8(components, options29) {
          var wsComponents = components;
          wsComponents.secure = isSecure(wsComponents);
          wsComponents.resourceName = (wsComponents.path || "/") + (wsComponents.query ? "?" + wsComponents.query : "");
          wsComponents.path = void 0;
          wsComponents.query = void 0;
          return wsComponents;
        }, "parse"),
        serialize: /* @__PURE__ */ __name(function serialize2(wsComponents, options29) {
          if (wsComponents.port === (isSecure(wsComponents) ? 443 : 80) || wsComponents.port === "") {
            wsComponents.port = void 0;
          }
          if (typeof wsComponents.secure === "boolean") {
            wsComponents.scheme = wsComponents.secure ? "wss" : "ws";
            wsComponents.secure = void 0;
          }
          if (wsComponents.resourceName) {
            var _wsComponents$resourc = wsComponents.resourceName.split("?"), _wsComponents$resourc2 = slicedToArray(_wsComponents$resourc, 2), path67 = _wsComponents$resourc2[0], query = _wsComponents$resourc2[1];
            wsComponents.path = path67 && path67 !== "/" ? path67 : void 0;
            wsComponents.query = query;
            wsComponents.resourceName = void 0;
          }
          wsComponents.fragment = void 0;
          return wsComponents;
        }, "serialize")
      };
      var handler$3 = {
        scheme: "wss",
        domainHost: handler$2.domainHost,
        parse: handler$2.parse,
        serialize: handler$2.serialize
      };
      var O2 = {};
      var isIRI = true;
      var UNRESERVED$$ = "[A-Za-z0-9\\-\\.\\_\\~" + (isIRI ? "\\xA0-\\u200D\\u2010-\\u2029\\u202F-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF" : "") + "]";
      var HEXDIG$$ = "[0-9A-Fa-f]";
      var PCT_ENCODED$ = subexp(subexp("%[EFef]" + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$) + "|" + subexp("%[89A-Fa-f]" + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$) + "|" + subexp("%" + HEXDIG$$ + HEXDIG$$));
      var ATEXT$$ = "[A-Za-z0-9\\!\\$\\%\\'\\*\\+\\-\\^\\_\\`\\{\\|\\}\\~]";
      var QTEXT$$ = "[\\!\\$\\%\\'\\(\\)\\*\\+\\,\\-\\.0-9\\<\\>A-Z\\x5E-\\x7E]";
      var VCHAR$$ = merge(QTEXT$$, '[\\"\\\\]');
      var SOME_DELIMS$$ = "[\\!\\$\\'\\(\\)\\*\\+\\,\\;\\:\\@]";
      var UNRESERVED = new RegExp(UNRESERVED$$, "g");
      var PCT_ENCODED = new RegExp(PCT_ENCODED$, "g");
      var NOT_LOCAL_PART = new RegExp(merge("[^]", ATEXT$$, "[\\.]", '[\\"]', VCHAR$$), "g");
      var NOT_HFNAME = new RegExp(merge("[^]", UNRESERVED$$, SOME_DELIMS$$), "g");
      var NOT_HFVALUE = NOT_HFNAME;
      function decodeUnreserved(str) {
        var decStr = pctDecChars(str);
        return !decStr.match(UNRESERVED) ? str : decStr;
      }
      __name(decodeUnreserved, "decodeUnreserved");
      var handler$4 = {
        scheme: "mailto",
        parse: /* @__PURE__ */ __name(function parse$$1(components, options29) {
          var mailtoComponents = components;
          var to = mailtoComponents.to = mailtoComponents.path ? mailtoComponents.path.split(",") : [];
          mailtoComponents.path = void 0;
          if (mailtoComponents.query) {
            var unknownHeaders = false;
            var headers = {};
            var hfields = mailtoComponents.query.split("&");
            for (var x2 = 0, xl = hfields.length; x2 < xl; ++x2) {
              var hfield = hfields[x2].split("=");
              switch (hfield[0]) {
                case "to":
                  var toAddrs = hfield[1].split(",");
                  for (var _x = 0, _xl = toAddrs.length; _x < _xl; ++_x) {
                    to.push(toAddrs[_x]);
                  }
                  break;
                case "subject":
                  mailtoComponents.subject = unescapeComponent(hfield[1], options29);
                  break;
                case "body":
                  mailtoComponents.body = unescapeComponent(hfield[1], options29);
                  break;
                default:
                  unknownHeaders = true;
                  headers[unescapeComponent(hfield[0], options29)] = unescapeComponent(hfield[1], options29);
                  break;
              }
            }
            if (unknownHeaders)
              mailtoComponents.headers = headers;
          }
          mailtoComponents.query = void 0;
          for (var _x2 = 0, _xl2 = to.length; _x2 < _xl2; ++_x2) {
            var addr = to[_x2].split("@");
            addr[0] = unescapeComponent(addr[0]);
            if (!options29.unicodeSupport) {
              try {
                addr[1] = punycode.toASCII(unescapeComponent(addr[1], options29).toLowerCase());
              } catch (e3) {
                mailtoComponents.error = mailtoComponents.error || "Email address's domain name can not be converted to ASCII via punycode: " + e3;
              }
            } else {
              addr[1] = unescapeComponent(addr[1], options29).toLowerCase();
            }
            to[_x2] = addr.join("@");
          }
          return mailtoComponents;
        }, "parse$$1"),
        serialize: /* @__PURE__ */ __name(function serialize$$1(mailtoComponents, options29) {
          var components = mailtoComponents;
          var to = toArray(mailtoComponents.to);
          if (to) {
            for (var x2 = 0, xl = to.length; x2 < xl; ++x2) {
              var toAddr = String(to[x2]);
              var atIdx = toAddr.lastIndexOf("@");
              var localPart = toAddr.slice(0, atIdx).replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_LOCAL_PART, pctEncChar);
              var domain2 = toAddr.slice(atIdx + 1);
              try {
                domain2 = !options29.iri ? punycode.toASCII(unescapeComponent(domain2, options29).toLowerCase()) : punycode.toUnicode(domain2);
              } catch (e3) {
                components.error = components.error || "Email address's domain name can not be converted to " + (!options29.iri ? "ASCII" : "Unicode") + " via punycode: " + e3;
              }
              to[x2] = localPart + "@" + domain2;
            }
            components.path = to.join(",");
          }
          var headers = mailtoComponents.headers = mailtoComponents.headers || {};
          if (mailtoComponents.subject)
            headers["subject"] = mailtoComponents.subject;
          if (mailtoComponents.body)
            headers["body"] = mailtoComponents.body;
          var fields = [];
          for (var name in headers) {
            if (headers[name] !== O2[name]) {
              fields.push(name.replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_HFNAME, pctEncChar) + "=" + headers[name].replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_HFVALUE, pctEncChar));
            }
          }
          if (fields.length) {
            components.query = fields.join("&");
          }
          return components;
        }, "serialize$$1")
      };
      var URN_PARSE = /^([^\:]+)\:(.*)/;
      var handler$5 = {
        scheme: "urn",
        parse: /* @__PURE__ */ __name(function parse$$1(components, options29) {
          var matches = components.path && components.path.match(URN_PARSE);
          var urnComponents = components;
          if (matches) {
            var scheme = options29.scheme || urnComponents.scheme || "urn";
            var nid = matches[1].toLowerCase();
            var nss = matches[2];
            var urnScheme = scheme + ":" + (options29.nid || nid);
            var schemeHandler = SCHEMES[urnScheme];
            urnComponents.nid = nid;
            urnComponents.nss = nss;
            urnComponents.path = void 0;
            if (schemeHandler) {
              urnComponents = schemeHandler.parse(urnComponents, options29);
            }
          } else {
            urnComponents.error = urnComponents.error || "URN can not be parsed.";
          }
          return urnComponents;
        }, "parse$$1"),
        serialize: /* @__PURE__ */ __name(function serialize$$1(urnComponents, options29) {
          var scheme = options29.scheme || urnComponents.scheme || "urn";
          var nid = urnComponents.nid;
          var urnScheme = scheme + ":" + (options29.nid || nid);
          var schemeHandler = SCHEMES[urnScheme];
          if (schemeHandler) {
            urnComponents = schemeHandler.serialize(urnComponents, options29);
          }
          var uriComponents = urnComponents;
          var nss = urnComponents.nss;
          uriComponents.path = (nid || options29.nid) + ":" + nss;
          return uriComponents;
        }, "serialize$$1")
      };
      var UUID = /^[0-9A-Fa-f]{8}(?:\-[0-9A-Fa-f]{4}){3}\-[0-9A-Fa-f]{12}$/;
      var handler$6 = {
        scheme: "urn:uuid",
        parse: /* @__PURE__ */ __name(function parse8(urnComponents, options29) {
          var uuidComponents = urnComponents;
          uuidComponents.uuid = uuidComponents.nss;
          uuidComponents.nss = void 0;
          if (!options29.tolerant && (!uuidComponents.uuid || !uuidComponents.uuid.match(UUID))) {
            uuidComponents.error = uuidComponents.error || "UUID is not valid.";
          }
          return uuidComponents;
        }, "parse"),
        serialize: /* @__PURE__ */ __name(function serialize2(uuidComponents, options29) {
          var urnComponents = uuidComponents;
          urnComponents.nss = (uuidComponents.uuid || "").toLowerCase();
          return urnComponents;
        }, "serialize")
      };
      SCHEMES[handler30.scheme] = handler30;
      SCHEMES[handler$1.scheme] = handler$1;
      SCHEMES[handler$2.scheme] = handler$2;
      SCHEMES[handler$3.scheme] = handler$3;
      SCHEMES[handler$4.scheme] = handler$4;
      SCHEMES[handler$5.scheme] = handler$5;
      SCHEMES[handler$6.scheme] = handler$6;
      exports3.SCHEMES = SCHEMES;
      exports3.pctEncChar = pctEncChar;
      exports3.pctDecChars = pctDecChars;
      exports3.parse = parse7;
      exports3.removeDotSegments = removeDotSegments;
      exports3.serialize = serialize;
      exports3.resolveComponents = resolveComponents;
      exports3.resolve = resolve19;
      exports3.normalize = normalize3;
      exports3.equal = equal;
      exports3.escapeComponent = escapeComponent;
      exports3.unescapeComponent = unescapeComponent;
      Object.defineProperty(exports3, "__esModule", { value: true });
    });
  }
});

// ../../node_modules/.pnpm/fast-deep-equal@3.1.3/node_modules/fast-deep-equal/index.js
var require_fast_deep_equal = __commonJS({
  "../../node_modules/.pnpm/fast-deep-equal@3.1.3/node_modules/fast-deep-equal/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function equal(a, b2) {
      if (a === b2)
        return true;
      if (a && b2 && typeof a == "object" && typeof b2 == "object") {
        if (a.constructor !== b2.constructor)
          return false;
        var length, i, keys;
        if (Array.isArray(a)) {
          length = a.length;
          if (length != b2.length)
            return false;
          for (i = length; i-- !== 0; )
            if (!equal(a[i], b2[i]))
              return false;
          return true;
        }
        if (a.constructor === RegExp)
          return a.source === b2.source && a.flags === b2.flags;
        if (a.valueOf !== Object.prototype.valueOf)
          return a.valueOf() === b2.valueOf();
        if (a.toString !== Object.prototype.toString)
          return a.toString() === b2.toString();
        keys = Object.keys(a);
        length = keys.length;
        if (length !== Object.keys(b2).length)
          return false;
        for (i = length; i-- !== 0; )
          if (!Object.prototype.hasOwnProperty.call(b2, keys[i]))
            return false;
        for (i = length; i-- !== 0; ) {
          var key = keys[i];
          if (!equal(a[key], b2[key]))
            return false;
        }
        return true;
      }
      return a !== a && b2 !== b2;
    }, "equal");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/ucs2length.js
var require_ucs2length = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/ucs2length.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function ucs2length(str) {
      var length = 0, len = str.length, pos = 0, value;
      while (pos < len) {
        length++;
        value = str.charCodeAt(pos++);
        if (value >= 55296 && value <= 56319 && pos < len) {
          value = str.charCodeAt(pos);
          if ((value & 64512) == 56320)
            pos++;
        }
      }
      return length;
    }, "ucs2length");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/util.js
var require_util11 = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/util.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = {
      copy,
      checkDataType,
      checkDataTypes,
      coerceToTypes,
      toHash,
      getProperty,
      escapeQuotes,
      equal: require_fast_deep_equal(),
      ucs2length: require_ucs2length(),
      varOccurences,
      varReplace,
      schemaHasRules,
      schemaHasRulesExcept,
      schemaUnknownRules,
      toQuotedString,
      getPathExpr,
      getPath,
      getData,
      unescapeFragment,
      unescapeJsonPointer,
      escapeFragment,
      escapeJsonPointer
    };
    function copy(o2, to) {
      to = to || {};
      for (var key in o2)
        to[key] = o2[key];
      return to;
    }
    __name(copy, "copy");
    function checkDataType(dataType, data, strictNumbers, negate) {
      var EQUAL = negate ? " !== " : " === ", AND = negate ? " || " : " && ", OK = negate ? "!" : "", NOT = negate ? "" : "!";
      switch (dataType) {
        case "null":
          return data + EQUAL + "null";
        case "array":
          return OK + "Array.isArray(" + data + ")";
        case "object":
          return "(" + OK + data + AND + "typeof " + data + EQUAL + '"object"' + AND + NOT + "Array.isArray(" + data + "))";
        case "integer":
          return "(typeof " + data + EQUAL + '"number"' + AND + NOT + "(" + data + " % 1)" + AND + data + EQUAL + data + (strictNumbers ? AND + OK + "isFinite(" + data + ")" : "") + ")";
        case "number":
          return "(typeof " + data + EQUAL + '"' + dataType + '"' + (strictNumbers ? AND + OK + "isFinite(" + data + ")" : "") + ")";
        default:
          return "typeof " + data + EQUAL + '"' + dataType + '"';
      }
    }
    __name(checkDataType, "checkDataType");
    function checkDataTypes(dataTypes, data, strictNumbers) {
      switch (dataTypes.length) {
        case 1:
          return checkDataType(dataTypes[0], data, strictNumbers, true);
        default:
          var code = "";
          var types = toHash(dataTypes);
          if (types.array && types.object) {
            code = types.null ? "(" : "(!" + data + " || ";
            code += "typeof " + data + ' !== "object")';
            delete types.null;
            delete types.array;
            delete types.object;
          }
          if (types.number)
            delete types.integer;
          for (var t3 in types)
            code += (code ? " && " : "") + checkDataType(t3, data, strictNumbers, true);
          return code;
      }
    }
    __name(checkDataTypes, "checkDataTypes");
    var COERCE_TO_TYPES = toHash(["string", "number", "integer", "boolean", "null"]);
    function coerceToTypes(optionCoerceTypes, dataTypes) {
      if (Array.isArray(dataTypes)) {
        var types = [];
        for (var i = 0; i < dataTypes.length; i++) {
          var t3 = dataTypes[i];
          if (COERCE_TO_TYPES[t3])
            types[types.length] = t3;
          else if (optionCoerceTypes === "array" && t3 === "array")
            types[types.length] = t3;
        }
        if (types.length)
          return types;
      } else if (COERCE_TO_TYPES[dataTypes]) {
        return [dataTypes];
      } else if (optionCoerceTypes === "array" && dataTypes === "array") {
        return ["array"];
      }
    }
    __name(coerceToTypes, "coerceToTypes");
    function toHash(arr) {
      var hash = {};
      for (var i = 0; i < arr.length; i++)
        hash[arr[i]] = true;
      return hash;
    }
    __name(toHash, "toHash");
    var IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;
    var SINGLE_QUOTE = /'|\\/g;
    function getProperty(key) {
      return typeof key == "number" ? "[" + key + "]" : IDENTIFIER.test(key) ? "." + key : "['" + escapeQuotes(key) + "']";
    }
    __name(getProperty, "getProperty");
    function escapeQuotes(str) {
      return str.replace(SINGLE_QUOTE, "\\$&").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\f/g, "\\f").replace(/\t/g, "\\t");
    }
    __name(escapeQuotes, "escapeQuotes");
    function varOccurences(str, dataVar) {
      dataVar += "[^0-9]";
      var matches = str.match(new RegExp(dataVar, "g"));
      return matches ? matches.length : 0;
    }
    __name(varOccurences, "varOccurences");
    function varReplace(str, dataVar, expr) {
      dataVar += "([^0-9])";
      expr = expr.replace(/\$/g, "$$$$");
      return str.replace(new RegExp(dataVar, "g"), expr + "$1");
    }
    __name(varReplace, "varReplace");
    function schemaHasRules(schema, rules) {
      if (typeof schema == "boolean")
        return !schema;
      for (var key in schema)
        if (rules[key])
          return true;
    }
    __name(schemaHasRules, "schemaHasRules");
    function schemaHasRulesExcept(schema, rules, exceptKeyword) {
      if (typeof schema == "boolean")
        return !schema && exceptKeyword != "not";
      for (var key in schema)
        if (key != exceptKeyword && rules[key])
          return true;
    }
    __name(schemaHasRulesExcept, "schemaHasRulesExcept");
    function schemaUnknownRules(schema, rules) {
      if (typeof schema == "boolean")
        return;
      for (var key in schema)
        if (!rules[key])
          return key;
    }
    __name(schemaUnknownRules, "schemaUnknownRules");
    function toQuotedString(str) {
      return "'" + escapeQuotes(str) + "'";
    }
    __name(toQuotedString, "toQuotedString");
    function getPathExpr(currentPath, expr, jsonPointers, isNumber) {
      var path67 = jsonPointers ? "'/' + " + expr + (isNumber ? "" : ".replace(/~/g, '~0').replace(/\\//g, '~1')") : isNumber ? "'[' + " + expr + " + ']'" : "'[\\'' + " + expr + " + '\\']'";
      return joinPaths(currentPath, path67);
    }
    __name(getPathExpr, "getPathExpr");
    function getPath(currentPath, prop, jsonPointers) {
      var path67 = jsonPointers ? toQuotedString("/" + escapeJsonPointer(prop)) : toQuotedString(getProperty(prop));
      return joinPaths(currentPath, path67);
    }
    __name(getPath, "getPath");
    var JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/;
    var RELATIVE_JSON_POINTER = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
    function getData($data, lvl, paths) {
      var up, jsonPointer, data, matches;
      if ($data === "")
        return "rootData";
      if ($data[0] == "/") {
        if (!JSON_POINTER.test($data))
          throw new Error("Invalid JSON-pointer: " + $data);
        jsonPointer = $data;
        data = "rootData";
      } else {
        matches = $data.match(RELATIVE_JSON_POINTER);
        if (!matches)
          throw new Error("Invalid JSON-pointer: " + $data);
        up = +matches[1];
        jsonPointer = matches[2];
        if (jsonPointer == "#") {
          if (up >= lvl)
            throw new Error("Cannot access property/index " + up + " levels up, current level is " + lvl);
          return paths[lvl - up];
        }
        if (up > lvl)
          throw new Error("Cannot access data " + up + " levels up, current level is " + lvl);
        data = "data" + (lvl - up || "");
        if (!jsonPointer)
          return data;
      }
      var expr = data;
      var segments = jsonPointer.split("/");
      for (var i = 0; i < segments.length; i++) {
        var segment = segments[i];
        if (segment) {
          data += getProperty(unescapeJsonPointer(segment));
          expr += " && " + data;
        }
      }
      return expr;
    }
    __name(getData, "getData");
    function joinPaths(a, b2) {
      if (a == '""')
        return b2;
      return (a + " + " + b2).replace(/([^\\])' \+ '/g, "$1");
    }
    __name(joinPaths, "joinPaths");
    function unescapeFragment(str) {
      return unescapeJsonPointer(decodeURIComponent(str));
    }
    __name(unescapeFragment, "unescapeFragment");
    function escapeFragment(str) {
      return encodeURIComponent(escapeJsonPointer(str));
    }
    __name(escapeFragment, "escapeFragment");
    function escapeJsonPointer(str) {
      return str.replace(/~/g, "~0").replace(/\//g, "~1");
    }
    __name(escapeJsonPointer, "escapeJsonPointer");
    function unescapeJsonPointer(str) {
      return str.replace(/~1/g, "/").replace(/~0/g, "~");
    }
    __name(unescapeJsonPointer, "unescapeJsonPointer");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/schema_obj.js
var require_schema_obj = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/schema_obj.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var util4 = require_util11();
    module3.exports = SchemaObject;
    function SchemaObject(obj) {
      util4.copy(obj, this);
    }
    __name(SchemaObject, "SchemaObject");
  }
});

// ../../node_modules/.pnpm/json-schema-traverse@0.4.1/node_modules/json-schema-traverse/index.js
var require_json_schema_traverse = __commonJS({
  "../../node_modules/.pnpm/json-schema-traverse@0.4.1/node_modules/json-schema-traverse/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var traverse = module3.exports = function(schema, opts, cb) {
      if (typeof opts == "function") {
        cb = opts;
        opts = {};
      }
      cb = opts.cb || cb;
      var pre = typeof cb == "function" ? cb : cb.pre || function() {
      };
      var post = cb.post || function() {
      };
      _traverse(opts, pre, post, schema, "", schema);
    };
    traverse.keywords = {
      additionalItems: true,
      items: true,
      contains: true,
      additionalProperties: true,
      propertyNames: true,
      not: true
    };
    traverse.arrayKeywords = {
      items: true,
      allOf: true,
      anyOf: true,
      oneOf: true
    };
    traverse.propsKeywords = {
      definitions: true,
      properties: true,
      patternProperties: true,
      dependencies: true
    };
    traverse.skipKeywords = {
      default: true,
      enum: true,
      const: true,
      required: true,
      maximum: true,
      minimum: true,
      exclusiveMaximum: true,
      exclusiveMinimum: true,
      multipleOf: true,
      maxLength: true,
      minLength: true,
      pattern: true,
      format: true,
      maxItems: true,
      minItems: true,
      uniqueItems: true,
      maxProperties: true,
      minProperties: true
    };
    function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
      if (schema && typeof schema == "object" && !Array.isArray(schema)) {
        pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
        for (var key in schema) {
          var sch = schema[key];
          if (Array.isArray(sch)) {
            if (key in traverse.arrayKeywords) {
              for (var i = 0; i < sch.length; i++)
                _traverse(opts, pre, post, sch[i], jsonPtr + "/" + key + "/" + i, rootSchema, jsonPtr, key, schema, i);
            }
          } else if (key in traverse.propsKeywords) {
            if (sch && typeof sch == "object") {
              for (var prop in sch)
                _traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);
            }
          } else if (key in traverse.keywords || opts.allKeys && !(key in traverse.skipKeywords)) {
            _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema);
          }
        }
        post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
      }
    }
    __name(_traverse, "_traverse");
    function escapeJsonPtr(str) {
      return str.replace(/~/g, "~0").replace(/\//g, "~1");
    }
    __name(escapeJsonPtr, "escapeJsonPtr");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/resolve.js
var require_resolve2 = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/resolve.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var URI = require_uri_all();
    var equal = require_fast_deep_equal();
    var util4 = require_util11();
    var SchemaObject = require_schema_obj();
    var traverse = require_json_schema_traverse();
    module3.exports = resolve19;
    resolve19.normalizeId = normalizeId;
    resolve19.fullPath = getFullPath;
    resolve19.url = resolveUrl;
    resolve19.ids = resolveIds;
    resolve19.inlineRef = inlineRef;
    resolve19.schema = resolveSchema;
    function resolve19(compile, root, ref) {
      var refVal = this._refs[ref];
      if (typeof refVal == "string") {
        if (this._refs[refVal])
          refVal = this._refs[refVal];
        else
          return resolve19.call(this, compile, root, refVal);
      }
      refVal = refVal || this._schemas[ref];
      if (refVal instanceof SchemaObject) {
        return inlineRef(refVal.schema, this._opts.inlineRefs) ? refVal.schema : refVal.validate || this._compile(refVal);
      }
      var res = resolveSchema.call(this, root, ref);
      var schema, v2, baseId;
      if (res) {
        schema = res.schema;
        root = res.root;
        baseId = res.baseId;
      }
      if (schema instanceof SchemaObject) {
        v2 = schema.validate || compile.call(this, schema.schema, root, void 0, baseId);
      } else if (schema !== void 0) {
        v2 = inlineRef(schema, this._opts.inlineRefs) ? schema : compile.call(this, schema, root, void 0, baseId);
      }
      return v2;
    }
    __name(resolve19, "resolve");
    function resolveSchema(root, ref) {
      var p2 = URI.parse(ref), refPath = _getFullPath(p2), baseId = getFullPath(this._getId(root.schema));
      if (Object.keys(root.schema).length === 0 || refPath !== baseId) {
        var id = normalizeId(refPath);
        var refVal = this._refs[id];
        if (typeof refVal == "string") {
          return resolveRecursive.call(this, root, refVal, p2);
        } else if (refVal instanceof SchemaObject) {
          if (!refVal.validate)
            this._compile(refVal);
          root = refVal;
        } else {
          refVal = this._schemas[id];
          if (refVal instanceof SchemaObject) {
            if (!refVal.validate)
              this._compile(refVal);
            if (id == normalizeId(ref))
              return { schema: refVal, root, baseId };
            root = refVal;
          } else {
            return;
          }
        }
        if (!root.schema)
          return;
        baseId = getFullPath(this._getId(root.schema));
      }
      return getJsonPointer.call(this, p2, baseId, root.schema, root);
    }
    __name(resolveSchema, "resolveSchema");
    function resolveRecursive(root, ref, parsedRef) {
      var res = resolveSchema.call(this, root, ref);
      if (res) {
        var schema = res.schema;
        var baseId = res.baseId;
        root = res.root;
        var id = this._getId(schema);
        if (id)
          baseId = resolveUrl(baseId, id);
        return getJsonPointer.call(this, parsedRef, baseId, schema, root);
      }
    }
    __name(resolveRecursive, "resolveRecursive");
    var PREVENT_SCOPE_CHANGE = util4.toHash(["properties", "patternProperties", "enum", "dependencies", "definitions"]);
    function getJsonPointer(parsedRef, baseId, schema, root) {
      parsedRef.fragment = parsedRef.fragment || "";
      if (parsedRef.fragment.slice(0, 1) != "/")
        return;
      var parts = parsedRef.fragment.split("/");
      for (var i = 1; i < parts.length; i++) {
        var part = parts[i];
        if (part) {
          part = util4.unescapeFragment(part);
          schema = schema[part];
          if (schema === void 0)
            break;
          var id;
          if (!PREVENT_SCOPE_CHANGE[part]) {
            id = this._getId(schema);
            if (id)
              baseId = resolveUrl(baseId, id);
            if (schema.$ref) {
              var $ref = resolveUrl(baseId, schema.$ref);
              var res = resolveSchema.call(this, root, $ref);
              if (res) {
                schema = res.schema;
                root = res.root;
                baseId = res.baseId;
              }
            }
          }
        }
      }
      if (schema !== void 0 && schema !== root.schema)
        return { schema, root, baseId };
    }
    __name(getJsonPointer, "getJsonPointer");
    var SIMPLE_INLINED = util4.toHash([
      "type",
      "format",
      "pattern",
      "maxLength",
      "minLength",
      "maxProperties",
      "minProperties",
      "maxItems",
      "minItems",
      "maximum",
      "minimum",
      "uniqueItems",
      "multipleOf",
      "required",
      "enum"
    ]);
    function inlineRef(schema, limit) {
      if (limit === false)
        return false;
      if (limit === void 0 || limit === true)
        return checkNoRef(schema);
      else if (limit)
        return countKeys(schema) <= limit;
    }
    __name(inlineRef, "inlineRef");
    function checkNoRef(schema) {
      var item;
      if (Array.isArray(schema)) {
        for (var i = 0; i < schema.length; i++) {
          item = schema[i];
          if (typeof item == "object" && !checkNoRef(item))
            return false;
        }
      } else {
        for (var key in schema) {
          if (key == "$ref")
            return false;
          item = schema[key];
          if (typeof item == "object" && !checkNoRef(item))
            return false;
        }
      }
      return true;
    }
    __name(checkNoRef, "checkNoRef");
    function countKeys(schema) {
      var count = 0, item;
      if (Array.isArray(schema)) {
        for (var i = 0; i < schema.length; i++) {
          item = schema[i];
          if (typeof item == "object")
            count += countKeys(item);
          if (count == Infinity)
            return Infinity;
        }
      } else {
        for (var key in schema) {
          if (key == "$ref")
            return Infinity;
          if (SIMPLE_INLINED[key]) {
            count++;
          } else {
            item = schema[key];
            if (typeof item == "object")
              count += countKeys(item) + 1;
            if (count == Infinity)
              return Infinity;
          }
        }
      }
      return count;
    }
    __name(countKeys, "countKeys");
    function getFullPath(id, normalize3) {
      if (normalize3 !== false)
        id = normalizeId(id);
      var p2 = URI.parse(id);
      return _getFullPath(p2);
    }
    __name(getFullPath, "getFullPath");
    function _getFullPath(p2) {
      return URI.serialize(p2).split("#")[0] + "#";
    }
    __name(_getFullPath, "_getFullPath");
    var TRAILING_SLASH_HASH = /#\/?$/;
    function normalizeId(id) {
      return id ? id.replace(TRAILING_SLASH_HASH, "") : "";
    }
    __name(normalizeId, "normalizeId");
    function resolveUrl(baseId, id) {
      id = normalizeId(id);
      return URI.resolve(baseId, id);
    }
    __name(resolveUrl, "resolveUrl");
    function resolveIds(schema) {
      var schemaId = normalizeId(this._getId(schema));
      var baseIds = { "": schemaId };
      var fullPaths = { "": getFullPath(schemaId, false) };
      var localRefs = {};
      var self2 = this;
      traverse(schema, { allKeys: true }, function(sch, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
        if (jsonPtr === "")
          return;
        var id = self2._getId(sch);
        var baseId = baseIds[parentJsonPtr];
        var fullPath = fullPaths[parentJsonPtr] + "/" + parentKeyword;
        if (keyIndex !== void 0)
          fullPath += "/" + (typeof keyIndex == "number" ? keyIndex : util4.escapeFragment(keyIndex));
        if (typeof id == "string") {
          id = baseId = normalizeId(baseId ? URI.resolve(baseId, id) : id);
          var refVal = self2._refs[id];
          if (typeof refVal == "string")
            refVal = self2._refs[refVal];
          if (refVal && refVal.schema) {
            if (!equal(sch, refVal.schema))
              throw new Error('id "' + id + '" resolves to more than one schema');
          } else if (id != normalizeId(fullPath)) {
            if (id[0] == "#") {
              if (localRefs[id] && !equal(sch, localRefs[id]))
                throw new Error('id "' + id + '" resolves to more than one schema');
              localRefs[id] = sch;
            } else {
              self2._refs[id] = fullPath;
            }
          }
        }
        baseIds[jsonPtr] = baseId;
        fullPaths[jsonPtr] = fullPath;
      });
      return localRefs;
    }
    __name(resolveIds, "resolveIds");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/error_classes.js
var require_error_classes = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/error_classes.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var resolve19 = require_resolve2();
    module3.exports = {
      Validation: errorSubclass(ValidationError),
      MissingRef: errorSubclass(MissingRefError)
    };
    function ValidationError(errors) {
      this.message = "validation failed";
      this.errors = errors;
      this.ajv = this.validation = true;
    }
    __name(ValidationError, "ValidationError");
    MissingRefError.message = function(baseId, ref) {
      return "can't resolve reference " + ref + " from id " + baseId;
    };
    function MissingRefError(baseId, ref, message) {
      this.message = message || MissingRefError.message(baseId, ref);
      this.missingRef = resolve19.url(baseId, ref);
      this.missingSchema = resolve19.normalizeId(resolve19.fullPath(this.missingRef));
    }
    __name(MissingRefError, "MissingRefError");
    function errorSubclass(Subclass) {
      Subclass.prototype = Object.create(Error.prototype);
      Subclass.prototype.constructor = Subclass;
      return Subclass;
    }
    __name(errorSubclass, "errorSubclass");
  }
});

// ../../node_modules/.pnpm/fast-json-stable-stringify@2.1.0/node_modules/fast-json-stable-stringify/index.js
var require_fast_json_stable_stringify = __commonJS({
  "../../node_modules/.pnpm/fast-json-stable-stringify@2.1.0/node_modules/fast-json-stable-stringify/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = function(data, opts) {
      if (!opts)
        opts = {};
      if (typeof opts === "function")
        opts = { cmp: opts };
      var cycles = typeof opts.cycles === "boolean" ? opts.cycles : false;
      var cmp = opts.cmp && function(f) {
        return function(node2) {
          return function(a, b2) {
            var aobj = { key: a, value: node2[a] };
            var bobj = { key: b2, value: node2[b2] };
            return f(aobj, bobj);
          };
        };
      }(opts.cmp);
      var seen = [];
      return (/* @__PURE__ */ __name(function stringify(node2) {
        if (node2 && node2.toJSON && typeof node2.toJSON === "function") {
          node2 = node2.toJSON();
        }
        if (node2 === void 0)
          return;
        if (typeof node2 == "number")
          return isFinite(node2) ? "" + node2 : "null";
        if (typeof node2 !== "object")
          return JSON.stringify(node2);
        var i, out;
        if (Array.isArray(node2)) {
          out = "[";
          for (i = 0; i < node2.length; i++) {
            if (i)
              out += ",";
            out += stringify(node2[i]) || "null";
          }
          return out + "]";
        }
        if (node2 === null)
          return "null";
        if (seen.indexOf(node2) !== -1) {
          if (cycles)
            return JSON.stringify("__cycle__");
          throw new TypeError("Converting circular structure to JSON");
        }
        var seenIndex = seen.push(node2) - 1;
        var keys = Object.keys(node2).sort(cmp && cmp(node2));
        out = "";
        for (i = 0; i < keys.length; i++) {
          var key = keys[i];
          var value = stringify(node2[key]);
          if (!value)
            continue;
          if (out)
            out += ",";
          out += JSON.stringify(key) + ":" + value;
        }
        seen.splice(seenIndex, 1);
        return "{" + out + "}";
      }, "stringify"))(data);
    };
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/validate.js
var require_validate = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/validate.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate_validate(it2, $keyword, $ruleType) {
      var out = "";
      var $async = it2.schema.$async === true, $refKeywords = it2.util.schemaHasRulesExcept(it2.schema, it2.RULES.all, "$ref"), $id = it2.self._getId(it2.schema);
      if (it2.opts.strictKeywords) {
        var $unknownKwd = it2.util.schemaUnknownRules(it2.schema, it2.RULES.keywords);
        if ($unknownKwd) {
          var $keywordsMsg = "unknown keyword: " + $unknownKwd;
          if (it2.opts.strictKeywords === "log")
            it2.logger.warn($keywordsMsg);
          else
            throw new Error($keywordsMsg);
        }
      }
      if (it2.isTop) {
        out += " var validate = ";
        if ($async) {
          it2.async = true;
          out += "async ";
        }
        out += "function(data, dataPath, parentData, parentDataProperty, rootData) { 'use strict'; ";
        if ($id && (it2.opts.sourceCode || it2.opts.processCode)) {
          out += " " + ("/*# sourceURL=" + $id + " */") + " ";
        }
      }
      if (typeof it2.schema == "boolean" || !($refKeywords || it2.schema.$ref)) {
        var $keyword = "false schema";
        var $lvl = it2.level;
        var $dataLvl = it2.dataLevel;
        var $schema = it2.schema[$keyword];
        var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
        var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
        var $breakOnError = !it2.opts.allErrors;
        var $errorKeyword;
        var $data = "data" + ($dataLvl || "");
        var $valid = "valid" + $lvl;
        if (it2.schema === false) {
          if (it2.isTop) {
            $breakOnError = true;
          } else {
            out += " var " + $valid + " = false; ";
          }
          var $$outStack = $$outStack || [];
          $$outStack.push(out);
          out = "";
          if (it2.createErrors !== false) {
            out += " { keyword: '" + ($errorKeyword || "false schema") + "' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: {} ";
            if (it2.opts.messages !== false) {
              out += " , message: 'boolean schema is false' ";
            }
            if (it2.opts.verbose) {
              out += " , schema: false , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
            }
            out += " } ";
          } else {
            out += " {} ";
          }
          var __err = out;
          out = $$outStack.pop();
          if (!it2.compositeRule && $breakOnError) {
            if (it2.async) {
              out += " throw new ValidationError([" + __err + "]); ";
            } else {
              out += " validate.errors = [" + __err + "]; return false; ";
            }
          } else {
            out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
          }
        } else {
          if (it2.isTop) {
            if ($async) {
              out += " return data; ";
            } else {
              out += " validate.errors = null; return true; ";
            }
          } else {
            out += " var " + $valid + " = true; ";
          }
        }
        if (it2.isTop) {
          out += " }; return validate; ";
        }
        return out;
      }
      if (it2.isTop) {
        var $top = it2.isTop, $lvl = it2.level = 0, $dataLvl = it2.dataLevel = 0, $data = "data";
        it2.rootId = it2.resolve.fullPath(it2.self._getId(it2.root.schema));
        it2.baseId = it2.baseId || it2.rootId;
        delete it2.isTop;
        it2.dataPathArr = [""];
        if (it2.schema.default !== void 0 && it2.opts.useDefaults && it2.opts.strictDefaults) {
          var $defaultMsg = "default is ignored in the schema root";
          if (it2.opts.strictDefaults === "log")
            it2.logger.warn($defaultMsg);
          else
            throw new Error($defaultMsg);
        }
        out += " var vErrors = null; ";
        out += " var errors = 0;     ";
        out += " if (rootData === undefined) rootData = data; ";
      } else {
        var $lvl = it2.level, $dataLvl = it2.dataLevel, $data = "data" + ($dataLvl || "");
        if ($id)
          it2.baseId = it2.resolve.url(it2.baseId, $id);
        if ($async && !it2.async)
          throw new Error("async schema in sync schema");
        out += " var errs_" + $lvl + " = errors;";
      }
      var $valid = "valid" + $lvl, $breakOnError = !it2.opts.allErrors, $closingBraces1 = "", $closingBraces2 = "";
      var $errorKeyword;
      var $typeSchema = it2.schema.type, $typeIsArray = Array.isArray($typeSchema);
      if ($typeSchema && it2.opts.nullable && it2.schema.nullable === true) {
        if ($typeIsArray) {
          if ($typeSchema.indexOf("null") == -1)
            $typeSchema = $typeSchema.concat("null");
        } else if ($typeSchema != "null") {
          $typeSchema = [$typeSchema, "null"];
          $typeIsArray = true;
        }
      }
      if ($typeIsArray && $typeSchema.length == 1) {
        $typeSchema = $typeSchema[0];
        $typeIsArray = false;
      }
      if (it2.schema.$ref && $refKeywords) {
        if (it2.opts.extendRefs == "fail") {
          throw new Error('$ref: validation keywords used in schema at path "' + it2.errSchemaPath + '" (see option extendRefs)');
        } else if (it2.opts.extendRefs !== true) {
          $refKeywords = false;
          it2.logger.warn('$ref: keywords ignored in schema at path "' + it2.errSchemaPath + '"');
        }
      }
      if (it2.schema.$comment && it2.opts.$comment) {
        out += " " + it2.RULES.all.$comment.code(it2, "$comment");
      }
      if ($typeSchema) {
        if (it2.opts.coerceTypes) {
          var $coerceToTypes = it2.util.coerceToTypes(it2.opts.coerceTypes, $typeSchema);
        }
        var $rulesGroup = it2.RULES.types[$typeSchema];
        if ($coerceToTypes || $typeIsArray || $rulesGroup === true || $rulesGroup && !$shouldUseGroup($rulesGroup)) {
          var $schemaPath = it2.schemaPath + ".type", $errSchemaPath = it2.errSchemaPath + "/type";
          var $schemaPath = it2.schemaPath + ".type", $errSchemaPath = it2.errSchemaPath + "/type", $method = $typeIsArray ? "checkDataTypes" : "checkDataType";
          out += " if (" + it2.util[$method]($typeSchema, $data, it2.opts.strictNumbers, true) + ") { ";
          if ($coerceToTypes) {
            var $dataType = "dataType" + $lvl, $coerced = "coerced" + $lvl;
            out += " var " + $dataType + " = typeof " + $data + "; var " + $coerced + " = undefined; ";
            if (it2.opts.coerceTypes == "array") {
              out += " if (" + $dataType + " == 'object' && Array.isArray(" + $data + ") && " + $data + ".length == 1) { " + $data + " = " + $data + "[0]; " + $dataType + " = typeof " + $data + "; if (" + it2.util.checkDataType(it2.schema.type, $data, it2.opts.strictNumbers) + ") " + $coerced + " = " + $data + "; } ";
            }
            out += " if (" + $coerced + " !== undefined) ; ";
            var arr1 = $coerceToTypes;
            if (arr1) {
              var $type, $i = -1, l1 = arr1.length - 1;
              while ($i < l1) {
                $type = arr1[$i += 1];
                if ($type == "string") {
                  out += " else if (" + $dataType + " == 'number' || " + $dataType + " == 'boolean') " + $coerced + " = '' + " + $data + "; else if (" + $data + " === null) " + $coerced + " = ''; ";
                } else if ($type == "number" || $type == "integer") {
                  out += " else if (" + $dataType + " == 'boolean' || " + $data + " === null || (" + $dataType + " == 'string' && " + $data + " && " + $data + " == +" + $data + " ";
                  if ($type == "integer") {
                    out += " && !(" + $data + " % 1)";
                  }
                  out += ")) " + $coerced + " = +" + $data + "; ";
                } else if ($type == "boolean") {
                  out += " else if (" + $data + " === 'false' || " + $data + " === 0 || " + $data + " === null) " + $coerced + " = false; else if (" + $data + " === 'true' || " + $data + " === 1) " + $coerced + " = true; ";
                } else if ($type == "null") {
                  out += " else if (" + $data + " === '' || " + $data + " === 0 || " + $data + " === false) " + $coerced + " = null; ";
                } else if (it2.opts.coerceTypes == "array" && $type == "array") {
                  out += " else if (" + $dataType + " == 'string' || " + $dataType + " == 'number' || " + $dataType + " == 'boolean' || " + $data + " == null) " + $coerced + " = [" + $data + "]; ";
                }
              }
            }
            out += " else {   ";
            var $$outStack = $$outStack || [];
            $$outStack.push(out);
            out = "";
            if (it2.createErrors !== false) {
              out += " { keyword: '" + ($errorKeyword || "type") + "' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { type: '";
              if ($typeIsArray) {
                out += "" + $typeSchema.join(",");
              } else {
                out += "" + $typeSchema;
              }
              out += "' } ";
              if (it2.opts.messages !== false) {
                out += " , message: 'should be ";
                if ($typeIsArray) {
                  out += "" + $typeSchema.join(",");
                } else {
                  out += "" + $typeSchema;
                }
                out += "' ";
              }
              if (it2.opts.verbose) {
                out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
              }
              out += " } ";
            } else {
              out += " {} ";
            }
            var __err = out;
            out = $$outStack.pop();
            if (!it2.compositeRule && $breakOnError) {
              if (it2.async) {
                out += " throw new ValidationError([" + __err + "]); ";
              } else {
                out += " validate.errors = [" + __err + "]; return false; ";
              }
            } else {
              out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
            }
            out += " } if (" + $coerced + " !== undefined) {  ";
            var $parentData = $dataLvl ? "data" + ($dataLvl - 1 || "") : "parentData", $parentDataProperty = $dataLvl ? it2.dataPathArr[$dataLvl] : "parentDataProperty";
            out += " " + $data + " = " + $coerced + "; ";
            if (!$dataLvl) {
              out += "if (" + $parentData + " !== undefined)";
            }
            out += " " + $parentData + "[" + $parentDataProperty + "] = " + $coerced + "; } ";
          } else {
            var $$outStack = $$outStack || [];
            $$outStack.push(out);
            out = "";
            if (it2.createErrors !== false) {
              out += " { keyword: '" + ($errorKeyword || "type") + "' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { type: '";
              if ($typeIsArray) {
                out += "" + $typeSchema.join(",");
              } else {
                out += "" + $typeSchema;
              }
              out += "' } ";
              if (it2.opts.messages !== false) {
                out += " , message: 'should be ";
                if ($typeIsArray) {
                  out += "" + $typeSchema.join(",");
                } else {
                  out += "" + $typeSchema;
                }
                out += "' ";
              }
              if (it2.opts.verbose) {
                out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
              }
              out += " } ";
            } else {
              out += " {} ";
            }
            var __err = out;
            out = $$outStack.pop();
            if (!it2.compositeRule && $breakOnError) {
              if (it2.async) {
                out += " throw new ValidationError([" + __err + "]); ";
              } else {
                out += " validate.errors = [" + __err + "]; return false; ";
              }
            } else {
              out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
            }
          }
          out += " } ";
        }
      }
      if (it2.schema.$ref && !$refKeywords) {
        out += " " + it2.RULES.all.$ref.code(it2, "$ref") + " ";
        if ($breakOnError) {
          out += " } if (errors === ";
          if ($top) {
            out += "0";
          } else {
            out += "errs_" + $lvl;
          }
          out += ") { ";
          $closingBraces2 += "}";
        }
      } else {
        var arr2 = it2.RULES;
        if (arr2) {
          var $rulesGroup, i2 = -1, l2 = arr2.length - 1;
          while (i2 < l2) {
            $rulesGroup = arr2[i2 += 1];
            if ($shouldUseGroup($rulesGroup)) {
              if ($rulesGroup.type) {
                out += " if (" + it2.util.checkDataType($rulesGroup.type, $data, it2.opts.strictNumbers) + ") { ";
              }
              if (it2.opts.useDefaults) {
                if ($rulesGroup.type == "object" && it2.schema.properties) {
                  var $schema = it2.schema.properties, $schemaKeys = Object.keys($schema);
                  var arr3 = $schemaKeys;
                  if (arr3) {
                    var $propertyKey, i3 = -1, l3 = arr3.length - 1;
                    while (i3 < l3) {
                      $propertyKey = arr3[i3 += 1];
                      var $sch = $schema[$propertyKey];
                      if ($sch.default !== void 0) {
                        var $passData = $data + it2.util.getProperty($propertyKey);
                        if (it2.compositeRule) {
                          if (it2.opts.strictDefaults) {
                            var $defaultMsg = "default is ignored for: " + $passData;
                            if (it2.opts.strictDefaults === "log")
                              it2.logger.warn($defaultMsg);
                            else
                              throw new Error($defaultMsg);
                          }
                        } else {
                          out += " if (" + $passData + " === undefined ";
                          if (it2.opts.useDefaults == "empty") {
                            out += " || " + $passData + " === null || " + $passData + " === '' ";
                          }
                          out += " ) " + $passData + " = ";
                          if (it2.opts.useDefaults == "shared") {
                            out += " " + it2.useDefault($sch.default) + " ";
                          } else {
                            out += " " + JSON.stringify($sch.default) + " ";
                          }
                          out += "; ";
                        }
                      }
                    }
                  }
                } else if ($rulesGroup.type == "array" && Array.isArray(it2.schema.items)) {
                  var arr4 = it2.schema.items;
                  if (arr4) {
                    var $sch, $i = -1, l4 = arr4.length - 1;
                    while ($i < l4) {
                      $sch = arr4[$i += 1];
                      if ($sch.default !== void 0) {
                        var $passData = $data + "[" + $i + "]";
                        if (it2.compositeRule) {
                          if (it2.opts.strictDefaults) {
                            var $defaultMsg = "default is ignored for: " + $passData;
                            if (it2.opts.strictDefaults === "log")
                              it2.logger.warn($defaultMsg);
                            else
                              throw new Error($defaultMsg);
                          }
                        } else {
                          out += " if (" + $passData + " === undefined ";
                          if (it2.opts.useDefaults == "empty") {
                            out += " || " + $passData + " === null || " + $passData + " === '' ";
                          }
                          out += " ) " + $passData + " = ";
                          if (it2.opts.useDefaults == "shared") {
                            out += " " + it2.useDefault($sch.default) + " ";
                          } else {
                            out += " " + JSON.stringify($sch.default) + " ";
                          }
                          out += "; ";
                        }
                      }
                    }
                  }
                }
              }
              var arr5 = $rulesGroup.rules;
              if (arr5) {
                var $rule, i5 = -1, l5 = arr5.length - 1;
                while (i5 < l5) {
                  $rule = arr5[i5 += 1];
                  if ($shouldUseRule($rule)) {
                    var $code = $rule.code(it2, $rule.keyword, $rulesGroup.type);
                    if ($code) {
                      out += " " + $code + " ";
                      if ($breakOnError) {
                        $closingBraces1 += "}";
                      }
                    }
                  }
                }
              }
              if ($breakOnError) {
                out += " " + $closingBraces1 + " ";
                $closingBraces1 = "";
              }
              if ($rulesGroup.type) {
                out += " } ";
                if ($typeSchema && $typeSchema === $rulesGroup.type && !$coerceToTypes) {
                  out += " else { ";
                  var $schemaPath = it2.schemaPath + ".type", $errSchemaPath = it2.errSchemaPath + "/type";
                  var $$outStack = $$outStack || [];
                  $$outStack.push(out);
                  out = "";
                  if (it2.createErrors !== false) {
                    out += " { keyword: '" + ($errorKeyword || "type") + "' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { type: '";
                    if ($typeIsArray) {
                      out += "" + $typeSchema.join(",");
                    } else {
                      out += "" + $typeSchema;
                    }
                    out += "' } ";
                    if (it2.opts.messages !== false) {
                      out += " , message: 'should be ";
                      if ($typeIsArray) {
                        out += "" + $typeSchema.join(",");
                      } else {
                        out += "" + $typeSchema;
                      }
                      out += "' ";
                    }
                    if (it2.opts.verbose) {
                      out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
                    }
                    out += " } ";
                  } else {
                    out += " {} ";
                  }
                  var __err = out;
                  out = $$outStack.pop();
                  if (!it2.compositeRule && $breakOnError) {
                    if (it2.async) {
                      out += " throw new ValidationError([" + __err + "]); ";
                    } else {
                      out += " validate.errors = [" + __err + "]; return false; ";
                    }
                  } else {
                    out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
                  }
                  out += " } ";
                }
              }
              if ($breakOnError) {
                out += " if (errors === ";
                if ($top) {
                  out += "0";
                } else {
                  out += "errs_" + $lvl;
                }
                out += ") { ";
                $closingBraces2 += "}";
              }
            }
          }
        }
      }
      if ($breakOnError) {
        out += " " + $closingBraces2 + " ";
      }
      if ($top) {
        if ($async) {
          out += " if (errors === 0) return data;           ";
          out += " else throw new ValidationError(vErrors); ";
        } else {
          out += " validate.errors = vErrors; ";
          out += " return errors === 0;       ";
        }
        out += " }; return validate;";
      } else {
        out += " var " + $valid + " = errors === errs_" + $lvl + ";";
      }
      function $shouldUseGroup($rulesGroup2) {
        var rules = $rulesGroup2.rules;
        for (var i = 0; i < rules.length; i++)
          if ($shouldUseRule(rules[i]))
            return true;
      }
      __name($shouldUseGroup, "$shouldUseGroup");
      function $shouldUseRule($rule2) {
        return it2.schema[$rule2.keyword] !== void 0 || $rule2.implements && $ruleImplementsSomeKeyword($rule2);
      }
      __name($shouldUseRule, "$shouldUseRule");
      function $ruleImplementsSomeKeyword($rule2) {
        var impl = $rule2.implements;
        for (var i = 0; i < impl.length; i++)
          if (it2.schema[impl[i]] !== void 0)
            return true;
      }
      __name($ruleImplementsSomeKeyword, "$ruleImplementsSomeKeyword");
      return out;
    }, "generate_validate");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/index.js
var require_compile = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var resolve19 = require_resolve2();
    var util4 = require_util11();
    var errorClasses = require_error_classes();
    var stableStringify = require_fast_json_stable_stringify();
    var validateGenerator = require_validate();
    var ucs2length = util4.ucs2length;
    var equal = require_fast_deep_equal();
    var ValidationError = errorClasses.Validation;
    module3.exports = compile;
    function compile(schema, root, localRefs, baseId) {
      var self2 = this, opts = this._opts, refVal = [void 0], refs = {}, patterns = [], patternsHash = {}, defaults = [], defaultsHash = {}, customRules = [];
      root = root || { schema, refVal, refs };
      var c2 = checkCompiling.call(this, schema, root, baseId);
      var compilation = this._compilations[c2.index];
      if (c2.compiling)
        return compilation.callValidate = callValidate;
      var formats = this._formats;
      var RULES = this.RULES;
      try {
        var v2 = localCompile(schema, root, localRefs, baseId);
        compilation.validate = v2;
        var cv = compilation.callValidate;
        if (cv) {
          cv.schema = v2.schema;
          cv.errors = null;
          cv.refs = v2.refs;
          cv.refVal = v2.refVal;
          cv.root = v2.root;
          cv.$async = v2.$async;
          if (opts.sourceCode)
            cv.source = v2.source;
        }
        return v2;
      } finally {
        endCompiling.call(this, schema, root, baseId);
      }
      function callValidate() {
        var validate2 = compilation.validate;
        var result = validate2.apply(this, arguments);
        callValidate.errors = validate2.errors;
        return result;
      }
      __name(callValidate, "callValidate");
      function localCompile(_schema, _root, localRefs2, baseId2) {
        var isRoot = !_root || _root && _root.schema == _schema;
        if (_root.schema != root.schema)
          return compile.call(self2, _schema, _root, localRefs2, baseId2);
        var $async = _schema.$async === true;
        var sourceCode = validateGenerator({
          isTop: true,
          schema: _schema,
          isRoot,
          baseId: baseId2,
          root: _root,
          schemaPath: "",
          errSchemaPath: "#",
          errorPath: '""',
          MissingRefError: errorClasses.MissingRef,
          RULES,
          validate: validateGenerator,
          util: util4,
          resolve: resolve19,
          resolveRef,
          usePattern,
          useDefault,
          useCustomRule,
          opts,
          formats,
          logger: self2.logger,
          self: self2
        });
        sourceCode = vars(refVal, refValCode) + vars(patterns, patternCode) + vars(defaults, defaultCode) + vars(customRules, customRuleCode) + sourceCode;
        if (opts.processCode)
          sourceCode = opts.processCode(sourceCode, _schema);
        var validate2;
        try {
          var makeValidate = new Function(
            "self",
            "RULES",
            "formats",
            "root",
            "refVal",
            "defaults",
            "customRules",
            "equal",
            "ucs2length",
            "ValidationError",
            sourceCode
          );
          validate2 = makeValidate(
            self2,
            RULES,
            formats,
            root,
            refVal,
            defaults,
            customRules,
            equal,
            ucs2length,
            ValidationError
          );
          refVal[0] = validate2;
        } catch (e3) {
          self2.logger.error("Error compiling schema, function code:", sourceCode);
          throw e3;
        }
        validate2.schema = _schema;
        validate2.errors = null;
        validate2.refs = refs;
        validate2.refVal = refVal;
        validate2.root = isRoot ? validate2 : _root;
        if ($async)
          validate2.$async = true;
        if (opts.sourceCode === true) {
          validate2.source = {
            code: sourceCode,
            patterns,
            defaults
          };
        }
        return validate2;
      }
      __name(localCompile, "localCompile");
      function resolveRef(baseId2, ref, isRoot) {
        ref = resolve19.url(baseId2, ref);
        var refIndex = refs[ref];
        var _refVal, refCode;
        if (refIndex !== void 0) {
          _refVal = refVal[refIndex];
          refCode = "refVal[" + refIndex + "]";
          return resolvedRef(_refVal, refCode);
        }
        if (!isRoot && root.refs) {
          var rootRefId = root.refs[ref];
          if (rootRefId !== void 0) {
            _refVal = root.refVal[rootRefId];
            refCode = addLocalRef(ref, _refVal);
            return resolvedRef(_refVal, refCode);
          }
        }
        refCode = addLocalRef(ref);
        var v3 = resolve19.call(self2, localCompile, root, ref);
        if (v3 === void 0) {
          var localSchema = localRefs && localRefs[ref];
          if (localSchema) {
            v3 = resolve19.inlineRef(localSchema, opts.inlineRefs) ? localSchema : compile.call(self2, localSchema, root, localRefs, baseId2);
          }
        }
        if (v3 === void 0) {
          removeLocalRef(ref);
        } else {
          replaceLocalRef(ref, v3);
          return resolvedRef(v3, refCode);
        }
      }
      __name(resolveRef, "resolveRef");
      function addLocalRef(ref, v3) {
        var refId = refVal.length;
        refVal[refId] = v3;
        refs[ref] = refId;
        return "refVal" + refId;
      }
      __name(addLocalRef, "addLocalRef");
      function removeLocalRef(ref) {
        delete refs[ref];
      }
      __name(removeLocalRef, "removeLocalRef");
      function replaceLocalRef(ref, v3) {
        var refId = refs[ref];
        refVal[refId] = v3;
      }
      __name(replaceLocalRef, "replaceLocalRef");
      function resolvedRef(refVal2, code) {
        return typeof refVal2 == "object" || typeof refVal2 == "boolean" ? { code, schema: refVal2, inline: true } : { code, $async: refVal2 && !!refVal2.$async };
      }
      __name(resolvedRef, "resolvedRef");
      function usePattern(regexStr) {
        var index = patternsHash[regexStr];
        if (index === void 0) {
          index = patternsHash[regexStr] = patterns.length;
          patterns[index] = regexStr;
        }
        return "pattern" + index;
      }
      __name(usePattern, "usePattern");
      function useDefault(value) {
        switch (typeof value) {
          case "boolean":
          case "number":
            return "" + value;
          case "string":
            return util4.toQuotedString(value);
          case "object":
            if (value === null)
              return "null";
            var valueStr = stableStringify(value);
            var index = defaultsHash[valueStr];
            if (index === void 0) {
              index = defaultsHash[valueStr] = defaults.length;
              defaults[index] = value;
            }
            return "default" + index;
        }
      }
      __name(useDefault, "useDefault");
      function useCustomRule(rule, schema2, parentSchema, it2) {
        if (self2._opts.validateSchema !== false) {
          var deps = rule.definition.dependencies;
          if (deps && !deps.every(function(keyword) {
            return Object.prototype.hasOwnProperty.call(parentSchema, keyword);
          }))
            throw new Error("parent schema must have all required keywords: " + deps.join(","));
          var validateSchema = rule.definition.validateSchema;
          if (validateSchema) {
            var valid = validateSchema(schema2);
            if (!valid) {
              var message = "keyword schema is invalid: " + self2.errorsText(validateSchema.errors);
              if (self2._opts.validateSchema == "log")
                self2.logger.error(message);
              else
                throw new Error(message);
            }
          }
        }
        var compile2 = rule.definition.compile, inline = rule.definition.inline, macro = rule.definition.macro;
        var validate2;
        if (compile2) {
          validate2 = compile2.call(self2, schema2, parentSchema, it2);
        } else if (macro) {
          validate2 = macro.call(self2, schema2, parentSchema, it2);
          if (opts.validateSchema !== false)
            self2.validateSchema(validate2, true);
        } else if (inline) {
          validate2 = inline.call(self2, it2, rule.keyword, schema2, parentSchema);
        } else {
          validate2 = rule.definition.validate;
          if (!validate2)
            return;
        }
        if (validate2 === void 0)
          throw new Error('custom keyword "' + rule.keyword + '"failed to compile');
        var index = customRules.length;
        customRules[index] = validate2;
        return {
          code: "customRule" + index,
          validate: validate2
        };
      }
      __name(useCustomRule, "useCustomRule");
    }
    __name(compile, "compile");
    function checkCompiling(schema, root, baseId) {
      var index = compIndex.call(this, schema, root, baseId);
      if (index >= 0)
        return { index, compiling: true };
      index = this._compilations.length;
      this._compilations[index] = {
        schema,
        root,
        baseId
      };
      return { index, compiling: false };
    }
    __name(checkCompiling, "checkCompiling");
    function endCompiling(schema, root, baseId) {
      var i = compIndex.call(this, schema, root, baseId);
      if (i >= 0)
        this._compilations.splice(i, 1);
    }
    __name(endCompiling, "endCompiling");
    function compIndex(schema, root, baseId) {
      for (var i = 0; i < this._compilations.length; i++) {
        var c2 = this._compilations[i];
        if (c2.schema == schema && c2.root == root && c2.baseId == baseId)
          return i;
      }
      return -1;
    }
    __name(compIndex, "compIndex");
    function patternCode(i, patterns) {
      return "var pattern" + i + " = new RegExp(" + util4.toQuotedString(patterns[i]) + ");";
    }
    __name(patternCode, "patternCode");
    function defaultCode(i) {
      return "var default" + i + " = defaults[" + i + "];";
    }
    __name(defaultCode, "defaultCode");
    function refValCode(i, refVal) {
      return refVal[i] === void 0 ? "" : "var refVal" + i + " = refVal[" + i + "];";
    }
    __name(refValCode, "refValCode");
    function customRuleCode(i) {
      return "var customRule" + i + " = customRules[" + i + "];";
    }
    __name(customRuleCode, "customRuleCode");
    function vars(arr, statement) {
      if (!arr.length)
        return "";
      var code = "";
      for (var i = 0; i < arr.length; i++)
        code += statement(i, arr);
      return code;
    }
    __name(vars, "vars");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/cache.js
var require_cache2 = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/cache.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var Cache3 = module3.exports = /* @__PURE__ */ __name(function Cache4() {
      this._cache = {};
    }, "Cache");
    Cache3.prototype.put = /* @__PURE__ */ __name(function Cache_put(key, value) {
      this._cache[key] = value;
    }, "Cache_put");
    Cache3.prototype.get = /* @__PURE__ */ __name(function Cache_get(key) {
      return this._cache[key];
    }, "Cache_get");
    Cache3.prototype.del = /* @__PURE__ */ __name(function Cache_del(key) {
      delete this._cache[key];
    }, "Cache_del");
    Cache3.prototype.clear = /* @__PURE__ */ __name(function Cache_clear() {
      this._cache = {};
    }, "Cache_clear");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/formats.js
var require_formats2 = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/formats.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var util4 = require_util11();
    var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
    var DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
    var TIME = /^(\d\d):(\d\d):(\d\d)(\.\d+)?(z|[+-]\d\d(?::?\d\d)?)?$/i;
    var HOSTNAME = /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i;
    var URI = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
    var URIREF = /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
    var URITEMPLATE = /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i;
    var URL7 = /^(?:(?:http[s\u017F]?|ftp):\/\/)(?:(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+(?::(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*)?@)?(?:(?!10(?:\.[0-9]{1,3}){3})(?!127(?:\.[0-9]{1,3}){3})(?!169\.254(?:\.[0-9]{1,3}){2})(?!192\.168(?:\.[0-9]{1,3}){2})(?!172\.(?:1[6-9]|2[0-9]|3[01])(?:\.[0-9]{1,3}){2})(?:[1-9][0-9]?|1[0-9][0-9]|2[01][0-9]|22[0-3])(?:\.(?:1?[0-9]{1,2}|2[0-4][0-9]|25[0-5])){2}(?:\.(?:[1-9][0-9]?|1[0-9][0-9]|2[0-4][0-9]|25[0-4]))|(?:(?:(?:[0-9a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+-)*(?:[0-9a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+)(?:\.(?:(?:[0-9a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+-)*(?:[0-9a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+)*(?:\.(?:(?:[a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]){2,})))(?::[0-9]{2,5})?(?:\/(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*)?$/i;
    var UUID = /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i;
    var JSON_POINTER = /^(?:\/(?:[^~/]|~0|~1)*)*$/;
    var JSON_POINTER_URI_FRAGMENT = /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i;
    var RELATIVE_JSON_POINTER = /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/;
    module3.exports = formats;
    function formats(mode) {
      mode = mode == "full" ? "full" : "fast";
      return util4.copy(formats[mode]);
    }
    __name(formats, "formats");
    formats.fast = {
      // date: http://tools.ietf.org/html/rfc3339#section-5.6
      date: /^\d\d\d\d-[0-1]\d-[0-3]\d$/,
      // date-time: http://tools.ietf.org/html/rfc3339#section-5.6
      time: /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i,
      "date-time": /^\d\d\d\d-[0-1]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i,
      // uri: https://github.com/mafintosh/is-my-json-valid/blob/master/formats.js
      uri: /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i,
      "uri-reference": /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i,
      "uri-template": URITEMPLATE,
      url: URL7,
      // email (sources from jsen validator):
      // http://stackoverflow.com/questions/201323/using-a-regular-expression-to-validate-an-email-address#answer-8829363
      // http://www.w3.org/TR/html5/forms.html#valid-e-mail-address (search for 'willful violation')
      email: /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i,
      hostname: HOSTNAME,
      // optimized https://www.safaribooksonline.com/library/view/regular-expressions-cookbook/9780596802837/ch07s16.html
      ipv4: /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/,
      // optimized http://stackoverflow.com/questions/53497/regular-expression-that-matches-valid-ipv6-addresses
      ipv6: /^\s*(?:(?:(?:[0-9a-f]{1,4}:){7}(?:[0-9a-f]{1,4}|:))|(?:(?:[0-9a-f]{1,4}:){6}(?::[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){5}(?:(?:(?::[0-9a-f]{1,4}){1,2})|:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){4}(?:(?:(?::[0-9a-f]{1,4}){1,3})|(?:(?::[0-9a-f]{1,4})?:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){3}(?:(?:(?::[0-9a-f]{1,4}){1,4})|(?:(?::[0-9a-f]{1,4}){0,2}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){2}(?:(?:(?::[0-9a-f]{1,4}){1,5})|(?:(?::[0-9a-f]{1,4}){0,3}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){1}(?:(?:(?::[0-9a-f]{1,4}){1,6})|(?:(?::[0-9a-f]{1,4}){0,4}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?::(?:(?:(?::[0-9a-f]{1,4}){1,7})|(?:(?::[0-9a-f]{1,4}){0,5}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(?:%.+)?\s*$/i,
      regex: regex2,
      // uuid: http://tools.ietf.org/html/rfc4122
      uuid: UUID,
      // JSON-pointer: https://tools.ietf.org/html/rfc6901
      // uri fragment: https://tools.ietf.org/html/rfc3986#appendix-A
      "json-pointer": JSON_POINTER,
      "json-pointer-uri-fragment": JSON_POINTER_URI_FRAGMENT,
      // relative JSON-pointer: http://tools.ietf.org/html/draft-luff-relative-json-pointer-00
      "relative-json-pointer": RELATIVE_JSON_POINTER
    };
    formats.full = {
      date,
      time,
      "date-time": date_time,
      uri,
      "uri-reference": URIREF,
      "uri-template": URITEMPLATE,
      url: URL7,
      email: /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i,
      hostname: HOSTNAME,
      ipv4: /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/,
      ipv6: /^\s*(?:(?:(?:[0-9a-f]{1,4}:){7}(?:[0-9a-f]{1,4}|:))|(?:(?:[0-9a-f]{1,4}:){6}(?::[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){5}(?:(?:(?::[0-9a-f]{1,4}){1,2})|:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){4}(?:(?:(?::[0-9a-f]{1,4}){1,3})|(?:(?::[0-9a-f]{1,4})?:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){3}(?:(?:(?::[0-9a-f]{1,4}){1,4})|(?:(?::[0-9a-f]{1,4}){0,2}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){2}(?:(?:(?::[0-9a-f]{1,4}){1,5})|(?:(?::[0-9a-f]{1,4}){0,3}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){1}(?:(?:(?::[0-9a-f]{1,4}){1,6})|(?:(?::[0-9a-f]{1,4}){0,4}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?::(?:(?:(?::[0-9a-f]{1,4}){1,7})|(?:(?::[0-9a-f]{1,4}){0,5}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(?:%.+)?\s*$/i,
      regex: regex2,
      uuid: UUID,
      "json-pointer": JSON_POINTER,
      "json-pointer-uri-fragment": JSON_POINTER_URI_FRAGMENT,
      "relative-json-pointer": RELATIVE_JSON_POINTER
    };
    function isLeapYear(year2) {
      return year2 % 4 === 0 && (year2 % 100 !== 0 || year2 % 400 === 0);
    }
    __name(isLeapYear, "isLeapYear");
    function date(str) {
      var matches = str.match(DATE);
      if (!matches)
        return false;
      var year2 = +matches[1];
      var month2 = +matches[2];
      var day2 = +matches[3];
      return month2 >= 1 && month2 <= 12 && day2 >= 1 && day2 <= (month2 == 2 && isLeapYear(year2) ? 29 : DAYS[month2]);
    }
    __name(date, "date");
    function time(str, full) {
      var matches = str.match(TIME);
      if (!matches)
        return false;
      var hour2 = matches[1];
      var minute2 = matches[2];
      var second = matches[3];
      var timeZone = matches[5];
      return (hour2 <= 23 && minute2 <= 59 && second <= 59 || hour2 == 23 && minute2 == 59 && second == 60) && (!full || timeZone);
    }
    __name(time, "time");
    var DATE_TIME_SEPARATOR = /t|\s/i;
    function date_time(str) {
      var dateTime = str.split(DATE_TIME_SEPARATOR);
      return dateTime.length == 2 && date(dateTime[0]) && time(dateTime[1], true);
    }
    __name(date_time, "date_time");
    var NOT_URI_FRAGMENT = /\/|:/;
    function uri(str) {
      return NOT_URI_FRAGMENT.test(str) && URI.test(str);
    }
    __name(uri, "uri");
    var Z_ANCHOR = /[^\\]\\Z/;
    function regex2(str) {
      if (Z_ANCHOR.test(str))
        return false;
      try {
        new RegExp(str);
        return true;
      } catch (e3) {
        return false;
      }
    }
    __name(regex2, "regex");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/ref.js
var require_ref = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/ref.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate_ref(it2, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it2.level;
      var $dataLvl = it2.dataLevel;
      var $schema = it2.schema[$keyword];
      var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it2.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $valid = "valid" + $lvl;
      var $async, $refCode;
      if ($schema == "#" || $schema == "#/") {
        if (it2.isRoot) {
          $async = it2.async;
          $refCode = "validate";
        } else {
          $async = it2.root.schema.$async === true;
          $refCode = "root.refVal[0]";
        }
      } else {
        var $refVal = it2.resolveRef(it2.baseId, $schema, it2.isRoot);
        if ($refVal === void 0) {
          var $message = it2.MissingRefError.message(it2.baseId, $schema);
          if (it2.opts.missingRefs == "fail") {
            it2.logger.error($message);
            var $$outStack = $$outStack || [];
            $$outStack.push(out);
            out = "";
            if (it2.createErrors !== false) {
              out += " { keyword: '$ref' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { ref: '" + it2.util.escapeQuotes($schema) + "' } ";
              if (it2.opts.messages !== false) {
                out += " , message: 'can\\'t resolve reference " + it2.util.escapeQuotes($schema) + "' ";
              }
              if (it2.opts.verbose) {
                out += " , schema: " + it2.util.toQuotedString($schema) + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
              }
              out += " } ";
            } else {
              out += " {} ";
            }
            var __err = out;
            out = $$outStack.pop();
            if (!it2.compositeRule && $breakOnError) {
              if (it2.async) {
                out += " throw new ValidationError([" + __err + "]); ";
              } else {
                out += " validate.errors = [" + __err + "]; return false; ";
              }
            } else {
              out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
            }
            if ($breakOnError) {
              out += " if (false) { ";
            }
          } else if (it2.opts.missingRefs == "ignore") {
            it2.logger.warn($message);
            if ($breakOnError) {
              out += " if (true) { ";
            }
          } else {
            throw new it2.MissingRefError(it2.baseId, $schema, $message);
          }
        } else if ($refVal.inline) {
          var $it = it2.util.copy(it2);
          $it.level++;
          var $nextValid = "valid" + $it.level;
          $it.schema = $refVal.schema;
          $it.schemaPath = "";
          $it.errSchemaPath = $schema;
          var $code = it2.validate($it).replace(/validate\.schema/g, $refVal.code);
          out += " " + $code + " ";
          if ($breakOnError) {
            out += " if (" + $nextValid + ") { ";
          }
        } else {
          $async = $refVal.$async === true || it2.async && $refVal.$async !== false;
          $refCode = $refVal.code;
        }
      }
      if ($refCode) {
        var $$outStack = $$outStack || [];
        $$outStack.push(out);
        out = "";
        if (it2.opts.passContext) {
          out += " " + $refCode + ".call(this, ";
        } else {
          out += " " + $refCode + "( ";
        }
        out += " " + $data + ", (dataPath || '')";
        if (it2.errorPath != '""') {
          out += " + " + it2.errorPath;
        }
        var $parentData = $dataLvl ? "data" + ($dataLvl - 1 || "") : "parentData", $parentDataProperty = $dataLvl ? it2.dataPathArr[$dataLvl] : "parentDataProperty";
        out += " , " + $parentData + " , " + $parentDataProperty + ", rootData)  ";
        var __callValidate = out;
        out = $$outStack.pop();
        if ($async) {
          if (!it2.async)
            throw new Error("async schema referenced by sync schema");
          if ($breakOnError) {
            out += " var " + $valid + "; ";
          }
          out += " try { await " + __callValidate + "; ";
          if ($breakOnError) {
            out += " " + $valid + " = true; ";
          }
          out += " } catch (e) { if (!(e instanceof ValidationError)) throw e; if (vErrors === null) vErrors = e.errors; else vErrors = vErrors.concat(e.errors); errors = vErrors.length; ";
          if ($breakOnError) {
            out += " " + $valid + " = false; ";
          }
          out += " } ";
          if ($breakOnError) {
            out += " if (" + $valid + ") { ";
          }
        } else {
          out += " if (!" + __callValidate + ") { if (vErrors === null) vErrors = " + $refCode + ".errors; else vErrors = vErrors.concat(" + $refCode + ".errors); errors = vErrors.length; } ";
          if ($breakOnError) {
            out += " else { ";
          }
        }
      }
      return out;
    }, "generate_ref");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/allOf.js
var require_allOf = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/allOf.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate_allOf(it2, $keyword, $ruleType) {
      var out = " ";
      var $schema = it2.schema[$keyword];
      var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
      var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it2.opts.allErrors;
      var $it = it2.util.copy(it2);
      var $closingBraces = "";
      $it.level++;
      var $nextValid = "valid" + $it.level;
      var $currentBaseId = $it.baseId, $allSchemasEmpty = true;
      var arr1 = $schema;
      if (arr1) {
        var $sch, $i = -1, l1 = arr1.length - 1;
        while ($i < l1) {
          $sch = arr1[$i += 1];
          if (it2.opts.strictKeywords ? typeof $sch == "object" && Object.keys($sch).length > 0 || $sch === false : it2.util.schemaHasRules($sch, it2.RULES.all)) {
            $allSchemasEmpty = false;
            $it.schema = $sch;
            $it.schemaPath = $schemaPath + "[" + $i + "]";
            $it.errSchemaPath = $errSchemaPath + "/" + $i;
            out += "  " + it2.validate($it) + " ";
            $it.baseId = $currentBaseId;
            if ($breakOnError) {
              out += " if (" + $nextValid + ") { ";
              $closingBraces += "}";
            }
          }
        }
      }
      if ($breakOnError) {
        if ($allSchemasEmpty) {
          out += " if (true) { ";
        } else {
          out += " " + $closingBraces.slice(0, -1) + " ";
        }
      }
      return out;
    }, "generate_allOf");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/anyOf.js
var require_anyOf = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/anyOf.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate_anyOf(it2, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it2.level;
      var $dataLvl = it2.dataLevel;
      var $schema = it2.schema[$keyword];
      var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
      var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it2.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $valid = "valid" + $lvl;
      var $errs = "errs__" + $lvl;
      var $it = it2.util.copy(it2);
      var $closingBraces = "";
      $it.level++;
      var $nextValid = "valid" + $it.level;
      var $noEmptySchema = $schema.every(function($sch2) {
        return it2.opts.strictKeywords ? typeof $sch2 == "object" && Object.keys($sch2).length > 0 || $sch2 === false : it2.util.schemaHasRules($sch2, it2.RULES.all);
      });
      if ($noEmptySchema) {
        var $currentBaseId = $it.baseId;
        out += " var " + $errs + " = errors; var " + $valid + " = false;  ";
        var $wasComposite = it2.compositeRule;
        it2.compositeRule = $it.compositeRule = true;
        var arr1 = $schema;
        if (arr1) {
          var $sch, $i = -1, l1 = arr1.length - 1;
          while ($i < l1) {
            $sch = arr1[$i += 1];
            $it.schema = $sch;
            $it.schemaPath = $schemaPath + "[" + $i + "]";
            $it.errSchemaPath = $errSchemaPath + "/" + $i;
            out += "  " + it2.validate($it) + " ";
            $it.baseId = $currentBaseId;
            out += " " + $valid + " = " + $valid + " || " + $nextValid + "; if (!" + $valid + ") { ";
            $closingBraces += "}";
          }
        }
        it2.compositeRule = $it.compositeRule = $wasComposite;
        out += " " + $closingBraces + " if (!" + $valid + ") {   var err =   ";
        if (it2.createErrors !== false) {
          out += " { keyword: 'anyOf' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: {} ";
          if (it2.opts.messages !== false) {
            out += " , message: 'should match some schema in anyOf' ";
          }
          if (it2.opts.verbose) {
            out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
          }
          out += " } ";
        } else {
          out += " {} ";
        }
        out += ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
        if (!it2.compositeRule && $breakOnError) {
          if (it2.async) {
            out += " throw new ValidationError(vErrors); ";
          } else {
            out += " validate.errors = vErrors; return false; ";
          }
        }
        out += " } else {  errors = " + $errs + "; if (vErrors !== null) { if (" + $errs + ") vErrors.length = " + $errs + "; else vErrors = null; } ";
        if (it2.opts.allErrors) {
          out += " } ";
        }
      } else {
        if ($breakOnError) {
          out += " if (true) { ";
        }
      }
      return out;
    }, "generate_anyOf");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/comment.js
var require_comment = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/comment.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate_comment(it2, $keyword, $ruleType) {
      var out = " ";
      var $schema = it2.schema[$keyword];
      var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it2.opts.allErrors;
      var $comment = it2.util.toQuotedString($schema);
      if (it2.opts.$comment === true) {
        out += " console.log(" + $comment + ");";
      } else if (typeof it2.opts.$comment == "function") {
        out += " self._opts.$comment(" + $comment + ", " + it2.util.toQuotedString($errSchemaPath) + ", validate.root.schema);";
      }
      return out;
    }, "generate_comment");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/const.js
var require_const = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/const.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate_const(it2, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it2.level;
      var $dataLvl = it2.dataLevel;
      var $schema = it2.schema[$keyword];
      var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
      var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it2.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $valid = "valid" + $lvl;
      var $isData = it2.opts.$data && $schema && $schema.$data, $schemaValue;
      if ($isData) {
        out += " var schema" + $lvl + " = " + it2.util.getData($schema.$data, $dataLvl, it2.dataPathArr) + "; ";
        $schemaValue = "schema" + $lvl;
      } else {
        $schemaValue = $schema;
      }
      if (!$isData) {
        out += " var schema" + $lvl + " = validate.schema" + $schemaPath + ";";
      }
      out += "var " + $valid + " = equal(" + $data + ", schema" + $lvl + "); if (!" + $valid + ") {   ";
      var $$outStack = $$outStack || [];
      $$outStack.push(out);
      out = "";
      if (it2.createErrors !== false) {
        out += " { keyword: 'const' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { allowedValue: schema" + $lvl + " } ";
        if (it2.opts.messages !== false) {
          out += " , message: 'should be equal to constant' ";
        }
        if (it2.opts.verbose) {
          out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
        }
        out += " } ";
      } else {
        out += " {} ";
      }
      var __err = out;
      out = $$outStack.pop();
      if (!it2.compositeRule && $breakOnError) {
        if (it2.async) {
          out += " throw new ValidationError([" + __err + "]); ";
        } else {
          out += " validate.errors = [" + __err + "]; return false; ";
        }
      } else {
        out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
      }
      out += " }";
      if ($breakOnError) {
        out += " else { ";
      }
      return out;
    }, "generate_const");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/contains.js
var require_contains = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/contains.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate_contains(it2, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it2.level;
      var $dataLvl = it2.dataLevel;
      var $schema = it2.schema[$keyword];
      var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
      var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it2.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $valid = "valid" + $lvl;
      var $errs = "errs__" + $lvl;
      var $it = it2.util.copy(it2);
      var $closingBraces = "";
      $it.level++;
      var $nextValid = "valid" + $it.level;
      var $idx = "i" + $lvl, $dataNxt = $it.dataLevel = it2.dataLevel + 1, $nextData = "data" + $dataNxt, $currentBaseId = it2.baseId, $nonEmptySchema = it2.opts.strictKeywords ? typeof $schema == "object" && Object.keys($schema).length > 0 || $schema === false : it2.util.schemaHasRules($schema, it2.RULES.all);
      out += "var " + $errs + " = errors;var " + $valid + ";";
      if ($nonEmptySchema) {
        var $wasComposite = it2.compositeRule;
        it2.compositeRule = $it.compositeRule = true;
        $it.schema = $schema;
        $it.schemaPath = $schemaPath;
        $it.errSchemaPath = $errSchemaPath;
        out += " var " + $nextValid + " = false; for (var " + $idx + " = 0; " + $idx + " < " + $data + ".length; " + $idx + "++) { ";
        $it.errorPath = it2.util.getPathExpr(it2.errorPath, $idx, it2.opts.jsonPointers, true);
        var $passData = $data + "[" + $idx + "]";
        $it.dataPathArr[$dataNxt] = $idx;
        var $code = it2.validate($it);
        $it.baseId = $currentBaseId;
        if (it2.util.varOccurences($code, $nextData) < 2) {
          out += " " + it2.util.varReplace($code, $nextData, $passData) + " ";
        } else {
          out += " var " + $nextData + " = " + $passData + "; " + $code + " ";
        }
        out += " if (" + $nextValid + ") break; }  ";
        it2.compositeRule = $it.compositeRule = $wasComposite;
        out += " " + $closingBraces + " if (!" + $nextValid + ") {";
      } else {
        out += " if (" + $data + ".length == 0) {";
      }
      var $$outStack = $$outStack || [];
      $$outStack.push(out);
      out = "";
      if (it2.createErrors !== false) {
        out += " { keyword: 'contains' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: {} ";
        if (it2.opts.messages !== false) {
          out += " , message: 'should contain a valid item' ";
        }
        if (it2.opts.verbose) {
          out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
        }
        out += " } ";
      } else {
        out += " {} ";
      }
      var __err = out;
      out = $$outStack.pop();
      if (!it2.compositeRule && $breakOnError) {
        if (it2.async) {
          out += " throw new ValidationError([" + __err + "]); ";
        } else {
          out += " validate.errors = [" + __err + "]; return false; ";
        }
      } else {
        out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
      }
      out += " } else { ";
      if ($nonEmptySchema) {
        out += "  errors = " + $errs + "; if (vErrors !== null) { if (" + $errs + ") vErrors.length = " + $errs + "; else vErrors = null; } ";
      }
      if (it2.opts.allErrors) {
        out += " } ";
      }
      return out;
    }, "generate_contains");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/dependencies.js
var require_dependencies = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/dependencies.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate_dependencies(it2, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it2.level;
      var $dataLvl = it2.dataLevel;
      var $schema = it2.schema[$keyword];
      var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
      var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it2.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $errs = "errs__" + $lvl;
      var $it = it2.util.copy(it2);
      var $closingBraces = "";
      $it.level++;
      var $nextValid = "valid" + $it.level;
      var $schemaDeps = {}, $propertyDeps = {}, $ownProperties = it2.opts.ownProperties;
      for ($property in $schema) {
        if ($property == "__proto__")
          continue;
        var $sch = $schema[$property];
        var $deps = Array.isArray($sch) ? $propertyDeps : $schemaDeps;
        $deps[$property] = $sch;
      }
      out += "var " + $errs + " = errors;";
      var $currentErrorPath = it2.errorPath;
      out += "var missing" + $lvl + ";";
      for (var $property in $propertyDeps) {
        $deps = $propertyDeps[$property];
        if ($deps.length) {
          out += " if ( " + $data + it2.util.getProperty($property) + " !== undefined ";
          if ($ownProperties) {
            out += " && Object.prototype.hasOwnProperty.call(" + $data + ", '" + it2.util.escapeQuotes($property) + "') ";
          }
          if ($breakOnError) {
            out += " && ( ";
            var arr1 = $deps;
            if (arr1) {
              var $propertyKey, $i = -1, l1 = arr1.length - 1;
              while ($i < l1) {
                $propertyKey = arr1[$i += 1];
                if ($i) {
                  out += " || ";
                }
                var $prop = it2.util.getProperty($propertyKey), $useData = $data + $prop;
                out += " ( ( " + $useData + " === undefined ";
                if ($ownProperties) {
                  out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", '" + it2.util.escapeQuotes($propertyKey) + "') ";
                }
                out += ") && (missing" + $lvl + " = " + it2.util.toQuotedString(it2.opts.jsonPointers ? $propertyKey : $prop) + ") ) ";
              }
            }
            out += ")) {  ";
            var $propertyPath = "missing" + $lvl, $missingProperty = "' + " + $propertyPath + " + '";
            if (it2.opts._errorDataPathProperty) {
              it2.errorPath = it2.opts.jsonPointers ? it2.util.getPathExpr($currentErrorPath, $propertyPath, true) : $currentErrorPath + " + " + $propertyPath;
            }
            var $$outStack = $$outStack || [];
            $$outStack.push(out);
            out = "";
            if (it2.createErrors !== false) {
              out += " { keyword: 'dependencies' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { property: '" + it2.util.escapeQuotes($property) + "', missingProperty: '" + $missingProperty + "', depsCount: " + $deps.length + ", deps: '" + it2.util.escapeQuotes($deps.length == 1 ? $deps[0] : $deps.join(", ")) + "' } ";
              if (it2.opts.messages !== false) {
                out += " , message: 'should have ";
                if ($deps.length == 1) {
                  out += "property " + it2.util.escapeQuotes($deps[0]);
                } else {
                  out += "properties " + it2.util.escapeQuotes($deps.join(", "));
                }
                out += " when property " + it2.util.escapeQuotes($property) + " is present' ";
              }
              if (it2.opts.verbose) {
                out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
              }
              out += " } ";
            } else {
              out += " {} ";
            }
            var __err = out;
            out = $$outStack.pop();
            if (!it2.compositeRule && $breakOnError) {
              if (it2.async) {
                out += " throw new ValidationError([" + __err + "]); ";
              } else {
                out += " validate.errors = [" + __err + "]; return false; ";
              }
            } else {
              out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
            }
          } else {
            out += " ) { ";
            var arr2 = $deps;
            if (arr2) {
              var $propertyKey, i2 = -1, l2 = arr2.length - 1;
              while (i2 < l2) {
                $propertyKey = arr2[i2 += 1];
                var $prop = it2.util.getProperty($propertyKey), $missingProperty = it2.util.escapeQuotes($propertyKey), $useData = $data + $prop;
                if (it2.opts._errorDataPathProperty) {
                  it2.errorPath = it2.util.getPath($currentErrorPath, $propertyKey, it2.opts.jsonPointers);
                }
                out += " if ( " + $useData + " === undefined ";
                if ($ownProperties) {
                  out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", '" + it2.util.escapeQuotes($propertyKey) + "') ";
                }
                out += ") {  var err =   ";
                if (it2.createErrors !== false) {
                  out += " { keyword: 'dependencies' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { property: '" + it2.util.escapeQuotes($property) + "', missingProperty: '" + $missingProperty + "', depsCount: " + $deps.length + ", deps: '" + it2.util.escapeQuotes($deps.length == 1 ? $deps[0] : $deps.join(", ")) + "' } ";
                  if (it2.opts.messages !== false) {
                    out += " , message: 'should have ";
                    if ($deps.length == 1) {
                      out += "property " + it2.util.escapeQuotes($deps[0]);
                    } else {
                      out += "properties " + it2.util.escapeQuotes($deps.join(", "));
                    }
                    out += " when property " + it2.util.escapeQuotes($property) + " is present' ";
                  }
                  if (it2.opts.verbose) {
                    out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
                  }
                  out += " } ";
                } else {
                  out += " {} ";
                }
                out += ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } ";
              }
            }
          }
          out += " }   ";
          if ($breakOnError) {
            $closingBraces += "}";
            out += " else { ";
          }
        }
      }
      it2.errorPath = $currentErrorPath;
      var $currentBaseId = $it.baseId;
      for (var $property in $schemaDeps) {
        var $sch = $schemaDeps[$property];
        if (it2.opts.strictKeywords ? typeof $sch == "object" && Object.keys($sch).length > 0 || $sch === false : it2.util.schemaHasRules($sch, it2.RULES.all)) {
          out += " " + $nextValid + " = true; if ( " + $data + it2.util.getProperty($property) + " !== undefined ";
          if ($ownProperties) {
            out += " && Object.prototype.hasOwnProperty.call(" + $data + ", '" + it2.util.escapeQuotes($property) + "') ";
          }
          out += ") { ";
          $it.schema = $sch;
          $it.schemaPath = $schemaPath + it2.util.getProperty($property);
          $it.errSchemaPath = $errSchemaPath + "/" + it2.util.escapeFragment($property);
          out += "  " + it2.validate($it) + " ";
          $it.baseId = $currentBaseId;
          out += " }  ";
          if ($breakOnError) {
            out += " if (" + $nextValid + ") { ";
            $closingBraces += "}";
          }
        }
      }
      if ($breakOnError) {
        out += "   " + $closingBraces + " if (" + $errs + " == errors) {";
      }
      return out;
    }, "generate_dependencies");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/enum.js
var require_enum = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/enum.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate_enum(it2, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it2.level;
      var $dataLvl = it2.dataLevel;
      var $schema = it2.schema[$keyword];
      var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
      var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it2.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $valid = "valid" + $lvl;
      var $isData = it2.opts.$data && $schema && $schema.$data, $schemaValue;
      if ($isData) {
        out += " var schema" + $lvl + " = " + it2.util.getData($schema.$data, $dataLvl, it2.dataPathArr) + "; ";
        $schemaValue = "schema" + $lvl;
      } else {
        $schemaValue = $schema;
      }
      var $i = "i" + $lvl, $vSchema = "schema" + $lvl;
      if (!$isData) {
        out += " var " + $vSchema + " = validate.schema" + $schemaPath + ";";
      }
      out += "var " + $valid + ";";
      if ($isData) {
        out += " if (schema" + $lvl + " === undefined) " + $valid + " = true; else if (!Array.isArray(schema" + $lvl + ")) " + $valid + " = false; else {";
      }
      out += "" + $valid + " = false;for (var " + $i + "=0; " + $i + "<" + $vSchema + ".length; " + $i + "++) if (equal(" + $data + ", " + $vSchema + "[" + $i + "])) { " + $valid + " = true; break; }";
      if ($isData) {
        out += "  }  ";
      }
      out += " if (!" + $valid + ") {   ";
      var $$outStack = $$outStack || [];
      $$outStack.push(out);
      out = "";
      if (it2.createErrors !== false) {
        out += " { keyword: 'enum' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { allowedValues: schema" + $lvl + " } ";
        if (it2.opts.messages !== false) {
          out += " , message: 'should be equal to one of the allowed values' ";
        }
        if (it2.opts.verbose) {
          out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
        }
        out += " } ";
      } else {
        out += " {} ";
      }
      var __err = out;
      out = $$outStack.pop();
      if (!it2.compositeRule && $breakOnError) {
        if (it2.async) {
          out += " throw new ValidationError([" + __err + "]); ";
        } else {
          out += " validate.errors = [" + __err + "]; return false; ";
        }
      } else {
        out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
      }
      out += " }";
      if ($breakOnError) {
        out += " else { ";
      }
      return out;
    }, "generate_enum");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/format.js
var require_format = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/format.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate_format(it2, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it2.level;
      var $dataLvl = it2.dataLevel;
      var $schema = it2.schema[$keyword];
      var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
      var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it2.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      if (it2.opts.format === false) {
        if ($breakOnError) {
          out += " if (true) { ";
        }
        return out;
      }
      var $isData = it2.opts.$data && $schema && $schema.$data, $schemaValue;
      if ($isData) {
        out += " var schema" + $lvl + " = " + it2.util.getData($schema.$data, $dataLvl, it2.dataPathArr) + "; ";
        $schemaValue = "schema" + $lvl;
      } else {
        $schemaValue = $schema;
      }
      var $unknownFormats = it2.opts.unknownFormats, $allowUnknown = Array.isArray($unknownFormats);
      if ($isData) {
        var $format = "format" + $lvl, $isObject = "isObject" + $lvl, $formatType = "formatType" + $lvl;
        out += " var " + $format + " = formats[" + $schemaValue + "]; var " + $isObject + " = typeof " + $format + " == 'object' && !(" + $format + " instanceof RegExp) && " + $format + ".validate; var " + $formatType + " = " + $isObject + " && " + $format + ".type || 'string'; if (" + $isObject + ") { ";
        if (it2.async) {
          out += " var async" + $lvl + " = " + $format + ".async; ";
        }
        out += " " + $format + " = " + $format + ".validate; } if (  ";
        if ($isData) {
          out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'string') || ";
        }
        out += " (";
        if ($unknownFormats != "ignore") {
          out += " (" + $schemaValue + " && !" + $format + " ";
          if ($allowUnknown) {
            out += " && self._opts.unknownFormats.indexOf(" + $schemaValue + ") == -1 ";
          }
          out += ") || ";
        }
        out += " (" + $format + " && " + $formatType + " == '" + $ruleType + "' && !(typeof " + $format + " == 'function' ? ";
        if (it2.async) {
          out += " (async" + $lvl + " ? await " + $format + "(" + $data + ") : " + $format + "(" + $data + ")) ";
        } else {
          out += " " + $format + "(" + $data + ") ";
        }
        out += " : " + $format + ".test(" + $data + "))))) {";
      } else {
        var $format = it2.formats[$schema];
        if (!$format) {
          if ($unknownFormats == "ignore") {
            it2.logger.warn('unknown format "' + $schema + '" ignored in schema at path "' + it2.errSchemaPath + '"');
            if ($breakOnError) {
              out += " if (true) { ";
            }
            return out;
          } else if ($allowUnknown && $unknownFormats.indexOf($schema) >= 0) {
            if ($breakOnError) {
              out += " if (true) { ";
            }
            return out;
          } else {
            throw new Error('unknown format "' + $schema + '" is used in schema at path "' + it2.errSchemaPath + '"');
          }
        }
        var $isObject = typeof $format == "object" && !($format instanceof RegExp) && $format.validate;
        var $formatType = $isObject && $format.type || "string";
        if ($isObject) {
          var $async = $format.async === true;
          $format = $format.validate;
        }
        if ($formatType != $ruleType) {
          if ($breakOnError) {
            out += " if (true) { ";
          }
          return out;
        }
        if ($async) {
          if (!it2.async)
            throw new Error("async format in sync schema");
          var $formatRef = "formats" + it2.util.getProperty($schema) + ".validate";
          out += " if (!(await " + $formatRef + "(" + $data + "))) { ";
        } else {
          out += " if (! ";
          var $formatRef = "formats" + it2.util.getProperty($schema);
          if ($isObject)
            $formatRef += ".validate";
          if (typeof $format == "function") {
            out += " " + $formatRef + "(" + $data + ") ";
          } else {
            out += " " + $formatRef + ".test(" + $data + ") ";
          }
          out += ") { ";
        }
      }
      var $$outStack = $$outStack || [];
      $$outStack.push(out);
      out = "";
      if (it2.createErrors !== false) {
        out += " { keyword: 'format' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { format:  ";
        if ($isData) {
          out += "" + $schemaValue;
        } else {
          out += "" + it2.util.toQuotedString($schema);
        }
        out += "  } ";
        if (it2.opts.messages !== false) {
          out += ` , message: 'should match format "`;
          if ($isData) {
            out += "' + " + $schemaValue + " + '";
          } else {
            out += "" + it2.util.escapeQuotes($schema);
          }
          out += `"' `;
        }
        if (it2.opts.verbose) {
          out += " , schema:  ";
          if ($isData) {
            out += "validate.schema" + $schemaPath;
          } else {
            out += "" + it2.util.toQuotedString($schema);
          }
          out += "         , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
        }
        out += " } ";
      } else {
        out += " {} ";
      }
      var __err = out;
      out = $$outStack.pop();
      if (!it2.compositeRule && $breakOnError) {
        if (it2.async) {
          out += " throw new ValidationError([" + __err + "]); ";
        } else {
          out += " validate.errors = [" + __err + "]; return false; ";
        }
      } else {
        out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
      }
      out += " } ";
      if ($breakOnError) {
        out += " else { ";
      }
      return out;
    }, "generate_format");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/if.js
var require_if = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/if.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate_if(it2, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it2.level;
      var $dataLvl = it2.dataLevel;
      var $schema = it2.schema[$keyword];
      var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
      var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it2.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $valid = "valid" + $lvl;
      var $errs = "errs__" + $lvl;
      var $it = it2.util.copy(it2);
      $it.level++;
      var $nextValid = "valid" + $it.level;
      var $thenSch = it2.schema["then"], $elseSch = it2.schema["else"], $thenPresent = $thenSch !== void 0 && (it2.opts.strictKeywords ? typeof $thenSch == "object" && Object.keys($thenSch).length > 0 || $thenSch === false : it2.util.schemaHasRules($thenSch, it2.RULES.all)), $elsePresent = $elseSch !== void 0 && (it2.opts.strictKeywords ? typeof $elseSch == "object" && Object.keys($elseSch).length > 0 || $elseSch === false : it2.util.schemaHasRules($elseSch, it2.RULES.all)), $currentBaseId = $it.baseId;
      if ($thenPresent || $elsePresent) {
        var $ifClause;
        $it.createErrors = false;
        $it.schema = $schema;
        $it.schemaPath = $schemaPath;
        $it.errSchemaPath = $errSchemaPath;
        out += " var " + $errs + " = errors; var " + $valid + " = true;  ";
        var $wasComposite = it2.compositeRule;
        it2.compositeRule = $it.compositeRule = true;
        out += "  " + it2.validate($it) + " ";
        $it.baseId = $currentBaseId;
        $it.createErrors = true;
        out += "  errors = " + $errs + "; if (vErrors !== null) { if (" + $errs + ") vErrors.length = " + $errs + "; else vErrors = null; }  ";
        it2.compositeRule = $it.compositeRule = $wasComposite;
        if ($thenPresent) {
          out += " if (" + $nextValid + ") {  ";
          $it.schema = it2.schema["then"];
          $it.schemaPath = it2.schemaPath + ".then";
          $it.errSchemaPath = it2.errSchemaPath + "/then";
          out += "  " + it2.validate($it) + " ";
          $it.baseId = $currentBaseId;
          out += " " + $valid + " = " + $nextValid + "; ";
          if ($thenPresent && $elsePresent) {
            $ifClause = "ifClause" + $lvl;
            out += " var " + $ifClause + " = 'then'; ";
          } else {
            $ifClause = "'then'";
          }
          out += " } ";
          if ($elsePresent) {
            out += " else { ";
          }
        } else {
          out += " if (!" + $nextValid + ") { ";
        }
        if ($elsePresent) {
          $it.schema = it2.schema["else"];
          $it.schemaPath = it2.schemaPath + ".else";
          $it.errSchemaPath = it2.errSchemaPath + "/else";
          out += "  " + it2.validate($it) + " ";
          $it.baseId = $currentBaseId;
          out += " " + $valid + " = " + $nextValid + "; ";
          if ($thenPresent && $elsePresent) {
            $ifClause = "ifClause" + $lvl;
            out += " var " + $ifClause + " = 'else'; ";
          } else {
            $ifClause = "'else'";
          }
          out += " } ";
        }
        out += " if (!" + $valid + ") {   var err =   ";
        if (it2.createErrors !== false) {
          out += " { keyword: 'if' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { failingKeyword: " + $ifClause + " } ";
          if (it2.opts.messages !== false) {
            out += ` , message: 'should match "' + ` + $ifClause + ` + '" schema' `;
          }
          if (it2.opts.verbose) {
            out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
          }
          out += " } ";
        } else {
          out += " {} ";
        }
        out += ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
        if (!it2.compositeRule && $breakOnError) {
          if (it2.async) {
            out += " throw new ValidationError(vErrors); ";
          } else {
            out += " validate.errors = vErrors; return false; ";
          }
        }
        out += " }   ";
        if ($breakOnError) {
          out += " else { ";
        }
      } else {
        if ($breakOnError) {
          out += " if (true) { ";
        }
      }
      return out;
    }, "generate_if");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/items.js
var require_items = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/items.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate_items(it2, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it2.level;
      var $dataLvl = it2.dataLevel;
      var $schema = it2.schema[$keyword];
      var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
      var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it2.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $valid = "valid" + $lvl;
      var $errs = "errs__" + $lvl;
      var $it = it2.util.copy(it2);
      var $closingBraces = "";
      $it.level++;
      var $nextValid = "valid" + $it.level;
      var $idx = "i" + $lvl, $dataNxt = $it.dataLevel = it2.dataLevel + 1, $nextData = "data" + $dataNxt, $currentBaseId = it2.baseId;
      out += "var " + $errs + " = errors;var " + $valid + ";";
      if (Array.isArray($schema)) {
        var $additionalItems = it2.schema.additionalItems;
        if ($additionalItems === false) {
          out += " " + $valid + " = " + $data + ".length <= " + $schema.length + "; ";
          var $currErrSchemaPath = $errSchemaPath;
          $errSchemaPath = it2.errSchemaPath + "/additionalItems";
          out += "  if (!" + $valid + ") {   ";
          var $$outStack = $$outStack || [];
          $$outStack.push(out);
          out = "";
          if (it2.createErrors !== false) {
            out += " { keyword: 'additionalItems' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { limit: " + $schema.length + " } ";
            if (it2.opts.messages !== false) {
              out += " , message: 'should NOT have more than " + $schema.length + " items' ";
            }
            if (it2.opts.verbose) {
              out += " , schema: false , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
            }
            out += " } ";
          } else {
            out += " {} ";
          }
          var __err = out;
          out = $$outStack.pop();
          if (!it2.compositeRule && $breakOnError) {
            if (it2.async) {
              out += " throw new ValidationError([" + __err + "]); ";
            } else {
              out += " validate.errors = [" + __err + "]; return false; ";
            }
          } else {
            out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
          }
          out += " } ";
          $errSchemaPath = $currErrSchemaPath;
          if ($breakOnError) {
            $closingBraces += "}";
            out += " else { ";
          }
        }
        var arr1 = $schema;
        if (arr1) {
          var $sch, $i = -1, l1 = arr1.length - 1;
          while ($i < l1) {
            $sch = arr1[$i += 1];
            if (it2.opts.strictKeywords ? typeof $sch == "object" && Object.keys($sch).length > 0 || $sch === false : it2.util.schemaHasRules($sch, it2.RULES.all)) {
              out += " " + $nextValid + " = true; if (" + $data + ".length > " + $i + ") { ";
              var $passData = $data + "[" + $i + "]";
              $it.schema = $sch;
              $it.schemaPath = $schemaPath + "[" + $i + "]";
              $it.errSchemaPath = $errSchemaPath + "/" + $i;
              $it.errorPath = it2.util.getPathExpr(it2.errorPath, $i, it2.opts.jsonPointers, true);
              $it.dataPathArr[$dataNxt] = $i;
              var $code = it2.validate($it);
              $it.baseId = $currentBaseId;
              if (it2.util.varOccurences($code, $nextData) < 2) {
                out += " " + it2.util.varReplace($code, $nextData, $passData) + " ";
              } else {
                out += " var " + $nextData + " = " + $passData + "; " + $code + " ";
              }
              out += " }  ";
              if ($breakOnError) {
                out += " if (" + $nextValid + ") { ";
                $closingBraces += "}";
              }
            }
          }
        }
        if (typeof $additionalItems == "object" && (it2.opts.strictKeywords ? typeof $additionalItems == "object" && Object.keys($additionalItems).length > 0 || $additionalItems === false : it2.util.schemaHasRules($additionalItems, it2.RULES.all))) {
          $it.schema = $additionalItems;
          $it.schemaPath = it2.schemaPath + ".additionalItems";
          $it.errSchemaPath = it2.errSchemaPath + "/additionalItems";
          out += " " + $nextValid + " = true; if (" + $data + ".length > " + $schema.length + ") {  for (var " + $idx + " = " + $schema.length + "; " + $idx + " < " + $data + ".length; " + $idx + "++) { ";
          $it.errorPath = it2.util.getPathExpr(it2.errorPath, $idx, it2.opts.jsonPointers, true);
          var $passData = $data + "[" + $idx + "]";
          $it.dataPathArr[$dataNxt] = $idx;
          var $code = it2.validate($it);
          $it.baseId = $currentBaseId;
          if (it2.util.varOccurences($code, $nextData) < 2) {
            out += " " + it2.util.varReplace($code, $nextData, $passData) + " ";
          } else {
            out += " var " + $nextData + " = " + $passData + "; " + $code + " ";
          }
          if ($breakOnError) {
            out += " if (!" + $nextValid + ") break; ";
          }
          out += " } }  ";
          if ($breakOnError) {
            out += " if (" + $nextValid + ") { ";
            $closingBraces += "}";
          }
        }
      } else if (it2.opts.strictKeywords ? typeof $schema == "object" && Object.keys($schema).length > 0 || $schema === false : it2.util.schemaHasRules($schema, it2.RULES.all)) {
        $it.schema = $schema;
        $it.schemaPath = $schemaPath;
        $it.errSchemaPath = $errSchemaPath;
        out += "  for (var " + $idx + " = 0; " + $idx + " < " + $data + ".length; " + $idx + "++) { ";
        $it.errorPath = it2.util.getPathExpr(it2.errorPath, $idx, it2.opts.jsonPointers, true);
        var $passData = $data + "[" + $idx + "]";
        $it.dataPathArr[$dataNxt] = $idx;
        var $code = it2.validate($it);
        $it.baseId = $currentBaseId;
        if (it2.util.varOccurences($code, $nextData) < 2) {
          out += " " + it2.util.varReplace($code, $nextData, $passData) + " ";
        } else {
          out += " var " + $nextData + " = " + $passData + "; " + $code + " ";
        }
        if ($breakOnError) {
          out += " if (!" + $nextValid + ") break; ";
        }
        out += " }";
      }
      if ($breakOnError) {
        out += " " + $closingBraces + " if (" + $errs + " == errors) {";
      }
      return out;
    }, "generate_items");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/_limit.js
var require_limit = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/_limit.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate__limit(it2, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it2.level;
      var $dataLvl = it2.dataLevel;
      var $schema = it2.schema[$keyword];
      var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
      var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it2.opts.allErrors;
      var $errorKeyword;
      var $data = "data" + ($dataLvl || "");
      var $isData = it2.opts.$data && $schema && $schema.$data, $schemaValue;
      if ($isData) {
        out += " var schema" + $lvl + " = " + it2.util.getData($schema.$data, $dataLvl, it2.dataPathArr) + "; ";
        $schemaValue = "schema" + $lvl;
      } else {
        $schemaValue = $schema;
      }
      var $isMax = $keyword == "maximum", $exclusiveKeyword = $isMax ? "exclusiveMaximum" : "exclusiveMinimum", $schemaExcl = it2.schema[$exclusiveKeyword], $isDataExcl = it2.opts.$data && $schemaExcl && $schemaExcl.$data, $op = $isMax ? "<" : ">", $notOp = $isMax ? ">" : "<", $errorKeyword = void 0;
      if (!($isData || typeof $schema == "number" || $schema === void 0)) {
        throw new Error($keyword + " must be number");
      }
      if (!($isDataExcl || $schemaExcl === void 0 || typeof $schemaExcl == "number" || typeof $schemaExcl == "boolean")) {
        throw new Error($exclusiveKeyword + " must be number or boolean");
      }
      if ($isDataExcl) {
        var $schemaValueExcl = it2.util.getData($schemaExcl.$data, $dataLvl, it2.dataPathArr), $exclusive = "exclusive" + $lvl, $exclType = "exclType" + $lvl, $exclIsNumber = "exclIsNumber" + $lvl, $opExpr = "op" + $lvl, $opStr = "' + " + $opExpr + " + '";
        out += " var schemaExcl" + $lvl + " = " + $schemaValueExcl + "; ";
        $schemaValueExcl = "schemaExcl" + $lvl;
        out += " var " + $exclusive + "; var " + $exclType + " = typeof " + $schemaValueExcl + "; if (" + $exclType + " != 'boolean' && " + $exclType + " != 'undefined' && " + $exclType + " != 'number') { ";
        var $errorKeyword = $exclusiveKeyword;
        var $$outStack = $$outStack || [];
        $$outStack.push(out);
        out = "";
        if (it2.createErrors !== false) {
          out += " { keyword: '" + ($errorKeyword || "_exclusiveLimit") + "' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: {} ";
          if (it2.opts.messages !== false) {
            out += " , message: '" + $exclusiveKeyword + " should be boolean' ";
          }
          if (it2.opts.verbose) {
            out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
          }
          out += " } ";
        } else {
          out += " {} ";
        }
        var __err = out;
        out = $$outStack.pop();
        if (!it2.compositeRule && $breakOnError) {
          if (it2.async) {
            out += " throw new ValidationError([" + __err + "]); ";
          } else {
            out += " validate.errors = [" + __err + "]; return false; ";
          }
        } else {
          out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
        }
        out += " } else if ( ";
        if ($isData) {
          out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'number') || ";
        }
        out += " " + $exclType + " == 'number' ? ( (" + $exclusive + " = " + $schemaValue + " === undefined || " + $schemaValueExcl + " " + $op + "= " + $schemaValue + ") ? " + $data + " " + $notOp + "= " + $schemaValueExcl + " : " + $data + " " + $notOp + " " + $schemaValue + " ) : ( (" + $exclusive + " = " + $schemaValueExcl + " === true) ? " + $data + " " + $notOp + "= " + $schemaValue + " : " + $data + " " + $notOp + " " + $schemaValue + " ) || " + $data + " !== " + $data + ") { var op" + $lvl + " = " + $exclusive + " ? '" + $op + "' : '" + $op + "='; ";
        if ($schema === void 0) {
          $errorKeyword = $exclusiveKeyword;
          $errSchemaPath = it2.errSchemaPath + "/" + $exclusiveKeyword;
          $schemaValue = $schemaValueExcl;
          $isData = $isDataExcl;
        }
      } else {
        var $exclIsNumber = typeof $schemaExcl == "number", $opStr = $op;
        if ($exclIsNumber && $isData) {
          var $opExpr = "'" + $opStr + "'";
          out += " if ( ";
          if ($isData) {
            out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'number') || ";
          }
          out += " ( " + $schemaValue + " === undefined || " + $schemaExcl + " " + $op + "= " + $schemaValue + " ? " + $data + " " + $notOp + "= " + $schemaExcl + " : " + $data + " " + $notOp + " " + $schemaValue + " ) || " + $data + " !== " + $data + ") { ";
        } else {
          if ($exclIsNumber && $schema === void 0) {
            $exclusive = true;
            $errorKeyword = $exclusiveKeyword;
            $errSchemaPath = it2.errSchemaPath + "/" + $exclusiveKeyword;
            $schemaValue = $schemaExcl;
            $notOp += "=";
          } else {
            if ($exclIsNumber)
              $schemaValue = Math[$isMax ? "min" : "max"]($schemaExcl, $schema);
            if ($schemaExcl === ($exclIsNumber ? $schemaValue : true)) {
              $exclusive = true;
              $errorKeyword = $exclusiveKeyword;
              $errSchemaPath = it2.errSchemaPath + "/" + $exclusiveKeyword;
              $notOp += "=";
            } else {
              $exclusive = false;
              $opStr += "=";
            }
          }
          var $opExpr = "'" + $opStr + "'";
          out += " if ( ";
          if ($isData) {
            out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'number') || ";
          }
          out += " " + $data + " " + $notOp + " " + $schemaValue + " || " + $data + " !== " + $data + ") { ";
        }
      }
      $errorKeyword = $errorKeyword || $keyword;
      var $$outStack = $$outStack || [];
      $$outStack.push(out);
      out = "";
      if (it2.createErrors !== false) {
        out += " { keyword: '" + ($errorKeyword || "_limit") + "' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { comparison: " + $opExpr + ", limit: " + $schemaValue + ", exclusive: " + $exclusive + " } ";
        if (it2.opts.messages !== false) {
          out += " , message: 'should be " + $opStr + " ";
          if ($isData) {
            out += "' + " + $schemaValue;
          } else {
            out += "" + $schemaValue + "'";
          }
        }
        if (it2.opts.verbose) {
          out += " , schema:  ";
          if ($isData) {
            out += "validate.schema" + $schemaPath;
          } else {
            out += "" + $schema;
          }
          out += "         , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
        }
        out += " } ";
      } else {
        out += " {} ";
      }
      var __err = out;
      out = $$outStack.pop();
      if (!it2.compositeRule && $breakOnError) {
        if (it2.async) {
          out += " throw new ValidationError([" + __err + "]); ";
        } else {
          out += " validate.errors = [" + __err + "]; return false; ";
        }
      } else {
        out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
      }
      out += " } ";
      if ($breakOnError) {
        out += " else { ";
      }
      return out;
    }, "generate__limit");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/_limitItems.js
var require_limitItems = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/_limitItems.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate__limitItems(it2, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it2.level;
      var $dataLvl = it2.dataLevel;
      var $schema = it2.schema[$keyword];
      var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
      var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it2.opts.allErrors;
      var $errorKeyword;
      var $data = "data" + ($dataLvl || "");
      var $isData = it2.opts.$data && $schema && $schema.$data, $schemaValue;
      if ($isData) {
        out += " var schema" + $lvl + " = " + it2.util.getData($schema.$data, $dataLvl, it2.dataPathArr) + "; ";
        $schemaValue = "schema" + $lvl;
      } else {
        $schemaValue = $schema;
      }
      if (!($isData || typeof $schema == "number")) {
        throw new Error($keyword + " must be number");
      }
      var $op = $keyword == "maxItems" ? ">" : "<";
      out += "if ( ";
      if ($isData) {
        out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'number') || ";
      }
      out += " " + $data + ".length " + $op + " " + $schemaValue + ") { ";
      var $errorKeyword = $keyword;
      var $$outStack = $$outStack || [];
      $$outStack.push(out);
      out = "";
      if (it2.createErrors !== false) {
        out += " { keyword: '" + ($errorKeyword || "_limitItems") + "' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { limit: " + $schemaValue + " } ";
        if (it2.opts.messages !== false) {
          out += " , message: 'should NOT have ";
          if ($keyword == "maxItems") {
            out += "more";
          } else {
            out += "fewer";
          }
          out += " than ";
          if ($isData) {
            out += "' + " + $schemaValue + " + '";
          } else {
            out += "" + $schema;
          }
          out += " items' ";
        }
        if (it2.opts.verbose) {
          out += " , schema:  ";
          if ($isData) {
            out += "validate.schema" + $schemaPath;
          } else {
            out += "" + $schema;
          }
          out += "         , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
        }
        out += " } ";
      } else {
        out += " {} ";
      }
      var __err = out;
      out = $$outStack.pop();
      if (!it2.compositeRule && $breakOnError) {
        if (it2.async) {
          out += " throw new ValidationError([" + __err + "]); ";
        } else {
          out += " validate.errors = [" + __err + "]; return false; ";
        }
      } else {
        out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
      }
      out += "} ";
      if ($breakOnError) {
        out += " else { ";
      }
      return out;
    }, "generate__limitItems");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/_limitLength.js
var require_limitLength = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/_limitLength.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate__limitLength(it2, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it2.level;
      var $dataLvl = it2.dataLevel;
      var $schema = it2.schema[$keyword];
      var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
      var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it2.opts.allErrors;
      var $errorKeyword;
      var $data = "data" + ($dataLvl || "");
      var $isData = it2.opts.$data && $schema && $schema.$data, $schemaValue;
      if ($isData) {
        out += " var schema" + $lvl + " = " + it2.util.getData($schema.$data, $dataLvl, it2.dataPathArr) + "; ";
        $schemaValue = "schema" + $lvl;
      } else {
        $schemaValue = $schema;
      }
      if (!($isData || typeof $schema == "number")) {
        throw new Error($keyword + " must be number");
      }
      var $op = $keyword == "maxLength" ? ">" : "<";
      out += "if ( ";
      if ($isData) {
        out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'number') || ";
      }
      if (it2.opts.unicode === false) {
        out += " " + $data + ".length ";
      } else {
        out += " ucs2length(" + $data + ") ";
      }
      out += " " + $op + " " + $schemaValue + ") { ";
      var $errorKeyword = $keyword;
      var $$outStack = $$outStack || [];
      $$outStack.push(out);
      out = "";
      if (it2.createErrors !== false) {
        out += " { keyword: '" + ($errorKeyword || "_limitLength") + "' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { limit: " + $schemaValue + " } ";
        if (it2.opts.messages !== false) {
          out += " , message: 'should NOT be ";
          if ($keyword == "maxLength") {
            out += "longer";
          } else {
            out += "shorter";
          }
          out += " than ";
          if ($isData) {
            out += "' + " + $schemaValue + " + '";
          } else {
            out += "" + $schema;
          }
          out += " characters' ";
        }
        if (it2.opts.verbose) {
          out += " , schema:  ";
          if ($isData) {
            out += "validate.schema" + $schemaPath;
          } else {
            out += "" + $schema;
          }
          out += "         , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
        }
        out += " } ";
      } else {
        out += " {} ";
      }
      var __err = out;
      out = $$outStack.pop();
      if (!it2.compositeRule && $breakOnError) {
        if (it2.async) {
          out += " throw new ValidationError([" + __err + "]); ";
        } else {
          out += " validate.errors = [" + __err + "]; return false; ";
        }
      } else {
        out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
      }
      out += "} ";
      if ($breakOnError) {
        out += " else { ";
      }
      return out;
    }, "generate__limitLength");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/_limitProperties.js
var require_limitProperties = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/_limitProperties.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate__limitProperties(it2, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it2.level;
      var $dataLvl = it2.dataLevel;
      var $schema = it2.schema[$keyword];
      var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
      var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it2.opts.allErrors;
      var $errorKeyword;
      var $data = "data" + ($dataLvl || "");
      var $isData = it2.opts.$data && $schema && $schema.$data, $schemaValue;
      if ($isData) {
        out += " var schema" + $lvl + " = " + it2.util.getData($schema.$data, $dataLvl, it2.dataPathArr) + "; ";
        $schemaValue = "schema" + $lvl;
      } else {
        $schemaValue = $schema;
      }
      if (!($isData || typeof $schema == "number")) {
        throw new Error($keyword + " must be number");
      }
      var $op = $keyword == "maxProperties" ? ">" : "<";
      out += "if ( ";
      if ($isData) {
        out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'number') || ";
      }
      out += " Object.keys(" + $data + ").length " + $op + " " + $schemaValue + ") { ";
      var $errorKeyword = $keyword;
      var $$outStack = $$outStack || [];
      $$outStack.push(out);
      out = "";
      if (it2.createErrors !== false) {
        out += " { keyword: '" + ($errorKeyword || "_limitProperties") + "' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { limit: " + $schemaValue + " } ";
        if (it2.opts.messages !== false) {
          out += " , message: 'should NOT have ";
          if ($keyword == "maxProperties") {
            out += "more";
          } else {
            out += "fewer";
          }
          out += " than ";
          if ($isData) {
            out += "' + " + $schemaValue + " + '";
          } else {
            out += "" + $schema;
          }
          out += " properties' ";
        }
        if (it2.opts.verbose) {
          out += " , schema:  ";
          if ($isData) {
            out += "validate.schema" + $schemaPath;
          } else {
            out += "" + $schema;
          }
          out += "         , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
        }
        out += " } ";
      } else {
        out += " {} ";
      }
      var __err = out;
      out = $$outStack.pop();
      if (!it2.compositeRule && $breakOnError) {
        if (it2.async) {
          out += " throw new ValidationError([" + __err + "]); ";
        } else {
          out += " validate.errors = [" + __err + "]; return false; ";
        }
      } else {
        out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
      }
      out += "} ";
      if ($breakOnError) {
        out += " else { ";
      }
      return out;
    }, "generate__limitProperties");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/multipleOf.js
var require_multipleOf = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/multipleOf.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate_multipleOf(it2, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it2.level;
      var $dataLvl = it2.dataLevel;
      var $schema = it2.schema[$keyword];
      var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
      var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it2.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $isData = it2.opts.$data && $schema && $schema.$data, $schemaValue;
      if ($isData) {
        out += " var schema" + $lvl + " = " + it2.util.getData($schema.$data, $dataLvl, it2.dataPathArr) + "; ";
        $schemaValue = "schema" + $lvl;
      } else {
        $schemaValue = $schema;
      }
      if (!($isData || typeof $schema == "number")) {
        throw new Error($keyword + " must be number");
      }
      out += "var division" + $lvl + ";if (";
      if ($isData) {
        out += " " + $schemaValue + " !== undefined && ( typeof " + $schemaValue + " != 'number' || ";
      }
      out += " (division" + $lvl + " = " + $data + " / " + $schemaValue + ", ";
      if (it2.opts.multipleOfPrecision) {
        out += " Math.abs(Math.round(division" + $lvl + ") - division" + $lvl + ") > 1e-" + it2.opts.multipleOfPrecision + " ";
      } else {
        out += " division" + $lvl + " !== parseInt(division" + $lvl + ") ";
      }
      out += " ) ";
      if ($isData) {
        out += "  )  ";
      }
      out += " ) {   ";
      var $$outStack = $$outStack || [];
      $$outStack.push(out);
      out = "";
      if (it2.createErrors !== false) {
        out += " { keyword: 'multipleOf' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { multipleOf: " + $schemaValue + " } ";
        if (it2.opts.messages !== false) {
          out += " , message: 'should be multiple of ";
          if ($isData) {
            out += "' + " + $schemaValue;
          } else {
            out += "" + $schemaValue + "'";
          }
        }
        if (it2.opts.verbose) {
          out += " , schema:  ";
          if ($isData) {
            out += "validate.schema" + $schemaPath;
          } else {
            out += "" + $schema;
          }
          out += "         , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
        }
        out += " } ";
      } else {
        out += " {} ";
      }
      var __err = out;
      out = $$outStack.pop();
      if (!it2.compositeRule && $breakOnError) {
        if (it2.async) {
          out += " throw new ValidationError([" + __err + "]); ";
        } else {
          out += " validate.errors = [" + __err + "]; return false; ";
        }
      } else {
        out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
      }
      out += "} ";
      if ($breakOnError) {
        out += " else { ";
      }
      return out;
    }, "generate_multipleOf");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/not.js
var require_not = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/not.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate_not(it2, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it2.level;
      var $dataLvl = it2.dataLevel;
      var $schema = it2.schema[$keyword];
      var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
      var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it2.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $errs = "errs__" + $lvl;
      var $it = it2.util.copy(it2);
      $it.level++;
      var $nextValid = "valid" + $it.level;
      if (it2.opts.strictKeywords ? typeof $schema == "object" && Object.keys($schema).length > 0 || $schema === false : it2.util.schemaHasRules($schema, it2.RULES.all)) {
        $it.schema = $schema;
        $it.schemaPath = $schemaPath;
        $it.errSchemaPath = $errSchemaPath;
        out += " var " + $errs + " = errors;  ";
        var $wasComposite = it2.compositeRule;
        it2.compositeRule = $it.compositeRule = true;
        $it.createErrors = false;
        var $allErrorsOption;
        if ($it.opts.allErrors) {
          $allErrorsOption = $it.opts.allErrors;
          $it.opts.allErrors = false;
        }
        out += " " + it2.validate($it) + " ";
        $it.createErrors = true;
        if ($allErrorsOption)
          $it.opts.allErrors = $allErrorsOption;
        it2.compositeRule = $it.compositeRule = $wasComposite;
        out += " if (" + $nextValid + ") {   ";
        var $$outStack = $$outStack || [];
        $$outStack.push(out);
        out = "";
        if (it2.createErrors !== false) {
          out += " { keyword: 'not' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: {} ";
          if (it2.opts.messages !== false) {
            out += " , message: 'should NOT be valid' ";
          }
          if (it2.opts.verbose) {
            out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
          }
          out += " } ";
        } else {
          out += " {} ";
        }
        var __err = out;
        out = $$outStack.pop();
        if (!it2.compositeRule && $breakOnError) {
          if (it2.async) {
            out += " throw new ValidationError([" + __err + "]); ";
          } else {
            out += " validate.errors = [" + __err + "]; return false; ";
          }
        } else {
          out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
        }
        out += " } else {  errors = " + $errs + "; if (vErrors !== null) { if (" + $errs + ") vErrors.length = " + $errs + "; else vErrors = null; } ";
        if (it2.opts.allErrors) {
          out += " } ";
        }
      } else {
        out += "  var err =   ";
        if (it2.createErrors !== false) {
          out += " { keyword: 'not' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: {} ";
          if (it2.opts.messages !== false) {
            out += " , message: 'should NOT be valid' ";
          }
          if (it2.opts.verbose) {
            out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
          }
          out += " } ";
        } else {
          out += " {} ";
        }
        out += ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
        if ($breakOnError) {
          out += " if (false) { ";
        }
      }
      return out;
    }, "generate_not");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/oneOf.js
var require_oneOf = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/oneOf.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate_oneOf(it2, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it2.level;
      var $dataLvl = it2.dataLevel;
      var $schema = it2.schema[$keyword];
      var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
      var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it2.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $valid = "valid" + $lvl;
      var $errs = "errs__" + $lvl;
      var $it = it2.util.copy(it2);
      var $closingBraces = "";
      $it.level++;
      var $nextValid = "valid" + $it.level;
      var $currentBaseId = $it.baseId, $prevValid = "prevValid" + $lvl, $passingSchemas = "passingSchemas" + $lvl;
      out += "var " + $errs + " = errors , " + $prevValid + " = false , " + $valid + " = false , " + $passingSchemas + " = null; ";
      var $wasComposite = it2.compositeRule;
      it2.compositeRule = $it.compositeRule = true;
      var arr1 = $schema;
      if (arr1) {
        var $sch, $i = -1, l1 = arr1.length - 1;
        while ($i < l1) {
          $sch = arr1[$i += 1];
          if (it2.opts.strictKeywords ? typeof $sch == "object" && Object.keys($sch).length > 0 || $sch === false : it2.util.schemaHasRules($sch, it2.RULES.all)) {
            $it.schema = $sch;
            $it.schemaPath = $schemaPath + "[" + $i + "]";
            $it.errSchemaPath = $errSchemaPath + "/" + $i;
            out += "  " + it2.validate($it) + " ";
            $it.baseId = $currentBaseId;
          } else {
            out += " var " + $nextValid + " = true; ";
          }
          if ($i) {
            out += " if (" + $nextValid + " && " + $prevValid + ") { " + $valid + " = false; " + $passingSchemas + " = [" + $passingSchemas + ", " + $i + "]; } else { ";
            $closingBraces += "}";
          }
          out += " if (" + $nextValid + ") { " + $valid + " = " + $prevValid + " = true; " + $passingSchemas + " = " + $i + "; }";
        }
      }
      it2.compositeRule = $it.compositeRule = $wasComposite;
      out += "" + $closingBraces + "if (!" + $valid + ") {   var err =   ";
      if (it2.createErrors !== false) {
        out += " { keyword: 'oneOf' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { passingSchemas: " + $passingSchemas + " } ";
        if (it2.opts.messages !== false) {
          out += " , message: 'should match exactly one schema in oneOf' ";
        }
        if (it2.opts.verbose) {
          out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
        }
        out += " } ";
      } else {
        out += " {} ";
      }
      out += ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
      if (!it2.compositeRule && $breakOnError) {
        if (it2.async) {
          out += " throw new ValidationError(vErrors); ";
        } else {
          out += " validate.errors = vErrors; return false; ";
        }
      }
      out += "} else {  errors = " + $errs + "; if (vErrors !== null) { if (" + $errs + ") vErrors.length = " + $errs + "; else vErrors = null; }";
      if (it2.opts.allErrors) {
        out += " } ";
      }
      return out;
    }, "generate_oneOf");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/pattern.js
var require_pattern = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/pattern.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate_pattern(it2, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it2.level;
      var $dataLvl = it2.dataLevel;
      var $schema = it2.schema[$keyword];
      var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
      var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it2.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $isData = it2.opts.$data && $schema && $schema.$data, $schemaValue;
      if ($isData) {
        out += " var schema" + $lvl + " = " + it2.util.getData($schema.$data, $dataLvl, it2.dataPathArr) + "; ";
        $schemaValue = "schema" + $lvl;
      } else {
        $schemaValue = $schema;
      }
      var $regexp = $isData ? "(new RegExp(" + $schemaValue + "))" : it2.usePattern($schema);
      out += "if ( ";
      if ($isData) {
        out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'string') || ";
      }
      out += " !" + $regexp + ".test(" + $data + ") ) {   ";
      var $$outStack = $$outStack || [];
      $$outStack.push(out);
      out = "";
      if (it2.createErrors !== false) {
        out += " { keyword: 'pattern' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { pattern:  ";
        if ($isData) {
          out += "" + $schemaValue;
        } else {
          out += "" + it2.util.toQuotedString($schema);
        }
        out += "  } ";
        if (it2.opts.messages !== false) {
          out += ` , message: 'should match pattern "`;
          if ($isData) {
            out += "' + " + $schemaValue + " + '";
          } else {
            out += "" + it2.util.escapeQuotes($schema);
          }
          out += `"' `;
        }
        if (it2.opts.verbose) {
          out += " , schema:  ";
          if ($isData) {
            out += "validate.schema" + $schemaPath;
          } else {
            out += "" + it2.util.toQuotedString($schema);
          }
          out += "         , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
        }
        out += " } ";
      } else {
        out += " {} ";
      }
      var __err = out;
      out = $$outStack.pop();
      if (!it2.compositeRule && $breakOnError) {
        if (it2.async) {
          out += " throw new ValidationError([" + __err + "]); ";
        } else {
          out += " validate.errors = [" + __err + "]; return false; ";
        }
      } else {
        out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
      }
      out += "} ";
      if ($breakOnError) {
        out += " else { ";
      }
      return out;
    }, "generate_pattern");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/properties.js
var require_properties = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/properties.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate_properties(it2, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it2.level;
      var $dataLvl = it2.dataLevel;
      var $schema = it2.schema[$keyword];
      var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
      var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it2.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $errs = "errs__" + $lvl;
      var $it = it2.util.copy(it2);
      var $closingBraces = "";
      $it.level++;
      var $nextValid = "valid" + $it.level;
      var $key = "key" + $lvl, $idx = "idx" + $lvl, $dataNxt = $it.dataLevel = it2.dataLevel + 1, $nextData = "data" + $dataNxt, $dataProperties = "dataProperties" + $lvl;
      var $schemaKeys = Object.keys($schema || {}).filter(notProto), $pProperties = it2.schema.patternProperties || {}, $pPropertyKeys = Object.keys($pProperties).filter(notProto), $aProperties = it2.schema.additionalProperties, $someProperties = $schemaKeys.length || $pPropertyKeys.length, $noAdditional = $aProperties === false, $additionalIsSchema = typeof $aProperties == "object" && Object.keys($aProperties).length, $removeAdditional = it2.opts.removeAdditional, $checkAdditional = $noAdditional || $additionalIsSchema || $removeAdditional, $ownProperties = it2.opts.ownProperties, $currentBaseId = it2.baseId;
      var $required = it2.schema.required;
      if ($required && !(it2.opts.$data && $required.$data) && $required.length < it2.opts.loopRequired) {
        var $requiredHash = it2.util.toHash($required);
      }
      function notProto(p2) {
        return p2 !== "__proto__";
      }
      __name(notProto, "notProto");
      out += "var " + $errs + " = errors;var " + $nextValid + " = true;";
      if ($ownProperties) {
        out += " var " + $dataProperties + " = undefined;";
      }
      if ($checkAdditional) {
        if ($ownProperties) {
          out += " " + $dataProperties + " = " + $dataProperties + " || Object.keys(" + $data + "); for (var " + $idx + "=0; " + $idx + "<" + $dataProperties + ".length; " + $idx + "++) { var " + $key + " = " + $dataProperties + "[" + $idx + "]; ";
        } else {
          out += " for (var " + $key + " in " + $data + ") { ";
        }
        if ($someProperties) {
          out += " var isAdditional" + $lvl + " = !(false ";
          if ($schemaKeys.length) {
            if ($schemaKeys.length > 8) {
              out += " || validate.schema" + $schemaPath + ".hasOwnProperty(" + $key + ") ";
            } else {
              var arr1 = $schemaKeys;
              if (arr1) {
                var $propertyKey, i1 = -1, l1 = arr1.length - 1;
                while (i1 < l1) {
                  $propertyKey = arr1[i1 += 1];
                  out += " || " + $key + " == " + it2.util.toQuotedString($propertyKey) + " ";
                }
              }
            }
          }
          if ($pPropertyKeys.length) {
            var arr2 = $pPropertyKeys;
            if (arr2) {
              var $pProperty, $i = -1, l2 = arr2.length - 1;
              while ($i < l2) {
                $pProperty = arr2[$i += 1];
                out += " || " + it2.usePattern($pProperty) + ".test(" + $key + ") ";
              }
            }
          }
          out += " ); if (isAdditional" + $lvl + ") { ";
        }
        if ($removeAdditional == "all") {
          out += " delete " + $data + "[" + $key + "]; ";
        } else {
          var $currentErrorPath = it2.errorPath;
          var $additionalProperty = "' + " + $key + " + '";
          if (it2.opts._errorDataPathProperty) {
            it2.errorPath = it2.util.getPathExpr(it2.errorPath, $key, it2.opts.jsonPointers);
          }
          if ($noAdditional) {
            if ($removeAdditional) {
              out += " delete " + $data + "[" + $key + "]; ";
            } else {
              out += " " + $nextValid + " = false; ";
              var $currErrSchemaPath = $errSchemaPath;
              $errSchemaPath = it2.errSchemaPath + "/additionalProperties";
              var $$outStack = $$outStack || [];
              $$outStack.push(out);
              out = "";
              if (it2.createErrors !== false) {
                out += " { keyword: 'additionalProperties' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { additionalProperty: '" + $additionalProperty + "' } ";
                if (it2.opts.messages !== false) {
                  out += " , message: '";
                  if (it2.opts._errorDataPathProperty) {
                    out += "is an invalid additional property";
                  } else {
                    out += "should NOT have additional properties";
                  }
                  out += "' ";
                }
                if (it2.opts.verbose) {
                  out += " , schema: false , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
                }
                out += " } ";
              } else {
                out += " {} ";
              }
              var __err = out;
              out = $$outStack.pop();
              if (!it2.compositeRule && $breakOnError) {
                if (it2.async) {
                  out += " throw new ValidationError([" + __err + "]); ";
                } else {
                  out += " validate.errors = [" + __err + "]; return false; ";
                }
              } else {
                out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
              }
              $errSchemaPath = $currErrSchemaPath;
              if ($breakOnError) {
                out += " break; ";
              }
            }
          } else if ($additionalIsSchema) {
            if ($removeAdditional == "failing") {
              out += " var " + $errs + " = errors;  ";
              var $wasComposite = it2.compositeRule;
              it2.compositeRule = $it.compositeRule = true;
              $it.schema = $aProperties;
              $it.schemaPath = it2.schemaPath + ".additionalProperties";
              $it.errSchemaPath = it2.errSchemaPath + "/additionalProperties";
              $it.errorPath = it2.opts._errorDataPathProperty ? it2.errorPath : it2.util.getPathExpr(it2.errorPath, $key, it2.opts.jsonPointers);
              var $passData = $data + "[" + $key + "]";
              $it.dataPathArr[$dataNxt] = $key;
              var $code = it2.validate($it);
              $it.baseId = $currentBaseId;
              if (it2.util.varOccurences($code, $nextData) < 2) {
                out += " " + it2.util.varReplace($code, $nextData, $passData) + " ";
              } else {
                out += " var " + $nextData + " = " + $passData + "; " + $code + " ";
              }
              out += " if (!" + $nextValid + ") { errors = " + $errs + "; if (validate.errors !== null) { if (errors) validate.errors.length = errors; else validate.errors = null; } delete " + $data + "[" + $key + "]; }  ";
              it2.compositeRule = $it.compositeRule = $wasComposite;
            } else {
              $it.schema = $aProperties;
              $it.schemaPath = it2.schemaPath + ".additionalProperties";
              $it.errSchemaPath = it2.errSchemaPath + "/additionalProperties";
              $it.errorPath = it2.opts._errorDataPathProperty ? it2.errorPath : it2.util.getPathExpr(it2.errorPath, $key, it2.opts.jsonPointers);
              var $passData = $data + "[" + $key + "]";
              $it.dataPathArr[$dataNxt] = $key;
              var $code = it2.validate($it);
              $it.baseId = $currentBaseId;
              if (it2.util.varOccurences($code, $nextData) < 2) {
                out += " " + it2.util.varReplace($code, $nextData, $passData) + " ";
              } else {
                out += " var " + $nextData + " = " + $passData + "; " + $code + " ";
              }
              if ($breakOnError) {
                out += " if (!" + $nextValid + ") break; ";
              }
            }
          }
          it2.errorPath = $currentErrorPath;
        }
        if ($someProperties) {
          out += " } ";
        }
        out += " }  ";
        if ($breakOnError) {
          out += " if (" + $nextValid + ") { ";
          $closingBraces += "}";
        }
      }
      var $useDefaults = it2.opts.useDefaults && !it2.compositeRule;
      if ($schemaKeys.length) {
        var arr3 = $schemaKeys;
        if (arr3) {
          var $propertyKey, i3 = -1, l3 = arr3.length - 1;
          while (i3 < l3) {
            $propertyKey = arr3[i3 += 1];
            var $sch = $schema[$propertyKey];
            if (it2.opts.strictKeywords ? typeof $sch == "object" && Object.keys($sch).length > 0 || $sch === false : it2.util.schemaHasRules($sch, it2.RULES.all)) {
              var $prop = it2.util.getProperty($propertyKey), $passData = $data + $prop, $hasDefault = $useDefaults && $sch.default !== void 0;
              $it.schema = $sch;
              $it.schemaPath = $schemaPath + $prop;
              $it.errSchemaPath = $errSchemaPath + "/" + it2.util.escapeFragment($propertyKey);
              $it.errorPath = it2.util.getPath(it2.errorPath, $propertyKey, it2.opts.jsonPointers);
              $it.dataPathArr[$dataNxt] = it2.util.toQuotedString($propertyKey);
              var $code = it2.validate($it);
              $it.baseId = $currentBaseId;
              if (it2.util.varOccurences($code, $nextData) < 2) {
                $code = it2.util.varReplace($code, $nextData, $passData);
                var $useData = $passData;
              } else {
                var $useData = $nextData;
                out += " var " + $nextData + " = " + $passData + "; ";
              }
              if ($hasDefault) {
                out += " " + $code + " ";
              } else {
                if ($requiredHash && $requiredHash[$propertyKey]) {
                  out += " if ( " + $useData + " === undefined ";
                  if ($ownProperties) {
                    out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", '" + it2.util.escapeQuotes($propertyKey) + "') ";
                  }
                  out += ") { " + $nextValid + " = false; ";
                  var $currentErrorPath = it2.errorPath, $currErrSchemaPath = $errSchemaPath, $missingProperty = it2.util.escapeQuotes($propertyKey);
                  if (it2.opts._errorDataPathProperty) {
                    it2.errorPath = it2.util.getPath($currentErrorPath, $propertyKey, it2.opts.jsonPointers);
                  }
                  $errSchemaPath = it2.errSchemaPath + "/required";
                  var $$outStack = $$outStack || [];
                  $$outStack.push(out);
                  out = "";
                  if (it2.createErrors !== false) {
                    out += " { keyword: 'required' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { missingProperty: '" + $missingProperty + "' } ";
                    if (it2.opts.messages !== false) {
                      out += " , message: '";
                      if (it2.opts._errorDataPathProperty) {
                        out += "is a required property";
                      } else {
                        out += "should have required property \\'" + $missingProperty + "\\'";
                      }
                      out += "' ";
                    }
                    if (it2.opts.verbose) {
                      out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
                    }
                    out += " } ";
                  } else {
                    out += " {} ";
                  }
                  var __err = out;
                  out = $$outStack.pop();
                  if (!it2.compositeRule && $breakOnError) {
                    if (it2.async) {
                      out += " throw new ValidationError([" + __err + "]); ";
                    } else {
                      out += " validate.errors = [" + __err + "]; return false; ";
                    }
                  } else {
                    out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
                  }
                  $errSchemaPath = $currErrSchemaPath;
                  it2.errorPath = $currentErrorPath;
                  out += " } else { ";
                } else {
                  if ($breakOnError) {
                    out += " if ( " + $useData + " === undefined ";
                    if ($ownProperties) {
                      out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", '" + it2.util.escapeQuotes($propertyKey) + "') ";
                    }
                    out += ") { " + $nextValid + " = true; } else { ";
                  } else {
                    out += " if (" + $useData + " !== undefined ";
                    if ($ownProperties) {
                      out += " &&   Object.prototype.hasOwnProperty.call(" + $data + ", '" + it2.util.escapeQuotes($propertyKey) + "') ";
                    }
                    out += " ) { ";
                  }
                }
                out += " " + $code + " } ";
              }
            }
            if ($breakOnError) {
              out += " if (" + $nextValid + ") { ";
              $closingBraces += "}";
            }
          }
        }
      }
      if ($pPropertyKeys.length) {
        var arr4 = $pPropertyKeys;
        if (arr4) {
          var $pProperty, i4 = -1, l4 = arr4.length - 1;
          while (i4 < l4) {
            $pProperty = arr4[i4 += 1];
            var $sch = $pProperties[$pProperty];
            if (it2.opts.strictKeywords ? typeof $sch == "object" && Object.keys($sch).length > 0 || $sch === false : it2.util.schemaHasRules($sch, it2.RULES.all)) {
              $it.schema = $sch;
              $it.schemaPath = it2.schemaPath + ".patternProperties" + it2.util.getProperty($pProperty);
              $it.errSchemaPath = it2.errSchemaPath + "/patternProperties/" + it2.util.escapeFragment($pProperty);
              if ($ownProperties) {
                out += " " + $dataProperties + " = " + $dataProperties + " || Object.keys(" + $data + "); for (var " + $idx + "=0; " + $idx + "<" + $dataProperties + ".length; " + $idx + "++) { var " + $key + " = " + $dataProperties + "[" + $idx + "]; ";
              } else {
                out += " for (var " + $key + " in " + $data + ") { ";
              }
              out += " if (" + it2.usePattern($pProperty) + ".test(" + $key + ")) { ";
              $it.errorPath = it2.util.getPathExpr(it2.errorPath, $key, it2.opts.jsonPointers);
              var $passData = $data + "[" + $key + "]";
              $it.dataPathArr[$dataNxt] = $key;
              var $code = it2.validate($it);
              $it.baseId = $currentBaseId;
              if (it2.util.varOccurences($code, $nextData) < 2) {
                out += " " + it2.util.varReplace($code, $nextData, $passData) + " ";
              } else {
                out += " var " + $nextData + " = " + $passData + "; " + $code + " ";
              }
              if ($breakOnError) {
                out += " if (!" + $nextValid + ") break; ";
              }
              out += " } ";
              if ($breakOnError) {
                out += " else " + $nextValid + " = true; ";
              }
              out += " }  ";
              if ($breakOnError) {
                out += " if (" + $nextValid + ") { ";
                $closingBraces += "}";
              }
            }
          }
        }
      }
      if ($breakOnError) {
        out += " " + $closingBraces + " if (" + $errs + " == errors) {";
      }
      return out;
    }, "generate_properties");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/propertyNames.js
var require_propertyNames = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/propertyNames.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate_propertyNames(it2, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it2.level;
      var $dataLvl = it2.dataLevel;
      var $schema = it2.schema[$keyword];
      var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
      var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it2.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $errs = "errs__" + $lvl;
      var $it = it2.util.copy(it2);
      var $closingBraces = "";
      $it.level++;
      var $nextValid = "valid" + $it.level;
      out += "var " + $errs + " = errors;";
      if (it2.opts.strictKeywords ? typeof $schema == "object" && Object.keys($schema).length > 0 || $schema === false : it2.util.schemaHasRules($schema, it2.RULES.all)) {
        $it.schema = $schema;
        $it.schemaPath = $schemaPath;
        $it.errSchemaPath = $errSchemaPath;
        var $key = "key" + $lvl, $idx = "idx" + $lvl, $i = "i" + $lvl, $invalidName = "' + " + $key + " + '", $dataNxt = $it.dataLevel = it2.dataLevel + 1, $nextData = "data" + $dataNxt, $dataProperties = "dataProperties" + $lvl, $ownProperties = it2.opts.ownProperties, $currentBaseId = it2.baseId;
        if ($ownProperties) {
          out += " var " + $dataProperties + " = undefined; ";
        }
        if ($ownProperties) {
          out += " " + $dataProperties + " = " + $dataProperties + " || Object.keys(" + $data + "); for (var " + $idx + "=0; " + $idx + "<" + $dataProperties + ".length; " + $idx + "++) { var " + $key + " = " + $dataProperties + "[" + $idx + "]; ";
        } else {
          out += " for (var " + $key + " in " + $data + ") { ";
        }
        out += " var startErrs" + $lvl + " = errors; ";
        var $passData = $key;
        var $wasComposite = it2.compositeRule;
        it2.compositeRule = $it.compositeRule = true;
        var $code = it2.validate($it);
        $it.baseId = $currentBaseId;
        if (it2.util.varOccurences($code, $nextData) < 2) {
          out += " " + it2.util.varReplace($code, $nextData, $passData) + " ";
        } else {
          out += " var " + $nextData + " = " + $passData + "; " + $code + " ";
        }
        it2.compositeRule = $it.compositeRule = $wasComposite;
        out += " if (!" + $nextValid + ") { for (var " + $i + "=startErrs" + $lvl + "; " + $i + "<errors; " + $i + "++) { vErrors[" + $i + "].propertyName = " + $key + "; }   var err =   ";
        if (it2.createErrors !== false) {
          out += " { keyword: 'propertyNames' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { propertyName: '" + $invalidName + "' } ";
          if (it2.opts.messages !== false) {
            out += " , message: 'property name \\'" + $invalidName + "\\' is invalid' ";
          }
          if (it2.opts.verbose) {
            out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
          }
          out += " } ";
        } else {
          out += " {} ";
        }
        out += ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
        if (!it2.compositeRule && $breakOnError) {
          if (it2.async) {
            out += " throw new ValidationError(vErrors); ";
          } else {
            out += " validate.errors = vErrors; return false; ";
          }
        }
        if ($breakOnError) {
          out += " break; ";
        }
        out += " } }";
      }
      if ($breakOnError) {
        out += " " + $closingBraces + " if (" + $errs + " == errors) {";
      }
      return out;
    }, "generate_propertyNames");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/required.js
var require_required = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/required.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate_required(it2, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it2.level;
      var $dataLvl = it2.dataLevel;
      var $schema = it2.schema[$keyword];
      var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
      var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it2.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $valid = "valid" + $lvl;
      var $isData = it2.opts.$data && $schema && $schema.$data, $schemaValue;
      if ($isData) {
        out += " var schema" + $lvl + " = " + it2.util.getData($schema.$data, $dataLvl, it2.dataPathArr) + "; ";
        $schemaValue = "schema" + $lvl;
      } else {
        $schemaValue = $schema;
      }
      var $vSchema = "schema" + $lvl;
      if (!$isData) {
        if ($schema.length < it2.opts.loopRequired && it2.schema.properties && Object.keys(it2.schema.properties).length) {
          var $required = [];
          var arr1 = $schema;
          if (arr1) {
            var $property, i1 = -1, l1 = arr1.length - 1;
            while (i1 < l1) {
              $property = arr1[i1 += 1];
              var $propertySch = it2.schema.properties[$property];
              if (!($propertySch && (it2.opts.strictKeywords ? typeof $propertySch == "object" && Object.keys($propertySch).length > 0 || $propertySch === false : it2.util.schemaHasRules($propertySch, it2.RULES.all)))) {
                $required[$required.length] = $property;
              }
            }
          }
        } else {
          var $required = $schema;
        }
      }
      if ($isData || $required.length) {
        var $currentErrorPath = it2.errorPath, $loopRequired = $isData || $required.length >= it2.opts.loopRequired, $ownProperties = it2.opts.ownProperties;
        if ($breakOnError) {
          out += " var missing" + $lvl + "; ";
          if ($loopRequired) {
            if (!$isData) {
              out += " var " + $vSchema + " = validate.schema" + $schemaPath + "; ";
            }
            var $i = "i" + $lvl, $propertyPath = "schema" + $lvl + "[" + $i + "]", $missingProperty = "' + " + $propertyPath + " + '";
            if (it2.opts._errorDataPathProperty) {
              it2.errorPath = it2.util.getPathExpr($currentErrorPath, $propertyPath, it2.opts.jsonPointers);
            }
            out += " var " + $valid + " = true; ";
            if ($isData) {
              out += " if (schema" + $lvl + " === undefined) " + $valid + " = true; else if (!Array.isArray(schema" + $lvl + ")) " + $valid + " = false; else {";
            }
            out += " for (var " + $i + " = 0; " + $i + " < " + $vSchema + ".length; " + $i + "++) { " + $valid + " = " + $data + "[" + $vSchema + "[" + $i + "]] !== undefined ";
            if ($ownProperties) {
              out += " &&   Object.prototype.hasOwnProperty.call(" + $data + ", " + $vSchema + "[" + $i + "]) ";
            }
            out += "; if (!" + $valid + ") break; } ";
            if ($isData) {
              out += "  }  ";
            }
            out += "  if (!" + $valid + ") {   ";
            var $$outStack = $$outStack || [];
            $$outStack.push(out);
            out = "";
            if (it2.createErrors !== false) {
              out += " { keyword: 'required' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { missingProperty: '" + $missingProperty + "' } ";
              if (it2.opts.messages !== false) {
                out += " , message: '";
                if (it2.opts._errorDataPathProperty) {
                  out += "is a required property";
                } else {
                  out += "should have required property \\'" + $missingProperty + "\\'";
                }
                out += "' ";
              }
              if (it2.opts.verbose) {
                out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
              }
              out += " } ";
            } else {
              out += " {} ";
            }
            var __err = out;
            out = $$outStack.pop();
            if (!it2.compositeRule && $breakOnError) {
              if (it2.async) {
                out += " throw new ValidationError([" + __err + "]); ";
              } else {
                out += " validate.errors = [" + __err + "]; return false; ";
              }
            } else {
              out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
            }
            out += " } else { ";
          } else {
            out += " if ( ";
            var arr2 = $required;
            if (arr2) {
              var $propertyKey, $i = -1, l2 = arr2.length - 1;
              while ($i < l2) {
                $propertyKey = arr2[$i += 1];
                if ($i) {
                  out += " || ";
                }
                var $prop = it2.util.getProperty($propertyKey), $useData = $data + $prop;
                out += " ( ( " + $useData + " === undefined ";
                if ($ownProperties) {
                  out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", '" + it2.util.escapeQuotes($propertyKey) + "') ";
                }
                out += ") && (missing" + $lvl + " = " + it2.util.toQuotedString(it2.opts.jsonPointers ? $propertyKey : $prop) + ") ) ";
              }
            }
            out += ") {  ";
            var $propertyPath = "missing" + $lvl, $missingProperty = "' + " + $propertyPath + " + '";
            if (it2.opts._errorDataPathProperty) {
              it2.errorPath = it2.opts.jsonPointers ? it2.util.getPathExpr($currentErrorPath, $propertyPath, true) : $currentErrorPath + " + " + $propertyPath;
            }
            var $$outStack = $$outStack || [];
            $$outStack.push(out);
            out = "";
            if (it2.createErrors !== false) {
              out += " { keyword: 'required' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { missingProperty: '" + $missingProperty + "' } ";
              if (it2.opts.messages !== false) {
                out += " , message: '";
                if (it2.opts._errorDataPathProperty) {
                  out += "is a required property";
                } else {
                  out += "should have required property \\'" + $missingProperty + "\\'";
                }
                out += "' ";
              }
              if (it2.opts.verbose) {
                out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
              }
              out += " } ";
            } else {
              out += " {} ";
            }
            var __err = out;
            out = $$outStack.pop();
            if (!it2.compositeRule && $breakOnError) {
              if (it2.async) {
                out += " throw new ValidationError([" + __err + "]); ";
              } else {
                out += " validate.errors = [" + __err + "]; return false; ";
              }
            } else {
              out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
            }
            out += " } else { ";
          }
        } else {
          if ($loopRequired) {
            if (!$isData) {
              out += " var " + $vSchema + " = validate.schema" + $schemaPath + "; ";
            }
            var $i = "i" + $lvl, $propertyPath = "schema" + $lvl + "[" + $i + "]", $missingProperty = "' + " + $propertyPath + " + '";
            if (it2.opts._errorDataPathProperty) {
              it2.errorPath = it2.util.getPathExpr($currentErrorPath, $propertyPath, it2.opts.jsonPointers);
            }
            if ($isData) {
              out += " if (" + $vSchema + " && !Array.isArray(" + $vSchema + ")) {  var err =   ";
              if (it2.createErrors !== false) {
                out += " { keyword: 'required' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { missingProperty: '" + $missingProperty + "' } ";
                if (it2.opts.messages !== false) {
                  out += " , message: '";
                  if (it2.opts._errorDataPathProperty) {
                    out += "is a required property";
                  } else {
                    out += "should have required property \\'" + $missingProperty + "\\'";
                  }
                  out += "' ";
                }
                if (it2.opts.verbose) {
                  out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
                }
                out += " } ";
              } else {
                out += " {} ";
              }
              out += ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } else if (" + $vSchema + " !== undefined) { ";
            }
            out += " for (var " + $i + " = 0; " + $i + " < " + $vSchema + ".length; " + $i + "++) { if (" + $data + "[" + $vSchema + "[" + $i + "]] === undefined ";
            if ($ownProperties) {
              out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", " + $vSchema + "[" + $i + "]) ";
            }
            out += ") {  var err =   ";
            if (it2.createErrors !== false) {
              out += " { keyword: 'required' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { missingProperty: '" + $missingProperty + "' } ";
              if (it2.opts.messages !== false) {
                out += " , message: '";
                if (it2.opts._errorDataPathProperty) {
                  out += "is a required property";
                } else {
                  out += "should have required property \\'" + $missingProperty + "\\'";
                }
                out += "' ";
              }
              if (it2.opts.verbose) {
                out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
              }
              out += " } ";
            } else {
              out += " {} ";
            }
            out += ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } } ";
            if ($isData) {
              out += "  }  ";
            }
          } else {
            var arr3 = $required;
            if (arr3) {
              var $propertyKey, i3 = -1, l3 = arr3.length - 1;
              while (i3 < l3) {
                $propertyKey = arr3[i3 += 1];
                var $prop = it2.util.getProperty($propertyKey), $missingProperty = it2.util.escapeQuotes($propertyKey), $useData = $data + $prop;
                if (it2.opts._errorDataPathProperty) {
                  it2.errorPath = it2.util.getPath($currentErrorPath, $propertyKey, it2.opts.jsonPointers);
                }
                out += " if ( " + $useData + " === undefined ";
                if ($ownProperties) {
                  out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", '" + it2.util.escapeQuotes($propertyKey) + "') ";
                }
                out += ") {  var err =   ";
                if (it2.createErrors !== false) {
                  out += " { keyword: 'required' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { missingProperty: '" + $missingProperty + "' } ";
                  if (it2.opts.messages !== false) {
                    out += " , message: '";
                    if (it2.opts._errorDataPathProperty) {
                      out += "is a required property";
                    } else {
                      out += "should have required property \\'" + $missingProperty + "\\'";
                    }
                    out += "' ";
                  }
                  if (it2.opts.verbose) {
                    out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
                  }
                  out += " } ";
                } else {
                  out += " {} ";
                }
                out += ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } ";
              }
            }
          }
        }
        it2.errorPath = $currentErrorPath;
      } else if ($breakOnError) {
        out += " if (true) {";
      }
      return out;
    }, "generate_required");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/uniqueItems.js
var require_uniqueItems = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/uniqueItems.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate_uniqueItems(it2, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it2.level;
      var $dataLvl = it2.dataLevel;
      var $schema = it2.schema[$keyword];
      var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
      var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it2.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $valid = "valid" + $lvl;
      var $isData = it2.opts.$data && $schema && $schema.$data, $schemaValue;
      if ($isData) {
        out += " var schema" + $lvl + " = " + it2.util.getData($schema.$data, $dataLvl, it2.dataPathArr) + "; ";
        $schemaValue = "schema" + $lvl;
      } else {
        $schemaValue = $schema;
      }
      if (($schema || $isData) && it2.opts.uniqueItems !== false) {
        if ($isData) {
          out += " var " + $valid + "; if (" + $schemaValue + " === false || " + $schemaValue + " === undefined) " + $valid + " = true; else if (typeof " + $schemaValue + " != 'boolean') " + $valid + " = false; else { ";
        }
        out += " var i = " + $data + ".length , " + $valid + " = true , j; if (i > 1) { ";
        var $itemType = it2.schema.items && it2.schema.items.type, $typeIsArray = Array.isArray($itemType);
        if (!$itemType || $itemType == "object" || $itemType == "array" || $typeIsArray && ($itemType.indexOf("object") >= 0 || $itemType.indexOf("array") >= 0)) {
          out += " outer: for (;i--;) { for (j = i; j--;) { if (equal(" + $data + "[i], " + $data + "[j])) { " + $valid + " = false; break outer; } } } ";
        } else {
          out += " var itemIndices = {}, item; for (;i--;) { var item = " + $data + "[i]; ";
          var $method = "checkDataType" + ($typeIsArray ? "s" : "");
          out += " if (" + it2.util[$method]($itemType, "item", it2.opts.strictNumbers, true) + ") continue; ";
          if ($typeIsArray) {
            out += ` if (typeof item == 'string') item = '"' + item; `;
          }
          out += " if (typeof itemIndices[item] == 'number') { " + $valid + " = false; j = itemIndices[item]; break; } itemIndices[item] = i; } ";
        }
        out += " } ";
        if ($isData) {
          out += "  }  ";
        }
        out += " if (!" + $valid + ") {   ";
        var $$outStack = $$outStack || [];
        $$outStack.push(out);
        out = "";
        if (it2.createErrors !== false) {
          out += " { keyword: 'uniqueItems' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { i: i, j: j } ";
          if (it2.opts.messages !== false) {
            out += " , message: 'should NOT have duplicate items (items ## ' + j + ' and ' + i + ' are identical)' ";
          }
          if (it2.opts.verbose) {
            out += " , schema:  ";
            if ($isData) {
              out += "validate.schema" + $schemaPath;
            } else {
              out += "" + $schema;
            }
            out += "         , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
          }
          out += " } ";
        } else {
          out += " {} ";
        }
        var __err = out;
        out = $$outStack.pop();
        if (!it2.compositeRule && $breakOnError) {
          if (it2.async) {
            out += " throw new ValidationError([" + __err + "]); ";
          } else {
            out += " validate.errors = [" + __err + "]; return false; ";
          }
        } else {
          out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
        }
        out += " } ";
        if ($breakOnError) {
          out += " else { ";
        }
      } else {
        if ($breakOnError) {
          out += " if (true) { ";
        }
      }
      return out;
    }, "generate_uniqueItems");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/index.js
var require_dotjs = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = {
      "$ref": require_ref(),
      allOf: require_allOf(),
      anyOf: require_anyOf(),
      "$comment": require_comment(),
      const: require_const(),
      contains: require_contains(),
      dependencies: require_dependencies(),
      "enum": require_enum(),
      format: require_format(),
      "if": require_if(),
      items: require_items(),
      maximum: require_limit(),
      minimum: require_limit(),
      maxItems: require_limitItems(),
      minItems: require_limitItems(),
      maxLength: require_limitLength(),
      minLength: require_limitLength(),
      maxProperties: require_limitProperties(),
      minProperties: require_limitProperties(),
      multipleOf: require_multipleOf(),
      not: require_not(),
      oneOf: require_oneOf(),
      pattern: require_pattern(),
      properties: require_properties(),
      propertyNames: require_propertyNames(),
      required: require_required(),
      uniqueItems: require_uniqueItems(),
      validate: require_validate()
    };
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/rules.js
var require_rules = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/rules.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var ruleModules = require_dotjs();
    var toHash = require_util11().toHash;
    module3.exports = /* @__PURE__ */ __name(function rules() {
      var RULES = [
        {
          type: "number",
          rules: [
            { "maximum": ["exclusiveMaximum"] },
            { "minimum": ["exclusiveMinimum"] },
            "multipleOf",
            "format"
          ]
        },
        {
          type: "string",
          rules: ["maxLength", "minLength", "pattern", "format"]
        },
        {
          type: "array",
          rules: ["maxItems", "minItems", "items", "contains", "uniqueItems"]
        },
        {
          type: "object",
          rules: [
            "maxProperties",
            "minProperties",
            "required",
            "dependencies",
            "propertyNames",
            { "properties": ["additionalProperties", "patternProperties"] }
          ]
        },
        { rules: ["$ref", "const", "enum", "not", "anyOf", "oneOf", "allOf", "if"] }
      ];
      var ALL = ["type", "$comment"];
      var KEYWORDS = [
        "$schema",
        "$id",
        "id",
        "$data",
        "$async",
        "title",
        "description",
        "default",
        "definitions",
        "examples",
        "readOnly",
        "writeOnly",
        "contentMediaType",
        "contentEncoding",
        "additionalItems",
        "then",
        "else"
      ];
      var TYPES = ["number", "integer", "string", "array", "object", "boolean", "null"];
      RULES.all = toHash(ALL);
      RULES.types = toHash(TYPES);
      RULES.forEach(function(group) {
        group.rules = group.rules.map(function(keyword) {
          var implKeywords;
          if (typeof keyword == "object") {
            var key = Object.keys(keyword)[0];
            implKeywords = keyword[key];
            keyword = key;
            implKeywords.forEach(function(k2) {
              ALL.push(k2);
              RULES.all[k2] = true;
            });
          }
          ALL.push(keyword);
          var rule = RULES.all[keyword] = {
            keyword,
            code: ruleModules[keyword],
            implements: implKeywords
          };
          return rule;
        });
        RULES.all.$comment = {
          keyword: "$comment",
          code: ruleModules.$comment
        };
        if (group.type)
          RULES.types[group.type] = group;
      });
      RULES.keywords = toHash(ALL.concat(KEYWORDS));
      RULES.custom = {};
      return RULES;
    }, "rules");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/data.js
var require_data = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/data.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var KEYWORDS = [
      "multipleOf",
      "maximum",
      "exclusiveMaximum",
      "minimum",
      "exclusiveMinimum",
      "maxLength",
      "minLength",
      "pattern",
      "additionalItems",
      "maxItems",
      "minItems",
      "uniqueItems",
      "maxProperties",
      "minProperties",
      "required",
      "additionalProperties",
      "enum",
      "format",
      "const"
    ];
    module3.exports = function(metaSchema, keywordsJsonPointers) {
      for (var i = 0; i < keywordsJsonPointers.length; i++) {
        metaSchema = JSON.parse(JSON.stringify(metaSchema));
        var segments = keywordsJsonPointers[i].split("/");
        var keywords = metaSchema;
        var j2;
        for (j2 = 1; j2 < segments.length; j2++)
          keywords = keywords[segments[j2]];
        for (j2 = 0; j2 < KEYWORDS.length; j2++) {
          var key = KEYWORDS[j2];
          var schema = keywords[key];
          if (schema) {
            keywords[key] = {
              anyOf: [
                schema,
                { $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#" }
              ]
            };
          }
        }
      }
      return metaSchema;
    };
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/async.js
var require_async2 = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/async.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var MissingRefError = require_error_classes().MissingRef;
    module3.exports = compileAsync;
    function compileAsync(schema, meta, callback) {
      var self2 = this;
      if (typeof this._opts.loadSchema != "function")
        throw new Error("options.loadSchema should be a function");
      if (typeof meta == "function") {
        callback = meta;
        meta = void 0;
      }
      var p2 = loadMetaSchemaOf(schema).then(function() {
        var schemaObj = self2._addSchema(schema, void 0, meta);
        return schemaObj.validate || _compileAsync(schemaObj);
      });
      if (callback) {
        p2.then(
          function(v2) {
            callback(null, v2);
          },
          callback
        );
      }
      return p2;
      function loadMetaSchemaOf(sch) {
        var $schema = sch.$schema;
        return $schema && !self2.getSchema($schema) ? compileAsync.call(self2, { $ref: $schema }, true) : Promise.resolve();
      }
      __name(loadMetaSchemaOf, "loadMetaSchemaOf");
      function _compileAsync(schemaObj) {
        try {
          return self2._compile(schemaObj);
        } catch (e3) {
          if (e3 instanceof MissingRefError)
            return loadMissingSchema(e3);
          throw e3;
        }
        function loadMissingSchema(e3) {
          var ref = e3.missingSchema;
          if (added(ref))
            throw new Error("Schema " + ref + " is loaded but " + e3.missingRef + " cannot be resolved");
          var schemaPromise = self2._loadingSchemas[ref];
          if (!schemaPromise) {
            schemaPromise = self2._loadingSchemas[ref] = self2._opts.loadSchema(ref);
            schemaPromise.then(removePromise, removePromise);
          }
          return schemaPromise.then(function(sch) {
            if (!added(ref)) {
              return loadMetaSchemaOf(sch).then(function() {
                if (!added(ref))
                  self2.addSchema(sch, ref, void 0, meta);
              });
            }
          }).then(function() {
            return _compileAsync(schemaObj);
          });
          function removePromise() {
            delete self2._loadingSchemas[ref];
          }
          __name(removePromise, "removePromise");
          function added(ref2) {
            return self2._refs[ref2] || self2._schemas[ref2];
          }
          __name(added, "added");
        }
        __name(loadMissingSchema, "loadMissingSchema");
      }
      __name(_compileAsync, "_compileAsync");
    }
    __name(compileAsync, "compileAsync");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/custom.js
var require_custom = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/dotjs/custom.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function generate_custom(it2, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it2.level;
      var $dataLvl = it2.dataLevel;
      var $schema = it2.schema[$keyword];
      var $schemaPath = it2.schemaPath + it2.util.getProperty($keyword);
      var $errSchemaPath = it2.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it2.opts.allErrors;
      var $errorKeyword;
      var $data = "data" + ($dataLvl || "");
      var $valid = "valid" + $lvl;
      var $errs = "errs__" + $lvl;
      var $isData = it2.opts.$data && $schema && $schema.$data, $schemaValue;
      if ($isData) {
        out += " var schema" + $lvl + " = " + it2.util.getData($schema.$data, $dataLvl, it2.dataPathArr) + "; ";
        $schemaValue = "schema" + $lvl;
      } else {
        $schemaValue = $schema;
      }
      var $rule = this, $definition = "definition" + $lvl, $rDef = $rule.definition, $closingBraces = "";
      var $compile, $inline, $macro, $ruleValidate, $validateCode;
      if ($isData && $rDef.$data) {
        $validateCode = "keywordValidate" + $lvl;
        var $validateSchema = $rDef.validateSchema;
        out += " var " + $definition + " = RULES.custom['" + $keyword + "'].definition; var " + $validateCode + " = " + $definition + ".validate;";
      } else {
        $ruleValidate = it2.useCustomRule($rule, $schema, it2.schema, it2);
        if (!$ruleValidate)
          return;
        $schemaValue = "validate.schema" + $schemaPath;
        $validateCode = $ruleValidate.code;
        $compile = $rDef.compile;
        $inline = $rDef.inline;
        $macro = $rDef.macro;
      }
      var $ruleErrs = $validateCode + ".errors", $i = "i" + $lvl, $ruleErr = "ruleErr" + $lvl, $asyncKeyword = $rDef.async;
      if ($asyncKeyword && !it2.async)
        throw new Error("async keyword in sync schema");
      if (!($inline || $macro)) {
        out += "" + $ruleErrs + " = null;";
      }
      out += "var " + $errs + " = errors;var " + $valid + ";";
      if ($isData && $rDef.$data) {
        $closingBraces += "}";
        out += " if (" + $schemaValue + " === undefined) { " + $valid + " = true; } else { ";
        if ($validateSchema) {
          $closingBraces += "}";
          out += " " + $valid + " = " + $definition + ".validateSchema(" + $schemaValue + "); if (" + $valid + ") { ";
        }
      }
      if ($inline) {
        if ($rDef.statements) {
          out += " " + $ruleValidate.validate + " ";
        } else {
          out += " " + $valid + " = " + $ruleValidate.validate + "; ";
        }
      } else if ($macro) {
        var $it = it2.util.copy(it2);
        var $closingBraces = "";
        $it.level++;
        var $nextValid = "valid" + $it.level;
        $it.schema = $ruleValidate.validate;
        $it.schemaPath = "";
        var $wasComposite = it2.compositeRule;
        it2.compositeRule = $it.compositeRule = true;
        var $code = it2.validate($it).replace(/validate\.schema/g, $validateCode);
        it2.compositeRule = $it.compositeRule = $wasComposite;
        out += " " + $code;
      } else {
        var $$outStack = $$outStack || [];
        $$outStack.push(out);
        out = "";
        out += "  " + $validateCode + ".call( ";
        if (it2.opts.passContext) {
          out += "this";
        } else {
          out += "self";
        }
        if ($compile || $rDef.schema === false) {
          out += " , " + $data + " ";
        } else {
          out += " , " + $schemaValue + " , " + $data + " , validate.schema" + it2.schemaPath + " ";
        }
        out += " , (dataPath || '')";
        if (it2.errorPath != '""') {
          out += " + " + it2.errorPath;
        }
        var $parentData = $dataLvl ? "data" + ($dataLvl - 1 || "") : "parentData", $parentDataProperty = $dataLvl ? it2.dataPathArr[$dataLvl] : "parentDataProperty";
        out += " , " + $parentData + " , " + $parentDataProperty + " , rootData )  ";
        var def_callRuleValidate = out;
        out = $$outStack.pop();
        if ($rDef.errors === false) {
          out += " " + $valid + " = ";
          if ($asyncKeyword) {
            out += "await ";
          }
          out += "" + def_callRuleValidate + "; ";
        } else {
          if ($asyncKeyword) {
            $ruleErrs = "customErrors" + $lvl;
            out += " var " + $ruleErrs + " = null; try { " + $valid + " = await " + def_callRuleValidate + "; } catch (e) { " + $valid + " = false; if (e instanceof ValidationError) " + $ruleErrs + " = e.errors; else throw e; } ";
          } else {
            out += " " + $ruleErrs + " = null; " + $valid + " = " + def_callRuleValidate + "; ";
          }
        }
      }
      if ($rDef.modifying) {
        out += " if (" + $parentData + ") " + $data + " = " + $parentData + "[" + $parentDataProperty + "];";
      }
      out += "" + $closingBraces;
      if ($rDef.valid) {
        if ($breakOnError) {
          out += " if (true) { ";
        }
      } else {
        out += " if ( ";
        if ($rDef.valid === void 0) {
          out += " !";
          if ($macro) {
            out += "" + $nextValid;
          } else {
            out += "" + $valid;
          }
        } else {
          out += " " + !$rDef.valid + " ";
        }
        out += ") { ";
        $errorKeyword = $rule.keyword;
        var $$outStack = $$outStack || [];
        $$outStack.push(out);
        out = "";
        var $$outStack = $$outStack || [];
        $$outStack.push(out);
        out = "";
        if (it2.createErrors !== false) {
          out += " { keyword: '" + ($errorKeyword || "custom") + "' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { keyword: '" + $rule.keyword + "' } ";
          if (it2.opts.messages !== false) {
            out += ` , message: 'should pass "` + $rule.keyword + `" keyword validation' `;
          }
          if (it2.opts.verbose) {
            out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
          }
          out += " } ";
        } else {
          out += " {} ";
        }
        var __err = out;
        out = $$outStack.pop();
        if (!it2.compositeRule && $breakOnError) {
          if (it2.async) {
            out += " throw new ValidationError([" + __err + "]); ";
          } else {
            out += " validate.errors = [" + __err + "]; return false; ";
          }
        } else {
          out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
        }
        var def_customError = out;
        out = $$outStack.pop();
        if ($inline) {
          if ($rDef.errors) {
            if ($rDef.errors != "full") {
              out += "  for (var " + $i + "=" + $errs + "; " + $i + "<errors; " + $i + "++) { var " + $ruleErr + " = vErrors[" + $i + "]; if (" + $ruleErr + ".dataPath === undefined) " + $ruleErr + ".dataPath = (dataPath || '') + " + it2.errorPath + "; if (" + $ruleErr + ".schemaPath === undefined) { " + $ruleErr + '.schemaPath = "' + $errSchemaPath + '"; } ';
              if (it2.opts.verbose) {
                out += " " + $ruleErr + ".schema = " + $schemaValue + "; " + $ruleErr + ".data = " + $data + "; ";
              }
              out += " } ";
            }
          } else {
            if ($rDef.errors === false) {
              out += " " + def_customError + " ";
            } else {
              out += " if (" + $errs + " == errors) { " + def_customError + " } else {  for (var " + $i + "=" + $errs + "; " + $i + "<errors; " + $i + "++) { var " + $ruleErr + " = vErrors[" + $i + "]; if (" + $ruleErr + ".dataPath === undefined) " + $ruleErr + ".dataPath = (dataPath || '') + " + it2.errorPath + "; if (" + $ruleErr + ".schemaPath === undefined) { " + $ruleErr + '.schemaPath = "' + $errSchemaPath + '"; } ';
              if (it2.opts.verbose) {
                out += " " + $ruleErr + ".schema = " + $schemaValue + "; " + $ruleErr + ".data = " + $data + "; ";
              }
              out += " } } ";
            }
          }
        } else if ($macro) {
          out += "   var err =   ";
          if (it2.createErrors !== false) {
            out += " { keyword: '" + ($errorKeyword || "custom") + "' , dataPath: (dataPath || '') + " + it2.errorPath + " , schemaPath: " + it2.util.toQuotedString($errSchemaPath) + " , params: { keyword: '" + $rule.keyword + "' } ";
            if (it2.opts.messages !== false) {
              out += ` , message: 'should pass "` + $rule.keyword + `" keyword validation' `;
            }
            if (it2.opts.verbose) {
              out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it2.schemaPath + " , data: " + $data + " ";
            }
            out += " } ";
          } else {
            out += " {} ";
          }
          out += ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
          if (!it2.compositeRule && $breakOnError) {
            if (it2.async) {
              out += " throw new ValidationError(vErrors); ";
            } else {
              out += " validate.errors = vErrors; return false; ";
            }
          }
        } else {
          if ($rDef.errors === false) {
            out += " " + def_customError + " ";
          } else {
            out += " if (Array.isArray(" + $ruleErrs + ")) { if (vErrors === null) vErrors = " + $ruleErrs + "; else vErrors = vErrors.concat(" + $ruleErrs + "); errors = vErrors.length;  for (var " + $i + "=" + $errs + "; " + $i + "<errors; " + $i + "++) { var " + $ruleErr + " = vErrors[" + $i + "]; if (" + $ruleErr + ".dataPath === undefined) " + $ruleErr + ".dataPath = (dataPath || '') + " + it2.errorPath + ";  " + $ruleErr + '.schemaPath = "' + $errSchemaPath + '";  ';
            if (it2.opts.verbose) {
              out += " " + $ruleErr + ".schema = " + $schemaValue + "; " + $ruleErr + ".data = " + $data + "; ";
            }
            out += " } } else { " + def_customError + " } ";
          }
        }
        out += " } ";
        if ($breakOnError) {
          out += " else { ";
        }
      }
      return out;
    }, "generate_custom");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/refs/json-schema-draft-07.json
var require_json_schema_draft_07 = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/refs/json-schema-draft-07.json"(exports2, module3) {
    module3.exports = {
      $schema: "http://json-schema.org/draft-07/schema#",
      $id: "http://json-schema.org/draft-07/schema#",
      title: "Core schema meta-schema",
      definitions: {
        schemaArray: {
          type: "array",
          minItems: 1,
          items: { $ref: "#" }
        },
        nonNegativeInteger: {
          type: "integer",
          minimum: 0
        },
        nonNegativeIntegerDefault0: {
          allOf: [
            { $ref: "#/definitions/nonNegativeInteger" },
            { default: 0 }
          ]
        },
        simpleTypes: {
          enum: [
            "array",
            "boolean",
            "integer",
            "null",
            "number",
            "object",
            "string"
          ]
        },
        stringArray: {
          type: "array",
          items: { type: "string" },
          uniqueItems: true,
          default: []
        }
      },
      type: ["object", "boolean"],
      properties: {
        $id: {
          type: "string",
          format: "uri-reference"
        },
        $schema: {
          type: "string",
          format: "uri"
        },
        $ref: {
          type: "string",
          format: "uri-reference"
        },
        $comment: {
          type: "string"
        },
        title: {
          type: "string"
        },
        description: {
          type: "string"
        },
        default: true,
        readOnly: {
          type: "boolean",
          default: false
        },
        examples: {
          type: "array",
          items: true
        },
        multipleOf: {
          type: "number",
          exclusiveMinimum: 0
        },
        maximum: {
          type: "number"
        },
        exclusiveMaximum: {
          type: "number"
        },
        minimum: {
          type: "number"
        },
        exclusiveMinimum: {
          type: "number"
        },
        maxLength: { $ref: "#/definitions/nonNegativeInteger" },
        minLength: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
        pattern: {
          type: "string",
          format: "regex"
        },
        additionalItems: { $ref: "#" },
        items: {
          anyOf: [
            { $ref: "#" },
            { $ref: "#/definitions/schemaArray" }
          ],
          default: true
        },
        maxItems: { $ref: "#/definitions/nonNegativeInteger" },
        minItems: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
        uniqueItems: {
          type: "boolean",
          default: false
        },
        contains: { $ref: "#" },
        maxProperties: { $ref: "#/definitions/nonNegativeInteger" },
        minProperties: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
        required: { $ref: "#/definitions/stringArray" },
        additionalProperties: { $ref: "#" },
        definitions: {
          type: "object",
          additionalProperties: { $ref: "#" },
          default: {}
        },
        properties: {
          type: "object",
          additionalProperties: { $ref: "#" },
          default: {}
        },
        patternProperties: {
          type: "object",
          additionalProperties: { $ref: "#" },
          propertyNames: { format: "regex" },
          default: {}
        },
        dependencies: {
          type: "object",
          additionalProperties: {
            anyOf: [
              { $ref: "#" },
              { $ref: "#/definitions/stringArray" }
            ]
          }
        },
        propertyNames: { $ref: "#" },
        const: true,
        enum: {
          type: "array",
          items: true,
          minItems: 1,
          uniqueItems: true
        },
        type: {
          anyOf: [
            { $ref: "#/definitions/simpleTypes" },
            {
              type: "array",
              items: { $ref: "#/definitions/simpleTypes" },
              minItems: 1,
              uniqueItems: true
            }
          ]
        },
        format: { type: "string" },
        contentMediaType: { type: "string" },
        contentEncoding: { type: "string" },
        if: { $ref: "#" },
        then: { $ref: "#" },
        else: { $ref: "#" },
        allOf: { $ref: "#/definitions/schemaArray" },
        anyOf: { $ref: "#/definitions/schemaArray" },
        oneOf: { $ref: "#/definitions/schemaArray" },
        not: { $ref: "#" }
      },
      default: true
    };
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/definition_schema.js
var require_definition_schema = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/definition_schema.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var metaSchema = require_json_schema_draft_07();
    module3.exports = {
      $id: "https://github.com/ajv-validator/ajv/blob/master/lib/definition_schema.js",
      definitions: {
        simpleTypes: metaSchema.definitions.simpleTypes
      },
      type: "object",
      dependencies: {
        schema: ["validate"],
        $data: ["validate"],
        statements: ["inline"],
        valid: { not: { required: ["macro"] } }
      },
      properties: {
        type: metaSchema.properties.type,
        schema: { type: "boolean" },
        statements: { type: "boolean" },
        dependencies: {
          type: "array",
          items: { type: "string" }
        },
        metaSchema: { type: "object" },
        modifying: { type: "boolean" },
        valid: { type: "boolean" },
        $data: { type: "boolean" },
        async: { type: "boolean" },
        errors: {
          anyOf: [
            { type: "boolean" },
            { const: "full" }
          ]
        }
      }
    };
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/keyword.js
var require_keyword = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/keyword.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var IDENTIFIER = /^[a-z_$][a-z0-9_$-]*$/i;
    var customRuleCode = require_custom();
    var definitionSchema = require_definition_schema();
    module3.exports = {
      add: addKeyword,
      get: getKeyword,
      remove: removeKeyword,
      validate: validateKeyword
    };
    function addKeyword(keyword, definition) {
      var RULES = this.RULES;
      if (RULES.keywords[keyword])
        throw new Error("Keyword " + keyword + " is already defined");
      if (!IDENTIFIER.test(keyword))
        throw new Error("Keyword " + keyword + " is not a valid identifier");
      if (definition) {
        this.validateKeyword(definition, true);
        var dataType = definition.type;
        if (Array.isArray(dataType)) {
          for (var i = 0; i < dataType.length; i++)
            _addRule(keyword, dataType[i], definition);
        } else {
          _addRule(keyword, dataType, definition);
        }
        var metaSchema = definition.metaSchema;
        if (metaSchema) {
          if (definition.$data && this._opts.$data) {
            metaSchema = {
              anyOf: [
                metaSchema,
                { "$ref": "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#" }
              ]
            };
          }
          definition.validateSchema = this.compile(metaSchema, true);
        }
      }
      RULES.keywords[keyword] = RULES.all[keyword] = true;
      function _addRule(keyword2, dataType2, definition2) {
        var ruleGroup;
        for (var i2 = 0; i2 < RULES.length; i2++) {
          var rg = RULES[i2];
          if (rg.type == dataType2) {
            ruleGroup = rg;
            break;
          }
        }
        if (!ruleGroup) {
          ruleGroup = { type: dataType2, rules: [] };
          RULES.push(ruleGroup);
        }
        var rule = {
          keyword: keyword2,
          definition: definition2,
          custom: true,
          code: customRuleCode,
          implements: definition2.implements
        };
        ruleGroup.rules.push(rule);
        RULES.custom[keyword2] = rule;
      }
      __name(_addRule, "_addRule");
      return this;
    }
    __name(addKeyword, "addKeyword");
    function getKeyword(keyword) {
      var rule = this.RULES.custom[keyword];
      return rule ? rule.definition : this.RULES.keywords[keyword] || false;
    }
    __name(getKeyword, "getKeyword");
    function removeKeyword(keyword) {
      var RULES = this.RULES;
      delete RULES.keywords[keyword];
      delete RULES.all[keyword];
      delete RULES.custom[keyword];
      for (var i = 0; i < RULES.length; i++) {
        var rules = RULES[i].rules;
        for (var j2 = 0; j2 < rules.length; j2++) {
          if (rules[j2].keyword == keyword) {
            rules.splice(j2, 1);
            break;
          }
        }
      }
      return this;
    }
    __name(removeKeyword, "removeKeyword");
    function validateKeyword(definition, throwError) {
      validateKeyword.errors = null;
      var v2 = this._validateKeyword = this._validateKeyword || this.compile(definitionSchema, true);
      if (v2(definition))
        return true;
      validateKeyword.errors = v2.errors;
      if (throwError)
        throw new Error("custom keyword definition is invalid: " + this.errorsText(v2.errors));
      else
        return false;
    }
    __name(validateKeyword, "validateKeyword");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/refs/data.json
var require_data2 = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/refs/data.json"(exports2, module3) {
    module3.exports = {
      $schema: "http://json-schema.org/draft-07/schema#",
      $id: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#",
      description: "Meta-schema for $data reference (JSON Schema extension proposal)",
      type: "object",
      required: ["$data"],
      properties: {
        $data: {
          type: "string",
          anyOf: [
            { format: "relative-json-pointer" },
            { format: "json-pointer" }
          ]
        }
      },
      additionalProperties: false
    };
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/ajv.js
var require_ajv = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/ajv.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var compileSchema = require_compile();
    var resolve19 = require_resolve2();
    var Cache3 = require_cache2();
    var SchemaObject = require_schema_obj();
    var stableStringify = require_fast_json_stable_stringify();
    var formats = require_formats2();
    var rules = require_rules();
    var $dataMetaSchema = require_data();
    var util4 = require_util11();
    module3.exports = Ajv;
    Ajv.prototype.validate = validate2;
    Ajv.prototype.compile = compile;
    Ajv.prototype.addSchema = addSchema;
    Ajv.prototype.addMetaSchema = addMetaSchema;
    Ajv.prototype.validateSchema = validateSchema;
    Ajv.prototype.getSchema = getSchema;
    Ajv.prototype.removeSchema = removeSchema;
    Ajv.prototype.addFormat = addFormat;
    Ajv.prototype.errorsText = errorsText;
    Ajv.prototype._addSchema = _addSchema;
    Ajv.prototype._compile = _compile;
    Ajv.prototype.compileAsync = require_async2();
    var customKeyword = require_keyword();
    Ajv.prototype.addKeyword = customKeyword.add;
    Ajv.prototype.getKeyword = customKeyword.get;
    Ajv.prototype.removeKeyword = customKeyword.remove;
    Ajv.prototype.validateKeyword = customKeyword.validate;
    var errorClasses = require_error_classes();
    Ajv.ValidationError = errorClasses.Validation;
    Ajv.MissingRefError = errorClasses.MissingRef;
    Ajv.$dataMetaSchema = $dataMetaSchema;
    var META_SCHEMA_ID = "http://json-schema.org/draft-07/schema";
    var META_IGNORE_OPTIONS = ["removeAdditional", "useDefaults", "coerceTypes", "strictDefaults"];
    var META_SUPPORT_DATA = ["/properties"];
    function Ajv(opts) {
      if (!(this instanceof Ajv))
        return new Ajv(opts);
      opts = this._opts = util4.copy(opts) || {};
      setLogger(this);
      this._schemas = {};
      this._refs = {};
      this._fragments = {};
      this._formats = formats(opts.format);
      this._cache = opts.cache || new Cache3();
      this._loadingSchemas = {};
      this._compilations = [];
      this.RULES = rules();
      this._getId = chooseGetId(opts);
      opts.loopRequired = opts.loopRequired || Infinity;
      if (opts.errorDataPath == "property")
        opts._errorDataPathProperty = true;
      if (opts.serialize === void 0)
        opts.serialize = stableStringify;
      this._metaOpts = getMetaSchemaOptions(this);
      if (opts.formats)
        addInitialFormats(this);
      if (opts.keywords)
        addInitialKeywords(this);
      addDefaultMetaSchema(this);
      if (typeof opts.meta == "object")
        this.addMetaSchema(opts.meta);
      if (opts.nullable)
        this.addKeyword("nullable", { metaSchema: { type: "boolean" } });
      addInitialSchemas(this);
    }
    __name(Ajv, "Ajv");
    function validate2(schemaKeyRef, data) {
      var v2;
      if (typeof schemaKeyRef == "string") {
        v2 = this.getSchema(schemaKeyRef);
        if (!v2)
          throw new Error('no schema with key or ref "' + schemaKeyRef + '"');
      } else {
        var schemaObj = this._addSchema(schemaKeyRef);
        v2 = schemaObj.validate || this._compile(schemaObj);
      }
      var valid = v2(data);
      if (v2.$async !== true)
        this.errors = v2.errors;
      return valid;
    }
    __name(validate2, "validate");
    function compile(schema, _meta) {
      var schemaObj = this._addSchema(schema, void 0, _meta);
      return schemaObj.validate || this._compile(schemaObj);
    }
    __name(compile, "compile");
    function addSchema(schema, key, _skipValidation, _meta) {
      if (Array.isArray(schema)) {
        for (var i = 0; i < schema.length; i++)
          this.addSchema(schema[i], void 0, _skipValidation, _meta);
        return this;
      }
      var id = this._getId(schema);
      if (id !== void 0 && typeof id != "string")
        throw new Error("schema id must be string");
      key = resolve19.normalizeId(key || id);
      checkUnique(this, key);
      this._schemas[key] = this._addSchema(schema, _skipValidation, _meta, true);
      return this;
    }
    __name(addSchema, "addSchema");
    function addMetaSchema(schema, key, skipValidation) {
      this.addSchema(schema, key, skipValidation, true);
      return this;
    }
    __name(addMetaSchema, "addMetaSchema");
    function validateSchema(schema, throwOrLogError) {
      var $schema = schema.$schema;
      if ($schema !== void 0 && typeof $schema != "string")
        throw new Error("$schema must be a string");
      $schema = $schema || this._opts.defaultMeta || defaultMeta(this);
      if (!$schema) {
        this.logger.warn("meta-schema not available");
        this.errors = null;
        return true;
      }
      var valid = this.validate($schema, schema);
      if (!valid && throwOrLogError) {
        var message = "schema is invalid: " + this.errorsText();
        if (this._opts.validateSchema == "log")
          this.logger.error(message);
        else
          throw new Error(message);
      }
      return valid;
    }
    __name(validateSchema, "validateSchema");
    function defaultMeta(self2) {
      var meta = self2._opts.meta;
      self2._opts.defaultMeta = typeof meta == "object" ? self2._getId(meta) || meta : self2.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0;
      return self2._opts.defaultMeta;
    }
    __name(defaultMeta, "defaultMeta");
    function getSchema(keyRef) {
      var schemaObj = _getSchemaObj(this, keyRef);
      switch (typeof schemaObj) {
        case "object":
          return schemaObj.validate || this._compile(schemaObj);
        case "string":
          return this.getSchema(schemaObj);
        case "undefined":
          return _getSchemaFragment(this, keyRef);
      }
    }
    __name(getSchema, "getSchema");
    function _getSchemaFragment(self2, ref) {
      var res = resolve19.schema.call(self2, { schema: {} }, ref);
      if (res) {
        var schema = res.schema, root = res.root, baseId = res.baseId;
        var v2 = compileSchema.call(self2, schema, root, void 0, baseId);
        self2._fragments[ref] = new SchemaObject({
          ref,
          fragment: true,
          schema,
          root,
          baseId,
          validate: v2
        });
        return v2;
      }
    }
    __name(_getSchemaFragment, "_getSchemaFragment");
    function _getSchemaObj(self2, keyRef) {
      keyRef = resolve19.normalizeId(keyRef);
      return self2._schemas[keyRef] || self2._refs[keyRef] || self2._fragments[keyRef];
    }
    __name(_getSchemaObj, "_getSchemaObj");
    function removeSchema(schemaKeyRef) {
      if (schemaKeyRef instanceof RegExp) {
        _removeAllSchemas(this, this._schemas, schemaKeyRef);
        _removeAllSchemas(this, this._refs, schemaKeyRef);
        return this;
      }
      switch (typeof schemaKeyRef) {
        case "undefined":
          _removeAllSchemas(this, this._schemas);
          _removeAllSchemas(this, this._refs);
          this._cache.clear();
          return this;
        case "string":
          var schemaObj = _getSchemaObj(this, schemaKeyRef);
          if (schemaObj)
            this._cache.del(schemaObj.cacheKey);
          delete this._schemas[schemaKeyRef];
          delete this._refs[schemaKeyRef];
          return this;
        case "object":
          var serialize = this._opts.serialize;
          var cacheKey = serialize ? serialize(schemaKeyRef) : schemaKeyRef;
          this._cache.del(cacheKey);
          var id = this._getId(schemaKeyRef);
          if (id) {
            id = resolve19.normalizeId(id);
            delete this._schemas[id];
            delete this._refs[id];
          }
      }
      return this;
    }
    __name(removeSchema, "removeSchema");
    function _removeAllSchemas(self2, schemas, regex2) {
      for (var keyRef in schemas) {
        var schemaObj = schemas[keyRef];
        if (!schemaObj.meta && (!regex2 || regex2.test(keyRef))) {
          self2._cache.del(schemaObj.cacheKey);
          delete schemas[keyRef];
        }
      }
    }
    __name(_removeAllSchemas, "_removeAllSchemas");
    function _addSchema(schema, skipValidation, meta, shouldAddSchema) {
      if (typeof schema != "object" && typeof schema != "boolean")
        throw new Error("schema should be object or boolean");
      var serialize = this._opts.serialize;
      var cacheKey = serialize ? serialize(schema) : schema;
      var cached = this._cache.get(cacheKey);
      if (cached)
        return cached;
      shouldAddSchema = shouldAddSchema || this._opts.addUsedSchema !== false;
      var id = resolve19.normalizeId(this._getId(schema));
      if (id && shouldAddSchema)
        checkUnique(this, id);
      var willValidate = this._opts.validateSchema !== false && !skipValidation;
      var recursiveMeta;
      if (willValidate && !(recursiveMeta = id && id == resolve19.normalizeId(schema.$schema)))
        this.validateSchema(schema, true);
      var localRefs = resolve19.ids.call(this, schema);
      var schemaObj = new SchemaObject({
        id,
        schema,
        localRefs,
        cacheKey,
        meta
      });
      if (id[0] != "#" && shouldAddSchema)
        this._refs[id] = schemaObj;
      this._cache.put(cacheKey, schemaObj);
      if (willValidate && recursiveMeta)
        this.validateSchema(schema, true);
      return schemaObj;
    }
    __name(_addSchema, "_addSchema");
    function _compile(schemaObj, root) {
      if (schemaObj.compiling) {
        schemaObj.validate = callValidate;
        callValidate.schema = schemaObj.schema;
        callValidate.errors = null;
        callValidate.root = root ? root : callValidate;
        if (schemaObj.schema.$async === true)
          callValidate.$async = true;
        return callValidate;
      }
      schemaObj.compiling = true;
      var currentOpts;
      if (schemaObj.meta) {
        currentOpts = this._opts;
        this._opts = this._metaOpts;
      }
      var v2;
      try {
        v2 = compileSchema.call(this, schemaObj.schema, root, schemaObj.localRefs);
      } catch (e3) {
        delete schemaObj.validate;
        throw e3;
      } finally {
        schemaObj.compiling = false;
        if (schemaObj.meta)
          this._opts = currentOpts;
      }
      schemaObj.validate = v2;
      schemaObj.refs = v2.refs;
      schemaObj.refVal = v2.refVal;
      schemaObj.root = v2.root;
      return v2;
      function callValidate() {
        var _validate = schemaObj.validate;
        var result = _validate.apply(this, arguments);
        callValidate.errors = _validate.errors;
        return result;
      }
      __name(callValidate, "callValidate");
    }
    __name(_compile, "_compile");
    function chooseGetId(opts) {
      switch (opts.schemaId) {
        case "auto":
          return _get$IdOrId;
        case "id":
          return _getId;
        default:
          return _get$Id;
      }
    }
    __name(chooseGetId, "chooseGetId");
    function _getId(schema) {
      if (schema.$id)
        this.logger.warn("schema $id ignored", schema.$id);
      return schema.id;
    }
    __name(_getId, "_getId");
    function _get$Id(schema) {
      if (schema.id)
        this.logger.warn("schema id ignored", schema.id);
      return schema.$id;
    }
    __name(_get$Id, "_get$Id");
    function _get$IdOrId(schema) {
      if (schema.$id && schema.id && schema.$id != schema.id)
        throw new Error("schema $id is different from id");
      return schema.$id || schema.id;
    }
    __name(_get$IdOrId, "_get$IdOrId");
    function errorsText(errors, options29) {
      errors = errors || this.errors;
      if (!errors)
        return "No errors";
      options29 = options29 || {};
      var separator = options29.separator === void 0 ? ", " : options29.separator;
      var dataVar = options29.dataVar === void 0 ? "data" : options29.dataVar;
      var text = "";
      for (var i = 0; i < errors.length; i++) {
        var e3 = errors[i];
        if (e3)
          text += dataVar + e3.dataPath + " " + e3.message + separator;
      }
      return text.slice(0, -separator.length);
    }
    __name(errorsText, "errorsText");
    function addFormat(name, format10) {
      if (typeof format10 == "string")
        format10 = new RegExp(format10);
      this._formats[name] = format10;
      return this;
    }
    __name(addFormat, "addFormat");
    function addDefaultMetaSchema(self2) {
      var $dataSchema;
      if (self2._opts.$data) {
        $dataSchema = require_data2();
        self2.addMetaSchema($dataSchema, $dataSchema.$id, true);
      }
      if (self2._opts.meta === false)
        return;
      var metaSchema = require_json_schema_draft_07();
      if (self2._opts.$data)
        metaSchema = $dataMetaSchema(metaSchema, META_SUPPORT_DATA);
      self2.addMetaSchema(metaSchema, META_SCHEMA_ID, true);
      self2._refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
    }
    __name(addDefaultMetaSchema, "addDefaultMetaSchema");
    function addInitialSchemas(self2) {
      var optsSchemas = self2._opts.schemas;
      if (!optsSchemas)
        return;
      if (Array.isArray(optsSchemas))
        self2.addSchema(optsSchemas);
      else
        for (var key in optsSchemas)
          self2.addSchema(optsSchemas[key], key);
    }
    __name(addInitialSchemas, "addInitialSchemas");
    function addInitialFormats(self2) {
      for (var name in self2._opts.formats) {
        var format10 = self2._opts.formats[name];
        self2.addFormat(name, format10);
      }
    }
    __name(addInitialFormats, "addInitialFormats");
    function addInitialKeywords(self2) {
      for (var name in self2._opts.keywords) {
        var keyword = self2._opts.keywords[name];
        self2.addKeyword(name, keyword);
      }
    }
    __name(addInitialKeywords, "addInitialKeywords");
    function checkUnique(self2, id) {
      if (self2._schemas[id] || self2._refs[id])
        throw new Error('schema with key or id "' + id + '" already exists');
    }
    __name(checkUnique, "checkUnique");
    function getMetaSchemaOptions(self2) {
      var metaOpts = util4.copy(self2._opts);
      for (var i = 0; i < META_IGNORE_OPTIONS.length; i++)
        delete metaOpts[META_IGNORE_OPTIONS[i]];
      return metaOpts;
    }
    __name(getMetaSchemaOptions, "getMetaSchemaOptions");
    function setLogger(self2) {
      var logger3 = self2._opts.logger;
      if (logger3 === false) {
        self2.logger = { log: noop, warn: noop, error: noop };
      } else {
        if (logger3 === void 0)
          logger3 = console;
        if (!(typeof logger3 == "object" && logger3.log && logger3.warn && logger3.error))
          throw new Error("logger must implement log, warn and error methods");
        self2.logger = logger3;
      }
    }
    __name(setLogger, "setLogger");
    function noop() {
    }
    __name(noop, "noop");
  }
});

// ../../node_modules/.pnpm/deepmerge@4.2.2/node_modules/deepmerge/dist/cjs.js
var require_cjs = __commonJS({
  "../../node_modules/.pnpm/deepmerge@4.2.2/node_modules/deepmerge/dist/cjs.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var isMergeableObject = /* @__PURE__ */ __name(function isMergeableObject2(value) {
      return isNonNullObject(value) && !isSpecial(value);
    }, "isMergeableObject");
    function isNonNullObject(value) {
      return !!value && typeof value === "object";
    }
    __name(isNonNullObject, "isNonNullObject");
    function isSpecial(value) {
      var stringValue = Object.prototype.toString.call(value);
      return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
    }
    __name(isSpecial, "isSpecial");
    var canUseSymbol = typeof Symbol === "function" && Symbol.for;
    var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for("react.element") : 60103;
    function isReactElement(value) {
      return value.$$typeof === REACT_ELEMENT_TYPE;
    }
    __name(isReactElement, "isReactElement");
    function emptyTarget(val) {
      return Array.isArray(val) ? [] : {};
    }
    __name(emptyTarget, "emptyTarget");
    function cloneUnlessOtherwiseSpecified(value, options29) {
      return options29.clone !== false && options29.isMergeableObject(value) ? deepmerge(emptyTarget(value), value, options29) : value;
    }
    __name(cloneUnlessOtherwiseSpecified, "cloneUnlessOtherwiseSpecified");
    function defaultArrayMerge(target, source, options29) {
      return target.concat(source).map(function(element) {
        return cloneUnlessOtherwiseSpecified(element, options29);
      });
    }
    __name(defaultArrayMerge, "defaultArrayMerge");
    function getMergeFunction(key, options29) {
      if (!options29.customMerge) {
        return deepmerge;
      }
      var customMerge = options29.customMerge(key);
      return typeof customMerge === "function" ? customMerge : deepmerge;
    }
    __name(getMergeFunction, "getMergeFunction");
    function getEnumerableOwnPropertySymbols(target) {
      return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
        return target.propertyIsEnumerable(symbol);
      }) : [];
    }
    __name(getEnumerableOwnPropertySymbols, "getEnumerableOwnPropertySymbols");
    function getKeys(target) {
      return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
    }
    __name(getKeys, "getKeys");
    function propertyIsOnObject(object, property) {
      try {
        return property in object;
      } catch (_3) {
        return false;
      }
    }
    __name(propertyIsOnObject, "propertyIsOnObject");
    function propertyIsUnsafe(target, key) {
      return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
    }
    __name(propertyIsUnsafe, "propertyIsUnsafe");
    function mergeObject(target, source, options29) {
      var destination = {};
      if (options29.isMergeableObject(target)) {
        getKeys(target).forEach(function(key) {
          destination[key] = cloneUnlessOtherwiseSpecified(target[key], options29);
        });
      }
      getKeys(source).forEach(function(key) {
        if (propertyIsUnsafe(target, key)) {
          return;
        }
        if (propertyIsOnObject(target, key) && options29.isMergeableObject(source[key])) {
          destination[key] = getMergeFunction(key, options29)(target[key], source[key], options29);
        } else {
          destination[key] = cloneUnlessOtherwiseSpecified(source[key], options29);
        }
      });
      return destination;
    }
    __name(mergeObject, "mergeObject");
    function deepmerge(target, source, options29) {
      options29 = options29 || {};
      options29.arrayMerge = options29.arrayMerge || defaultArrayMerge;
      options29.isMergeableObject = options29.isMergeableObject || isMergeableObject;
      options29.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
      var sourceIsArray = Array.isArray(source);
      var targetIsArray = Array.isArray(target);
      var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
      if (!sourceAndTargetTypesMatch) {
        return cloneUnlessOtherwiseSpecified(source, options29);
      } else if (sourceIsArray) {
        return options29.arrayMerge(target, source, options29);
      } else {
        return mergeObject(target, source, options29);
      }
    }
    __name(deepmerge, "deepmerge");
    deepmerge.all = /* @__PURE__ */ __name(function deepmergeAll(array, options29) {
      if (!Array.isArray(array)) {
        throw new Error("first argument should be an array");
      }
      return array.reduce(function(prev, next) {
        return deepmerge(prev, next, options29);
      }, {});
    }, "deepmergeAll");
    var deepmerge_1 = deepmerge;
    module3.exports = deepmerge_1;
  }
});

// ../../node_modules/.pnpm/rfdc@1.3.0/node_modules/rfdc/index.js
var require_rfdc = __commonJS({
  "../../node_modules/.pnpm/rfdc@1.3.0/node_modules/rfdc/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = rfdc;
    function copyBuffer(cur) {
      if (cur instanceof Buffer) {
        return Buffer.from(cur);
      }
      return new cur.constructor(cur.buffer.slice(), cur.byteOffset, cur.length);
    }
    __name(copyBuffer, "copyBuffer");
    function rfdc(opts) {
      opts = opts || {};
      if (opts.circles)
        return rfdcCircles(opts);
      return opts.proto ? cloneProto : clone;
      function cloneArray(a, fn2) {
        var keys = Object.keys(a);
        var a2 = new Array(keys.length);
        for (var i = 0; i < keys.length; i++) {
          var k2 = keys[i];
          var cur = a[k2];
          if (typeof cur !== "object" || cur === null) {
            a2[k2] = cur;
          } else if (cur instanceof Date) {
            a2[k2] = new Date(cur);
          } else if (ArrayBuffer.isView(cur)) {
            a2[k2] = copyBuffer(cur);
          } else {
            a2[k2] = fn2(cur);
          }
        }
        return a2;
      }
      __name(cloneArray, "cloneArray");
      function clone(o2) {
        if (typeof o2 !== "object" || o2 === null)
          return o2;
        if (o2 instanceof Date)
          return new Date(o2);
        if (Array.isArray(o2))
          return cloneArray(o2, clone);
        if (o2 instanceof Map)
          return new Map(cloneArray(Array.from(o2), clone));
        if (o2 instanceof Set)
          return new Set(cloneArray(Array.from(o2), clone));
        var o22 = {};
        for (var k2 in o2) {
          if (Object.hasOwnProperty.call(o2, k2) === false)
            continue;
          var cur = o2[k2];
          if (typeof cur !== "object" || cur === null) {
            o22[k2] = cur;
          } else if (cur instanceof Date) {
            o22[k2] = new Date(cur);
          } else if (cur instanceof Map) {
            o22[k2] = new Map(cloneArray(Array.from(cur), clone));
          } else if (cur instanceof Set) {
            o22[k2] = new Set(cloneArray(Array.from(cur), clone));
          } else if (ArrayBuffer.isView(cur)) {
            o22[k2] = copyBuffer(cur);
          } else {
            o22[k2] = clone(cur);
          }
        }
        return o22;
      }
      __name(clone, "clone");
      function cloneProto(o2) {
        if (typeof o2 !== "object" || o2 === null)
          return o2;
        if (o2 instanceof Date)
          return new Date(o2);
        if (Array.isArray(o2))
          return cloneArray(o2, cloneProto);
        if (o2 instanceof Map)
          return new Map(cloneArray(Array.from(o2), cloneProto));
        if (o2 instanceof Set)
          return new Set(cloneArray(Array.from(o2), cloneProto));
        var o22 = {};
        for (var k2 in o2) {
          var cur = o2[k2];
          if (typeof cur !== "object" || cur === null) {
            o22[k2] = cur;
          } else if (cur instanceof Date) {
            o22[k2] = new Date(cur);
          } else if (cur instanceof Map) {
            o22[k2] = new Map(cloneArray(Array.from(cur), cloneProto));
          } else if (cur instanceof Set) {
            o22[k2] = new Set(cloneArray(Array.from(cur), cloneProto));
          } else if (ArrayBuffer.isView(cur)) {
            o22[k2] = copyBuffer(cur);
          } else {
            o22[k2] = cloneProto(cur);
          }
        }
        return o22;
      }
      __name(cloneProto, "cloneProto");
    }
    __name(rfdc, "rfdc");
    function rfdcCircles(opts) {
      var refs = [];
      var refsNew = [];
      return opts.proto ? cloneProto : clone;
      function cloneArray(a, fn2) {
        var keys = Object.keys(a);
        var a2 = new Array(keys.length);
        for (var i = 0; i < keys.length; i++) {
          var k2 = keys[i];
          var cur = a[k2];
          if (typeof cur !== "object" || cur === null) {
            a2[k2] = cur;
          } else if (cur instanceof Date) {
            a2[k2] = new Date(cur);
          } else if (ArrayBuffer.isView(cur)) {
            a2[k2] = copyBuffer(cur);
          } else {
            var index = refs.indexOf(cur);
            if (index !== -1) {
              a2[k2] = refsNew[index];
            } else {
              a2[k2] = fn2(cur);
            }
          }
        }
        return a2;
      }
      __name(cloneArray, "cloneArray");
      function clone(o2) {
        if (typeof o2 !== "object" || o2 === null)
          return o2;
        if (o2 instanceof Date)
          return new Date(o2);
        if (Array.isArray(o2))
          return cloneArray(o2, clone);
        if (o2 instanceof Map)
          return new Map(cloneArray(Array.from(o2), clone));
        if (o2 instanceof Set)
          return new Set(cloneArray(Array.from(o2), clone));
        var o22 = {};
        refs.push(o2);
        refsNew.push(o22);
        for (var k2 in o2) {
          if (Object.hasOwnProperty.call(o2, k2) === false)
            continue;
          var cur = o2[k2];
          if (typeof cur !== "object" || cur === null) {
            o22[k2] = cur;
          } else if (cur instanceof Date) {
            o22[k2] = new Date(cur);
          } else if (cur instanceof Map) {
            o22[k2] = new Map(cloneArray(Array.from(cur), clone));
          } else if (cur instanceof Set) {
            o22[k2] = new Set(cloneArray(Array.from(cur), clone));
          } else if (ArrayBuffer.isView(cur)) {
            o22[k2] = copyBuffer(cur);
          } else {
            var i = refs.indexOf(cur);
            if (i !== -1) {
              o22[k2] = refsNew[i];
            } else {
              o22[k2] = clone(cur);
            }
          }
        }
        refs.pop();
        refsNew.pop();
        return o22;
      }
      __name(clone, "clone");
      function cloneProto(o2) {
        if (typeof o2 !== "object" || o2 === null)
          return o2;
        if (o2 instanceof Date)
          return new Date(o2);
        if (Array.isArray(o2))
          return cloneArray(o2, cloneProto);
        if (o2 instanceof Map)
          return new Map(cloneArray(Array.from(o2), cloneProto));
        if (o2 instanceof Set)
          return new Set(cloneArray(Array.from(o2), cloneProto));
        var o22 = {};
        refs.push(o2);
        refsNew.push(o22);
        for (var k2 in o2) {
          var cur = o2[k2];
          if (typeof cur !== "object" || cur === null) {
            o22[k2] = cur;
          } else if (cur instanceof Date) {
            o22[k2] = new Date(cur);
          } else if (cur instanceof Map) {
            o22[k2] = new Map(cloneArray(Array.from(cur), cloneProto));
          } else if (cur instanceof Set) {
            o22[k2] = new Set(cloneArray(Array.from(cur), cloneProto));
          } else if (ArrayBuffer.isView(cur)) {
            o22[k2] = copyBuffer(cur);
          } else {
            var i = refs.indexOf(cur);
            if (i !== -1) {
              o22[k2] = refsNew[i];
            } else {
              o22[k2] = cloneProto(cur);
            }
          }
        }
        refs.pop();
        refsNew.pop();
        return o22;
      }
      __name(cloneProto, "cloneProto");
    }
    __name(rfdcCircles, "rfdcCircles");
  }
});

// ../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/equal.js
var require_equal = __commonJS({
  "../../node_modules/.pnpm/ajv@6.12.6/node_modules/ajv/lib/compile/equal.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = require_fast_deep_equal();
  }
});

// ../../node_modules/.pnpm/fast-json-stringify@2.7.13/node_modules/fast-json-stringify/schema-validator.js
var require_schema_validator = __commonJS({
  "../../node_modules/.pnpm/fast-json-stringify@2.7.13/node_modules/fast-json-stringify/schema-validator.js"(exports2, module3) {
    init_import_meta_url();
    function nop() {
      return true;
    }
    __name(nop, "nop");
    var formats = require_formats2()();
    var equal = require_equal();
    var validate2 = function() {
      var refVal = [];
      var refVal1 = {
        "type": "integer",
        "minimum": 0
      };
      refVal[1] = refVal1;
      var refVal2 = function() {
        return /* @__PURE__ */ __name(function validate3(data, dataPath, parentData, parentDataProperty, rootData) {
          "use strict";
          var vErrors = null;
          var errors = 0;
          var errs_1 = errors;
          var errs_2 = errors;
          if (typeof data !== "number" || data % 1 || data !== data) {
            validate3.errors = [{
              keyword: "type",
              dataPath: (dataPath || "") + "",
              schemaPath: "#/definitions/nonNegativeInteger/type",
              params: {
                type: "integer"
              },
              message: "should be integer"
            }];
            return false;
          }
          if (typeof data === "number") {
            if (data < 0 || data !== data) {
              validate3.errors = [{
                keyword: "minimum",
                dataPath: (dataPath || "") + "",
                schemaPath: "#/definitions/nonNegativeInteger/minimum",
                params: {
                  comparison: ">=",
                  limit: 0,
                  exclusive: false
                },
                message: "should be >= 0"
              }];
              return false;
            }
          }
          var valid2 = errors === errs_2;
          var valid1 = errors === errs_1;
          validate3.errors = vErrors;
          return errors === 0;
        }, "validate");
      }();
      refVal2.schema = {
        "allOf": [{
          "$ref": "#/definitions/nonNegativeInteger"
        }, {
          "default": 0
        }]
      };
      refVal2.errors = null;
      refVal[2] = refVal2;
      var refVal3 = function() {
        return /* @__PURE__ */ __name(function validate3(data, dataPath, parentData, parentDataProperty, rootData) {
          "use strict";
          var vErrors = null;
          var errors = 0;
          if (rootData === void 0)
            rootData = data;
          if (Array.isArray(data)) {
            if (data.length < 1) {
              validate3.errors = [{
                keyword: "minItems",
                dataPath: (dataPath || "") + "",
                schemaPath: "#/minItems",
                params: {
                  limit: 1
                },
                message: "should NOT have fewer than 1 items"
              }];
              return false;
            } else {
              var errs__0 = errors;
              var valid0;
              for (var i0 = 0; i0 < data.length; i0++) {
                var errs_1 = errors;
                if (!nop(data[i0], (dataPath || "") + "[" + i0 + "]", data, i0, rootData)) {
                  if (vErrors === null)
                    vErrors = nop.errors;
                  else
                    vErrors = vErrors.concat(nop.errors);
                  errors = vErrors.length;
                }
                var valid1 = errors === errs_1;
                if (!valid1)
                  break;
              }
            }
          } else {
            validate3.errors = [{
              keyword: "type",
              dataPath: (dataPath || "") + "",
              schemaPath: "#/type",
              params: {
                type: "array"
              },
              message: "should be array"
            }];
            return false;
          }
          validate3.errors = vErrors;
          return errors === 0;
        }, "validate");
      }();
      refVal3.schema = {
        "type": "array",
        "minItems": 1,
        "items": {
          "$ref": "#"
        }
      };
      refVal3.errors = null;
      refVal[3] = refVal3;
      var refVal4 = {
        "type": "array",
        "items": {
          "type": "string"
        },
        "uniqueItems": true,
        "default": []
      };
      refVal[4] = refVal4;
      var refVal5 = {
        "enum": ["array", "boolean", "integer", "null", "number", "object", "string"]
      };
      refVal[5] = refVal5;
      return /* @__PURE__ */ __name(function validate3(data, dataPath, parentData, parentDataProperty, rootData) {
        "use strict";
        var vErrors = null;
        var errors = 0;
        if (rootData === void 0)
          rootData = data;
        if ((!data || typeof data !== "object" || Array.isArray(data)) && typeof data !== "boolean") {
          validate3.errors = [{
            keyword: "type",
            dataPath: (dataPath || "") + "",
            schemaPath: "#/type",
            params: {
              type: "object,boolean"
            },
            message: "should be object,boolean"
          }];
          return false;
        }
        if (data && typeof data === "object" && !Array.isArray(data)) {
          var errs__0 = errors;
          var valid1 = true;
          var data1 = data.$id;
          if (data1 === void 0) {
            valid1 = true;
          } else {
            var errs_1 = errors;
            if (errors === errs_1) {
              if (typeof data1 === "string") {
                if (!formats["uri-reference"].test(data1)) {
                  validate3.errors = [{
                    keyword: "format",
                    dataPath: (dataPath || "") + ".$id",
                    schemaPath: "#/properties/%24id/format",
                    params: {
                      format: "uri-reference"
                    },
                    message: 'should match format "uri-reference"'
                  }];
                  return false;
                }
              } else {
                validate3.errors = [{
                  keyword: "type",
                  dataPath: (dataPath || "") + ".$id",
                  schemaPath: "#/properties/%24id/type",
                  params: {
                    type: "string"
                  },
                  message: "should be string"
                }];
                return false;
              }
            }
            var valid1 = errors === errs_1;
          }
          if (valid1) {
            var data1 = data.$schema;
            if (data1 === void 0) {
              valid1 = true;
            } else {
              var errs_1 = errors;
              if (errors === errs_1) {
                if (typeof data1 === "string") {
                  if (!formats.uri.test(data1)) {
                    validate3.errors = [{
                      keyword: "format",
                      dataPath: (dataPath || "") + ".$schema",
                      schemaPath: "#/properties/%24schema/format",
                      params: {
                        format: "uri"
                      },
                      message: 'should match format "uri"'
                    }];
                    return false;
                  }
                } else {
                  validate3.errors = [{
                    keyword: "type",
                    dataPath: (dataPath || "") + ".$schema",
                    schemaPath: "#/properties/%24schema/type",
                    params: {
                      type: "string"
                    },
                    message: "should be string"
                  }];
                  return false;
                }
              }
              var valid1 = errors === errs_1;
            }
            if (valid1) {
              var data1 = data.$ref;
              if (data1 === void 0) {
                valid1 = true;
              } else {
                var errs_1 = errors;
                if (errors === errs_1) {
                  if (typeof data1 === "string") {
                    if (!formats["uri-reference"].test(data1)) {
                      validate3.errors = [{
                        keyword: "format",
                        dataPath: (dataPath || "") + ".$ref",
                        schemaPath: "#/properties/%24ref/format",
                        params: {
                          format: "uri-reference"
                        },
                        message: 'should match format "uri-reference"'
                      }];
                      return false;
                    }
                  } else {
                    validate3.errors = [{
                      keyword: "type",
                      dataPath: (dataPath || "") + ".$ref",
                      schemaPath: "#/properties/%24ref/type",
                      params: {
                        type: "string"
                      },
                      message: "should be string"
                    }];
                    return false;
                  }
                }
                var valid1 = errors === errs_1;
              }
              if (valid1) {
                if (data.$comment === void 0) {
                  valid1 = true;
                } else {
                  var errs_1 = errors;
                  if (typeof data.$comment !== "string") {
                    validate3.errors = [{
                      keyword: "type",
                      dataPath: (dataPath || "") + ".$comment",
                      schemaPath: "#/properties/%24comment/type",
                      params: {
                        type: "string"
                      },
                      message: "should be string"
                    }];
                    return false;
                  }
                  var valid1 = errors === errs_1;
                }
                if (valid1) {
                  if (data.title === void 0) {
                    valid1 = true;
                  } else {
                    var errs_1 = errors;
                    if (typeof data.title !== "string") {
                      validate3.errors = [{
                        keyword: "type",
                        dataPath: (dataPath || "") + ".title",
                        schemaPath: "#/properties/title/type",
                        params: {
                          type: "string"
                        },
                        message: "should be string"
                      }];
                      return false;
                    }
                    var valid1 = errors === errs_1;
                  }
                  if (valid1) {
                    if (data.description === void 0) {
                      valid1 = true;
                    } else {
                      var errs_1 = errors;
                      if (typeof data.description !== "string") {
                        validate3.errors = [{
                          keyword: "type",
                          dataPath: (dataPath || "") + ".description",
                          schemaPath: "#/properties/description/type",
                          params: {
                            type: "string"
                          },
                          message: "should be string"
                        }];
                        return false;
                      }
                      var valid1 = errors === errs_1;
                    }
                    if (valid1) {
                      if (valid1) {
                        if (data.readOnly === void 0) {
                          valid1 = true;
                        } else {
                          var errs_1 = errors;
                          if (typeof data.readOnly !== "boolean") {
                            validate3.errors = [{
                              keyword: "type",
                              dataPath: (dataPath || "") + ".readOnly",
                              schemaPath: "#/properties/readOnly/type",
                              params: {
                                type: "boolean"
                              },
                              message: "should be boolean"
                            }];
                            return false;
                          }
                          var valid1 = errors === errs_1;
                        }
                        if (valid1) {
                          if (data.examples === void 0) {
                            valid1 = true;
                          } else {
                            var errs_1 = errors;
                            if (Array.isArray(data.examples)) {
                              var errs__1 = errors;
                              var valid1;
                            } else {
                              validate3.errors = [{
                                keyword: "type",
                                dataPath: (dataPath || "") + ".examples",
                                schemaPath: "#/properties/examples/type",
                                params: {
                                  type: "array"
                                },
                                message: "should be array"
                              }];
                              return false;
                            }
                            var valid1 = errors === errs_1;
                          }
                          if (valid1) {
                            var data1 = data.multipleOf;
                            if (data1 === void 0) {
                              valid1 = true;
                            } else {
                              var errs_1 = errors;
                              if (typeof data1 === "number") {
                                if (data1 <= 0 || data1 !== data1) {
                                  validate3.errors = [{
                                    keyword: "exclusiveMinimum",
                                    dataPath: (dataPath || "") + ".multipleOf",
                                    schemaPath: "#/properties/multipleOf/exclusiveMinimum",
                                    params: {
                                      comparison: ">",
                                      limit: 0,
                                      exclusive: true
                                    },
                                    message: "should be > 0"
                                  }];
                                  return false;
                                }
                              } else {
                                validate3.errors = [{
                                  keyword: "type",
                                  dataPath: (dataPath || "") + ".multipleOf",
                                  schemaPath: "#/properties/multipleOf/type",
                                  params: {
                                    type: "number"
                                  },
                                  message: "should be number"
                                }];
                                return false;
                              }
                              var valid1 = errors === errs_1;
                            }
                            if (valid1) {
                              if (data.maximum === void 0) {
                                valid1 = true;
                              } else {
                                var errs_1 = errors;
                                if (typeof data.maximum !== "number") {
                                  validate3.errors = [{
                                    keyword: "type",
                                    dataPath: (dataPath || "") + ".maximum",
                                    schemaPath: "#/properties/maximum/type",
                                    params: {
                                      type: "number"
                                    },
                                    message: "should be number"
                                  }];
                                  return false;
                                }
                                var valid1 = errors === errs_1;
                              }
                              if (valid1) {
                                if (data.exclusiveMaximum === void 0) {
                                  valid1 = true;
                                } else {
                                  var errs_1 = errors;
                                  if (typeof data.exclusiveMaximum !== "number") {
                                    validate3.errors = [{
                                      keyword: "type",
                                      dataPath: (dataPath || "") + ".exclusiveMaximum",
                                      schemaPath: "#/properties/exclusiveMaximum/type",
                                      params: {
                                        type: "number"
                                      },
                                      message: "should be number"
                                    }];
                                    return false;
                                  }
                                  var valid1 = errors === errs_1;
                                }
                                if (valid1) {
                                  if (data.minimum === void 0) {
                                    valid1 = true;
                                  } else {
                                    var errs_1 = errors;
                                    if (typeof data.minimum !== "number") {
                                      validate3.errors = [{
                                        keyword: "type",
                                        dataPath: (dataPath || "") + ".minimum",
                                        schemaPath: "#/properties/minimum/type",
                                        params: {
                                          type: "number"
                                        },
                                        message: "should be number"
                                      }];
                                      return false;
                                    }
                                    var valid1 = errors === errs_1;
                                  }
                                  if (valid1) {
                                    if (data.exclusiveMinimum === void 0) {
                                      valid1 = true;
                                    } else {
                                      var errs_1 = errors;
                                      if (typeof data.exclusiveMinimum !== "number") {
                                        validate3.errors = [{
                                          keyword: "type",
                                          dataPath: (dataPath || "") + ".exclusiveMinimum",
                                          schemaPath: "#/properties/exclusiveMinimum/type",
                                          params: {
                                            type: "number"
                                          },
                                          message: "should be number"
                                        }];
                                        return false;
                                      }
                                      var valid1 = errors === errs_1;
                                    }
                                    if (valid1) {
                                      var data1 = data.maxLength;
                                      if (data1 === void 0) {
                                        valid1 = true;
                                      } else {
                                        var errs_1 = errors;
                                        var errs_2 = errors;
                                        if (typeof data1 !== "number" || data1 % 1 || data1 !== data1) {
                                          validate3.errors = [{
                                            keyword: "type",
                                            dataPath: (dataPath || "") + ".maxLength",
                                            schemaPath: "#/definitions/nonNegativeInteger/type",
                                            params: {
                                              type: "integer"
                                            },
                                            message: "should be integer"
                                          }];
                                          return false;
                                        }
                                        if (typeof data1 === "number") {
                                          if (data1 < 0 || data1 !== data1) {
                                            validate3.errors = [{
                                              keyword: "minimum",
                                              dataPath: (dataPath || "") + ".maxLength",
                                              schemaPath: "#/definitions/nonNegativeInteger/minimum",
                                              params: {
                                                comparison: ">=",
                                                limit: 0,
                                                exclusive: false
                                              },
                                              message: "should be >= 0"
                                            }];
                                            return false;
                                          }
                                        }
                                        var valid2 = errors === errs_2;
                                        var valid1 = errors === errs_1;
                                      }
                                      if (valid1) {
                                        if (data.minLength === void 0) {
                                          valid1 = true;
                                        } else {
                                          var errs_1 = errors;
                                          if (!refVal2(data.minLength, (dataPath || "") + ".minLength", data, "minLength", rootData)) {
                                            if (vErrors === null)
                                              vErrors = refVal2.errors;
                                            else
                                              vErrors = vErrors.concat(refVal2.errors);
                                            errors = vErrors.length;
                                          }
                                          var valid1 = errors === errs_1;
                                        }
                                        if (valid1) {
                                          var data1 = data.pattern;
                                          if (data1 === void 0) {
                                            valid1 = true;
                                          } else {
                                            var errs_1 = errors;
                                            if (errors === errs_1) {
                                              if (typeof data1 === "string") {
                                                if (!formats.regex(data1)) {
                                                  validate3.errors = [{
                                                    keyword: "format",
                                                    dataPath: (dataPath || "") + ".pattern",
                                                    schemaPath: "#/properties/pattern/format",
                                                    params: {
                                                      format: "regex"
                                                    },
                                                    message: 'should match format "regex"'
                                                  }];
                                                  return false;
                                                }
                                              } else {
                                                validate3.errors = [{
                                                  keyword: "type",
                                                  dataPath: (dataPath || "") + ".pattern",
                                                  schemaPath: "#/properties/pattern/type",
                                                  params: {
                                                    type: "string"
                                                  },
                                                  message: "should be string"
                                                }];
                                                return false;
                                              }
                                            }
                                            var valid1 = errors === errs_1;
                                          }
                                          if (valid1) {
                                            if (data.additionalItems === void 0) {
                                              valid1 = true;
                                            } else {
                                              var errs_1 = errors;
                                              if (!validate3(data.additionalItems, (dataPath || "") + ".additionalItems", data, "additionalItems", rootData)) {
                                                if (vErrors === null)
                                                  vErrors = validate3.errors;
                                                else
                                                  vErrors = vErrors.concat(validate3.errors);
                                                errors = vErrors.length;
                                              }
                                              var valid1 = errors === errs_1;
                                            }
                                            if (valid1) {
                                              var data1 = data.items;
                                              if (data1 === void 0) {
                                                valid1 = true;
                                              } else {
                                                var errs_1 = errors;
                                                var errs__1 = errors;
                                                var valid1 = false;
                                                var errs_2 = errors;
                                                if (!validate3(data1, (dataPath || "") + ".items", data, "items", rootData)) {
                                                  if (vErrors === null)
                                                    vErrors = validate3.errors;
                                                  else
                                                    vErrors = vErrors.concat(validate3.errors);
                                                  errors = vErrors.length;
                                                }
                                                var valid2 = errors === errs_2;
                                                valid1 = valid1 || valid2;
                                                if (!valid1) {
                                                  var errs_2 = errors;
                                                  if (!refVal3(data1, (dataPath || "") + ".items", data, "items", rootData)) {
                                                    if (vErrors === null)
                                                      vErrors = refVal3.errors;
                                                    else
                                                      vErrors = vErrors.concat(refVal3.errors);
                                                    errors = vErrors.length;
                                                  }
                                                  var valid2 = errors === errs_2;
                                                  valid1 = valid1 || valid2;
                                                }
                                                if (!valid1) {
                                                  var err = {
                                                    keyword: "anyOf",
                                                    dataPath: (dataPath || "") + ".items",
                                                    schemaPath: "#/properties/items/anyOf",
                                                    params: {},
                                                    message: "should match some schema in anyOf"
                                                  };
                                                  if (vErrors === null)
                                                    vErrors = [err];
                                                  else
                                                    vErrors.push(err);
                                                  errors++;
                                                  validate3.errors = vErrors;
                                                  return false;
                                                } else {
                                                  errors = errs__1;
                                                  if (vErrors !== null) {
                                                    if (errs__1)
                                                      vErrors.length = errs__1;
                                                    else
                                                      vErrors = null;
                                                  }
                                                }
                                                var valid1 = errors === errs_1;
                                              }
                                              if (valid1) {
                                                var data1 = data.maxItems;
                                                if (data1 === void 0) {
                                                  valid1 = true;
                                                } else {
                                                  var errs_1 = errors;
                                                  var errs_2 = errors;
                                                  if (typeof data1 !== "number" || data1 % 1 || data1 !== data1) {
                                                    validate3.errors = [{
                                                      keyword: "type",
                                                      dataPath: (dataPath || "") + ".maxItems",
                                                      schemaPath: "#/definitions/nonNegativeInteger/type",
                                                      params: {
                                                        type: "integer"
                                                      },
                                                      message: "should be integer"
                                                    }];
                                                    return false;
                                                  }
                                                  if (typeof data1 === "number") {
                                                    if (data1 < 0 || data1 !== data1) {
                                                      validate3.errors = [{
                                                        keyword: "minimum",
                                                        dataPath: (dataPath || "") + ".maxItems",
                                                        schemaPath: "#/definitions/nonNegativeInteger/minimum",
                                                        params: {
                                                          comparison: ">=",
                                                          limit: 0,
                                                          exclusive: false
                                                        },
                                                        message: "should be >= 0"
                                                      }];
                                                      return false;
                                                    }
                                                  }
                                                  var valid2 = errors === errs_2;
                                                  var valid1 = errors === errs_1;
                                                }
                                                if (valid1) {
                                                  if (data.minItems === void 0) {
                                                    valid1 = true;
                                                  } else {
                                                    var errs_1 = errors;
                                                    if (!refVal[2](data.minItems, (dataPath || "") + ".minItems", data, "minItems", rootData)) {
                                                      if (vErrors === null)
                                                        vErrors = refVal[2].errors;
                                                      else
                                                        vErrors = vErrors.concat(refVal[2].errors);
                                                      errors = vErrors.length;
                                                    }
                                                    var valid1 = errors === errs_1;
                                                  }
                                                  if (valid1) {
                                                    if (data.uniqueItems === void 0) {
                                                      valid1 = true;
                                                    } else {
                                                      var errs_1 = errors;
                                                      if (typeof data.uniqueItems !== "boolean") {
                                                        validate3.errors = [{
                                                          keyword: "type",
                                                          dataPath: (dataPath || "") + ".uniqueItems",
                                                          schemaPath: "#/properties/uniqueItems/type",
                                                          params: {
                                                            type: "boolean"
                                                          },
                                                          message: "should be boolean"
                                                        }];
                                                        return false;
                                                      }
                                                      var valid1 = errors === errs_1;
                                                    }
                                                    if (valid1) {
                                                      if (data.contains === void 0) {
                                                        valid1 = true;
                                                      } else {
                                                        var errs_1 = errors;
                                                        if (!validate3(data.contains, (dataPath || "") + ".contains", data, "contains", rootData)) {
                                                          if (vErrors === null)
                                                            vErrors = validate3.errors;
                                                          else
                                                            vErrors = vErrors.concat(validate3.errors);
                                                          errors = vErrors.length;
                                                        }
                                                        var valid1 = errors === errs_1;
                                                      }
                                                      if (valid1) {
                                                        var data1 = data.maxProperties;
                                                        if (data1 === void 0) {
                                                          valid1 = true;
                                                        } else {
                                                          var errs_1 = errors;
                                                          var errs_2 = errors;
                                                          if (typeof data1 !== "number" || data1 % 1 || data1 !== data1) {
                                                            validate3.errors = [{
                                                              keyword: "type",
                                                              dataPath: (dataPath || "") + ".maxProperties",
                                                              schemaPath: "#/definitions/nonNegativeInteger/type",
                                                              params: {
                                                                type: "integer"
                                                              },
                                                              message: "should be integer"
                                                            }];
                                                            return false;
                                                          }
                                                          if (typeof data1 === "number") {
                                                            if (data1 < 0 || data1 !== data1) {
                                                              validate3.errors = [{
                                                                keyword: "minimum",
                                                                dataPath: (dataPath || "") + ".maxProperties",
                                                                schemaPath: "#/definitions/nonNegativeInteger/minimum",
                                                                params: {
                                                                  comparison: ">=",
                                                                  limit: 0,
                                                                  exclusive: false
                                                                },
                                                                message: "should be >= 0"
                                                              }];
                                                              return false;
                                                            }
                                                          }
                                                          var valid2 = errors === errs_2;
                                                          var valid1 = errors === errs_1;
                                                        }
                                                        if (valid1) {
                                                          if (data.minProperties === void 0) {
                                                            valid1 = true;
                                                          } else {
                                                            var errs_1 = errors;
                                                            if (!refVal[2](data.minProperties, (dataPath || "") + ".minProperties", data, "minProperties", rootData)) {
                                                              if (vErrors === null)
                                                                vErrors = refVal[2].errors;
                                                              else
                                                                vErrors = vErrors.concat(refVal[2].errors);
                                                              errors = vErrors.length;
                                                            }
                                                            var valid1 = errors === errs_1;
                                                          }
                                                          if (valid1) {
                                                            var data1 = data.required;
                                                            if (data1 === void 0) {
                                                              valid1 = true;
                                                            } else {
                                                              var errs_1 = errors;
                                                              var errs_2 = errors;
                                                              if (Array.isArray(data1)) {
                                                                var errs__2 = errors;
                                                                var valid2;
                                                                for (var i2 = 0; i2 < data1.length; i2++) {
                                                                  var errs_3 = errors;
                                                                  if (typeof data1[i2] !== "string") {
                                                                    validate3.errors = [{
                                                                      keyword: "type",
                                                                      dataPath: (dataPath || "") + ".required[" + i2 + "]",
                                                                      schemaPath: "#/definitions/stringArray/items/type",
                                                                      params: {
                                                                        type: "string"
                                                                      },
                                                                      message: "should be string"
                                                                    }];
                                                                    return false;
                                                                  }
                                                                  var valid3 = errors === errs_3;
                                                                  if (!valid3)
                                                                    break;
                                                                }
                                                                if (errs__2 == errors) {
                                                                  var i = data1.length, valid2 = true, j2;
                                                                  if (i > 1) {
                                                                    var itemIndices = {}, item;
                                                                    for (; i--; ) {
                                                                      var item = data1[i];
                                                                      if (typeof item !== "string")
                                                                        continue;
                                                                      if (typeof itemIndices[item] == "number") {
                                                                        valid2 = false;
                                                                        j2 = itemIndices[item];
                                                                        break;
                                                                      }
                                                                      itemIndices[item] = i;
                                                                    }
                                                                  }
                                                                  if (!valid2) {
                                                                    validate3.errors = [{
                                                                      keyword: "uniqueItems",
                                                                      dataPath: (dataPath || "") + ".required",
                                                                      schemaPath: "#/definitions/stringArray/uniqueItems",
                                                                      params: {
                                                                        i,
                                                                        j: j2
                                                                      },
                                                                      message: "should NOT have duplicate items (items ## " + j2 + " and " + i + " are identical)"
                                                                    }];
                                                                    return false;
                                                                  }
                                                                }
                                                              } else {
                                                                validate3.errors = [{
                                                                  keyword: "type",
                                                                  dataPath: (dataPath || "") + ".required",
                                                                  schemaPath: "#/definitions/stringArray/type",
                                                                  params: {
                                                                    type: "array"
                                                                  },
                                                                  message: "should be array"
                                                                }];
                                                                return false;
                                                              }
                                                              var valid2 = errors === errs_2;
                                                              var valid1 = errors === errs_1;
                                                            }
                                                            if (valid1) {
                                                              if (data.additionalProperties === void 0) {
                                                                valid1 = true;
                                                              } else {
                                                                var errs_1 = errors;
                                                                if (!validate3(data.additionalProperties, (dataPath || "") + ".additionalProperties", data, "additionalProperties", rootData)) {
                                                                  if (vErrors === null)
                                                                    vErrors = validate3.errors;
                                                                  else
                                                                    vErrors = vErrors.concat(validate3.errors);
                                                                  errors = vErrors.length;
                                                                }
                                                                var valid1 = errors === errs_1;
                                                              }
                                                              if (valid1) {
                                                                var data1 = data.definitions;
                                                                if (data1 === void 0) {
                                                                  valid1 = true;
                                                                } else {
                                                                  var errs_1 = errors;
                                                                  if (data1 && typeof data1 === "object" && !Array.isArray(data1)) {
                                                                    var errs__1 = errors;
                                                                    var valid2 = true;
                                                                    for (var key1 in data1) {
                                                                      var errs_2 = errors;
                                                                      if (!validate3(data1[key1], (dataPath || "") + ".definitions['" + key1 + "']", data1, key1, rootData)) {
                                                                        if (vErrors === null)
                                                                          vErrors = validate3.errors;
                                                                        else
                                                                          vErrors = vErrors.concat(validate3.errors);
                                                                        errors = vErrors.length;
                                                                      }
                                                                      var valid2 = errors === errs_2;
                                                                      if (!valid2)
                                                                        break;
                                                                    }
                                                                  } else {
                                                                    validate3.errors = [{
                                                                      keyword: "type",
                                                                      dataPath: (dataPath || "") + ".definitions",
                                                                      schemaPath: "#/properties/definitions/type",
                                                                      params: {
                                                                        type: "object"
                                                                      },
                                                                      message: "should be object"
                                                                    }];
                                                                    return false;
                                                                  }
                                                                  var valid1 = errors === errs_1;
                                                                }
                                                                if (valid1) {
                                                                  var data1 = data.properties;
                                                                  if (data1 === void 0) {
                                                                    valid1 = true;
                                                                  } else {
                                                                    var errs_1 = errors;
                                                                    if (data1 && typeof data1 === "object" && !Array.isArray(data1)) {
                                                                      var errs__1 = errors;
                                                                      var valid2 = true;
                                                                      for (var key1 in data1) {
                                                                        var errs_2 = errors;
                                                                        if (!validate3(data1[key1], (dataPath || "") + ".properties['" + key1 + "']", data1, key1, rootData)) {
                                                                          if (vErrors === null)
                                                                            vErrors = validate3.errors;
                                                                          else
                                                                            vErrors = vErrors.concat(validate3.errors);
                                                                          errors = vErrors.length;
                                                                        }
                                                                        var valid2 = errors === errs_2;
                                                                        if (!valid2)
                                                                          break;
                                                                      }
                                                                    } else {
                                                                      validate3.errors = [{
                                                                        keyword: "type",
                                                                        dataPath: (dataPath || "") + ".properties",
                                                                        schemaPath: "#/properties/properties/type",
                                                                        params: {
                                                                          type: "object"
                                                                        },
                                                                        message: "should be object"
                                                                      }];
                                                                      return false;
                                                                    }
                                                                    var valid1 = errors === errs_1;
                                                                  }
                                                                  if (valid1) {
                                                                    var data1 = data.patternProperties;
                                                                    if (data1 === void 0) {
                                                                      valid1 = true;
                                                                    } else {
                                                                      var errs_1 = errors;
                                                                      if (data1 && typeof data1 === "object" && !Array.isArray(data1)) {
                                                                        var errs__1 = errors;
                                                                        for (var key1 in data1) {
                                                                          var startErrs1 = errors;
                                                                          var data2 = key1;
                                                                          var errs_2 = errors;
                                                                          if (errors === errs_2) {
                                                                            if (typeof data2 === "string") {
                                                                              if (!formats.regex(data2)) {
                                                                                var err = {
                                                                                  keyword: "format",
                                                                                  dataPath: (dataPath || "") + ".patternProperties",
                                                                                  schemaPath: "#/properties/patternProperties/propertyNames/format",
                                                                                  params: {
                                                                                    format: "regex"
                                                                                  },
                                                                                  message: 'should match format "regex"'
                                                                                };
                                                                                if (vErrors === null)
                                                                                  vErrors = [err];
                                                                                else
                                                                                  vErrors.push(err);
                                                                                errors++;
                                                                              }
                                                                            }
                                                                          }
                                                                          var valid2 = errors === errs_2;
                                                                          if (!valid2) {
                                                                            for (var i1 = startErrs1; i1 < errors; i1++) {
                                                                              vErrors[i1].propertyName = key1;
                                                                            }
                                                                            var err = {
                                                                              keyword: "propertyNames",
                                                                              dataPath: (dataPath || "") + ".patternProperties",
                                                                              schemaPath: "#/properties/patternProperties/propertyNames",
                                                                              params: {
                                                                                propertyName: "" + key1
                                                                              },
                                                                              message: "property name '" + key1 + "' is invalid"
                                                                            };
                                                                            if (vErrors === null)
                                                                              vErrors = [err];
                                                                            else
                                                                              vErrors.push(err);
                                                                            errors++;
                                                                            validate3.errors = vErrors;
                                                                            return false;
                                                                            break;
                                                                          }
                                                                        }
                                                                        if (errs__1 == errors) {
                                                                          var errs__1 = errors;
                                                                          var valid2 = true;
                                                                          for (var key1 in data1) {
                                                                            var errs_2 = errors;
                                                                            if (!validate3(data1[key1], (dataPath || "") + ".patternProperties['" + key1 + "']", data1, key1, rootData)) {
                                                                              if (vErrors === null)
                                                                                vErrors = validate3.errors;
                                                                              else
                                                                                vErrors = vErrors.concat(validate3.errors);
                                                                              errors = vErrors.length;
                                                                            }
                                                                            var valid2 = errors === errs_2;
                                                                            if (!valid2)
                                                                              break;
                                                                          }
                                                                        }
                                                                      } else {
                                                                        validate3.errors = [{
                                                                          keyword: "type",
                                                                          dataPath: (dataPath || "") + ".patternProperties",
                                                                          schemaPath: "#/properties/patternProperties/type",
                                                                          params: {
                                                                            type: "object"
                                                                          },
                                                                          message: "should be object"
                                                                        }];
                                                                        return false;
                                                                      }
                                                                      var valid1 = errors === errs_1;
                                                                    }
                                                                    if (valid1) {
                                                                      var data1 = data.dependencies;
                                                                      if (data1 === void 0) {
                                                                        valid1 = true;
                                                                      } else {
                                                                        var errs_1 = errors;
                                                                        if (data1 && typeof data1 === "object" && !Array.isArray(data1)) {
                                                                          var errs__1 = errors;
                                                                          var valid2 = true;
                                                                          for (var key1 in data1) {
                                                                            var data2 = data1[key1];
                                                                            var errs_2 = errors;
                                                                            var errs__2 = errors;
                                                                            var valid2 = false;
                                                                            var errs_3 = errors;
                                                                            if (!validate3(data2, (dataPath || "") + ".dependencies['" + key1 + "']", data1, key1, rootData)) {
                                                                              if (vErrors === null)
                                                                                vErrors = validate3.errors;
                                                                              else
                                                                                vErrors = vErrors.concat(validate3.errors);
                                                                              errors = vErrors.length;
                                                                            }
                                                                            var valid3 = errors === errs_3;
                                                                            valid2 = valid2 || valid3;
                                                                            if (!valid2) {
                                                                              var errs_3 = errors;
                                                                              var errs_4 = errors;
                                                                              if (Array.isArray(data2)) {
                                                                                var errs__4 = errors;
                                                                                var valid4;
                                                                                for (var i4 = 0; i4 < data2.length; i4++) {
                                                                                  var errs_5 = errors;
                                                                                  if (typeof data2[i4] !== "string") {
                                                                                    var err = {
                                                                                      keyword: "type",
                                                                                      dataPath: (dataPath || "") + ".dependencies['" + key1 + "'][" + i4 + "]",
                                                                                      schemaPath: "#/definitions/stringArray/items/type",
                                                                                      params: {
                                                                                        type: "string"
                                                                                      },
                                                                                      message: "should be string"
                                                                                    };
                                                                                    if (vErrors === null)
                                                                                      vErrors = [err];
                                                                                    else
                                                                                      vErrors.push(err);
                                                                                    errors++;
                                                                                  }
                                                                                  var valid5 = errors === errs_5;
                                                                                  if (!valid5)
                                                                                    break;
                                                                                }
                                                                                if (errs__4 == errors) {
                                                                                  var i = data2.length, valid4 = true, j2;
                                                                                  if (i > 1) {
                                                                                    var itemIndices = {}, item;
                                                                                    for (; i--; ) {
                                                                                      var item = data2[i];
                                                                                      if (typeof item !== "string")
                                                                                        continue;
                                                                                      if (typeof itemIndices[item] == "number") {
                                                                                        valid4 = false;
                                                                                        j2 = itemIndices[item];
                                                                                        break;
                                                                                      }
                                                                                      itemIndices[item] = i;
                                                                                    }
                                                                                  }
                                                                                  if (!valid4) {
                                                                                    var err = {
                                                                                      keyword: "uniqueItems",
                                                                                      dataPath: (dataPath || "") + ".dependencies['" + key1 + "']",
                                                                                      schemaPath: "#/definitions/stringArray/uniqueItems",
                                                                                      params: {
                                                                                        i,
                                                                                        j: j2
                                                                                      },
                                                                                      message: "should NOT have duplicate items (items ## " + j2 + " and " + i + " are identical)"
                                                                                    };
                                                                                    if (vErrors === null)
                                                                                      vErrors = [err];
                                                                                    else
                                                                                      vErrors.push(err);
                                                                                    errors++;
                                                                                  }
                                                                                }
                                                                              } else {
                                                                                var err = {
                                                                                  keyword: "type",
                                                                                  dataPath: (dataPath || "") + ".dependencies['" + key1 + "']",
                                                                                  schemaPath: "#/definitions/stringArray/type",
                                                                                  params: {
                                                                                    type: "array"
                                                                                  },
                                                                                  message: "should be array"
                                                                                };
                                                                                if (vErrors === null)
                                                                                  vErrors = [err];
                                                                                else
                                                                                  vErrors.push(err);
                                                                                errors++;
                                                                              }
                                                                              var valid4 = errors === errs_4;
                                                                              var valid3 = errors === errs_3;
                                                                              valid2 = valid2 || valid3;
                                                                            }
                                                                            if (!valid2) {
                                                                              var err = {
                                                                                keyword: "anyOf",
                                                                                dataPath: (dataPath || "") + ".dependencies['" + key1 + "']",
                                                                                schemaPath: "#/properties/dependencies/additionalProperties/anyOf",
                                                                                params: {},
                                                                                message: "should match some schema in anyOf"
                                                                              };
                                                                              if (vErrors === null)
                                                                                vErrors = [err];
                                                                              else
                                                                                vErrors.push(err);
                                                                              errors++;
                                                                              validate3.errors = vErrors;
                                                                              return false;
                                                                            } else {
                                                                              errors = errs__2;
                                                                              if (vErrors !== null) {
                                                                                if (errs__2)
                                                                                  vErrors.length = errs__2;
                                                                                else
                                                                                  vErrors = null;
                                                                              }
                                                                            }
                                                                            var valid2 = errors === errs_2;
                                                                            if (!valid2)
                                                                              break;
                                                                          }
                                                                        } else {
                                                                          validate3.errors = [{
                                                                            keyword: "type",
                                                                            dataPath: (dataPath || "") + ".dependencies",
                                                                            schemaPath: "#/properties/dependencies/type",
                                                                            params: {
                                                                              type: "object"
                                                                            },
                                                                            message: "should be object"
                                                                          }];
                                                                          return false;
                                                                        }
                                                                        var valid1 = errors === errs_1;
                                                                      }
                                                                      if (valid1) {
                                                                        if (data.propertyNames === void 0) {
                                                                          valid1 = true;
                                                                        } else {
                                                                          var errs_1 = errors;
                                                                          if (!validate3(data.propertyNames, (dataPath || "") + ".propertyNames", data, "propertyNames", rootData)) {
                                                                            if (vErrors === null)
                                                                              vErrors = validate3.errors;
                                                                            else
                                                                              vErrors = vErrors.concat(validate3.errors);
                                                                            errors = vErrors.length;
                                                                          }
                                                                          var valid1 = errors === errs_1;
                                                                        }
                                                                        if (valid1) {
                                                                          if (valid1) {
                                                                            var data1 = data.enum;
                                                                            if (data1 === void 0) {
                                                                              valid1 = true;
                                                                            } else {
                                                                              var errs_1 = errors;
                                                                              if (Array.isArray(data1)) {
                                                                                if (data1.length < 1) {
                                                                                  validate3.errors = [{
                                                                                    keyword: "minItems",
                                                                                    dataPath: (dataPath || "") + ".enum",
                                                                                    schemaPath: "#/properties/enum/minItems",
                                                                                    params: {
                                                                                      limit: 1
                                                                                    },
                                                                                    message: "should NOT have fewer than 1 items"
                                                                                  }];
                                                                                  return false;
                                                                                } else {
                                                                                  var errs__1 = errors;
                                                                                  var valid1;
                                                                                  if (errs__1 == errors) {
                                                                                    var i = data1.length, valid1 = true, j2;
                                                                                    if (i > 1) {
                                                                                      outer:
                                                                                        for (; i--; ) {
                                                                                          for (j2 = i; j2--; ) {
                                                                                            if (equal(data1[i], data1[j2])) {
                                                                                              valid1 = false;
                                                                                              break outer;
                                                                                            }
                                                                                          }
                                                                                        }
                                                                                    }
                                                                                    if (!valid1) {
                                                                                      validate3.errors = [{
                                                                                        keyword: "uniqueItems",
                                                                                        dataPath: (dataPath || "") + ".enum",
                                                                                        schemaPath: "#/properties/enum/uniqueItems",
                                                                                        params: {
                                                                                          i,
                                                                                          j: j2
                                                                                        },
                                                                                        message: "should NOT have duplicate items (items ## " + j2 + " and " + i + " are identical)"
                                                                                      }];
                                                                                      return false;
                                                                                    }
                                                                                  }
                                                                                }
                                                                              } else {
                                                                                validate3.errors = [{
                                                                                  keyword: "type",
                                                                                  dataPath: (dataPath || "") + ".enum",
                                                                                  schemaPath: "#/properties/enum/type",
                                                                                  params: {
                                                                                    type: "array"
                                                                                  },
                                                                                  message: "should be array"
                                                                                }];
                                                                                return false;
                                                                              }
                                                                              var valid1 = errors === errs_1;
                                                                            }
                                                                            if (valid1) {
                                                                              var data1 = data.type;
                                                                              if (data1 === void 0) {
                                                                                valid1 = true;
                                                                              } else {
                                                                                var errs_1 = errors;
                                                                                var errs__1 = errors;
                                                                                var valid1 = false;
                                                                                var errs_2 = errors;
                                                                                var errs_3 = errors;
                                                                                var schema3 = refVal5.enum;
                                                                                var valid3;
                                                                                valid3 = false;
                                                                                for (var i3 = 0; i3 < schema3.length; i3++)
                                                                                  if (equal(data1, schema3[i3])) {
                                                                                    valid3 = true;
                                                                                    break;
                                                                                  }
                                                                                if (!valid3) {
                                                                                  var err = {
                                                                                    keyword: "enum",
                                                                                    dataPath: (dataPath || "") + ".type",
                                                                                    schemaPath: "#/definitions/simpleTypes/enum",
                                                                                    params: {
                                                                                      allowedValues: schema3
                                                                                    },
                                                                                    message: "should be equal to one of the allowed values"
                                                                                  };
                                                                                  if (vErrors === null)
                                                                                    vErrors = [err];
                                                                                  else
                                                                                    vErrors.push(err);
                                                                                  errors++;
                                                                                }
                                                                                var valid3 = errors === errs_3;
                                                                                var valid2 = errors === errs_2;
                                                                                valid1 = valid1 || valid2;
                                                                                if (!valid1) {
                                                                                  var errs_2 = errors;
                                                                                  if (Array.isArray(data1)) {
                                                                                    if (data1.length < 1) {
                                                                                      var err = {
                                                                                        keyword: "minItems",
                                                                                        dataPath: (dataPath || "") + ".type",
                                                                                        schemaPath: "#/properties/type/anyOf/1/minItems",
                                                                                        params: {
                                                                                          limit: 1
                                                                                        },
                                                                                        message: "should NOT have fewer than 1 items"
                                                                                      };
                                                                                      if (vErrors === null)
                                                                                        vErrors = [err];
                                                                                      else
                                                                                        vErrors.push(err);
                                                                                      errors++;
                                                                                    } else {
                                                                                      var errs__2 = errors;
                                                                                      var valid2;
                                                                                      for (var i2 = 0; i2 < data1.length; i2++) {
                                                                                        var errs_3 = errors;
                                                                                        var errs_4 = errors;
                                                                                        var schema4 = refVal[5].enum;
                                                                                        var valid4;
                                                                                        valid4 = false;
                                                                                        for (var i4 = 0; i4 < schema4.length; i4++)
                                                                                          if (equal(data1[i2], schema4[i4])) {
                                                                                            valid4 = true;
                                                                                            break;
                                                                                          }
                                                                                        if (!valid4) {
                                                                                          var err = {
                                                                                            keyword: "enum",
                                                                                            dataPath: (dataPath || "") + ".type[" + i2 + "]",
                                                                                            schemaPath: "#/definitions/simpleTypes/enum",
                                                                                            params: {
                                                                                              allowedValues: schema4
                                                                                            },
                                                                                            message: "should be equal to one of the allowed values"
                                                                                          };
                                                                                          if (vErrors === null)
                                                                                            vErrors = [err];
                                                                                          else
                                                                                            vErrors.push(err);
                                                                                          errors++;
                                                                                        }
                                                                                        var valid4 = errors === errs_4;
                                                                                        var valid3 = errors === errs_3;
                                                                                        if (!valid3)
                                                                                          break;
                                                                                      }
                                                                                      if (errs__2 == errors) {
                                                                                        var i = data1.length, valid2 = true, j2;
                                                                                        if (i > 1) {
                                                                                          outer:
                                                                                            for (; i--; ) {
                                                                                              for (j2 = i; j2--; ) {
                                                                                                if (equal(data1[i], data1[j2])) {
                                                                                                  valid2 = false;
                                                                                                  break outer;
                                                                                                }
                                                                                              }
                                                                                            }
                                                                                        }
                                                                                        if (!valid2) {
                                                                                          var err = {
                                                                                            keyword: "uniqueItems",
                                                                                            dataPath: (dataPath || "") + ".type",
                                                                                            schemaPath: "#/properties/type/anyOf/1/uniqueItems",
                                                                                            params: {
                                                                                              i,
                                                                                              j: j2
                                                                                            },
                                                                                            message: "should NOT have duplicate items (items ## " + j2 + " and " + i + " are identical)"
                                                                                          };
                                                                                          if (vErrors === null)
                                                                                            vErrors = [err];
                                                                                          else
                                                                                            vErrors.push(err);
                                                                                          errors++;
                                                                                        }
                                                                                      }
                                                                                    }
                                                                                  } else {
                                                                                    var err = {
                                                                                      keyword: "type",
                                                                                      dataPath: (dataPath || "") + ".type",
                                                                                      schemaPath: "#/properties/type/anyOf/1/type",
                                                                                      params: {
                                                                                        type: "array"
                                                                                      },
                                                                                      message: "should be array"
                                                                                    };
                                                                                    if (vErrors === null)
                                                                                      vErrors = [err];
                                                                                    else
                                                                                      vErrors.push(err);
                                                                                    errors++;
                                                                                  }
                                                                                  var valid2 = errors === errs_2;
                                                                                  valid1 = valid1 || valid2;
                                                                                }
                                                                                if (!valid1) {
                                                                                  var err = {
                                                                                    keyword: "anyOf",
                                                                                    dataPath: (dataPath || "") + ".type",
                                                                                    schemaPath: "#/properties/type/anyOf",
                                                                                    params: {},
                                                                                    message: "should match some schema in anyOf"
                                                                                  };
                                                                                  if (vErrors === null)
                                                                                    vErrors = [err];
                                                                                  else
                                                                                    vErrors.push(err);
                                                                                  errors++;
                                                                                  validate3.errors = vErrors;
                                                                                  return false;
                                                                                } else {
                                                                                  errors = errs__1;
                                                                                  if (vErrors !== null) {
                                                                                    if (errs__1)
                                                                                      vErrors.length = errs__1;
                                                                                    else
                                                                                      vErrors = null;
                                                                                  }
                                                                                }
                                                                                var valid1 = errors === errs_1;
                                                                              }
                                                                              if (valid1) {
                                                                                if (data.format === void 0) {
                                                                                  valid1 = true;
                                                                                } else {
                                                                                  var errs_1 = errors;
                                                                                  if (typeof data.format !== "string") {
                                                                                    validate3.errors = [{
                                                                                      keyword: "type",
                                                                                      dataPath: (dataPath || "") + ".format",
                                                                                      schemaPath: "#/properties/format/type",
                                                                                      params: {
                                                                                        type: "string"
                                                                                      },
                                                                                      message: "should be string"
                                                                                    }];
                                                                                    return false;
                                                                                  }
                                                                                  var valid1 = errors === errs_1;
                                                                                }
                                                                                if (valid1) {
                                                                                  if (data.contentMediaType === void 0) {
                                                                                    valid1 = true;
                                                                                  } else {
                                                                                    var errs_1 = errors;
                                                                                    if (typeof data.contentMediaType !== "string") {
                                                                                      validate3.errors = [{
                                                                                        keyword: "type",
                                                                                        dataPath: (dataPath || "") + ".contentMediaType",
                                                                                        schemaPath: "#/properties/contentMediaType/type",
                                                                                        params: {
                                                                                          type: "string"
                                                                                        },
                                                                                        message: "should be string"
                                                                                      }];
                                                                                      return false;
                                                                                    }
                                                                                    var valid1 = errors === errs_1;
                                                                                  }
                                                                                  if (valid1) {
                                                                                    if (data.contentEncoding === void 0) {
                                                                                      valid1 = true;
                                                                                    } else {
                                                                                      var errs_1 = errors;
                                                                                      if (typeof data.contentEncoding !== "string") {
                                                                                        validate3.errors = [{
                                                                                          keyword: "type",
                                                                                          dataPath: (dataPath || "") + ".contentEncoding",
                                                                                          schemaPath: "#/properties/contentEncoding/type",
                                                                                          params: {
                                                                                            type: "string"
                                                                                          },
                                                                                          message: "should be string"
                                                                                        }];
                                                                                        return false;
                                                                                      }
                                                                                      var valid1 = errors === errs_1;
                                                                                    }
                                                                                    if (valid1) {
                                                                                      if (data.if === void 0) {
                                                                                        valid1 = true;
                                                                                      } else {
                                                                                        var errs_1 = errors;
                                                                                        if (!validate3(data.if, (dataPath || "") + ".if", data, "if", rootData)) {
                                                                                          if (vErrors === null)
                                                                                            vErrors = validate3.errors;
                                                                                          else
                                                                                            vErrors = vErrors.concat(validate3.errors);
                                                                                          errors = vErrors.length;
                                                                                        }
                                                                                        var valid1 = errors === errs_1;
                                                                                      }
                                                                                      if (valid1) {
                                                                                        if (data.then === void 0) {
                                                                                          valid1 = true;
                                                                                        } else {
                                                                                          var errs_1 = errors;
                                                                                          if (!validate3(data.then, (dataPath || "") + ".then", data, "then", rootData)) {
                                                                                            if (vErrors === null)
                                                                                              vErrors = validate3.errors;
                                                                                            else
                                                                                              vErrors = vErrors.concat(validate3.errors);
                                                                                            errors = vErrors.length;
                                                                                          }
                                                                                          var valid1 = errors === errs_1;
                                                                                        }
                                                                                        if (valid1) {
                                                                                          if (data.else === void 0) {
                                                                                            valid1 = true;
                                                                                          } else {
                                                                                            var errs_1 = errors;
                                                                                            if (!validate3(data.else, (dataPath || "") + ".else", data, "else", rootData)) {
                                                                                              if (vErrors === null)
                                                                                                vErrors = validate3.errors;
                                                                                              else
                                                                                                vErrors = vErrors.concat(validate3.errors);
                                                                                              errors = vErrors.length;
                                                                                            }
                                                                                            var valid1 = errors === errs_1;
                                                                                          }
                                                                                          if (valid1) {
                                                                                            if (data.allOf === void 0) {
                                                                                              valid1 = true;
                                                                                            } else {
                                                                                              var errs_1 = errors;
                                                                                              if (!refVal[3](data.allOf, (dataPath || "") + ".allOf", data, "allOf", rootData)) {
                                                                                                if (vErrors === null)
                                                                                                  vErrors = refVal[3].errors;
                                                                                                else
                                                                                                  vErrors = vErrors.concat(refVal[3].errors);
                                                                                                errors = vErrors.length;
                                                                                              }
                                                                                              var valid1 = errors === errs_1;
                                                                                            }
                                                                                            if (valid1) {
                                                                                              if (data.anyOf === void 0) {
                                                                                                valid1 = true;
                                                                                              } else {
                                                                                                var errs_1 = errors;
                                                                                                if (!refVal[3](data.anyOf, (dataPath || "") + ".anyOf", data, "anyOf", rootData)) {
                                                                                                  if (vErrors === null)
                                                                                                    vErrors = refVal[3].errors;
                                                                                                  else
                                                                                                    vErrors = vErrors.concat(refVal[3].errors);
                                                                                                  errors = vErrors.length;
                                                                                                }
                                                                                                var valid1 = errors === errs_1;
                                                                                              }
                                                                                              if (valid1) {
                                                                                                if (data.oneOf === void 0) {
                                                                                                  valid1 = true;
                                                                                                } else {
                                                                                                  var errs_1 = errors;
                                                                                                  if (!refVal[3](data.oneOf, (dataPath || "") + ".oneOf", data, "oneOf", rootData)) {
                                                                                                    if (vErrors === null)
                                                                                                      vErrors = refVal[3].errors;
                                                                                                    else
                                                                                                      vErrors = vErrors.concat(refVal[3].errors);
                                                                                                    errors = vErrors.length;
                                                                                                  }
                                                                                                  var valid1 = errors === errs_1;
                                                                                                }
                                                                                                if (valid1) {
                                                                                                  if (data.not === void 0) {
                                                                                                    valid1 = true;
                                                                                                  } else {
                                                                                                    var errs_1 = errors;
                                                                                                    if (!validate3(data.not, (dataPath || "") + ".not", data, "not", rootData)) {
                                                                                                      if (vErrors === null)
                                                                                                        vErrors = validate3.errors;
                                                                                                      else
                                                                                                        vErrors = vErrors.concat(validate3.errors);
                                                                                                      errors = vErrors.length;
                                                                                                    }
                                                                                                    var valid1 = errors === errs_1;
                                                                                                  }
                                                                                                }
                                                                                              }
                                                                                            }
                                                                                          }
                                                                                        }
                                                                                      }
                                                                                    }
                                                                                  }
                                                                                }
                                                                              }
                                                                            }
                                                                          }
                                                                        }
                                                                      }
                                                                    }
                                                                  }
                                                                }
                                                              }
                                                            }
                                                          }
                                                        }
                                                      }
                                                    }
                                                  }
                                                }
                                              }
                                            }
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
        validate3.errors = vErrors;
        return errors === 0;
      }, "validate");
    }();
    validate2.schema = {
      "$schema": "http://json-schema.org/draft-07/schema#",
      "$id": "http://json-schema.org/draft-07/schema#",
      "title": "Core schema meta-schema",
      "definitions": {
        "schemaArray": {
          "type": "array",
          "minItems": 1,
          "items": {
            "$ref": "#"
          }
        },
        "nonNegativeInteger": {
          "type": "integer",
          "minimum": 0
        },
        "nonNegativeIntegerDefault0": {
          "allOf": [{
            "$ref": "#/definitions/nonNegativeInteger"
          }, {
            "default": 0
          }]
        },
        "simpleTypes": {
          "enum": ["array", "boolean", "integer", "null", "number", "object", "string"]
        },
        "stringArray": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "uniqueItems": true,
          "default": []
        }
      },
      "type": ["object", "boolean"],
      "properties": {
        "$id": {
          "type": "string",
          "format": "uri-reference"
        },
        "$schema": {
          "type": "string",
          "format": "uri"
        },
        "$ref": {
          "type": "string",
          "format": "uri-reference"
        },
        "$comment": {
          "type": "string"
        },
        "title": {
          "type": "string"
        },
        "description": {
          "type": "string"
        },
        "default": true,
        "readOnly": {
          "type": "boolean",
          "default": false
        },
        "examples": {
          "type": "array",
          "items": true
        },
        "multipleOf": {
          "type": "number",
          "exclusiveMinimum": 0
        },
        "maximum": {
          "type": "number"
        },
        "exclusiveMaximum": {
          "type": "number"
        },
        "minimum": {
          "type": "number"
        },
        "exclusiveMinimum": {
          "type": "number"
        },
        "maxLength": {
          "$ref": "#/definitions/nonNegativeInteger"
        },
        "minLength": {
          "$ref": "#/definitions/nonNegativeIntegerDefault0"
        },
        "pattern": {
          "type": "string",
          "format": "regex"
        },
        "additionalItems": {
          "$ref": "#"
        },
        "items": {
          "anyOf": [{
            "$ref": "#"
          }, {
            "$ref": "#/definitions/schemaArray"
          }],
          "default": true
        },
        "maxItems": {
          "$ref": "#/definitions/nonNegativeInteger"
        },
        "minItems": {
          "$ref": "#/definitions/nonNegativeIntegerDefault0"
        },
        "uniqueItems": {
          "type": "boolean",
          "default": false
        },
        "contains": {
          "$ref": "#"
        },
        "maxProperties": {
          "$ref": "#/definitions/nonNegativeInteger"
        },
        "minProperties": {
          "$ref": "#/definitions/nonNegativeIntegerDefault0"
        },
        "required": {
          "$ref": "#/definitions/stringArray"
        },
        "additionalProperties": {
          "$ref": "#"
        },
        "definitions": {
          "type": "object",
          "additionalProperties": {
            "$ref": "#"
          },
          "default": {}
        },
        "properties": {
          "type": "object",
          "additionalProperties": {
            "$ref": "#"
          },
          "default": {}
        },
        "patternProperties": {
          "type": "object",
          "additionalProperties": {
            "$ref": "#"
          },
          "propertyNames": {
            "format": "regex"
          },
          "default": {}
        },
        "dependencies": {
          "type": "object",
          "additionalProperties": {
            "anyOf": [{
              "$ref": "#"
            }, {
              "$ref": "#/definitions/stringArray"
            }]
          }
        },
        "propertyNames": {
          "$ref": "#"
        },
        "const": true,
        "enum": {
          "type": "array",
          "items": true,
          "minItems": 1,
          "uniqueItems": true
        },
        "type": {
          "anyOf": [{
            "$ref": "#/definitions/simpleTypes"
          }, {
            "type": "array",
            "items": {
              "$ref": "#/definitions/simpleTypes"
            },
            "minItems": 1,
            "uniqueItems": true
          }]
        },
        "format": {
          "type": "string"
        },
        "contentMediaType": {
          "type": "string"
        },
        "contentEncoding": {
          "type": "string"
        },
        "if": {
          "$ref": "#"
        },
        "then": {
          "$ref": "#"
        },
        "else": {
          "$ref": "#"
        },
        "allOf": {
          "$ref": "#/definitions/schemaArray"
        },
        "anyOf": {
          "$ref": "#/definitions/schemaArray"
        },
        "oneOf": {
          "$ref": "#/definitions/schemaArray"
        },
        "not": {
          "$ref": "#"
        }
      },
      "default": true
    };
    validate2.errors = null;
    module3.exports = validate2;
  }
});

// ../../node_modules/.pnpm/string-similarity@4.0.4/node_modules/string-similarity/src/index.js
var require_src4 = __commonJS({
  "../../node_modules/.pnpm/string-similarity@4.0.4/node_modules/string-similarity/src/index.js"(exports2, module3) {
    init_import_meta_url();
    module3.exports = {
      compareTwoStrings,
      findBestMatch
    };
    function compareTwoStrings(first, second) {
      first = first.replace(/\s+/g, "");
      second = second.replace(/\s+/g, "");
      if (first === second)
        return 1;
      if (first.length < 2 || second.length < 2)
        return 0;
      let firstBigrams = /* @__PURE__ */ new Map();
      for (let i = 0; i < first.length - 1; i++) {
        const bigram = first.substring(i, i + 2);
        const count = firstBigrams.has(bigram) ? firstBigrams.get(bigram) + 1 : 1;
        firstBigrams.set(bigram, count);
      }
      ;
      let intersectionSize = 0;
      for (let i = 0; i < second.length - 1; i++) {
        const bigram = second.substring(i, i + 2);
        const count = firstBigrams.has(bigram) ? firstBigrams.get(bigram) : 0;
        if (count > 0) {
          firstBigrams.set(bigram, count - 1);
          intersectionSize++;
        }
      }
      return 2 * intersectionSize / (first.length + second.length - 2);
    }
    __name(compareTwoStrings, "compareTwoStrings");
    function findBestMatch(mainString, targetStrings) {
      if (!areArgsValid(mainString, targetStrings))
        throw new Error("Bad arguments: First argument should be a string, second should be an array of strings");
      const ratings = [];
      let bestMatchIndex = 0;
      for (let i = 0; i < targetStrings.length; i++) {
        const currentTargetString = targetStrings[i];
        const currentRating = compareTwoStrings(mainString, currentTargetString);
        ratings.push({ target: currentTargetString, rating: currentRating });
        if (currentRating > ratings[bestMatchIndex].rating) {
          bestMatchIndex = i;
        }
      }
      const bestMatch = ratings[bestMatchIndex];
      return { ratings, bestMatch, bestMatchIndex };
    }
    __name(findBestMatch, "findBestMatch");
    function areArgsValid(mainString, targetStrings) {
      if (typeof mainString !== "string")
        return false;
      if (!Array.isArray(targetStrings))
        return false;
      if (!targetStrings.length)
        return false;
      if (targetStrings.find(function(s) {
        return typeof s !== "string";
      }))
        return false;
      return true;
    }
    __name(areArgsValid, "areArgsValid");
  }
});

// ../../node_modules/.pnpm/fast-json-stringify@2.7.13/node_modules/fast-json-stringify/index.js
var require_fast_json_stringify = __commonJS({
  "../../node_modules/.pnpm/fast-json-stringify@2.7.13/node_modules/fast-json-stringify/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var Ajv = require_ajv();
    var merge = require_cjs();
    var clone = require_rfdc()({ proto: true });
    var fjsCloned = Symbol("fast-json-stringify.cloned");
    var validate2 = require_schema_validator();
    var stringSimilarity = null;
    var isLong;
    try {
      isLong = require("long").isLong;
    } catch (e3) {
      isLong = null;
    }
    var addComma = `
  if (addComma) {
    json += ','
  } else {
    addComma = true
  }
`;
    function isValidSchema(schema, name) {
      if (!validate2(schema)) {
        if (name) {
          name = `"${name}" `;
        } else {
          name = "";
        }
        const first = validate2.errors[0];
        const err = new Error(`${name}schema is invalid: data${first.dataPath} ${first.message}`);
        err.errors = isValidSchema.errors;
        throw err;
      }
    }
    __name(isValidSchema, "isValidSchema");
    function mergeLocation(source, dest) {
      return {
        schema: dest.schema || source.schema,
        root: dest.root || source.root,
        externalSchema: dest.externalSchema || source.externalSchema
      };
    }
    __name(mergeLocation, "mergeLocation");
    var arrayItemsReferenceSerializersMap = /* @__PURE__ */ new Map();
    var objectReferenceSerializersMap = /* @__PURE__ */ new Map();
    function build5(schema, options29) {
      arrayItemsReferenceSerializersMap.clear();
      objectReferenceSerializersMap.clear();
      options29 = options29 || {};
      isValidSchema(schema);
      if (options29.schema) {
        for (var key of Object.keys(options29.schema)) {
          isValidSchema(options29.schema[key], key);
        }
      }
      let intParseFunctionName = "trunc";
      if (options29.rounding) {
        if (["floor", "ceil", "round"].includes(options29.rounding)) {
          intParseFunctionName = options29.rounding;
        } else {
          throw new Error(`Unsupported integer rounding method ${options29.rounding}`);
        }
      }
      let code = `
    'use strict'
  `;
      code += `
    ${asFunctions}

    var isLong = ${isLong ? isLong.toString() : false}

    function parseInteger(int) { return Math.${intParseFunctionName}(int) }
    `;
      let location = {
        schema,
        root: schema,
        externalSchema: options29.schema
      };
      if (schema.$ref) {
        location = refFinder(schema.$ref, location);
        schema = location.schema;
      }
      if (schema.type === void 0) {
        schema.type = inferTypeByKeyword(schema);
      }
      let main2;
      switch (schema.type) {
        case "object":
          main2 = "$main";
          code = buildObject(location, code, main2);
          break;
        case "string":
          main2 = schema.nullable ? "$asStringNullable" : getStringSerializer(schema.format);
          break;
        case "integer":
          main2 = schema.nullable ? "$asIntegerNullable" : "$asInteger";
          break;
        case "number":
          main2 = schema.nullable ? "$asNumberNullable" : "$asNumber";
          break;
        case "boolean":
          main2 = schema.nullable ? "$asBooleanNullable" : "$asBoolean";
          break;
        case "null":
          main2 = "$asNull";
          break;
        case "array":
          main2 = "$main";
          code = buildArray(location, code, main2);
          schema = location.schema;
          break;
        case void 0:
          main2 = "$asAny";
          break;
        default:
          throw new Error(`${schema.type} unsupported`);
      }
      code += `
    ;
     return ${main2}
  `;
      const dependencies = [new Ajv(options29.ajv)];
      const dependenciesName = ["ajv"];
      dependenciesName.push(code);
      if (options29.debugMode) {
        dependenciesName.toString = function() {
          return dependenciesName.join("\n");
        };
        return dependenciesName;
      }
      arrayItemsReferenceSerializersMap.clear();
      objectReferenceSerializersMap.clear();
      return Function.apply(null, dependenciesName).apply(null, dependencies);
    }
    __name(build5, "build");
    var objectKeywords = [
      "maxProperties",
      "minProperties",
      "required",
      "properties",
      "patternProperties",
      "additionalProperties",
      "dependencies"
    ];
    var arrayKeywords = [
      "items",
      "additionalItems",
      "maxItems",
      "minItems",
      "uniqueItems",
      "contains"
    ];
    var stringKeywords = [
      "maxLength",
      "minLength",
      "pattern"
    ];
    var numberKeywords = [
      "multipleOf",
      "maximum",
      "exclusiveMaximum",
      "minimum",
      "exclusiveMinimum"
    ];
    function inferTypeByKeyword(schema) {
      for (var keyword of objectKeywords) {
        if (keyword in schema)
          return "object";
      }
      for (var keyword of arrayKeywords) {
        if (keyword in schema)
          return "array";
      }
      for (var keyword of stringKeywords) {
        if (keyword in schema)
          return "string";
      }
      for (var keyword of numberKeywords) {
        if (keyword in schema)
          return "number";
      }
      return schema.type;
    }
    __name(inferTypeByKeyword, "inferTypeByKeyword");
    var stringSerializerMap = {
      "date-time": "$asDatetime",
      date: "$asDate",
      time: "$asTime"
    };
    function getStringSerializer(format10) {
      return stringSerializerMap[format10] || "$asString";
    }
    __name(getStringSerializer, "getStringSerializer");
    function getTestSerializer(format10) {
      return stringSerializerMap[format10];
    }
    __name(getTestSerializer, "getTestSerializer");
    var asFunctions = `
function $pad2Zeros (num) {
  const s = '00' + num
  return s[s.length - 2] + s[s.length - 1]
}

function $asAny (i) {
  return JSON.stringify(i)
}

function $asNull () {
  return 'null'
}

function $asInteger (i) {
  if (isLong && isLong(i)) {
    return i.toString()
  } else if (typeof i === 'bigint') {
    return i.toString()
  } else if (Number.isInteger(i)) {
    return $asNumber(i)
  } else {
    /* eslint no-undef: "off" */
    return $asNumber(parseInteger(i))
  }
}

function $asIntegerNullable (i) {
  return i === null ? null : $asInteger(i)
}

function $asNumber (i) {
  const num = Number(i)
  if (isNaN(num)) {
    return 'null'
  } else {
    return '' + num
  }
}

function $asNumberNullable (i) {
  return i === null ? null : $asNumber(i)
}

function $asBoolean (bool) {
  return bool && 'true' || 'false' // eslint-disable-line
}

function $asBooleanNullable (bool) {
  return bool === null ? null : $asBoolean(bool)
}

function $asDatetime (date, skipQuotes) {
  const quotes = skipQuotes === true ? '' : '"'
  if (date instanceof Date) {
    return quotes + date.toISOString() + quotes
  } else if (date && typeof date.toISOString === 'function') {
    return quotes + date.toISOString() + quotes
  } else {
    return $asString(date, skipQuotes)
  }
}

function $asDate (date, skipQuotes) {
  const quotes = skipQuotes === true ? '' : '"'
  if (date instanceof Date) {
    return quotes + new Date(date.getTime() - (date.getTimezoneOffset() * 60000 )).toISOString().slice(0, 10) + quotes
  } else if (date && typeof date.format === 'function') {
    return quotes + date.format('YYYY-MM-DD') + quotes
  } else {
    return $asString(date, skipQuotes)
  }
}

function $asTime (date, skipQuotes) {
  const quotes = skipQuotes === true ? '' : '"'
  if (date instanceof Date) {
    const hour = new Intl.DateTimeFormat('en', { hour: 'numeric', hour12: false }).format(date)
    const minute = new Intl.DateTimeFormat('en', { minute: 'numeric' }).format(date)
    const second = new Intl.DateTimeFormat('en', { second: 'numeric' }).format(date)
    return quotes + $pad2Zeros(hour) + ':' + $pad2Zeros(minute) + ':' + $pad2Zeros(second) + quotes
  } else if (date && typeof date.format === 'function') {
    return quotes + date.format('HH:mm:ss') + quotes
  } else {
    return $asString(date, skipQuotes)
  }
}

function $asString (str, skipQuotes) {
  const quotes = skipQuotes === true ? '' : '"'
  if (str instanceof Date) {
    return quotes + str.toISOString() + quotes
  } else if (str === null) {
    return quotes + quotes
  } else if (str instanceof RegExp) {
    str = str.source
  } else if (typeof str !== 'string') {
    str = str.toString()
  }
  // If we skipQuotes it means that we are using it as test
  // no need to test the string length for the render
  if (skipQuotes) {
    return str
  }

  if (str.length < 42) {
    return $asStringSmall(str)
  } else {
    return JSON.stringify(str)
  }
}

function $asStringNullable (str) {
  return str === null ? null : $asString(str)
}

// magically escape strings for json
// relying on their charCodeAt
// everything below 32 needs JSON.stringify()
// every string that contain surrogate needs JSON.stringify()
// 34 and 92 happens all the time, so we
// have a fast case for them
function $asStringSmall (str) {
  const l = str.length
  let result = ''
  let last = 0
  let found = false
  let surrogateFound = false
  let point = 255
  // eslint-disable-next-line
  for (var i = 0; i < l && point >= 32; i++) {
    point = str.charCodeAt(i)
    if (point >= 0xD800 && point <= 0xDFFF) {
      // The current character is a surrogate.
      surrogateFound = true
    }
    if (point === 34 || point === 92) {
      result += str.slice(last, i) + '\\\\'
      last = i
      found = true
    }
  }

  if (!found) {
    result = str
  } else {
    result += str.slice(last)
  }
  return ((point < 32) || (surrogateFound === true)) ? JSON.stringify(str) : '"' + result + '"'
}
`;
    function addPatternProperties(location) {
      const schema = location.schema;
      const pp = schema.patternProperties;
      let code = `
      var properties = ${JSON.stringify(schema.properties)} || {}
      var keys = Object.keys(obj)
      for (var i = 0; i < keys.length; i++) {
        if (properties[keys[i]]) continue
  `;
      Object.keys(pp).forEach((regex2, index) => {
        let ppLocation = mergeLocation(location, { schema: pp[regex2] });
        if (pp[regex2].$ref) {
          ppLocation = refFinder(pp[regex2].$ref, location);
          pp[regex2] = ppLocation.schema;
        }
        const type = pp[regex2].type;
        const format10 = pp[regex2].format;
        const stringSerializer = getStringSerializer(format10);
        try {
          RegExp(regex2);
        } catch (err) {
          throw new Error(`${err.message}. Found at ${regex2} matching ${JSON.stringify(pp[regex2])}`);
        }
        const ifPpKeyExists = `if (/${regex2.replace(/\\*\//g, "\\/")}/.test(keys[i])) {`;
        if (type === "object") {
          code += `${buildObject(ppLocation, "", "buildObjectPP" + index)}
          ${ifPpKeyExists}
          ${addComma}
          json += $asString(keys[i]) + ':' + buildObjectPP${index}(obj[keys[i]])
      `;
        } else if (type === "array") {
          code += `${buildArray(ppLocation, "", "buildArrayPP" + index)}
          ${ifPpKeyExists}
          ${addComma}
          json += $asString(keys[i]) + ':' + buildArrayPP${index}(obj[keys[i]])
      `;
        } else if (type === "null") {
          code += `
          ${ifPpKeyExists}
          ${addComma}
          json += $asString(keys[i]) +':null'
      `;
        } else if (type === "string") {
          code += `
          ${ifPpKeyExists}
          ${addComma}
          json += $asString(keys[i]) + ':' + ${stringSerializer}(obj[keys[i]])
      `;
        } else if (type === "integer") {
          code += `
          ${ifPpKeyExists}
          ${addComma}
          json += $asString(keys[i]) + ':' + $asInteger(obj[keys[i]])
      `;
        } else if (type === "number") {
          code += `
          ${ifPpKeyExists}
          ${addComma}
          json += $asString(keys[i]) + ':' + $asNumber(obj[keys[i]])
      `;
        } else if (type === "boolean") {
          code += `
          ${ifPpKeyExists}
          ${addComma}
          json += $asString(keys[i]) + ':' + $asBoolean(obj[keys[i]])
      `;
        } else if (type === void 0) {
          code += `
          ${ifPpKeyExists}
          ${addComma}
          json += $asString(keys[i]) + ':' + $asAny(obj[keys[i]])
      `;
        } else {
          code += `
        ${ifPpKeyExists}
        throw new Error('Cannot coerce ' + obj[keys[i]] + ' to ' + ${JSON.stringify(type)})
      `;
        }
        code += `
          continue
        }
    `;
      });
      if (schema.additionalProperties) {
        code += additionalProperty(location);
      }
      code += `
      }
  `;
      return code;
    }
    __name(addPatternProperties, "addPatternProperties");
    function additionalProperty(location) {
      let ap = location.schema.additionalProperties;
      let code = "";
      if (ap === true) {
        return `
        if (obj[keys[i]] !== undefined && typeof obj[keys[i]] !== 'function' && typeof obj[keys[i]] !== 'symbol') {
          ${addComma}
          json += $asString(keys[i]) + ':' + JSON.stringify(obj[keys[i]])
        }
    `;
      }
      let apLocation = mergeLocation(location, { schema: ap });
      if (ap.$ref) {
        apLocation = refFinder(ap.$ref, location);
        ap = apLocation.schema;
      }
      const type = ap.type;
      const format10 = ap.format;
      const stringSerializer = getStringSerializer(format10);
      if (type === "object") {
        code += `${buildObject(apLocation, "", "buildObjectAP")}
        ${addComma}
        json += $asString(keys[i]) + ':' + buildObjectAP(obj[keys[i]])
    `;
      } else if (type === "array") {
        code += `${buildArray(apLocation, "", "buildArrayAP")}
        ${addComma}
        json += $asString(keys[i]) + ':' + buildArrayAP(obj[keys[i]])
    `;
      } else if (type === "null") {
        code += `
        ${addComma}
        json += $asString(keys[i]) +':null'
    `;
      } else if (type === "string") {
        code += `
        ${addComma}
        json += $asString(keys[i]) + ':' + ${stringSerializer}(obj[keys[i]])
    `;
      } else if (type === "integer") {
        code += `
        var t = Number(obj[keys[i]])
    `;
        if (isLong) {
          code += `
          if (isLong(obj[keys[i]]) || !isNaN(t)) {
            ${addComma}
            json += $asString(keys[i]) + ':' + $asInteger(obj[keys[i]])
          }
      `;
        } else {
          code += `
          if (!isNaN(t)) {
            ${addComma}
            json += $asString(keys[i]) + ':' + t
          }
      `;
        }
      } else if (type === "number") {
        code += `
        var t = Number(obj[keys[i]])
        if (!isNaN(t)) {
          ${addComma}
          json += $asString(keys[i]) + ':' + t
        }
    `;
      } else if (type === "boolean") {
        code += `
        ${addComma}
        json += $asString(keys[i]) + ':' + $asBoolean(obj[keys[i]])
    `;
      } else if (type === void 0) {
        code += `
        ${addComma}
        json += $asString(keys[i]) + ':' + $asAny(obj[keys[i]])
    `;
      } else {
        code += `
        throw new Error('Cannot coerce ' + obj[keys[i]] + ' to ' + ${JSON.stringify(type)})
    `;
      }
      return code;
    }
    __name(additionalProperty, "additionalProperty");
    function addAdditionalProperties(location) {
      return `
      var properties = ${JSON.stringify(location.schema.properties)} || {}
      var keys = Object.keys(obj)
      for (var i = 0; i < keys.length; i++) {
        if (properties[keys[i]]) continue
        ${additionalProperty(location)}
      }
  `;
    }
    __name(addAdditionalProperties, "addAdditionalProperties");
    function idFinder(schema, searchedId) {
      let objSchema;
      const explore = /* @__PURE__ */ __name((schema2, searchedId2) => {
        Object.keys(schema2 || {}).forEach((key, i, a) => {
          if (key === "$id" && schema2[key] === searchedId2) {
            objSchema = schema2;
          } else if (objSchema === void 0 && typeof schema2[key] === "object") {
            explore(schema2[key], searchedId2);
          }
        });
      }, "explore");
      explore(schema, searchedId);
      return objSchema;
    }
    __name(idFinder, "idFinder");
    function refFinder(ref, location) {
      const externalSchema = location.externalSchema;
      let root = location.root;
      let schema = location.schema;
      if (externalSchema && externalSchema[ref]) {
        return {
          schema: externalSchema[ref],
          root: externalSchema[ref],
          externalSchema
        };
      }
      ref = ref.split("#");
      if (ref[0]) {
        schema = externalSchema[ref[0]];
        root = externalSchema[ref[0]];
        if (schema === void 0) {
          findBadKey(externalSchema, [ref[0]]);
        }
        if (schema.$ref) {
          return refFinder(schema.$ref, {
            schema,
            root,
            externalSchema
          });
        }
      }
      let code = "return schema";
      if (ref[1]) {
        const walk = ref[1].split("/");
        if (walk.length === 1) {
          const targetId = `#${ref[1]}`;
          let dereferenced = idFinder(schema, targetId);
          if (dereferenced === void 0 && !ref[0]) {
            for (var key of Object.keys(externalSchema)) {
              dereferenced = idFinder(externalSchema[key], targetId);
              if (dereferenced !== void 0) {
                root = externalSchema[key];
                break;
              }
            }
          }
          return {
            schema: dereferenced,
            root,
            externalSchema
          };
        } else {
          for (var i = 1; i < walk.length; i++) {
            code += `[${JSON.stringify(walk[i])}]`;
          }
        }
      }
      let result;
      try {
        result = new Function("schema", code)(root);
      } catch (err) {
      }
      if (result === void 0 && ref[1]) {
        const walk = ref[1].split("/");
        findBadKey(schema, walk.slice(1));
      }
      if (result.$ref) {
        return refFinder(result.$ref, {
          schema,
          root,
          externalSchema
        });
      }
      return {
        schema: result,
        root,
        externalSchema
      };
      function findBadKey(obj, keys) {
        if (keys.length === 0)
          return null;
        const key2 = keys.shift();
        if (obj[key2] === void 0) {
          stringSimilarity = stringSimilarity || require_src4();
          const { bestMatch } = stringSimilarity.findBestMatch(key2, Object.keys(obj));
          if (bestMatch.rating >= 0.5) {
            throw new Error(`Cannot find reference ${JSON.stringify(key2)}, did you mean ${JSON.stringify(bestMatch.target)}?`);
          } else {
            throw new Error(`Cannot find reference ${JSON.stringify(key2)}`);
          }
        }
        return findBadKey(obj[key2], keys);
      }
      __name(findBadKey, "findBadKey");
    }
    __name(refFinder, "refFinder");
    function buildCode(location, code, laterCode, name) {
      if (location.schema.$ref) {
        location = refFinder(location.schema.$ref, location);
      }
      const schema = location.schema;
      let required = schema.required;
      Object.keys(schema.properties || {}).forEach((key, i2, a) => {
        let propertyLocation = mergeLocation(location, { schema: schema.properties[key] });
        if (schema.properties[key].$ref) {
          propertyLocation = refFinder(schema.properties[key].$ref, location);
          schema.properties[key] = propertyLocation.schema;
        }
        const type = schema.properties[key].type;
        const nullable = schema.properties[key].nullable;
        const sanitized = JSON.stringify(key);
        const asString = JSON.stringify(sanitized);
        if (nullable) {
          code += `
        if (obj[${sanitized}] === null) {
          ${addComma}
          json += ${asString} + ':null'
          var rendered = true
        } else {
      `;
        }
        if (type === "number") {
          code += `
          var t = Number(obj[${sanitized}])
          if (!isNaN(t)) {
            ${addComma}
            json += ${asString} + ':' + t
      `;
        } else if (type === "integer") {
          code += `
          var rendered = false
      `;
          if (isLong) {
            code += `
            if (isLong(obj[${sanitized}])) {
              ${addComma}
              json += ${asString} + ':' + obj[${sanitized}].toString()
              rendered = true
            } else {
              var t = Number(obj[${sanitized}])
              if (!isNaN(t)) {
                ${addComma}
                json += ${asString} + ':' + t
                rendered = true
              }
            }
        `;
          } else {
            code += `
            var t = $asInteger(obj[${sanitized}])
            if (!isNaN(t)) {
              ${addComma}
              json += ${asString} + ':' + t
              rendered = true
            }
        `;
          }
          code += `
          if (rendered) {
      `;
        } else {
          code += `
        if (obj[${sanitized}] !== undefined) {
          ${addComma}
          json += ${asString} + ':'
        `;
          const result = nested(laterCode, name, key, mergeLocation(propertyLocation, { schema: schema.properties[key] }), void 0, false);
          code += result.code;
          laterCode = result.laterCode;
        }
        const defaultValue = schema.properties[key].default;
        if (defaultValue !== void 0) {
          required = filterRequired(required, key);
          code += `
      } else {
        ${addComma}
        json += ${asString} + ':' + ${JSON.stringify(JSON.stringify(defaultValue))}
      `;
        } else if (required && required.indexOf(key) !== -1) {
          required = filterRequired(required, key);
          code += `
      } else {
        throw new Error('${sanitized} is required!')
      `;
        }
        code += `
      }
    `;
        if (nullable) {
          code += `
        }
      `;
        }
      });
      if (required && required.length > 0) {
        code += "var required = [";
        for (var i = 0; i < required.length; i++) {
          if (i > 0) {
            code += ",";
          }
          code += `${JSON.stringify(required[i])}`;
        }
        code += `]
      for (var i = 0; i < required.length; i++) {
        if (obj[required[i]] === undefined) throw new Error('"' + required[i] + '" is required!')
      }
    `;
      }
      if (schema.allOf) {
        const builtCode = buildCodeWithAllOfs(location, code, laterCode, name);
        code = builtCode.code;
        laterCode = builtCode.laterCode;
      }
      return { code, laterCode };
    }
    __name(buildCode, "buildCode");
    function filterRequired(required, key) {
      if (!required) {
        return required;
      }
      return required.filter((k2) => k2 !== key);
    }
    __name(filterRequired, "filterRequired");
    function buildCodeWithAllOfs(location, code, laterCode, name) {
      if (location.schema.allOf) {
        location.schema.allOf.forEach((ss) => {
          const builtCode = buildCodeWithAllOfs(mergeLocation(location, { schema: ss }), code, laterCode, name);
          code = builtCode.code;
          laterCode = builtCode.laterCode;
        });
      } else {
        const builtCode = buildCode(location, code, laterCode, name);
        code = builtCode.code;
        laterCode = builtCode.laterCode;
      }
      return { code, laterCode };
    }
    __name(buildCodeWithAllOfs, "buildCodeWithAllOfs");
    function buildInnerObject(location, name) {
      const schema = location.schema;
      const result = buildCodeWithAllOfs(location, "", "", name);
      if (schema.patternProperties) {
        result.code += addPatternProperties(location);
      } else if (schema.additionalProperties && !schema.patternProperties) {
        result.code += addAdditionalProperties(location);
      }
      return result;
    }
    __name(buildInnerObject, "buildInnerObject");
    function addIfThenElse(location, name) {
      let code = "";
      let r3;
      let laterCode = "";
      let innerR;
      const schema = location.schema;
      const copy = merge({}, schema);
      const i = copy.if;
      const then = copy.then;
      const e3 = copy.else ? copy.else : { additionalProperties: true };
      delete copy.if;
      delete copy.then;
      delete copy.else;
      let merged = merge(copy, then);
      let mergedLocation = mergeLocation(location, { schema: merged });
      code += `
    valid = ajv.validate(${JSON.stringify(i)}, obj)
    if (valid) {
  `;
      if (merged.if && merged.then) {
        innerR = addIfThenElse(mergedLocation, name + "Then");
        code += innerR.code;
        laterCode = innerR.laterCode;
      }
      r3 = buildInnerObject(mergedLocation, name + "Then");
      code += r3.code;
      laterCode += r3.laterCode;
      code += `
    }
  `;
      merged = merge(copy, e3);
      mergedLocation = mergeLocation(mergedLocation, { schema: merged });
      code += `
      else {
    `;
      if (merged.if && merged.then) {
        innerR = addIfThenElse(mergedLocation, name + "Else");
        code += innerR.code;
        laterCode += innerR.laterCode;
      }
      r3 = buildInnerObject(mergedLocation, name + "Else");
      code += r3.code;
      laterCode += r3.laterCode;
      code += `
      }
    `;
      return { code, laterCode };
    }
    __name(addIfThenElse, "addIfThenElse");
    function toJSON(variableName) {
      return `(${variableName} && typeof ${variableName}.toJSON === 'function')
    ? ${variableName}.toJSON()
    : ${variableName}
  `;
    }
    __name(toJSON, "toJSON");
    function buildObject(location, code, name) {
      const schema = location.schema;
      code += `
    function ${name} (input) {
  `;
      if (schema.nullable) {
        code += `
      if(input === null) {
        return 'null';
      }
  `;
      }
      if (objectReferenceSerializersMap.has(schema)) {
        code += `
      return ${objectReferenceSerializersMap.get(schema)}(input)
    }
    `;
        return code;
      }
      objectReferenceSerializersMap.set(schema, name);
      code += `
      var obj = ${toJSON("input")}
      var json = '{'
      var addComma = false
  `;
      let r3;
      if (schema.if && schema.then) {
        code += `
      var valid
    `;
        r3 = addIfThenElse(location, name);
      } else {
        r3 = buildInnerObject(location, name);
      }
      code += `${r3.code}
      json += '}'
      return json
    }
    ${r3.laterCode}
  `;
      return code;
    }
    __name(buildObject, "buildObject");
    function buildArray(location, code, name, key = null) {
      let schema = location.schema;
      code += `
    function ${name} (obj) {
  `;
      if (schema.nullable) {
        code += `
      if(obj === null) {
        return 'null';
      }
    `;
      }
      const laterCode = "";
      if (!schema.items) {
        schema.items = {};
      }
      if (schema.items.$ref) {
        if (!schema[fjsCloned]) {
          location.schema = clone(location.schema);
          schema = location.schema;
          schema[fjsCloned] = true;
        }
        location = refFinder(schema.items.$ref, location);
        schema.items = location.schema;
        if (arrayItemsReferenceSerializersMap.has(schema.items)) {
          code += `
      return ${arrayItemsReferenceSerializersMap.get(schema.items)}(obj)
      }
      `;
          return code;
        }
        arrayItemsReferenceSerializersMap.set(schema.items, name);
      }
      let result = { code: "", laterCode: "" };
      const accessor = "[i]";
      if (Array.isArray(schema.items)) {
        result = schema.items.reduce((res, item, i) => {
          const tmpRes = nested(laterCode, name, accessor, mergeLocation(location, { schema: item }), i, true);
          const condition = `i === ${i} && ${buildArrayTypeCondition(item.type, accessor)}`;
          return {
            code: `${res.code}
        ${i > 0 ? "else" : ""} if (${condition}) {
          ${tmpRes.code}
        }`,
            laterCode: `${res.laterCode}
        ${tmpRes.laterCode}`
          };
        }, result);
        if (schema.additionalItems) {
          const tmpRes = nested(laterCode, name, accessor, mergeLocation(location, { schema: schema.items }), void 0, true);
          result.code += `
      else if (i >= ${schema.items.length}) {
        ${tmpRes.code}
      }
      `;
        }
        result.code += `
    else {
      throw new Error(\`Item at \${i} does not match schema definition.\`)
    }
    `;
      } else {
        result = nested(laterCode, name, accessor, mergeLocation(location, { schema: schema.items }), void 0, true);
      }
      if (key) {
        code += `
    if(!Array.isArray(obj)) {
      throw new TypeError(\`Property '${key}' should be of type array, received '\${obj}' instead.\`)
    }
    `;
      }
      code += `
    var l = obj.length
    var jsonOutput= ''
    for (var i = 0; i < l; i++) {
      var json = ''
      ${result.code}
      jsonOutput += json

      if (json.length > 0 && i < l - 1) {
        jsonOutput += ','
      }
    }
    return \`[\${jsonOutput}]\`
  }
  ${result.laterCode}
  `;
      return code;
    }
    __name(buildArray, "buildArray");
    function buildArrayTypeCondition(type, accessor) {
      let condition;
      switch (type) {
        case "null":
          condition = `obj${accessor} === null`;
          break;
        case "string":
          condition = `typeof obj${accessor} === 'string'`;
          break;
        case "integer":
          condition = `Number.isInteger(obj${accessor})`;
          break;
        case "number":
          condition = `Number.isFinite(obj${accessor})`;
          break;
        case "boolean":
          condition = `typeof obj${accessor} === 'boolean'`;
          break;
        case "object":
          condition = `obj${accessor} && typeof obj${accessor} === 'object' && obj${accessor}.constructor === Object`;
          break;
        case "array":
          condition = `Array.isArray(obj${accessor})`;
          break;
        default:
          if (Array.isArray(type)) {
            const conditions = type.map((subType) => {
              return buildArrayTypeCondition(subType, accessor);
            });
            condition = `(${conditions.join(" || ")})`;
          } else {
            throw new Error(`${type} unsupported`);
          }
      }
      return condition;
    }
    __name(buildArrayTypeCondition, "buildArrayTypeCondition");
    function dereferenceOfRefs(location, type) {
      if (!location.schema[fjsCloned]) {
        const schemaClone = clone(location.schema);
        schemaClone[fjsCloned] = true;
        location.schema = schemaClone;
      }
      const schema = location.schema;
      const locations = [];
      schema[type].forEach((s, index) => {
        let sLocation = mergeLocation(location, { schema: s });
        while (s.$ref) {
          sLocation = refFinder(s.$ref, sLocation);
          schema[type][index] = sLocation.schema;
          s = schema[type][index];
        }
        locations[index] = sLocation;
      });
      return locations;
    }
    __name(dereferenceOfRefs, "dereferenceOfRefs");
    var strNameCounter = 0;
    function asFuncName(str) {
      let rep = str.replace(/[^a-zA-Z0-9$_]/g, "");
      if (rep.length === 0) {
        return "anan" + strNameCounter++;
      } else if (rep !== str) {
        rep += strNameCounter++;
      }
      return rep;
    }
    __name(asFuncName, "asFuncName");
    function nested(laterCode, name, key, location, subKey, isArray) {
      let code = "";
      let funcName;
      subKey = subKey || "";
      let schema = location.schema;
      if (schema.$ref) {
        schema = refFinder(schema.$ref, location);
      }
      if (schema.type === void 0) {
        const inferredType = inferTypeByKeyword(schema);
        if (inferredType) {
          schema.type = inferredType;
        }
      }
      const type = schema.type;
      const nullable = schema.nullable === true;
      const accessor = isArray ? key : `[${JSON.stringify(key)}]`;
      switch (type) {
        case "null":
          code += `
        json += $asNull()
      `;
          break;
        case "string": {
          const stringSerializer = getStringSerializer(schema.format);
          code += nullable ? `json += obj${accessor} === null ? null : ${stringSerializer}(obj${accessor})` : `json += ${stringSerializer}(obj${accessor})`;
          break;
        }
        case "integer":
          code += nullable ? `json += obj${accessor} === null ? null : $asInteger(obj${accessor})` : `json += $asInteger(obj${accessor})`;
          break;
        case "number":
          code += nullable ? `json += obj${accessor} === null ? null : $asNumber(obj${accessor})` : `json += $asNumber(obj${accessor})`;
          break;
        case "boolean":
          code += nullable ? `json += obj${accessor} === null ? null : $asBoolean(obj${accessor})` : `json += $asBoolean(obj${accessor})`;
          break;
        case "object":
          funcName = asFuncName(name + key + subKey);
          laterCode = buildObject(location, laterCode, funcName);
          code += `
        json += ${funcName}(obj${accessor})
      `;
          break;
        case "array":
          funcName = asFuncName("$arr" + name + key + subKey);
          laterCode = buildArray(location, laterCode, funcName, key);
          code += `
        json += ${funcName}(obj${accessor})
      `;
          break;
        case void 0:
          if ("anyOf" in schema) {
            const anyOfLocations = dereferenceOfRefs(location, "anyOf");
            anyOfLocations.forEach((location2, index) => {
              const nestedResult = nested(laterCode, name, key, location2, subKey !== "" ? subKey : "i" + index, isArray);
              const testSerializer = getTestSerializer(location2.schema.format);
              const testValue = testSerializer !== void 0 ? `${testSerializer}(obj${accessor}, true)` : `obj${accessor}`;
              code += `
            ${index === 0 ? "if" : "else if"}(ajv.validate(${JSON.stringify(location2.schema)}, ${testValue}))
              ${nestedResult.code}
          `;
              laterCode = nestedResult.laterCode;
            });
            code += `
          else json+= null
        `;
          } else if ("oneOf" in schema) {
            const oneOfLocations = dereferenceOfRefs(location, "oneOf");
            oneOfLocations.forEach((location2, index) => {
              const nestedResult = nested(laterCode, name, key, location2, subKey !== "" ? subKey : "i" + index, isArray);
              const testSerializer = getTestSerializer(location2.schema.format);
              const testValue = testSerializer !== void 0 ? `${testSerializer}(obj${accessor}, true)` : `obj${accessor}`;
              code += `
            ${index === 0 ? "if" : "else if"}(ajv.validate(${JSON.stringify(location2.schema)}, ${testValue}))
              ${nestedResult.code}
          `;
              laterCode = nestedResult.laterCode;
            });
            if (!isArray) {
              code += `
            else json+= null
          `;
            }
          } else if (isEmpty(schema)) {
            code += `
          json += JSON.stringify(obj${accessor})
        `;
          } else if ("const" in schema) {
            code += `
          if(ajv.validate(${JSON.stringify(schema)}, obj${accessor}))
            json += '${JSON.stringify(schema.const)}'
          else
            throw new Error(\`Item \${JSON.stringify(obj${accessor})} does not match schema definition.\`)
        `;
          } else if (schema.type === void 0) {
            code += `
          json += JSON.stringify(obj${accessor})
        `;
          } else {
            throw new Error(`${schema.type} unsupported`);
          }
          break;
        default:
          if (Array.isArray(type)) {
            const nullIndex = type.indexOf("null");
            const sortedTypes = nullIndex !== -1 ? [type[nullIndex]].concat(type.slice(0, nullIndex)).concat(type.slice(nullIndex + 1)) : type;
            sortedTypes.forEach((type2, index) => {
              const statement = index === 0 ? "if" : "else if";
              const tempSchema = Object.assign({}, schema, { type: type2 });
              const nestedResult = nested(laterCode, name, key, mergeLocation(location, { schema: tempSchema }), subKey, isArray);
              switch (type2) {
                case "string": {
                  code += `
                ${statement}(obj${accessor} === null || typeof obj${accessor} === "${type2}" || obj${accessor} instanceof Date || typeof obj${accessor}.toISOString === "function" || obj${accessor} instanceof RegExp || (typeof obj${accessor} === "object" && Object.hasOwnProperty.call(obj${accessor}, "toString")))
                  ${nestedResult.code}
              `;
                  break;
                }
                case "null": {
                  code += `
                ${statement}(obj${accessor} == null)
                  ${nestedResult.code}
              `;
                  break;
                }
                case "array": {
                  code += `
                ${statement}(Array.isArray(obj${accessor}))
                  ${nestedResult.code}
              `;
                  break;
                }
                case "integer": {
                  code += `
                ${statement}(Number.isInteger(obj${accessor}) || obj${accessor} === null)
                  ${nestedResult.code}
              `;
                  break;
                }
                case "number": {
                  code += `
                ${statement}(isNaN(obj${accessor}) === false)
                  ${nestedResult.code}
              `;
                  break;
                }
                default: {
                  code += `
                ${statement}(typeof obj${accessor} === "${type2}")
                  ${nestedResult.code}
              `;
                  break;
                }
              }
              laterCode = nestedResult.laterCode;
            });
            code += `
          else json+= null
        `;
          } else {
            throw new Error(`${type} unsupported`);
          }
      }
      return {
        code,
        laterCode
      };
    }
    __name(nested, "nested");
    function isEmpty(schema) {
      for (var key in schema) {
        if (schema.hasOwnProperty(key) && schema[key] !== void 0) {
          return false;
        }
      }
      return true;
    }
    __name(isEmpty, "isEmpty");
    module3.exports = build5;
    module3.exports.restore = function(debugModeStr, options29 = {}) {
      const dependencies = [debugModeStr];
      const args = [];
      if (debugModeStr.startsWith("ajv")) {
        dependencies.unshift("ajv");
        args.push(new Ajv(options29.ajv));
      }
      return Function.apply(null, ["ajv", debugModeStr]).apply(null, args);
    };
  }
});

// ../../node_modules/.pnpm/fast-safe-stringify@2.1.1/node_modules/fast-safe-stringify/index.js
var require_fast_safe_stringify = __commonJS({
  "../../node_modules/.pnpm/fast-safe-stringify@2.1.1/node_modules/fast-safe-stringify/index.js"(exports2, module3) {
    init_import_meta_url();
    module3.exports = stringify;
    stringify.default = stringify;
    stringify.stable = deterministicStringify;
    stringify.stableStringify = deterministicStringify;
    var LIMIT_REPLACE_NODE = "[...]";
    var CIRCULAR_REPLACE_NODE = "[Circular]";
    var arr = [];
    var replacerStack = [];
    function defaultOptions() {
      return {
        depthLimit: Number.MAX_SAFE_INTEGER,
        edgesLimit: Number.MAX_SAFE_INTEGER
      };
    }
    __name(defaultOptions, "defaultOptions");
    function stringify(obj, replacer2, spacer, options29) {
      if (typeof options29 === "undefined") {
        options29 = defaultOptions();
      }
      decirc(obj, "", 0, [], void 0, 0, options29);
      var res;
      try {
        if (replacerStack.length === 0) {
          res = JSON.stringify(obj, replacer2, spacer);
        } else {
          res = JSON.stringify(obj, replaceGetterValues(replacer2), spacer);
        }
      } catch (_3) {
        return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
      } finally {
        while (arr.length !== 0) {
          var part = arr.pop();
          if (part.length === 4) {
            Object.defineProperty(part[0], part[1], part[3]);
          } else {
            part[0][part[1]] = part[2];
          }
        }
      }
      return res;
    }
    __name(stringify, "stringify");
    function setReplace(replace, val, k2, parent) {
      var propertyDescriptor = Object.getOwnPropertyDescriptor(parent, k2);
      if (propertyDescriptor.get !== void 0) {
        if (propertyDescriptor.configurable) {
          Object.defineProperty(parent, k2, { value: replace });
          arr.push([parent, k2, val, propertyDescriptor]);
        } else {
          replacerStack.push([val, k2, replace]);
        }
      } else {
        parent[k2] = replace;
        arr.push([parent, k2, val]);
      }
    }
    __name(setReplace, "setReplace");
    function decirc(val, k2, edgeIndex, stack, parent, depth, options29) {
      depth += 1;
      var i;
      if (typeof val === "object" && val !== null) {
        for (i = 0; i < stack.length; i++) {
          if (stack[i] === val) {
            setReplace(CIRCULAR_REPLACE_NODE, val, k2, parent);
            return;
          }
        }
        if (typeof options29.depthLimit !== "undefined" && depth > options29.depthLimit) {
          setReplace(LIMIT_REPLACE_NODE, val, k2, parent);
          return;
        }
        if (typeof options29.edgesLimit !== "undefined" && edgeIndex + 1 > options29.edgesLimit) {
          setReplace(LIMIT_REPLACE_NODE, val, k2, parent);
          return;
        }
        stack.push(val);
        if (Array.isArray(val)) {
          for (i = 0; i < val.length; i++) {
            decirc(val[i], i, i, stack, val, depth, options29);
          }
        } else {
          var keys = Object.keys(val);
          for (i = 0; i < keys.length; i++) {
            var key = keys[i];
            decirc(val[key], key, i, stack, val, depth, options29);
          }
        }
        stack.pop();
      }
    }
    __name(decirc, "decirc");
    function compareFunction(a, b2) {
      if (a < b2) {
        return -1;
      }
      if (a > b2) {
        return 1;
      }
      return 0;
    }
    __name(compareFunction, "compareFunction");
    function deterministicStringify(obj, replacer2, spacer, options29) {
      if (typeof options29 === "undefined") {
        options29 = defaultOptions();
      }
      var tmp = deterministicDecirc(obj, "", 0, [], void 0, 0, options29) || obj;
      var res;
      try {
        if (replacerStack.length === 0) {
          res = JSON.stringify(tmp, replacer2, spacer);
        } else {
          res = JSON.stringify(tmp, replaceGetterValues(replacer2), spacer);
        }
      } catch (_3) {
        return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
      } finally {
        while (arr.length !== 0) {
          var part = arr.pop();
          if (part.length === 4) {
            Object.defineProperty(part[0], part[1], part[3]);
          } else {
            part[0][part[1]] = part[2];
          }
        }
      }
      return res;
    }
    __name(deterministicStringify, "deterministicStringify");
    function deterministicDecirc(val, k2, edgeIndex, stack, parent, depth, options29) {
      depth += 1;
      var i;
      if (typeof val === "object" && val !== null) {
        for (i = 0; i < stack.length; i++) {
          if (stack[i] === val) {
            setReplace(CIRCULAR_REPLACE_NODE, val, k2, parent);
            return;
          }
        }
        try {
          if (typeof val.toJSON === "function") {
            return;
          }
        } catch (_3) {
          return;
        }
        if (typeof options29.depthLimit !== "undefined" && depth > options29.depthLimit) {
          setReplace(LIMIT_REPLACE_NODE, val, k2, parent);
          return;
        }
        if (typeof options29.edgesLimit !== "undefined" && edgeIndex + 1 > options29.edgesLimit) {
          setReplace(LIMIT_REPLACE_NODE, val, k2, parent);
          return;
        }
        stack.push(val);
        if (Array.isArray(val)) {
          for (i = 0; i < val.length; i++) {
            deterministicDecirc(val[i], i, i, stack, val, depth, options29);
          }
        } else {
          var tmp = {};
          var keys = Object.keys(val).sort(compareFunction);
          for (i = 0; i < keys.length; i++) {
            var key = keys[i];
            deterministicDecirc(val[key], key, i, stack, val, depth, options29);
            tmp[key] = val[key];
          }
          if (typeof parent !== "undefined") {
            arr.push([parent, k2, val]);
            parent[k2] = tmp;
          } else {
            return tmp;
          }
        }
        stack.pop();
      }
    }
    __name(deterministicDecirc, "deterministicDecirc");
    function replaceGetterValues(replacer2) {
      replacer2 = typeof replacer2 !== "undefined" ? replacer2 : function(k2, v2) {
        return v2;
      };
      return function(key, val) {
        if (replacerStack.length > 0) {
          for (var i = 0; i < replacerStack.length; i++) {
            var part = replacerStack[i];
            if (part[1] === key && part[0] === val) {
              val = part[2];
              replacerStack.splice(i, 1);
              break;
            }
          }
        }
        return replacer2.call(this, key, val);
      };
    }
    __name(replaceGetterValues, "replaceGetterValues");
  }
});

// ../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js
var require_isArguments = __commonJS({
  "../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var toStr = Object.prototype.toString;
    module3.exports = /* @__PURE__ */ __name(function isArguments(value) {
      var str = toStr.call(value);
      var isArgs = str === "[object Arguments]";
      if (!isArgs) {
        isArgs = str !== "[object Array]" && value !== null && typeof value === "object" && typeof value.length === "number" && value.length >= 0 && toStr.call(value.callee) === "[object Function]";
      }
      return isArgs;
    }, "isArguments");
  }
});

// ../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/implementation.js
var require_implementation2 = __commonJS({
  "../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/implementation.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var keysShim;
    if (!Object.keys) {
      has = Object.prototype.hasOwnProperty;
      toStr = Object.prototype.toString;
      isArgs = require_isArguments();
      isEnumerable = Object.prototype.propertyIsEnumerable;
      hasDontEnumBug = !isEnumerable.call({ toString: null }, "toString");
      hasProtoEnumBug = isEnumerable.call(function() {
      }, "prototype");
      dontEnums = [
        "toString",
        "toLocaleString",
        "valueOf",
        "hasOwnProperty",
        "isPrototypeOf",
        "propertyIsEnumerable",
        "constructor"
      ];
      equalsConstructorPrototype = /* @__PURE__ */ __name(function(o2) {
        var ctor = o2.constructor;
        return ctor && ctor.prototype === o2;
      }, "equalsConstructorPrototype");
      excludedKeys = {
        $applicationCache: true,
        $console: true,
        $external: true,
        $frame: true,
        $frameElement: true,
        $frames: true,
        $innerHeight: true,
        $innerWidth: true,
        $onmozfullscreenchange: true,
        $onmozfullscreenerror: true,
        $outerHeight: true,
        $outerWidth: true,
        $pageXOffset: true,
        $pageYOffset: true,
        $parent: true,
        $scrollLeft: true,
        $scrollTop: true,
        $scrollX: true,
        $scrollY: true,
        $self: true,
        $webkitIndexedDB: true,
        $webkitStorageInfo: true,
        $window: true
      };
      hasAutomationEqualityBug = function() {
        if (typeof window === "undefined") {
          return false;
        }
        for (var k2 in window) {
          try {
            if (!excludedKeys["$" + k2] && has.call(window, k2) && window[k2] !== null && typeof window[k2] === "object") {
              try {
                equalsConstructorPrototype(window[k2]);
              } catch (e3) {
                return true;
              }
            }
          } catch (e3) {
            return true;
          }
        }
        return false;
      }();
      equalsConstructorPrototypeIfNotBuggy = /* @__PURE__ */ __name(function(o2) {
        if (typeof window === "undefined" || !hasAutomationEqualityBug) {
          return equalsConstructorPrototype(o2);
        }
        try {
          return equalsConstructorPrototype(o2);
        } catch (e3) {
          return false;
        }
      }, "equalsConstructorPrototypeIfNotBuggy");
      keysShim = /* @__PURE__ */ __name(function keys(object) {
        var isObject2 = object !== null && typeof object === "object";
        var isFunction2 = toStr.call(object) === "[object Function]";
        var isArguments = isArgs(object);
        var isString4 = isObject2 && toStr.call(object) === "[object String]";
        var theKeys = [];
        if (!isObject2 && !isFunction2 && !isArguments) {
          throw new TypeError("Object.keys called on a non-object");
        }
        var skipProto = hasProtoEnumBug && isFunction2;
        if (isString4 && object.length > 0 && !has.call(object, 0)) {
          for (var i = 0; i < object.length; ++i) {
            theKeys.push(String(i));
          }
        }
        if (isArguments && object.length > 0) {
          for (var j2 = 0; j2 < object.length; ++j2) {
            theKeys.push(String(j2));
          }
        } else {
          for (var name in object) {
            if (!(skipProto && name === "prototype") && has.call(object, name)) {
              theKeys.push(String(name));
            }
          }
        }
        if (hasDontEnumBug) {
          var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
          for (var k2 = 0; k2 < dontEnums.length; ++k2) {
            if (!(skipConstructor && dontEnums[k2] === "constructor") && has.call(object, dontEnums[k2])) {
              theKeys.push(dontEnums[k2]);
            }
          }
        }
        return theKeys;
      }, "keys");
    }
    var has;
    var toStr;
    var isArgs;
    var isEnumerable;
    var hasDontEnumBug;
    var hasProtoEnumBug;
    var dontEnums;
    var equalsConstructorPrototype;
    var excludedKeys;
    var hasAutomationEqualityBug;
    var equalsConstructorPrototypeIfNotBuggy;
    module3.exports = keysShim;
  }
});

// ../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/index.js
var require_object_keys = __commonJS({
  "../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var slice = Array.prototype.slice;
    var isArgs = require_isArguments();
    var origKeys = Object.keys;
    var keysShim = origKeys ? /* @__PURE__ */ __name(function keys(o2) {
      return origKeys(o2);
    }, "keys") : require_implementation2();
    var originalKeys = Object.keys;
    keysShim.shim = /* @__PURE__ */ __name(function shimObjectKeys() {
      if (Object.keys) {
        var keysWorksWithArguments = function() {
          var args = Object.keys(arguments);
          return args && args.length === arguments.length;
        }(1, 2);
        if (!keysWorksWithArguments) {
          Object.keys = /* @__PURE__ */ __name(function keys(object) {
            if (isArgs(object)) {
              return originalKeys(slice.call(object));
            }
            return originalKeys(object);
          }, "keys");
        }
      } else {
        Object.keys = keysShim;
      }
      return Object.keys || keysShim;
    }, "shimObjectKeys");
    module3.exports = keysShim;
  }
});

// ../../node_modules/.pnpm/has-property-descriptors@1.0.0/node_modules/has-property-descriptors/index.js
var require_has_property_descriptors = __commonJS({
  "../../node_modules/.pnpm/has-property-descriptors@1.0.0/node_modules/has-property-descriptors/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var GetIntrinsic = require_get_intrinsic();
    var $defineProperty = GetIntrinsic("%Object.defineProperty%", true);
    var hasPropertyDescriptors = /* @__PURE__ */ __name(function hasPropertyDescriptors2() {
      if ($defineProperty) {
        try {
          $defineProperty({}, "a", { value: 1 });
          return true;
        } catch (e3) {
          return false;
        }
      }
      return false;
    }, "hasPropertyDescriptors");
    hasPropertyDescriptors.hasArrayLengthDefineBug = /* @__PURE__ */ __name(function hasArrayLengthDefineBug() {
      if (!hasPropertyDescriptors()) {
        return null;
      }
      try {
        return $defineProperty([], "length", { value: 1 }).length !== 1;
      } catch (e3) {
        return true;
      }
    }, "hasArrayLengthDefineBug");
    module3.exports = hasPropertyDescriptors;
  }
});

// ../../node_modules/.pnpm/define-properties@1.2.0/node_modules/define-properties/index.js
var require_define_properties = __commonJS({
  "../../node_modules/.pnpm/define-properties@1.2.0/node_modules/define-properties/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var keys = require_object_keys();
    var hasSymbols = typeof Symbol === "function" && typeof Symbol("foo") === "symbol";
    var toStr = Object.prototype.toString;
    var concat = Array.prototype.concat;
    var origDefineProperty = Object.defineProperty;
    var isFunction2 = /* @__PURE__ */ __name(function(fn2) {
      return typeof fn2 === "function" && toStr.call(fn2) === "[object Function]";
    }, "isFunction");
    var hasPropertyDescriptors = require_has_property_descriptors()();
    var supportsDescriptors = origDefineProperty && hasPropertyDescriptors;
    var defineProperty2 = /* @__PURE__ */ __name(function(object, name, value, predicate) {
      if (name in object) {
        if (predicate === true) {
          if (object[name] === value) {
            return;
          }
        } else if (!isFunction2(predicate) || !predicate()) {
          return;
        }
      }
      if (supportsDescriptors) {
        origDefineProperty(object, name, {
          configurable: true,
          enumerable: false,
          value,
          writable: true
        });
      } else {
        object[name] = value;
      }
    }, "defineProperty");
    var defineProperties = /* @__PURE__ */ __name(function(object, map) {
      var predicates = arguments.length > 2 ? arguments[2] : {};
      var props = keys(map);
      if (hasSymbols) {
        props = concat.call(props, Object.getOwnPropertySymbols(map));
      }
      for (var i = 0; i < props.length; i += 1) {
        defineProperty2(object, props[i], map[props[i]], predicates[props[i]]);
      }
    }, "defineProperties");
    defineProperties.supportsDescriptors = !!supportsDescriptors;
    module3.exports = defineProperties;
  }
});

// ../../node_modules/.pnpm/globalthis@1.0.3/node_modules/globalthis/implementation.js
var require_implementation3 = __commonJS({
  "../../node_modules/.pnpm/globalthis@1.0.3/node_modules/globalthis/implementation.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = global;
  }
});

// ../../node_modules/.pnpm/globalthis@1.0.3/node_modules/globalthis/polyfill.js
var require_polyfill = __commonJS({
  "../../node_modules/.pnpm/globalthis@1.0.3/node_modules/globalthis/polyfill.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var implementation = require_implementation3();
    module3.exports = /* @__PURE__ */ __name(function getPolyfill() {
      if (typeof global !== "object" || !global || global.Math !== Math || global.Array !== Array) {
        return implementation;
      }
      return global;
    }, "getPolyfill");
  }
});

// ../../node_modules/.pnpm/globalthis@1.0.3/node_modules/globalthis/shim.js
var require_shim = __commonJS({
  "../../node_modules/.pnpm/globalthis@1.0.3/node_modules/globalthis/shim.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var define2 = require_define_properties();
    var getPolyfill = require_polyfill();
    module3.exports = /* @__PURE__ */ __name(function shimGlobal() {
      var polyfill2 = getPolyfill();
      if (define2.supportsDescriptors) {
        var descriptor2 = Object.getOwnPropertyDescriptor(polyfill2, "globalThis");
        if (!descriptor2 || descriptor2.configurable && (descriptor2.enumerable || !descriptor2.writable || globalThis !== polyfill2)) {
          Object.defineProperty(polyfill2, "globalThis", {
            configurable: true,
            enumerable: false,
            value: polyfill2,
            writable: true
          });
        }
      } else if (typeof globalThis !== "object" || globalThis !== polyfill2) {
        polyfill2.globalThis = polyfill2;
      }
      return polyfill2;
    }, "shimGlobal");
  }
});

// ../../node_modules/.pnpm/globalthis@1.0.3/node_modules/globalthis/index.js
var require_globalthis = __commonJS({
  "../../node_modules/.pnpm/globalthis@1.0.3/node_modules/globalthis/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var defineProperties = require_define_properties();
    var implementation = require_implementation3();
    var getPolyfill = require_polyfill();
    var shim3 = require_shim();
    var polyfill2 = getPolyfill();
    var getGlobal = /* @__PURE__ */ __name(function() {
      return polyfill2;
    }, "getGlobal");
    defineProperties(getGlobal, {
      getPolyfill,
      implementation,
      shim: shim3
    });
    module3.exports = getGlobal;
  }
});

// ../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/constants.js
var require_constants6 = __commonJS({
  "../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/constants.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.logLevels = void 0;
    exports2.logLevels = {
      debug: 20,
      error: 50,
      fatal: 60,
      info: 30,
      trace: 10,
      warn: 40
    };
  }
});

// ../../node_modules/.pnpm/fast-printf@1.6.9/node_modules/fast-printf/dist/src/tokenize.js
var require_tokenize = __commonJS({
  "../../node_modules/.pnpm/fast-printf@1.6.9/node_modules/fast-printf/dist/src/tokenize.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.tokenize = void 0;
    var TokenRule = /(?:%(?<flag>([+0-]|-\+))?(?<width>\d+)?(?<position>\d+\$)?(?<precision>\.\d+)?(?<conversion>[%BCESb-iosux]))|(\\%)/g;
    var tokenize = /* @__PURE__ */ __name((subject) => {
      let matchResult;
      const tokens = [];
      let argumentIndex = 0;
      let lastIndex = 0;
      let lastToken = null;
      while ((matchResult = TokenRule.exec(subject)) !== null) {
        if (matchResult.index > lastIndex) {
          lastToken = {
            literal: subject.slice(lastIndex, matchResult.index),
            type: "literal"
          };
          tokens.push(lastToken);
        }
        const match = matchResult[0];
        lastIndex = matchResult.index + match.length;
        if (match === "\\%" || match === "%%") {
          if (lastToken && lastToken.type === "literal") {
            lastToken.literal += "%";
          } else {
            lastToken = {
              literal: "%",
              type: "literal"
            };
            tokens.push(lastToken);
          }
        } else if (matchResult.groups) {
          lastToken = {
            conversion: matchResult.groups.conversion,
            flag: matchResult.groups.flag || null,
            placeholder: match,
            position: matchResult.groups.position ? Number.parseInt(matchResult.groups.position, 10) - 1 : argumentIndex++,
            precision: matchResult.groups.precision ? Number.parseInt(matchResult.groups.precision.slice(1), 10) : null,
            type: "placeholder",
            width: matchResult.groups.width ? Number.parseInt(matchResult.groups.width, 10) : null
          };
          tokens.push(lastToken);
        }
      }
      if (lastIndex <= subject.length - 1) {
        if (lastToken && lastToken.type === "literal") {
          lastToken.literal += subject.slice(lastIndex);
        } else {
          tokens.push({
            literal: subject.slice(lastIndex),
            type: "literal"
          });
        }
      }
      return tokens;
    }, "tokenize");
    exports2.tokenize = tokenize;
  }
});

// ../../node_modules/.pnpm/fast-printf@1.6.9/node_modules/fast-printf/dist/src/createPrintf.js
var require_createPrintf = __commonJS({
  "../../node_modules/.pnpm/fast-printf@1.6.9/node_modules/fast-printf/dist/src/createPrintf.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.createPrintf = void 0;
    var boolean_1 = require_lib4();
    var tokenize_1 = require_tokenize();
    var formatDefaultUnboundExpression = /* @__PURE__ */ __name((subject, token) => {
      return token.placeholder;
    }, "formatDefaultUnboundExpression");
    var createPrintf = /* @__PURE__ */ __name((configuration) => {
      var _a2;
      const padValue = /* @__PURE__ */ __name((value, width, flag) => {
        if (flag === "-") {
          return value.padEnd(width, " ");
        } else if (flag === "-+") {
          return ((Number(value) >= 0 ? "+" : "") + value).padEnd(width, " ");
        } else if (flag === "+") {
          return ((Number(value) >= 0 ? "+" : "") + value).padStart(width, " ");
        } else if (flag === "0") {
          return value.padStart(width, "0");
        } else {
          return value.padStart(width, " ");
        }
      }, "padValue");
      const formatUnboundExpression = (_a2 = configuration === null || configuration === void 0 ? void 0 : configuration.formatUnboundExpression) !== null && _a2 !== void 0 ? _a2 : formatDefaultUnboundExpression;
      const cache2 = {};
      return (subject, ...boundValues) => {
        let tokens = cache2[subject];
        if (!tokens) {
          tokens = cache2[subject] = tokenize_1.tokenize(subject);
        }
        let result = "";
        for (const token of tokens) {
          if (token.type === "literal") {
            result += token.literal;
          } else {
            let boundValue = boundValues[token.position];
            if (boundValue === void 0) {
              result += formatUnboundExpression(subject, token, boundValues);
            } else if (token.conversion === "b") {
              result += boolean_1.boolean(boundValue) ? "true" : "false";
            } else if (token.conversion === "B") {
              result += boolean_1.boolean(boundValue) ? "TRUE" : "FALSE";
            } else if (token.conversion === "c") {
              result += boundValue;
            } else if (token.conversion === "C") {
              result += String(boundValue).toUpperCase();
            } else if (token.conversion === "i" || token.conversion === "d") {
              boundValue = String(Math.trunc(boundValue));
              if (token.width !== null) {
                boundValue = padValue(boundValue, token.width, token.flag);
              }
              result += boundValue;
            } else if (token.conversion === "e") {
              result += Number(boundValue).toExponential();
            } else if (token.conversion === "E") {
              result += Number(boundValue).toExponential().toUpperCase();
            } else if (token.conversion === "f") {
              if (token.precision !== null) {
                boundValue = Number(boundValue).toFixed(token.precision);
              }
              if (token.width !== null) {
                boundValue = padValue(String(boundValue), token.width, token.flag);
              }
              result += boundValue;
            } else if (token.conversion === "o") {
              result += (Number.parseInt(String(boundValue), 10) >>> 0).toString(8);
            } else if (token.conversion === "s") {
              if (token.width !== null) {
                boundValue = padValue(String(boundValue), token.width, token.flag);
              }
              result += boundValue;
            } else if (token.conversion === "S") {
              if (token.width !== null) {
                boundValue = padValue(String(boundValue), token.width, token.flag);
              }
              result += String(boundValue).toUpperCase();
            } else if (token.conversion === "u") {
              result += Number.parseInt(String(boundValue), 10) >>> 0;
            } else if (token.conversion === "x") {
              boundValue = (Number.parseInt(String(boundValue), 10) >>> 0).toString(16);
              if (token.width !== null) {
                boundValue = padValue(String(boundValue), token.width, token.flag);
              }
              result += boundValue;
            } else {
              throw new Error("Unknown format specifier.");
            }
          }
        }
        return result;
      };
    }, "createPrintf");
    exports2.createPrintf = createPrintf;
  }
});

// ../../node_modules/.pnpm/fast-printf@1.6.9/node_modules/fast-printf/dist/src/printf.js
var require_printf = __commonJS({
  "../../node_modules/.pnpm/fast-printf@1.6.9/node_modules/fast-printf/dist/src/printf.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.printf = exports2.createPrintf = void 0;
    var createPrintf_1 = require_createPrintf();
    Object.defineProperty(exports2, "createPrintf", { enumerable: true, get: function() {
      return createPrintf_1.createPrintf;
    } });
    exports2.printf = createPrintf_1.createPrintf();
  }
});

// ../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/config.js
var require_config = __commonJS({
  "../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/config.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ROARR_LOG_FORMAT_VERSION = exports2.ROARR_VERSION = void 0;
    exports2.ROARR_VERSION = "5.0.0";
    exports2.ROARR_LOG_FORMAT_VERSION = "2.0.0";
  }
});

// ../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/utilities/hasOwnProperty.js
var require_hasOwnProperty = __commonJS({
  "../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/utilities/hasOwnProperty.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.hasOwnProperty = void 0;
    var hasOwnProperty2 = /* @__PURE__ */ __name((object, property) => {
      return Object.prototype.hasOwnProperty.call(object, property);
    }, "hasOwnProperty");
    exports2.hasOwnProperty = hasOwnProperty2;
  }
});

// ../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/utilities/index.js
var require_utilities = __commonJS({
  "../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/utilities/index.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.hasOwnProperty = void 0;
    var hasOwnProperty_1 = require_hasOwnProperty();
    Object.defineProperty(exports2, "hasOwnProperty", { enumerable: true, get: function() {
      return hasOwnProperty_1.hasOwnProperty;
    } });
  }
});

// ../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/factories/createLogger.js
var require_createLogger = __commonJS({
  "../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/factories/createLogger.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.createLogger = void 0;
    var fast_printf_1 = require_printf();
    var globalthis_1 = __importDefault(require_globalthis());
    var config_1 = require_config();
    var constants_1 = require_constants6();
    var utilities_1 = require_utilities();
    var loggedWarningAsyncLocalContext = false;
    var globalThis2 = (0, globalthis_1.default)();
    var getGlobalRoarrContext = /* @__PURE__ */ __name(() => {
      return globalThis2.ROARR;
    }, "getGlobalRoarrContext");
    var createDefaultAsyncLocalContext = /* @__PURE__ */ __name(() => {
      return {
        messageContext: {},
        transforms: []
      };
    }, "createDefaultAsyncLocalContext");
    var getAsyncLocalContext = /* @__PURE__ */ __name(() => {
      const asyncLocalStorage = getGlobalRoarrContext().asyncLocalStorage;
      if (!asyncLocalStorage) {
        throw new Error("AsyncLocalContext is unavailable.");
      }
      const asyncLocalContext = asyncLocalStorage.getStore();
      if (asyncLocalContext) {
        return asyncLocalContext;
      }
      return createDefaultAsyncLocalContext();
    }, "getAsyncLocalContext");
    var isAsyncLocalContextAvailable = /* @__PURE__ */ __name(() => {
      return Boolean(getGlobalRoarrContext().asyncLocalStorage);
    }, "isAsyncLocalContextAvailable");
    var getSequence = /* @__PURE__ */ __name(() => {
      if (isAsyncLocalContextAvailable()) {
        const asyncLocalContext = getAsyncLocalContext();
        if ((0, utilities_1.hasOwnProperty)(asyncLocalContext, "sequenceRoot") && (0, utilities_1.hasOwnProperty)(asyncLocalContext, "sequence")) {
          return String(asyncLocalContext.sequenceRoot) + "." + String(asyncLocalContext.sequence++);
        }
        return String(getGlobalRoarrContext().sequence++);
      }
      return String(getGlobalRoarrContext().sequence++);
    }, "getSequence");
    var createLogger = /* @__PURE__ */ __name((onMessage, parentMessageContext = {}, transforms = []) => {
      const log2 = /* @__PURE__ */ __name((a, b2, c2, d2, e3, f, g2, h2, i, j2) => {
        const time = Date.now();
        const sequence = getSequence();
        let asyncLocalContext;
        if (isAsyncLocalContextAvailable()) {
          asyncLocalContext = getAsyncLocalContext();
        } else {
          asyncLocalContext = createDefaultAsyncLocalContext();
        }
        let context2;
        let message;
        if (typeof a === "string") {
          context2 = {
            ...asyncLocalContext.messageContext,
            ...parentMessageContext
          };
        } else {
          context2 = {
            ...asyncLocalContext.messageContext,
            ...parentMessageContext,
            ...a
          };
        }
        if (typeof a === "string" && b2 === void 0) {
          message = a;
        } else if (typeof a === "string") {
          message = (0, fast_printf_1.printf)(a, b2, c2, d2, e3, f, g2, h2, i, j2);
        } else {
          let fallbackMessage = b2;
          if (typeof b2 !== "string") {
            if (b2 === void 0) {
              fallbackMessage = "";
            } else {
              throw new TypeError("Message must be a string. Received " + typeof b2 + ".");
            }
          }
          message = (0, fast_printf_1.printf)(fallbackMessage, c2, d2, e3, f, g2, h2, i, j2);
        }
        let packet = {
          context: context2,
          message,
          sequence,
          time,
          version: config_1.ROARR_LOG_FORMAT_VERSION
        };
        for (const transform of [...asyncLocalContext.transforms, ...transforms]) {
          packet = transform(packet);
          if (typeof packet !== "object" || packet === null) {
            throw new Error("Message transform function must return a message object.");
          }
        }
        onMessage(packet);
      }, "log");
      log2.child = (context2) => {
        let asyncLocalContext;
        if (isAsyncLocalContextAvailable()) {
          asyncLocalContext = getAsyncLocalContext();
        } else {
          asyncLocalContext = createDefaultAsyncLocalContext();
        }
        if (typeof context2 === "function") {
          return (0, exports2.createLogger)(onMessage, {
            ...asyncLocalContext.messageContext,
            ...parentMessageContext,
            ...context2
          }, [
            context2,
            ...transforms
          ]);
        }
        return (0, exports2.createLogger)(onMessage, {
          ...asyncLocalContext.messageContext,
          ...parentMessageContext,
          ...context2
        }, transforms);
      };
      log2.getContext = () => {
        let asyncLocalContext;
        if (isAsyncLocalContextAvailable()) {
          asyncLocalContext = getAsyncLocalContext();
        } else {
          asyncLocalContext = createDefaultAsyncLocalContext();
        }
        return {
          ...asyncLocalContext.messageContext,
          ...parentMessageContext
        };
      };
      log2.adopt = async (routine, context2) => {
        if (!isAsyncLocalContextAvailable()) {
          if (loggedWarningAsyncLocalContext === false) {
            loggedWarningAsyncLocalContext = true;
            onMessage({
              context: {
                logLevel: constants_1.logLevels.warn,
                package: "roarr"
              },
              message: "async_hooks are unavailable; Roarr.adopt will not function as expected",
              sequence: getSequence(),
              time: Date.now(),
              version: config_1.ROARR_LOG_FORMAT_VERSION
            });
          }
          return routine();
        }
        const asyncLocalContext = getAsyncLocalContext();
        let sequenceRoot;
        if ((0, utilities_1.hasOwnProperty)(asyncLocalContext, "sequenceRoot")) {
          sequenceRoot = asyncLocalContext.sequenceRoot + "." + String(asyncLocalContext.sequence++);
        } else {
          sequenceRoot = String(getGlobalRoarrContext().sequence++);
        }
        let nextContext = {
          ...asyncLocalContext.messageContext
        };
        const nextTransforms = [
          ...asyncLocalContext.transforms
        ];
        if (typeof context2 === "function") {
          nextTransforms.push(context2);
        } else {
          nextContext = {
            ...nextContext,
            ...context2
          };
        }
        const asyncLocalStorage = getGlobalRoarrContext().asyncLocalStorage;
        if (!asyncLocalStorage) {
          throw new Error("Async local context unavailable.");
        }
        return asyncLocalStorage.run({
          messageContext: nextContext,
          sequence: 0,
          sequenceRoot,
          transforms: nextTransforms
        }, () => {
          return routine();
        });
      };
      log2.trace = (a, b2, c2, d2, e3, f, g2, h2, i, j2) => {
        log2.child({
          logLevel: constants_1.logLevels.trace
        })(a, b2, c2, d2, e3, f, g2, h2, i, j2);
      };
      log2.debug = (a, b2, c2, d2, e3, f, g2, h2, i, j2) => {
        log2.child({
          logLevel: constants_1.logLevels.debug
        })(a, b2, c2, d2, e3, f, g2, h2, i, j2);
      };
      log2.info = (a, b2, c2, d2, e3, f, g2, h2, i, j2) => {
        log2.child({
          logLevel: constants_1.logLevels.info
        })(a, b2, c2, d2, e3, f, g2, h2, i, j2);
      };
      log2.warn = (a, b2, c2, d2, e3, f, g2, h2, i, j2) => {
        log2.child({
          logLevel: constants_1.logLevels.warn
        })(a, b2, c2, d2, e3, f, g2, h2, i, j2);
      };
      log2.error = (a, b2, c2, d2, e3, f, g2, h2, i, j2) => {
        log2.child({
          logLevel: constants_1.logLevels.error
        })(a, b2, c2, d2, e3, f, g2, h2, i, j2);
      };
      log2.fatal = (a, b2, c2, d2, e3, f, g2, h2, i, j2) => {
        log2.child({
          logLevel: constants_1.logLevels.fatal
        })(a, b2, c2, d2, e3, f, g2, h2, i, j2);
      };
      return log2;
    }, "createLogger");
    exports2.createLogger = createLogger;
  }
});

// ../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/factories/createMockLogger.js
var require_createMockLogger = __commonJS({
  "../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/factories/createMockLogger.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.createMockLogger = void 0;
    var constants_1 = require_constants6();
    var createMockLogger = /* @__PURE__ */ __name((onMessage, parentContext) => {
      const log2 = /* @__PURE__ */ __name(() => {
        return void 0;
      }, "log");
      log2.adopt = async (routine) => {
        return routine();
      };
      log2.child = (context2) => {
        return (0, exports2.createMockLogger)(onMessage, parentContext);
      };
      log2.getContext = () => {
        return {};
      };
      log2.trace = (a, b2, c2, d2, e3, f, g2, h2, i, j2) => {
        log2.child({
          logLevel: constants_1.logLevels.trace
        })(a, b2, c2, d2, e3, f, g2, h2, i, j2);
      };
      log2.debug = (a, b2, c2, d2, e3, f, g2, h2, i, j2) => {
        log2.child({
          logLevel: constants_1.logLevels.debug
        })(a, b2, c2, d2, e3, f, g2, h2, i, j2);
      };
      log2.info = (a, b2, c2, d2, e3, f, g2, h2, i, j2) => {
        log2.child({
          logLevel: constants_1.logLevels.info
        })(a, b2, c2, d2, e3, f, g2, h2, i, j2);
      };
      log2.warn = (a, b2, c2, d2, e3, f, g2, h2, i, j2) => {
        log2.child({
          logLevel: constants_1.logLevels.warn
        })(a, b2, c2, d2, e3, f, g2, h2, i, j2);
      };
      log2.error = (a, b2, c2, d2, e3, f, g2, h2, i, j2) => {
        log2.child({
          logLevel: constants_1.logLevels.error
        })(a, b2, c2, d2, e3, f, g2, h2, i, j2);
      };
      log2.fatal = (a, b2, c2, d2, e3, f, g2, h2, i, j2) => {
        log2.child({
          logLevel: constants_1.logLevels.fatal
        })(a, b2, c2, d2, e3, f, g2, h2, i, j2);
      };
      return log2;
    }, "createMockLogger");
    exports2.createMockLogger = createMockLogger;
  }
});

// ../../node_modules/.pnpm/semver-compare@1.0.0/node_modules/semver-compare/index.js
var require_semver_compare = __commonJS({
  "../../node_modules/.pnpm/semver-compare@1.0.0/node_modules/semver-compare/index.js"(exports2, module3) {
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function cmp(a, b2) {
      var pa2 = a.split(".");
      var pb = b2.split(".");
      for (var i = 0; i < 3; i++) {
        var na = Number(pa2[i]);
        var nb = Number(pb[i]);
        if (na > nb)
          return 1;
        if (nb > na)
          return -1;
        if (!isNaN(na) && isNaN(nb))
          return 1;
        if (isNaN(na) && !isNaN(nb))
          return -1;
      }
      return 0;
    }, "cmp");
  }
});

// ../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/factories/createNodeWriter.js
var require_createNodeWriter = __commonJS({
  "../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/factories/createNodeWriter.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.createNodeWriter = void 0;
    var createBlockingWriter = /* @__PURE__ */ __name((stream2) => {
      return (message) => {
        stream2.write(message + "\n");
      };
    }, "createBlockingWriter");
    var createNodeWriter = /* @__PURE__ */ __name(() => {
      var _a2;
      const targetStream = ((_a2 = process.env.ROARR_STREAM) !== null && _a2 !== void 0 ? _a2 : "STDOUT").toUpperCase();
      const stream2 = targetStream.toUpperCase() === "STDOUT" ? process.stdout : process.stderr;
      return createBlockingWriter(stream2);
    }, "createNodeWriter");
    exports2.createNodeWriter = createNodeWriter;
  }
});

// ../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/factories/createRoarrInitialGlobalState.js
var require_createRoarrInitialGlobalState = __commonJS({
  "../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/factories/createRoarrInitialGlobalState.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.createRoarrInitialGlobalState = void 0;
    var semver_compare_1 = __importDefault(require_semver_compare());
    var config_1 = require_config();
    var createNodeWriter_1 = require_createNodeWriter();
    var createRoarrInitialGlobalState = /* @__PURE__ */ __name((currentState) => {
      const versions = (currentState.versions || []).concat();
      if (versions.length > 1) {
        versions.sort(semver_compare_1.default);
      }
      const currentIsLatestVersion = !versions.length || (0, semver_compare_1.default)(config_1.ROARR_VERSION, versions[versions.length - 1]) === 1;
      if (!versions.includes(config_1.ROARR_VERSION)) {
        versions.push(config_1.ROARR_VERSION);
      }
      versions.sort(semver_compare_1.default);
      let newState = {
        sequence: 0,
        ...currentState,
        versions
      };
      if (currentIsLatestVersion || !newState.write) {
        try {
          const AsyncLocalStorage2 = require("async_hooks").AsyncLocalStorage;
          const asyncLocalStorage = new AsyncLocalStorage2();
          newState = {
            ...newState,
            ...{
              write: (0, createNodeWriter_1.createNodeWriter)()
            },
            asyncLocalStorage
          };
        } catch (_a2) {
        }
      }
      return newState;
    }, "createRoarrInitialGlobalState");
    exports2.createRoarrInitialGlobalState = createRoarrInitialGlobalState;
  }
});

// ../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/getLogLevelName.js
var require_getLogLevelName = __commonJS({
  "../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/getLogLevelName.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.getLogLevelName = void 0;
    var getLogLevelName = /* @__PURE__ */ __name((numericLogLevel) => {
      if (numericLogLevel <= 10) {
        return "trace";
      }
      if (numericLogLevel <= 20) {
        return "debug";
      }
      if (numericLogLevel <= 30) {
        return "info";
      }
      if (numericLogLevel <= 40) {
        return "warn";
      }
      if (numericLogLevel <= 50) {
        return "error";
      }
      return "fatal";
    }, "getLogLevelName");
    exports2.getLogLevelName = getLogLevelName;
  }
});

// ../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/Roarr.js
var require_Roarr = __commonJS({
  "../../node_modules/.pnpm/roarr@7.11.0/node_modules/roarr/dist/src/Roarr.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    var _a2;
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ROARR = exports2.Roarr = exports2.logLevels = exports2.getLogLevelName = void 0;
    var boolean_1 = require_lib4();
    var fast_json_stringify_1 = __importDefault(require_fast_json_stringify());
    var fast_safe_stringify_1 = __importDefault(require_fast_safe_stringify());
    var globalthis_1 = __importDefault(require_globalthis());
    var constants_1 = require_constants6();
    Object.defineProperty(exports2, "logLevels", { enumerable: true, get: function() {
      return constants_1.logLevels;
    } });
    var createLogger_1 = require_createLogger();
    var createMockLogger_1 = require_createMockLogger();
    var createRoarrInitialGlobalState_1 = require_createRoarrInitialGlobalState();
    var getLogLevelName_1 = require_getLogLevelName();
    Object.defineProperty(exports2, "getLogLevelName", { enumerable: true, get: function() {
      return getLogLevelName_1.getLogLevelName;
    } });
    var fastStringify = (0, fast_json_stringify_1.default)({
      properties: {
        message: {
          type: "string"
        },
        sequence: {
          type: "string"
        },
        time: {
          type: "integer"
        },
        version: {
          type: "string"
        }
      },
      type: "object"
    });
    var globalThis2 = (0, globalthis_1.default)();
    var ROARR = globalThis2.ROARR = (0, createRoarrInitialGlobalState_1.createRoarrInitialGlobalState)(globalThis2.ROARR || {});
    exports2.ROARR = ROARR;
    var logFactory = createLogger_1.createLogger;
    var enabled = (0, boolean_1.boolean)((_a2 = process.env.ROARR_LOG) !== null && _a2 !== void 0 ? _a2 : "");
    if (!enabled) {
      logFactory = createMockLogger_1.createMockLogger;
    }
    var serializeMessage = /* @__PURE__ */ __name((message) => {
      return '{"context":' + (0, fast_safe_stringify_1.default)(message.context) + "," + fastStringify(message).slice(1);
    }, "serializeMessage");
    var Roarr = logFactory((message) => {
      var _a3;
      if (ROARR.write) {
        ROARR.write(((_a3 = ROARR.serializeMessage) !== null && _a3 !== void 0 ? _a3 : serializeMessage)(message));
      }
    });
    exports2.Roarr = Roarr;
  }
});

// ../../node_modules/.pnpm/http-terminator@3.2.0/node_modules/http-terminator/dist/src/Logger.js
var require_Logger = __commonJS({
  "../../node_modules/.pnpm/http-terminator@3.2.0/node_modules/http-terminator/dist/src/Logger.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Logger = void 0;
    var roarr_1 = require_Roarr();
    exports2.Logger = roarr_1.Roarr.child({
      package: "http-terminator"
    });
  }
});

// ../../node_modules/.pnpm/http-terminator@3.2.0/node_modules/http-terminator/dist/src/factories/createInternalHttpTerminator.js
var require_createInternalHttpTerminator = __commonJS({
  "../../node_modules/.pnpm/http-terminator@3.2.0/node_modules/http-terminator/dist/src/factories/createInternalHttpTerminator.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.createInternalHttpTerminator = void 0;
    var http_1 = __importDefault(require("http"));
    var p_wait_for_1 = __importDefault(require_p_wait_for());
    var Logger_1 = require_Logger();
    var log2 = Logger_1.Logger.child({
      namespace: "createHttpTerminator"
    });
    var configurationDefaults = {
      gracefulTerminationTimeout: 1e3
    };
    var createInternalHttpTerminator = /* @__PURE__ */ __name((configurationInput) => {
      const configuration = {
        ...configurationDefaults,
        ...configurationInput
      };
      const server = configuration.server;
      const sockets = /* @__PURE__ */ new Set();
      const secureSockets = /* @__PURE__ */ new Set();
      let terminating;
      server.on("connection", (socket) => {
        if (terminating) {
          socket.destroy();
        } else {
          sockets.add(socket);
          socket.once("close", () => {
            sockets.delete(socket);
          });
        }
      });
      server.on("secureConnection", (socket) => {
        if (terminating) {
          socket.destroy();
        } else {
          secureSockets.add(socket);
          socket.once("close", () => {
            secureSockets.delete(socket);
          });
        }
      });
      const destroySocket = /* @__PURE__ */ __name((socket) => {
        socket.destroy();
        if (socket.server instanceof http_1.default.Server) {
          sockets.delete(socket);
        } else {
          secureSockets.delete(socket);
        }
      }, "destroySocket");
      const terminate = /* @__PURE__ */ __name(async () => {
        if (terminating) {
          log2.warn("already terminating HTTP server");
          return terminating;
        }
        let resolveTerminating;
        let rejectTerminating;
        terminating = new Promise((resolve19, reject) => {
          resolveTerminating = resolve19;
          rejectTerminating = reject;
        });
        server.on("request", (incomingMessage, outgoingMessage) => {
          if (!outgoingMessage.headersSent) {
            outgoingMessage.setHeader("connection", "close");
          }
        });
        for (const socket of sockets) {
          if (!(socket.server instanceof http_1.default.Server)) {
            continue;
          }
          const serverResponse = socket._httpMessage;
          if (serverResponse) {
            if (!serverResponse.headersSent) {
              serverResponse.setHeader("connection", "close");
            }
            continue;
          }
          destroySocket(socket);
        }
        for (const socket of secureSockets) {
          const serverResponse = socket._httpMessage;
          if (serverResponse) {
            if (!serverResponse.headersSent) {
              serverResponse.setHeader("connection", "close");
            }
            continue;
          }
          destroySocket(socket);
        }
        try {
          await (0, p_wait_for_1.default)(() => {
            return sockets.size === 0 && secureSockets.size === 0;
          }, {
            interval: 10,
            timeout: configuration.gracefulTerminationTimeout
          });
        } catch (_a2) {
        } finally {
          for (const socket of sockets) {
            destroySocket(socket);
          }
          for (const socket of secureSockets) {
            destroySocket(socket);
          }
        }
        server.close((error2) => {
          if (error2) {
            rejectTerminating(error2);
          } else {
            resolveTerminating();
          }
        });
        return terminating;
      }, "terminate");
      return {
        secureSockets,
        sockets,
        terminate
      };
    }, "createInternalHttpTerminator");
    exports2.createInternalHttpTerminator = createInternalHttpTerminator;
  }
});

// ../../node_modules/.pnpm/http-terminator@3.2.0/node_modules/http-terminator/dist/src/factories/createHttpTerminator.js
var require_createHttpTerminator = __commonJS({
  "../../node_modules/.pnpm/http-terminator@3.2.0/node_modules/http-terminator/dist/src/factories/createHttpTerminator.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.createHttpTerminator = void 0;
    var createInternalHttpTerminator_1 = require_createInternalHttpTerminator();
    var createHttpTerminator3 = /* @__PURE__ */ __name((configurationInput) => {
      const httpTerminator = (0, createInternalHttpTerminator_1.createInternalHttpTerminator)(configurationInput);
      return {
        terminate: httpTerminator.terminate
      };
    }, "createHttpTerminator");
    exports2.createHttpTerminator = createHttpTerminator3;
  }
});

// ../../node_modules/.pnpm/http-terminator@3.2.0/node_modules/http-terminator/dist/src/index.js
var require_src5 = __commonJS({
  "../../node_modules/.pnpm/http-terminator@3.2.0/node_modules/http-terminator/dist/src/index.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.createHttpTerminator = void 0;
    var createHttpTerminator_1 = require_createHttpTerminator();
    Object.defineProperty(exports2, "createHttpTerminator", { enumerable: true, get: function() {
      return createHttpTerminator_1.createHttpTerminator;
    } });
  }
});

// ../../node_modules/.pnpm/supports-color@9.2.2/node_modules/supports-color/index.js
var supports_color_exports = {};
__export(supports_color_exports, {
  createSupportsColor: () => createSupportsColor,
  default: () => supports_color_default
});
function hasFlag(flag, argv = import_node_process5.default.argv) {
  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
  const position = argv.indexOf(prefix + flag);
  const terminatorPosition = argv.indexOf("--");
  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
}
function envForceColor() {
  if ("FORCE_COLOR" in env3) {
    if (env3.FORCE_COLOR === "true") {
      return 1;
    }
    if (env3.FORCE_COLOR === "false") {
      return 0;
    }
    return env3.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env3.FORCE_COLOR, 10), 3);
  }
}
function translateLevel(level) {
  if (level === 0) {
    return false;
  }
  return {
    level,
    hasBasic: true,
    has256: level >= 2,
    has16m: level >= 3
  };
}
function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
  const noFlagForceColor = envForceColor();
  if (noFlagForceColor !== void 0) {
    flagForceColor = noFlagForceColor;
  }
  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
  if (forceColor === 0) {
    return 0;
  }
  if (sniffFlags) {
    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
      return 3;
    }
    if (hasFlag("color=256")) {
      return 2;
    }
  }
  if (haveStream && !streamIsTTY && forceColor === void 0) {
    return 0;
  }
  const min = forceColor || 0;
  if (env3.TERM === "dumb") {
    return min;
  }
  if (import_node_process5.default.platform === "win32") {
    const osRelease = import_node_os5.default.release().split(".");
    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
      return Number(osRelease[2]) >= 14931 ? 3 : 2;
    }
    return 1;
  }
  if ("CI" in env3) {
    if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE", "DRONE"].some((sign) => sign in env3) || env3.CI_NAME === "codeship") {
      return 1;
    }
    return min;
  }
  if ("TEAMCITY_VERSION" in env3) {
    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env3.TEAMCITY_VERSION) ? 1 : 0;
  }
  if ("TF_BUILD" in env3 && "AGENT_NAME" in env3) {
    return 1;
  }
  if (env3.COLORTERM === "truecolor") {
    return 3;
  }
  if ("TERM_PROGRAM" in env3) {
    const version3 = Number.parseInt((env3.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
    switch (env3.TERM_PROGRAM) {
      case "iTerm.app":
        return version3 >= 3 ? 3 : 2;
      case "Apple_Terminal":
        return 2;
    }
  }
  if (/-256(color)?$/i.test(env3.TERM)) {
    return 2;
  }
  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env3.TERM)) {
    return 1;
  }
  if ("COLORTERM" in env3) {
    return 1;
  }
  return min;
}
function createSupportsColor(stream2, options29 = {}) {
  const level = _supportsColor(stream2, {
    streamIsTTY: stream2 && stream2.isTTY,
    ...options29
  });
  return translateLevel(level);
}
var import_node_process5, import_node_os5, import_node_tty, env3, flagForceColor, supportsColor, supports_color_default;
var init_supports_color = __esm({
  "../../node_modules/.pnpm/supports-color@9.2.2/node_modules/supports-color/index.js"() {
    init_import_meta_url();
    import_node_process5 = __toESM(require("node:process"), 1);
    import_node_os5 = __toESM(require("node:os"), 1);
    import_node_tty = __toESM(require("node:tty"), 1);
    __name(hasFlag, "hasFlag");
    ({ env: env3 } = import_node_process5.default);
    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
      flagForceColor = 0;
    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
      flagForceColor = 1;
    }
    __name(envForceColor, "envForceColor");
    __name(translateLevel, "translateLevel");
    __name(_supportsColor, "_supportsColor");
    __name(createSupportsColor, "createSupportsColor");
    supportsColor = {
      stdout: createSupportsColor({ isTTY: import_node_tty.default.isatty(1) }),
      stderr: createSupportsColor({ isTTY: import_node_tty.default.isatty(2) })
    };
    supports_color_default = supportsColor;
  }
});

// ../../node_modules/.pnpm/ini@1.3.8/node_modules/ini/ini.js
var require_ini = __commonJS({
  "../../node_modules/.pnpm/ini@1.3.8/node_modules/ini/ini.js"(exports2) {
    init_import_meta_url();
    exports2.parse = exports2.decode = decode;
    exports2.stringify = exports2.encode = encode;
    exports2.safe = safe;
    exports2.unsafe = unsafe;
    var eol = typeof process !== "undefined" && process.platform === "win32" ? "\r\n" : "\n";
    function encode(obj, opt) {
      var children = [];
      var out = "";
      if (typeof opt === "string") {
        opt = {
          section: opt,
          whitespace: false
        };
      } else {
        opt = opt || {};
        opt.whitespace = opt.whitespace === true;
      }
      var separator = opt.whitespace ? " = " : "=";
      Object.keys(obj).forEach(function(k2, _3, __) {
        var val = obj[k2];
        if (val && Array.isArray(val)) {
          val.forEach(function(item) {
            out += safe(k2 + "[]") + separator + safe(item) + "\n";
          });
        } else if (val && typeof val === "object")
          children.push(k2);
        else
          out += safe(k2) + separator + safe(val) + eol;
      });
      if (opt.section && out.length)
        out = "[" + safe(opt.section) + "]" + eol + out;
      children.forEach(function(k2, _3, __) {
        var nk = dotSplit(k2).join("\\.");
        var section = (opt.section ? opt.section + "." : "") + nk;
        var child = encode(obj[k2], {
          section,
          whitespace: opt.whitespace
        });
        if (out.length && child.length)
          out += eol;
        out += child;
      });
      return out;
    }
    __name(encode, "encode");
    function dotSplit(str) {
      return str.replace(/\1/g, "LITERAL\\1LITERAL").replace(/\\\./g, "
").split(/\./).map(function(part) {
        return part.replace(/\1/g, "\\.").replace(/\2LITERAL\\1LITERAL\2/g, "
");
      });
    }
    __name(dotSplit, "dotSplit");
    function decode(str) {
      var out = {};
      var p2 = out;
      var section = null;
      var re = /^\[([^\]]*)\]$|^([^=]+)(=(.*))?$/i;
      var lines = str.split(/[\r\n]+/g);
      lines.forEach(function(line, _3, __) {
        if (!line || line.match(/^\s*[;#]/))
          return;
        var match = line.match(re);
        if (!match)
          return;
        if (match[1] !== void 0) {
          section = unsafe(match[1]);
          if (section === "__proto__") {
            p2 = {};
            return;
          }
          p2 = out[section] = out[section] || {};
          return;
        }
        var key = unsafe(match[2]);
        if (key === "__proto__")
          return;
        var value = match[3] ? unsafe(match[4]) : true;
        switch (value) {
          case "true":
          case "false":
          case "null":
            value = JSON.parse(value);
        }
        if (key.length > 2 && key.slice(-2) === "[]") {
          key = key.substring(0, key.length - 2);
          if (key === "__proto__")
            return;
          if (!p2[key])
            p2[key] = [];
          else if (!Array.isArray(p2[key]))
            p2[key] = [p2[key]];
        }
        if (Array.isArray(p2[key]))
          p2[key].push(value);
        else
          p2[key] = value;
      });
      Object.keys(out).filter(function(k2, _3, __) {
        if (!out[k2] || typeof out[k2] !== "object" || Array.isArray(out[k2]))
          return false;
        var parts = dotSplit(k2);
        var p3 = out;
        var l2 = parts.pop();
        var nl = l2.replace(/\\\./g, ".");
        parts.forEach(function(part, _4, __2) {
          if (part === "__proto__")
            return;
          if (!p3[part] || typeof p3[part] !== "object")
            p3[part] = {};
          p3 = p3[part];
        });
        if (p3 === out && nl === l2)
          return false;
        p3[nl] = out[k2];
        return true;
      }).forEach(function(del, _3, __) {
        delete out[del];
      });
      return out;
    }
    __name(decode, "decode");
    function isQuoted(val) {
      return val.charAt(0) === '"' && val.slice(-1) === '"' || val.charAt(0) === "'" && val.slice(-1) === "'";
    }
    __name(isQuoted, "isQuoted");
    function safe(val) {
      return typeof val !== "string" || val.match(/[=\r\n]/) || val.match(/^\[/) || val.length > 1 && isQuoted(val) || val !== val.trim() ? JSON.stringify(val) : val.replace(/;/g, "\\;").replace(/#/g, "\\#");
    }
    __name(safe, "safe");
    function unsafe(val, doUnesc) {
      val = (val || "").trim();
      if (isQuoted(val)) {
        if (val.charAt(0) === "'")
          val = val.substr(1, val.length - 2);
        try {
          val = JSON.parse(val);
        } catch (_3) {
        }
      } else {
        var esc = false;
        var unesc = "";
        for (var i = 0, l2 = val.length; i < l2; i++) {
          var c2 = val.charAt(i);
          if (esc) {
            if ("\\;#".indexOf(c2) !== -1)
              unesc += c2;
            else
              unesc += "\\" + c2;
            esc = false;
          } else if (";#".indexOf(c2) !== -1)
            break;
          else if (c2 === "\\")
            esc = true;
          else
            unesc += c2;
        }
        if (esc)
          unesc += "\\";
        return unesc.trim();
      }
      return val;
    }
    __name(unsafe, "unsafe");
  }
});

// ../../node_modules/.pnpm/strip-json-comments@2.0.1/node_modules/strip-json-comments/index.js
var require_strip_json_comments = __commonJS({
  "../../node_modules/.pnpm/strip-json-comments@2.0.1/node_modules/strip-json-comments/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var singleComment = 1;
    var multiComment = 2;
    function stripWithoutWhitespace() {
      return "";
    }
    __name(stripWithoutWhitespace, "stripWithoutWhitespace");
    function stripWithWhitespace(str, start, end) {
      return str.slice(start, end).replace(/\S/g, " ");
    }
    __name(stripWithWhitespace, "stripWithWhitespace");
    module3.exports = function(str, opts) {
      opts = opts || {};
      var currentChar;
      var nextChar;
      var insideString = false;
      var insideComment = false;
      var offset = 0;
      var ret = "";
      var strip = opts.whitespace === false ? stripWithoutWhitespace : stripWithWhitespace;
      for (var i = 0; i < str.length; i++) {
        currentChar = str[i];
        nextChar = str[i + 1];
        if (!insideComment && currentChar === '"') {
          var escaped = str[i - 1] === "\\" && str[i - 2] !== "\\";
          if (!escaped) {
            insideString = !insideString;
          }
        }
        if (insideString) {
          continue;
        }
        if (!insideComment && currentChar + nextChar === "//") {
          ret += str.slice(offset, i);
          offset = i;
          insideComment = singleComment;
          i++;
        } else if (insideComment === singleComment && currentChar + nextChar === "\r\n") {
          i++;
          insideComment = false;
          ret += strip(str, offset, i);
          offset = i;
          continue;
        } else if (insideComment === singleComment && currentChar === "\n") {
          insideComment = false;
          ret += strip(str, offset, i);
          offset = i;
        } else if (!insideComment && currentChar + nextChar === "/*") {
          ret += str.slice(offset, i);
          offset = i;
          insideComment = multiComment;
          i++;
          continue;
        } else if (insideComment === multiComment && currentChar + nextChar === "*/") {
          i++;
          insideComment = false;
          ret += strip(str, offset, i + 1);
          offset = i + 1;
          continue;
        }
      }
      return ret + (insideComment ? strip(str.substr(offset)) : str.substr(offset));
    };
  }
});

// ../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/lib/utils.js
var require_utils5 = __commonJS({
  "../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/lib/utils.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var fs26 = require("fs");
    var ini = require_ini();
    var path67 = require("path");
    var stripJsonComments = require_strip_json_comments();
    var parse7 = exports2.parse = function(content) {
      if (/^\s*{/.test(content))
        return JSON.parse(stripJsonComments(content));
      return ini.parse(content);
    };
    var file = exports2.file = function() {
      var args = [].slice.call(arguments).filter(function(arg) {
        return arg != null;
      });
      for (var i in args)
        if ("string" !== typeof args[i])
          return;
      var file2 = path67.join.apply(null, args);
      var content;
      try {
        return fs26.readFileSync(file2, "utf-8");
      } catch (err) {
        return;
      }
    };
    var json = exports2.json = function() {
      var content = file.apply(null, arguments);
      return content ? parse7(content) : null;
    };
    var env5 = exports2.env = function(prefix, env6) {
      env6 = env6 || process.env;
      var obj = {};
      var l2 = prefix.length;
      for (var k2 in env6) {
        if (k2.toLowerCase().indexOf(prefix.toLowerCase()) === 0) {
          var keypath = k2.substring(l2).split("__");
          var _emptyStringIndex;
          while ((_emptyStringIndex = keypath.indexOf("")) > -1) {
            keypath.splice(_emptyStringIndex, 1);
          }
          var cursor = obj;
          keypath.forEach(/* @__PURE__ */ __name(function _buildSubObj(_subkey, i) {
            if (!_subkey || typeof cursor !== "object")
              return;
            if (i === keypath.length - 1)
              cursor[_subkey] = env6[k2];
            if (cursor[_subkey] === void 0)
              cursor[_subkey] = {};
            cursor = cursor[_subkey];
          }, "_buildSubObj"));
        }
      }
      return obj;
    };
    var find = exports2.find = function() {
      var rel = path67.join.apply(null, [].slice.call(arguments));
      function find2(start, rel2) {
        var file2 = path67.join(start, rel2);
        try {
          fs26.statSync(file2);
          return file2;
        } catch (err) {
          if (path67.dirname(start) !== start)
            return find2(path67.dirname(start), rel2);
        }
      }
      __name(find2, "find");
      return find2(process.cwd(), rel);
    };
  }
});

// ../../node_modules/.pnpm/deep-extend@0.6.0/node_modules/deep-extend/lib/deep-extend.js
var require_deep_extend = __commonJS({
  "../../node_modules/.pnpm/deep-extend@0.6.0/node_modules/deep-extend/lib/deep-extend.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    function isSpecificValue(val) {
      return val instanceof Buffer || val instanceof Date || val instanceof RegExp ? true : false;
    }
    __name(isSpecificValue, "isSpecificValue");
    function cloneSpecificValue(val) {
      if (val instanceof Buffer) {
        var x2 = Buffer.alloc ? Buffer.alloc(val.length) : new Buffer(val.length);
        val.copy(x2);
        return x2;
      } else if (val instanceof Date) {
        return new Date(val.getTime());
      } else if (val instanceof RegExp) {
        return new RegExp(val);
      } else {
        throw new Error("Unexpected situation");
      }
    }
    __name(cloneSpecificValue, "cloneSpecificValue");
    function deepCloneArray(arr) {
      var clone = [];
      arr.forEach(function(item, index) {
        if (typeof item === "object" && item !== null) {
          if (Array.isArray(item)) {
            clone[index] = deepCloneArray(item);
          } else if (isSpecificValue(item)) {
            clone[index] = cloneSpecificValue(item);
          } else {
            clone[index] = deepExtend({}, item);
          }
        } else {
          clone[index] = item;
        }
      });
      return clone;
    }
    __name(deepCloneArray, "deepCloneArray");
    function safeGetProperty(object, property) {
      return property === "__proto__" ? void 0 : object[property];
    }
    __name(safeGetProperty, "safeGetProperty");
    var deepExtend = module3.exports = function() {
      if (arguments.length < 1 || typeof arguments[0] !== "object") {
        return false;
      }
      if (arguments.length < 2) {
        return arguments[0];
      }
      var target = arguments[0];
      var args = Array.prototype.slice.call(arguments, 1);
      var val, src, clone;
      args.forEach(function(obj) {
        if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
          return;
        }
        Object.keys(obj).forEach(function(key) {
          src = safeGetProperty(target, key);
          val = safeGetProperty(obj, key);
          if (val === target) {
            return;
          } else if (typeof val !== "object" || val === null) {
            target[key] = val;
            return;
          } else if (Array.isArray(val)) {
            target[key] = deepCloneArray(val);
            return;
          } else if (isSpecificValue(val)) {
            target[key] = cloneSpecificValue(val);
            return;
          } else if (typeof src !== "object" || src === null || Array.isArray(src)) {
            target[key] = deepExtend({}, val);
            return;
          } else {
            target[key] = deepExtend(src, val);
            return;
          }
        });
      });
      return target;
    };
  }
});

// ../../node_modules/.pnpm/minimist@1.2.6/node_modules/minimist/index.js
var require_minimist = __commonJS({
  "../../node_modules/.pnpm/minimist@1.2.6/node_modules/minimist/index.js"(exports2, module3) {
    init_import_meta_url();
    module3.exports = function(args, opts) {
      if (!opts)
        opts = {};
      var flags = { bools: {}, strings: {}, unknownFn: null };
      if (typeof opts["unknown"] === "function") {
        flags.unknownFn = opts["unknown"];
      }
      if (typeof opts["boolean"] === "boolean" && opts["boolean"]) {
        flags.allBools = true;
      } else {
        [].concat(opts["boolean"]).filter(Boolean).forEach(function(key2) {
          flags.bools[key2] = true;
        });
      }
      var aliases2 = {};
      Object.keys(opts.alias || {}).forEach(function(key2) {
        aliases2[key2] = [].concat(opts.alias[key2]);
        aliases2[key2].forEach(function(x2) {
          aliases2[x2] = [key2].concat(aliases2[key2].filter(function(y2) {
            return x2 !== y2;
          }));
        });
      });
      [].concat(opts.string).filter(Boolean).forEach(function(key2) {
        flags.strings[key2] = true;
        if (aliases2[key2]) {
          flags.strings[aliases2[key2]] = true;
        }
      });
      var defaults = opts["default"] || {};
      var argv = { _: [] };
      Object.keys(flags.bools).forEach(function(key2) {
        setArg(key2, defaults[key2] === void 0 ? false : defaults[key2]);
      });
      var notFlags = [];
      if (args.indexOf("--") !== -1) {
        notFlags = args.slice(args.indexOf("--") + 1);
        args = args.slice(0, args.indexOf("--"));
      }
      function argDefined(key2, arg2) {
        return flags.allBools && /^--[^=]+$/.test(arg2) || flags.strings[key2] || flags.bools[key2] || aliases2[key2];
      }
      __name(argDefined, "argDefined");
      function setArg(key2, val, arg2) {
        if (arg2 && flags.unknownFn && !argDefined(key2, arg2)) {
          if (flags.unknownFn(arg2) === false)
            return;
        }
        var value2 = !flags.strings[key2] && isNumber(val) ? Number(val) : val;
        setKey(argv, key2.split("."), value2);
        (aliases2[key2] || []).forEach(function(x2) {
          setKey(argv, x2.split("."), value2);
        });
      }
      __name(setArg, "setArg");
      function setKey(obj, keys, value2) {
        var o2 = obj;
        for (var i2 = 0; i2 < keys.length - 1; i2++) {
          var key2 = keys[i2];
          if (isConstructorOrProto(o2, key2))
            return;
          if (o2[key2] === void 0)
            o2[key2] = {};
          if (o2[key2] === Object.prototype || o2[key2] === Number.prototype || o2[key2] === String.prototype)
            o2[key2] = {};
          if (o2[key2] === Array.prototype)
            o2[key2] = [];
          o2 = o2[key2];
        }
        var key2 = keys[keys.length - 1];
        if (isConstructorOrProto(o2, key2))
          return;
        if (o2 === Object.prototype || o2 === Number.prototype || o2 === String.prototype)
          o2 = {};
        if (o2 === Array.prototype)
          o2 = [];
        if (o2[key2] === void 0 || flags.bools[key2] || typeof o2[key2] === "boolean") {
          o2[key2] = value2;
        } else if (Array.isArray(o2[key2])) {
          o2[key2].push(value2);
        } else {
          o2[key2] = [o2[key2], value2];
        }
      }
      __name(setKey, "setKey");
      function aliasIsBoolean(key2) {
        return aliases2[key2].some(function(x2) {
          return flags.bools[x2];
        });
      }
      __name(aliasIsBoolean, "aliasIsBoolean");
      for (var i = 0; i < args.length; i++) {
        var arg = args[i];
        if (/^--.+=/.test(arg)) {
          var m2 = arg.match(/^--([^=]+)=([\s\S]*)$/);
          var key = m2[1];
          var value = m2[2];
          if (flags.bools[key]) {
            value = value !== "false";
          }
          setArg(key, value, arg);
        } else if (/^--no-.+/.test(arg)) {
          var key = arg.match(/^--no-(.+)/)[1];
          setArg(key, false, arg);
        } else if (/^--.+/.test(arg)) {
          var key = arg.match(/^--(.+)/)[1];
          var next = args[i + 1];
          if (next !== void 0 && !/^-/.test(next) && !flags.bools[key] && !flags.allBools && (aliases2[key] ? !aliasIsBoolean(key) : true)) {
            setArg(key, next, arg);
            i++;
          } else if (/^(true|false)$/.test(next)) {
            setArg(key, next === "true", arg);
            i++;
          } else {
            setArg(key, flags.strings[key] ? "" : true, arg);
          }
        } else if (/^-[^-]+/.test(arg)) {
          var letters = arg.slice(1, -1).split("");
          var broken = false;
          for (var j2 = 0; j2 < letters.length; j2++) {
            var next = arg.slice(j2 + 2);
            if (next === "-") {
              setArg(letters[j2], next, arg);
              continue;
            }
            if (/[A-Za-z]/.test(letters[j2]) && /=/.test(next)) {
              setArg(letters[j2], next.split("=")[1], arg);
              broken = true;
              break;
            }
            if (/[A-Za-z]/.test(letters[j2]) && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
              setArg(letters[j2], next, arg);
              broken = true;
              break;
            }
            if (letters[j2 + 1] && letters[j2 + 1].match(/\W/)) {
              setArg(letters[j2], arg.slice(j2 + 2), arg);
              broken = true;
              break;
            } else {
              setArg(letters[j2], flags.strings[letters[j2]] ? "" : true, arg);
            }
          }
          var key = arg.slice(-1)[0];
          if (!broken && key !== "-") {
            if (args[i + 1] && !/^(-|--)[^-]/.test(args[i + 1]) && !flags.bools[key] && (aliases2[key] ? !aliasIsBoolean(key) : true)) {
              setArg(key, args[i + 1], arg);
              i++;
            } else if (args[i + 1] && /^(true|false)$/.test(args[i + 1])) {
              setArg(key, args[i + 1] === "true", arg);
              i++;
            } else {
              setArg(key, flags.strings[key] ? "" : true, arg);
            }
          }
        } else {
          if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
            argv._.push(
              flags.strings["_"] || !isNumber(arg) ? arg : Number(arg)
            );
          }
          if (opts.stopEarly) {
            argv._.push.apply(argv._, args.slice(i + 1));
            break;
          }
        }
      }
      Object.keys(defaults).forEach(function(key2) {
        if (!hasKey2(argv, key2.split("."))) {
          setKey(argv, key2.split("."), defaults[key2]);
          (aliases2[key2] || []).forEach(function(x2) {
            setKey(argv, x2.split("."), defaults[key2]);
          });
        }
      });
      if (opts["--"]) {
        argv["--"] = new Array();
        notFlags.forEach(function(key2) {
          argv["--"].push(key2);
        });
      } else {
        notFlags.forEach(function(key2) {
          argv._.push(key2);
        });
      }
      return argv;
    };
    function hasKey2(obj, keys) {
      var o2 = obj;
      keys.slice(0, -1).forEach(function(key2) {
        o2 = o2[key2] || {};
      });
      var key = keys[keys.length - 1];
      return key in o2;
    }
    __name(hasKey2, "hasKey");
    function isNumber(x2) {
      if (typeof x2 === "number")
        return true;
      if (/^0x[0-9a-f]+$/i.test(x2))
        return true;
      return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x2);
    }
    __name(isNumber, "isNumber");
    function isConstructorOrProto(obj, key) {
      return key === "constructor" && typeof obj[key] === "function" || key === "__proto__";
    }
    __name(isConstructorOrProto, "isConstructorOrProto");
  }
});

// ../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/index.js
var require_rc = __commonJS({
  "../../node_modules/.pnpm/rc@1.2.8/node_modules/rc/index.js"(exports2, module3) {
    init_import_meta_url();
    var cc = require_utils5();
    var join15 = require("path").join;
    var deepExtend = require_deep_extend();
    var etc = "/etc";
    var win = process.platform === "win32";
    var home = win ? process.env.USERPROFILE : process.env.HOME;
    module3.exports = function(name, defaults, argv, parse7) {
      if ("string" !== typeof name)
        throw new Error("rc(name): name *must* be string");
      if (!argv)
        argv = require_minimist()(process.argv.slice(2));
      defaults = ("string" === typeof defaults ? cc.json(defaults) : defaults) || {};
      parse7 = parse7 || cc.parse;
      var env5 = cc.env(name + "_");
      var configs = [defaults];
      var configFiles = [];
      function addConfigFile(file) {
        if (configFiles.indexOf(file) >= 0)
          return;
        var fileConfig = cc.file(file);
        if (fileConfig) {
          configs.push(parse7(fileConfig));
          configFiles.push(file);
        }
      }
      __name(addConfigFile, "addConfigFile");
      if (!win)
        [
          join15(etc, name, "config"),
          join15(etc, name + "rc")
        ].forEach(addConfigFile);
      if (home)
        [
          join15(home, ".config", name, "config"),
          join15(home, ".config", name),
          join15(home, "." + name, "config"),
          join15(home, "." + name + "rc")
        ].forEach(addConfigFile);
      addConfigFile(cc.find("." + name + "rc"));
      if (env5.config)
        addConfigFile(env5.config);
      if (argv.config)
        addConfigFile(argv.config);
      return deepExtend.apply(null, configs.concat([
        env5,
        argv,
        configFiles.length ? { configs: configFiles, config: configFiles[configFiles.length - 1] } : void 0
      ]));
    };
  }
});

// ../../node_modules/.pnpm/registry-url@3.1.0/node_modules/registry-url/index.js
var require_registry_url = __commonJS({
  "../../node_modules/.pnpm/registry-url@3.1.0/node_modules/registry-url/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = function(scope) {
      var rc = require_rc()("npm", { registry: "https://registry.npmjs.org/" });
      var url4 = rc[scope + ":registry"] || rc.registry;
      return url4.slice(-1) === "/" ? url4 : url4 + "/";
    };
  }
});

// ../../node_modules/.pnpm/registry-auth-token@3.3.2/node_modules/registry-auth-token/base64.js
var require_base64 = __commonJS({
  "../../node_modules/.pnpm/registry-auth-token@3.3.2/node_modules/registry-auth-token/base64.js"(exports2, module3) {
    init_import_meta_url();
    var safeBuffer = require_safe_buffer().Buffer;
    function decodeBase64(base642) {
      return safeBuffer.from(base642, "base64").toString("utf8");
    }
    __name(decodeBase64, "decodeBase64");
    function encodeBase64(string) {
      return safeBuffer.from(string, "utf8").toString("base64");
    }
    __name(encodeBase64, "encodeBase64");
    module3.exports = {
      decodeBase64,
      encodeBase64
    };
  }
});

// ../../node_modules/.pnpm/registry-auth-token@3.3.2/node_modules/registry-auth-token/index.js
var require_registry_auth_token = __commonJS({
  "../../node_modules/.pnpm/registry-auth-token@3.3.2/node_modules/registry-auth-token/index.js"(exports2, module3) {
    init_import_meta_url();
    var url4 = require("url");
    var base642 = require_base64();
    var decodeBase64 = base642.decodeBase64;
    var encodeBase64 = base642.encodeBase64;
    var tokenKey = ":_authToken";
    var userKey = ":username";
    var passwordKey = ":_password";
    module3.exports = function() {
      var checkUrl;
      var options29;
      if (arguments.length >= 2) {
        checkUrl = arguments[0];
        options29 = arguments[1];
      } else if (typeof arguments[0] === "string") {
        checkUrl = arguments[0];
      } else {
        options29 = arguments[0];
      }
      options29 = options29 || {};
      options29.npmrc = options29.npmrc || require_rc()("npm", { registry: "https://registry.npmjs.org/" });
      checkUrl = checkUrl || options29.npmrc.registry;
      return getRegistryAuthInfo(checkUrl, options29) || getLegacyAuthInfo(options29.npmrc);
    };
    function getRegistryAuthInfo(checkUrl, options29) {
      var parsed = url4.parse(checkUrl, false, true);
      var pathname;
      while (pathname !== "/" && parsed.pathname !== pathname) {
        pathname = parsed.pathname || "/";
        var regUrl = "//" + parsed.host + pathname.replace(/\/$/, "");
        var authInfo = getAuthInfoForUrl(regUrl, options29.npmrc);
        if (authInfo) {
          return authInfo;
        }
        if (!options29.recursive) {
          return /\/$/.test(checkUrl) ? void 0 : getRegistryAuthInfo(url4.resolve(checkUrl, "."), options29);
        }
        parsed.pathname = url4.resolve(normalizePath(pathname), "..") || "/";
      }
      return void 0;
    }
    __name(getRegistryAuthInfo, "getRegistryAuthInfo");
    function getLegacyAuthInfo(npmrc) {
      if (npmrc._auth) {
        return { token: npmrc._auth, type: "Basic" };
      }
      return void 0;
    }
    __name(getLegacyAuthInfo, "getLegacyAuthInfo");
    function normalizePath(path67) {
      return path67[path67.length - 1] === "/" ? path67 : path67 + "/";
    }
    __name(normalizePath, "normalizePath");
    function getAuthInfoForUrl(regUrl, npmrc) {
      var bearerAuth = getBearerToken(npmrc[regUrl + tokenKey] || npmrc[regUrl + "/" + tokenKey]);
      if (bearerAuth) {
        return bearerAuth;
      }
      var username = npmrc[regUrl + userKey] || npmrc[regUrl + "/" + userKey];
      var password = npmrc[regUrl + passwordKey] || npmrc[regUrl + "/" + passwordKey];
      var basicAuth = getTokenForUsernameAndPassword(username, password);
      if (basicAuth) {
        return basicAuth;
      }
      return void 0;
    }
    __name(getAuthInfoForUrl, "getAuthInfoForUrl");
    function getBearerToken(tok) {
      if (!tok) {
        return void 0;
      }
      var token = tok.replace(/^\$\{?([^}]*)\}?$/, function(fullMatch, envVar) {
        return process.env[envVar];
      });
      return { token, type: "Bearer" };
    }
    __name(getBearerToken, "getBearerToken");
    function getTokenForUsernameAndPassword(username, password) {
      if (!username || !password) {
        return void 0;
      }
      var pass = decodeBase64(password.replace(/^\$\{?([^}]*)\}?$/, function(fullMatch, envVar) {
        return process.env[envVar];
      }));
      var token = encodeBase64(username + ":" + pass);
      return {
        token,
        type: "Basic",
        password: pass,
        username
      };
    }
    __name(getTokenForUsernameAndPassword, "getTokenForUsernameAndPassword");
  }
});

// ../../node_modules/.pnpm/update-check@1.5.4/node_modules/update-check/index.js
var require_update_check = __commonJS({
  "../../node_modules/.pnpm/update-check@1.5.4/node_modules/update-check/index.js"(exports2, module3) {
    init_import_meta_url();
    var { URL: URL7 } = require("url");
    var { join: join15 } = require("path");
    var fs26 = require("fs");
    var { promisify: promisify2 } = require("util");
    var { tmpdir } = require("os");
    var registryUrl = require_registry_url();
    var writeFile6 = promisify2(fs26.writeFile);
    var mkdir6 = promisify2(fs26.mkdir);
    var readFile11 = promisify2(fs26.readFile);
    var compareVersions = /* @__PURE__ */ __name((a, b2) => a.localeCompare(b2, "en-US", { numeric: true }), "compareVersions");
    var encode = /* @__PURE__ */ __name((value) => encodeURIComponent(value).replace(/^%40/, "@"), "encode");
    var getFile = /* @__PURE__ */ __name(async (details, distTag) => {
      const rootDir = tmpdir();
      const subDir = join15(rootDir, "update-check");
      if (!fs26.existsSync(subDir)) {
        await mkdir6(subDir);
      }
      let name = `${details.name}-${distTag}.json`;
      if (details.scope) {
        name = `${details.scope}-${name}`;
      }
      return join15(subDir, name);
    }, "getFile");
    var evaluateCache = /* @__PURE__ */ __name(async (file, time, interval2) => {
      if (fs26.existsSync(file)) {
        const content = await readFile11(file, "utf8");
        const { lastUpdate, latest } = JSON.parse(content);
        const nextCheck = lastUpdate + interval2;
        if (nextCheck > time) {
          return {
            shouldCheck: false,
            latest
          };
        }
      }
      return {
        shouldCheck: true,
        latest: null
      };
    }, "evaluateCache");
    var updateCache = /* @__PURE__ */ __name(async (file, latest, lastUpdate) => {
      const content = JSON.stringify({
        latest,
        lastUpdate
      });
      await writeFile6(file, content, "utf8");
    }, "updateCache");
    var loadPackage = /* @__PURE__ */ __name((url4, authInfo) => new Promise((resolve19, reject) => {
      const options29 = {
        host: url4.hostname,
        path: url4.pathname,
        port: url4.port,
        headers: {
          accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*"
        },
        timeout: 2e3
      };
      if (authInfo) {
        options29.headers.authorization = `${authInfo.type} ${authInfo.token}`;
      }
      const { get } = url4.protocol === "https:" ? require("https") : require("http");
      get(options29, (response) => {
        const { statusCode } = response;
        if (statusCode !== 200) {
          const error2 = new Error(`Request failed with code ${statusCode}`);
          error2.code = statusCode;
          reject(error2);
          response.resume();
          return;
        }
        let rawData = "";
        response.setEncoding("utf8");
        response.on("data", (chunk) => {
          rawData += chunk;
        });
        response.on("end", () => {
          try {
            const parsedData = JSON.parse(rawData);
            resolve19(parsedData);
          } catch (e3) {
            reject(e3);
          }
        });
      }).on("error", reject).on("timeout", reject);
    }), "loadPackage");
    var getMostRecent = /* @__PURE__ */ __name(async ({ full, scope }, distTag) => {
      const regURL = registryUrl(scope);
      const url4 = new URL7(full, regURL);
      let spec = null;
      try {
        spec = await loadPackage(url4);
      } catch (err) {
        if (err.code && String(err.code).startsWith(4)) {
          const registryAuthToken = require_registry_auth_token();
          const authInfo = registryAuthToken(regURL, { recursive: true });
          spec = await loadPackage(url4, authInfo);
        } else {
          throw err;
        }
      }
      const version3 = spec["dist-tags"][distTag];
      if (!version3) {
        throw new Error(`Distribution tag ${distTag} is not available`);
      }
      return version3;
    }, "getMostRecent");
    var defaultConfig = {
      interval: 36e5,
      distTag: "latest"
    };
    var getDetails = /* @__PURE__ */ __name((name) => {
      const spec = {
        full: encode(name)
      };
      if (name.includes("/")) {
        const parts = name.split("/");
        spec.scope = parts[0];
        spec.name = parts[1];
      } else {
        spec.scope = null;
        spec.name = name;
      }
      return spec;
    }, "getDetails");
    module3.exports = async (pkg, config) => {
      if (typeof pkg !== "object") {
        throw new Error("The first parameter should be your package.json file content");
      }
      const details = getDetails(pkg.name);
      const time = Date.now();
      const { distTag, interval: interval2 } = Object.assign({}, defaultConfig, config);
      const file = await getFile(details, distTag);
      let latest = null;
      let shouldCheck = true;
      ({ shouldCheck, latest } = await evaluateCache(file, time, interval2));
      if (shouldCheck) {
        latest = await getMostRecent(details, distTag);
        await updateCache(file, latest, time);
      }
      const comparision = compareVersions(pkg.version, latest);
      if (comparision === -1) {
        return {
          latest,
          fromCache: !shouldCheck
        };
      }
      return null;
    };
  }
});

// ../pages-shared/metadata-generator/constants.ts
var REDIRECTS_VERSION, HEADERS_VERSION, ANALYTICS_VERSION, PERMITTED_STATUS_CODES, HEADER_SEPARATOR, MAX_LINE_LENGTH, MAX_HEADER_RULES, MAX_DYNAMIC_REDIRECT_RULES, MAX_STATIC_REDIRECT_RULES, UNSET_OPERATOR, SPLAT_REGEX, PLACEHOLDER_REGEX;
var init_constants = __esm({
  "../pages-shared/metadata-generator/constants.ts"() {
    init_import_meta_url();
    REDIRECTS_VERSION = 1;
    HEADERS_VERSION = 2;
    ANALYTICS_VERSION = 1;
    PERMITTED_STATUS_CODES = /* @__PURE__ */ new Set([200, 301, 302, 303, 307, 308]);
    HEADER_SEPARATOR = ":";
    MAX_LINE_LENGTH = 2e3;
    MAX_HEADER_RULES = 100;
    MAX_DYNAMIC_REDIRECT_RULES = 100;
    MAX_STATIC_REDIRECT_RULES = 2e3;
    UNSET_OPERATOR = "! ";
    SPLAT_REGEX = /\*/g;
    PLACEHOLDER_REGEX = /:[A-Za-z]\w*/g;
  }
});

// ../pages-shared/metadata-generator/createMetadataObject.ts
function createMetadataObject({
  redirects,
  headers,
  webAnalyticsToken,
  deploymentId,
  failOpen,
  logger: logger3 = noopLogger
}) {
  return {
    ...constructRedirects({ redirects, logger: logger3 }),
    ...constructHeaders({ headers, logger: logger3 }),
    ...constructWebAnalytics({ webAnalyticsToken, logger: logger3 }),
    deploymentId,
    failOpen
  };
}
function constructRedirects({
  redirects,
  logger: logger3
}) {
  if (!redirects)
    return {};
  const num_valid = redirects.rules.length;
  const num_invalid = redirects.invalid.length;
  logger3.log(
    `Parsed ${num_valid} valid redirect rule${num_valid === 1 ? "" : "s"}.`
  );
  if (num_invalid > 0) {
    logger3.warn(`Found invalid redirect lines:`);
    for (const { line, lineNumber, message } of redirects.invalid) {
      if (line) {
        logger3.warn(`  - ${lineNumber ? `#${lineNumber}: ` : ""}${line}`);
      }
      logger3.warn(`    ${message}`);
    }
  }
  if (num_valid === 0) {
    return {};
  }
  const staticRedirects = {};
  const dynamicRedirects = {};
  let canCreateStaticRule = true;
  for (const rule of redirects.rules) {
    if (!rule.from.match(SPLAT_REGEX) && !rule.from.match(PLACEHOLDER_REGEX)) {
      if (canCreateStaticRule) {
        staticRedirects[rule.from] = {
          status: rule.status,
          to: rule.to,
          lineNumber: rule.lineNumber
        };
        continue;
      } else {
        logger3.info(
          `The redirect rule ${rule.from} \u2192 ${rule.status} ${rule.to} could be made more performant by bringing it above any lines with splats or placeholders.`
        );
      }
    }
    dynamicRedirects[rule.from] = { status: rule.status, to: rule.to };
    canCreateStaticRule = false;
  }
  return {
    redirects: {
      version: REDIRECTS_VERSION,
      staticRules: staticRedirects,
      rules: dynamicRedirects
    }
  };
}
function constructHeaders({
  headers,
  logger: logger3
}) {
  if (!headers)
    return {};
  const num_valid = headers.rules.length;
  const num_invalid = headers.invalid.length;
  logger3.log(
    `Parsed ${num_valid} valid header rule${num_valid === 1 ? "" : "s"}.`
  );
  if (num_invalid > 0) {
    logger3.warn(`Found invalid header lines:`);
    for (const { line, lineNumber, message } of headers.invalid) {
      if (line) {
        logger3.warn(`  - ${lineNumber ? `#${lineNumber}: ` : ""} ${line}`);
      }
      logger3.warn(`    ${message}`);
    }
  }
  if (num_valid === 0) {
    return {};
  }
  const rules = {};
  for (const rule of headers.rules) {
    rules[rule.path] = {};
    if (Object.keys(rule.headers).length) {
      rules[rule.path].set = rule.headers;
    }
    if (rule.unsetHeaders.length) {
      rules[rule.path].unset = rule.unsetHeaders;
    }
  }
  return {
    headers: {
      version: HEADERS_VERSION,
      rules
    }
  };
}
function constructWebAnalytics({
  webAnalyticsToken
}) {
  if (!webAnalyticsToken)
    return {};
  return {
    analytics: {
      version: ANALYTICS_VERSION,
      token: webAnalyticsToken
    }
  };
}
var noopLogger;
var init_createMetadataObject = __esm({
  "../pages-shared/metadata-generator/createMetadataObject.ts"() {
    init_import_meta_url();
    init_constants();
    noopLogger = {
      debug: (_message) => {
      },
      log: (_message) => {
      },
      info: (_message) => {
      },
      warn: (_message) => {
      },
      error: (_error) => {
      }
    };
    __name(createMetadataObject, "createMetadataObject");
    __name(constructRedirects, "constructRedirects");
    __name(constructHeaders, "constructHeaders");
    __name(constructWebAnalytics, "constructWebAnalytics");
  }
});

// ../pages-shared/metadata-generator/validateURL.ts
function urlHasHost(token) {
  const host = URL_REGEX.exec(token);
  return Boolean(host && host.groups && host.groups.host);
}
var extractPathname, URL_REGEX, HOST_WITH_PORT_REGEX, PATH_REGEX, validateUrl;
var init_validateURL = __esm({
  "../pages-shared/metadata-generator/validateURL.ts"() {
    init_import_meta_url();
    extractPathname = /* @__PURE__ */ __name((path67 = "/", includeSearch, includeHash) => {
      if (!path67.startsWith("/"))
        path67 = `/${path67}`;
      const url4 = new URL(`//${path67}`, "relative://");
      return `${url4.pathname}${includeSearch ? url4.search : ""}${includeHash ? url4.hash : ""}`;
    }, "extractPathname");
    URL_REGEX = /^https:\/\/+(?<host>[^/]+)\/?(?<path>.*)/;
    HOST_WITH_PORT_REGEX = /.*:\d+$/;
    PATH_REGEX = /^\//;
    validateUrl = /* @__PURE__ */ __name((token, onlyRelative = false, disallowPorts = false, includeSearch = false, includeHash = false) => {
      const host = URL_REGEX.exec(token);
      if (host && host.groups && host.groups.host) {
        if (onlyRelative)
          return [
            void 0,
            `Only relative URLs are allowed. Skipping absolute URL ${token}.`
          ];
        if (disallowPorts && host.groups.host.match(HOST_WITH_PORT_REGEX)) {
          return [
            void 0,
            `Specifying ports is not supported. Skipping absolute URL ${token}.`
          ];
        }
        return [
          `https://${host.groups.host}${extractPathname(
            host.groups.path,
            includeSearch,
            includeHash
          )}`,
          void 0
        ];
      } else {
        if (!token.startsWith("/") && onlyRelative)
          token = `/${token}`;
        const path67 = PATH_REGEX.exec(token);
        if (path67) {
          try {
            return [extractPathname(token, includeSearch, includeHash), void 0];
          } catch {
            return [void 0, `Error parsing URL segment ${token}. Skipping.`];
          }
        }
      }
      return [
        void 0,
        onlyRelative ? "URLs should begin with a forward-slash." : 'URLs should either be relative (e.g. begin with a forward-slash), or use HTTPS (e.g. begin with "https://").'
      ];
    }, "validateUrl");
    __name(urlHasHost, "urlHasHost");
  }
});

// ../pages-shared/metadata-generator/parseHeaders.ts
function parseHeaders(input) {
  const lines = input.split("\n");
  const rules = [];
  const invalid = [];
  let rule = void 0;
  for (let i = 0; i < lines.length; i++) {
    const line = lines[i].trim();
    if (line.length === 0 || line.startsWith("#"))
      continue;
    if (line.length > MAX_LINE_LENGTH) {
      invalid.push({
        message: `Ignoring line ${i + 1} as it exceeds the maximum allowed length of ${MAX_LINE_LENGTH}.`
      });
      continue;
    }
    if (LINE_IS_PROBABLY_A_PATH.test(line)) {
      if (rules.length >= MAX_HEADER_RULES) {
        invalid.push({
          message: `Maximum number of rules supported is ${MAX_HEADER_RULES}. Skipping remaining ${lines.length - i} lines of file.`
        });
        break;
      }
      if (rule) {
        if (isValidRule(rule)) {
          rules.push({
            path: rule.path,
            headers: rule.headers,
            unsetHeaders: rule.unsetHeaders
          });
        } else {
          invalid.push({
            line: rule.line,
            lineNumber: i + 1,
            message: "No headers specified"
          });
        }
      }
      const [path67, pathError] = validateUrl(line, false, true);
      if (pathError) {
        invalid.push({
          line,
          lineNumber: i + 1,
          message: pathError
        });
        rule = void 0;
        continue;
      }
      rule = {
        path: path67,
        line,
        headers: {},
        unsetHeaders: []
      };
      continue;
    }
    if (!line.includes(HEADER_SEPARATOR)) {
      if (!rule) {
        invalid.push({
          line,
          lineNumber: i + 1,
          message: "Expected a path beginning with at least one forward-slash"
        });
      } else {
        if (line.trim().startsWith(UNSET_OPERATOR)) {
          rule.unsetHeaders.push(line.trim().replace(UNSET_OPERATOR, ""));
        } else {
          invalid.push({
            line,
            lineNumber: i + 1,
            message: "Expected a colon-separated header pair (e.g. name: value)"
          });
        }
      }
      continue;
    }
    const [rawName, ...rawValue] = line.split(HEADER_SEPARATOR);
    const name = rawName.trim().toLowerCase();
    if (name.includes(" ")) {
      invalid.push({
        line,
        lineNumber: i + 1,
        message: "Header name cannot include spaces"
      });
      continue;
    }
    const value = rawValue.join(HEADER_SEPARATOR).trim();
    if (name === "") {
      invalid.push({
        line,
        lineNumber: i + 1,
        message: "No header name specified"
      });
      continue;
    }
    if (value === "") {
      invalid.push({
        line,
        lineNumber: i + 1,
        message: "No header value specified"
      });
      continue;
    }
    if (!rule) {
      invalid.push({
        line,
        lineNumber: i + 1,
        message: `Path should come before header (${name}: ${value})`
      });
      continue;
    }
    const existingValues = rule.headers[name];
    rule.headers[name] = existingValues ? `${existingValues}, ${value}` : value;
  }
  if (rule) {
    if (isValidRule(rule)) {
      rules.push({
        path: rule.path,
        headers: rule.headers,
        unsetHeaders: rule.unsetHeaders
      });
    } else {
      invalid.push({ line: rule.line, message: "No headers specified" });
    }
  }
  return {
    rules,
    invalid
  };
}
function isValidRule(rule) {
  return Object.keys(rule.headers).length > 0 || rule.unsetHeaders.length > 0;
}
var LINE_IS_PROBABLY_A_PATH;
var init_parseHeaders = __esm({
  "../pages-shared/metadata-generator/parseHeaders.ts"() {
    init_import_meta_url();
    init_constants();
    init_validateURL();
    LINE_IS_PROBABLY_A_PATH = new RegExp(/^([^\s]+:\/\/|^\/)/);
    __name(parseHeaders, "parseHeaders");
    __name(isValidRule, "isValidRule");
  }
});

// ../pages-shared/metadata-generator/parseRedirects.ts
function parseRedirects(input) {
  const lines = input.split("\n");
  const rules = [];
  const seen_paths = /* @__PURE__ */ new Set();
  const invalid = [];
  let staticRules = 0;
  let dynamicRules = 0;
  let canCreateStaticRule = true;
  for (let i = 0; i < lines.length; i++) {
    const line = lines[i].trim();
    if (line.length === 0 || line.startsWith("#"))
      continue;
    if (line.length > MAX_LINE_LENGTH) {
      invalid.push({
        message: `Ignoring line ${i + 1} as it exceeds the maximum allowed length of ${MAX_LINE_LENGTH}.`
      });
      continue;
    }
    const tokens = line.split(/\s+/);
    if (tokens.length < 2 || tokens.length > 3) {
      invalid.push({
        line,
        lineNumber: i + 1,
        message: `Expected exactly 2 or 3 whitespace-separated tokens. Got ${tokens.length}.`
      });
      continue;
    }
    const [str_from, str_to, str_status = "302"] = tokens;
    const fromResult = validateUrl(str_from, true, true, false, false);
    if (fromResult[0] === void 0) {
      invalid.push({
        line,
        lineNumber: i + 1,
        message: fromResult[1]
      });
      continue;
    }
    const from = fromResult[0];
    if (canCreateStaticRule && !from.match(SPLAT_REGEX) && !from.match(PLACEHOLDER_REGEX)) {
      staticRules += 1;
      if (staticRules > MAX_STATIC_REDIRECT_RULES) {
        invalid.push({
          message: `Maximum number of static rules supported is ${MAX_STATIC_REDIRECT_RULES}. Skipping line.`
        });
        continue;
      }
    } else {
      dynamicRules += 1;
      canCreateStaticRule = false;
      if (dynamicRules > MAX_DYNAMIC_REDIRECT_RULES) {
        invalid.push({
          message: `Maximum number of dynamic rules supported is ${MAX_DYNAMIC_REDIRECT_RULES}. Skipping remaining ${lines.length - i} lines of file.`
        });
        break;
      }
    }
    const toResult = validateUrl(str_to, false, false, true, true);
    if (toResult[0] === void 0) {
      invalid.push({
        line,
        lineNumber: i + 1,
        message: toResult[1]
      });
      continue;
    }
    const to = toResult[0];
    const status2 = Number(str_status);
    if (isNaN(status2) || !PERMITTED_STATUS_CODES.has(status2)) {
      invalid.push({
        line,
        lineNumber: i + 1,
        message: `Valid status codes are 200, 301, 302 (default), 303, 307, or 308. Got ${str_status}.`
      });
      continue;
    }
    if (/\/\*?$/.test(from) && /\/index(.html)?$/.test(to) && !urlHasHost(to)) {
      invalid.push({
        line,
        lineNumber: i + 1,
        message: "Infinite loop detected in this rule and has been ignored. This will cause a redirect to strip `.html` or `/index` and end up triggering this rule again. Please fix or remove this rule to silence this warning."
      });
      continue;
    }
    if (seen_paths.has(from)) {
      invalid.push({
        line,
        lineNumber: i + 1,
        message: `Ignoring duplicate rule for path ${from}.`
      });
      continue;
    }
    seen_paths.add(from);
    if (status2 === 200) {
      if (urlHasHost(to)) {
        invalid.push({
          line,
          lineNumber: i + 1,
          message: `Proxy (200) redirects can only point to relative paths. Got ${to}`
        });
        continue;
      }
    }
    rules.push({ from, to, status: status2, lineNumber: i + 1 });
  }
  return {
    rules,
    invalid
  };
}
var init_parseRedirects = __esm({
  "../pages-shared/metadata-generator/parseRedirects.ts"() {
    init_import_meta_url();
    init_constants();
    init_validateURL();
    __name(parseRedirects, "parseRedirects");
  }
});

// ../../node_modules/.pnpm/mime@3.0.0/node_modules/mime/Mime.js
var require_Mime = __commonJS({
  "../../node_modules/.pnpm/mime@3.0.0/node_modules/mime/Mime.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    function Mime() {
      this._types = /* @__PURE__ */ Object.create(null);
      this._extensions = /* @__PURE__ */ Object.create(null);
      for (let i = 0; i < arguments.length; i++) {
        this.define(arguments[i]);
      }
      this.define = this.define.bind(this);
      this.getType = this.getType.bind(this);
      this.getExtension = this.getExtension.bind(this);
    }
    __name(Mime, "Mime");
    Mime.prototype.define = function(typeMap, force) {
      for (let type in typeMap) {
        let extensions = typeMap[type].map(function(t3) {
          return t3.toLowerCase();
        });
        type = type.toLowerCase();
        for (let i = 0; i < extensions.length; i++) {
          const ext = extensions[i];
          if (ext[0] === "*") {
            continue;
          }
          if (!force && ext in this._types) {
            throw new Error(
              'Attempt to change mapping for "' + ext + '" extension from "' + this._types[ext] + '" to "' + type + '". Pass `force=true` to allow this, otherwise remove "' + ext + '" from the list of extensions for "' + type + '".'
            );
          }
          this._types[ext] = type;
        }
        if (force || !this._extensions[type]) {
          const ext = extensions[0];
          this._extensions[type] = ext[0] !== "*" ? ext : ext.substr(1);
        }
      }
    };
    Mime.prototype.getType = function(path67) {
      path67 = String(path67);
      let last = path67.replace(/^.*[/\\]/, "").toLowerCase();
      let ext = last.replace(/^.*\./, "").toLowerCase();
      let hasPath = last.length < path67.length;
      let hasDot = ext.length < last.length - 1;
      return (hasDot || !hasPath) && this._types[ext] || null;
    };
    Mime.prototype.getExtension = function(type) {
      type = /^\s*([^;\s]*)/.test(type) && RegExp.$1;
      return type && this._extensions[type.toLowerCase()] || null;
    };
    module3.exports = Mime;
  }
});

// ../../node_modules/.pnpm/mime@3.0.0/node_modules/mime/types/standard.js
var require_standard = __commonJS({
  "../../node_modules/.pnpm/mime@3.0.0/node_modules/mime/types/standard.js"(exports2, module3) {
    init_import_meta_url();
    module3.exports = { "application/andrew-inset": ["ez"], "application/applixware": ["aw"], "application/atom+xml": ["atom"], "application/atomcat+xml": ["atomcat"], "application/atomdeleted+xml": ["atomdeleted"], "application/atomsvc+xml": ["atomsvc"], "application/atsc-dwd+xml": ["dwd"], "application/atsc-held+xml": ["held"], "application/atsc-rsat+xml": ["rsat"], "application/bdoc": ["bdoc"], "application/calendar+xml": ["xcs"], "application/ccxml+xml": ["ccxml"], "application/cdfx+xml": ["cdfx"], "application/cdmi-capability": ["cdmia"], "application/cdmi-container": ["cdmic"], "application/cdmi-domain": ["cdmid"], "application/cdmi-object": ["cdmio"], "application/cdmi-queue": ["cdmiq"], "application/cu-seeme": ["cu"], "application/dash+xml": ["mpd"], "application/davmount+xml": ["davmount"], "application/docbook+xml": ["dbk"], "application/dssc+der": ["dssc"], "application/dssc+xml": ["xdssc"], "application/ecmascript": ["es", "ecma"], "application/emma+xml": ["emma"], "application/emotionml+xml": ["emotionml"], "application/epub+zip": ["epub"], "application/exi": ["exi"], "application/express": ["exp"], "application/fdt+xml": ["fdt"], "application/font-tdpfr": ["pfr"], "application/geo+json": ["geojson"], "application/gml+xml": ["gml"], "application/gpx+xml": ["gpx"], "application/gxf": ["gxf"], "application/gzip": ["gz"], "application/hjson": ["hjson"], "application/hyperstudio": ["stk"], "application/inkml+xml": ["ink", "inkml"], "application/ipfix": ["ipfix"], "application/its+xml": ["its"], "application/java-archive": ["jar", "war", "ear"], "application/java-serialized-object": ["ser"], "application/java-vm": ["class"], "application/javascript": ["js", "mjs"], "application/json": ["json", "map"], "application/json5": ["json5"], "application/jsonml+json": ["jsonml"], "application/ld+json": ["jsonld"], "application/lgr+xml": ["lgr"], "application/lost+xml": ["lostxml"], "application/mac-binhex40": ["hqx"], "application/mac-compactpro": ["cpt"], "application/mads+xml": ["mads"], "application/manifest+json": ["webmanifest"], "application/marc": ["mrc"], "application/marcxml+xml": ["mrcx"], "application/mathematica": ["ma", "nb", "mb"], "application/mathml+xml": ["mathml"], "application/mbox": ["mbox"], "application/mediaservercontrol+xml": ["mscml"], "application/metalink+xml": ["metalink"], "application/metalink4+xml": ["meta4"], "application/mets+xml": ["mets"], "application/mmt-aei+xml": ["maei"], "application/mmt-usd+xml": ["musd"], "application/mods+xml": ["mods"], "application/mp21": ["m21", "mp21"], "application/mp4": ["mp4s", "m4p"], "application/msword": ["doc", "dot"], "application/mxf": ["mxf"], "application/n-quads": ["nq"], "application/n-triples": ["nt"], "application/node": ["cjs"], "application/octet-stream": ["bin", "dms", "lrf", "mar", "so", "dist", "distz", "pkg", "bpk", "dump", "elc", "deploy", "exe", "dll", "deb", "dmg", "iso", "img", "msi", "msp", "msm", "buffer"], "application/oda": ["oda"], "application/oebps-package+xml": ["opf"], "application/ogg": ["ogx"], "application/omdoc+xml": ["omdoc"], "application/onenote": ["onetoc", "onetoc2", "onetmp", "onepkg"], "application/oxps": ["oxps"], "application/p2p-overlay+xml": ["relo"], "application/patch-ops-error+xml": ["xer"], "application/pdf": ["pdf"], "application/pgp-encrypted": ["pgp"], "application/pgp-signature": ["asc", "sig"], "application/pics-rules": ["prf"], "application/pkcs10": ["p10"], "application/pkcs7-mime": ["p7m", "p7c"], "application/pkcs7-signature": ["p7s"], "application/pkcs8": ["p8"], "application/pkix-attr-cert": ["ac"], "application/pkix-cert": ["cer"], "application/pkix-crl": ["crl"], "application/pkix-pkipath": ["pkipath"], "application/pkixcmp": ["pki"], "application/pls+xml": ["pls"], "application/postscript": ["ai", "eps", "ps"], "application/provenance+xml": ["provx"], "application/pskc+xml": ["pskcxml"], "application/raml+yaml": ["raml"], "application/rdf+xml": ["rdf", "owl"], "application/reginfo+xml": ["rif"], "application/relax-ng-compact-syntax": ["rnc"], "application/resource-lists+xml": ["rl"], "application/resource-lists-diff+xml": ["rld"], "application/rls-services+xml": ["rs"], "application/route-apd+xml": ["rapd"], "application/route-s-tsid+xml": ["sls"], "application/route-usd+xml": ["rusd"], "application/rpki-ghostbusters": ["gbr"], "application/rpki-manifest": ["mft"], "application/rpki-roa": ["roa"], "application/rsd+xml": ["rsd"], "application/rss+xml": ["rss"], "application/rtf": ["rtf"], "application/sbml+xml": ["sbml"], "application/scvp-cv-request": ["scq"], "application/scvp-cv-response": ["scs"], "application/scvp-vp-request": ["spq"], "application/scvp-vp-response": ["spp"], "application/sdp": ["sdp"], "application/senml+xml": ["senmlx"], "application/sensml+xml": ["sensmlx"], "application/set-payment-initiation": ["setpay"], "application/set-registration-initiation": ["setreg"], "application/shf+xml": ["shf"], "application/sieve": ["siv", "sieve"], "application/smil+xml": ["smi", "smil"], "application/sparql-query": ["rq"], "application/sparql-results+xml": ["srx"], "application/srgs": ["gram"], "application/srgs+xml": ["grxml"], "application/sru+xml": ["sru"], "application/ssdl+xml": ["ssdl"], "application/ssml+xml": ["ssml"], "application/swid+xml": ["swidtag"], "application/tei+xml": ["tei", "teicorpus"], "application/thraud+xml": ["tfi"], "application/timestamped-data": ["tsd"], "application/toml": ["toml"], "application/trig": ["trig"], "application/ttml+xml": ["ttml"], "application/ubjson": ["ubj"], "application/urc-ressheet+xml": ["rsheet"], "application/urc-targetdesc+xml": ["td"], "application/voicexml+xml": ["vxml"], "application/wasm": ["wasm"], "application/widget": ["wgt"], "application/winhlp": ["hlp"], "application/wsdl+xml": ["wsdl"], "application/wspolicy+xml": ["wspolicy"], "application/xaml+xml": ["xaml"], "application/xcap-att+xml": ["xav"], "application/xcap-caps+xml": ["xca"], "application/xcap-diff+xml": ["xdf"], "application/xcap-el+xml": ["xel"], "application/xcap-ns+xml": ["xns"], "application/xenc+xml": ["xenc"], "application/xhtml+xml": ["xhtml", "xht"], "application/xliff+xml": ["xlf"], "application/xml": ["xml", "xsl", "xsd", "rng"], "application/xml-dtd": ["dtd"], "application/xop+xml": ["xop"], "application/xproc+xml": ["xpl"], "application/xslt+xml": ["*xsl", "xslt"], "application/xspf+xml": ["xspf"], "application/xv+xml": ["mxml", "xhvml", "xvml", "xvm"], "application/yang": ["yang"], "application/yin+xml": ["yin"], "application/zip": ["zip"], "audio/3gpp": ["*3gpp"], "audio/adpcm": ["adp"], "audio/amr": ["amr"], "audio/basic": ["au", "snd"], "audio/midi": ["mid", "midi", "kar", "rmi"], "audio/mobile-xmf": ["mxmf"], "audio/mp3": ["*mp3"], "audio/mp4": ["m4a", "mp4a"], "audio/mpeg": ["mpga", "mp2", "mp2a", "mp3", "m2a", "m3a"], "audio/ogg": ["oga", "ogg", "spx", "opus"], "audio/s3m": ["s3m"], "audio/silk": ["sil"], "audio/wav": ["wav"], "audio/wave": ["*wav"], "audio/webm": ["weba"], "audio/xm": ["xm"], "font/collection": ["ttc"], "font/otf": ["otf"], "font/ttf": ["ttf"], "font/woff": ["woff"], "font/woff2": ["woff2"], "image/aces": ["exr"], "image/apng": ["apng"], "image/avif": ["avif"], "image/bmp": ["bmp"], "image/cgm": ["cgm"], "image/dicom-rle": ["drle"], "image/emf": ["emf"], "image/fits": ["fits"], "image/g3fax": ["g3"], "image/gif": ["gif"], "image/heic": ["heic"], "image/heic-sequence": ["heics"], "image/heif": ["heif"], "image/heif-sequence": ["heifs"], "image/hej2k": ["hej2"], "image/hsj2": ["hsj2"], "image/ief": ["ief"], "image/jls": ["jls"], "image/jp2": ["jp2", "jpg2"], "image/jpeg": ["jpeg", "jpg", "jpe"], "image/jph": ["jph"], "image/jphc": ["jhc"], "image/jpm": ["jpm"], "image/jpx": ["jpx", "jpf"], "image/jxr": ["jxr"], "image/jxra": ["jxra"], "image/jxrs": ["jxrs"], "image/jxs": ["jxs"], "image/jxsc": ["jxsc"], "image/jxsi": ["jxsi"], "image/jxss": ["jxss"], "image/ktx": ["ktx"], "image/ktx2": ["ktx2"], "image/png": ["png"], "image/sgi": ["sgi"], "image/svg+xml": ["svg", "svgz"], "image/t38": ["t38"], "image/tiff": ["tif", "tiff"], "image/tiff-fx": ["tfx"], "image/webp": ["webp"], "image/wmf": ["wmf"], "message/disposition-notification": ["disposition-notification"], "message/global": ["u8msg"], "message/global-delivery-status": ["u8dsn"], "message/global-disposition-notification": ["u8mdn"], "message/global-headers": ["u8hdr"], "message/rfc822": ["eml", "mime"], "model/3mf": ["3mf"], "model/gltf+json": ["gltf"], "model/gltf-binary": ["glb"], "model/iges": ["igs", "iges"], "model/mesh": ["msh", "mesh", "silo"], "model/mtl": ["mtl"], "model/obj": ["obj"], "model/step+xml": ["stpx"], "model/step+zip": ["stpz"], "model/step-xml+zip": ["stpxz"], "model/stl": ["stl"], "model/vrml": ["wrl", "vrml"], "model/x3d+binary": ["*x3db", "x3dbz"], "model/x3d+fastinfoset": ["x3db"], "model/x3d+vrml": ["*x3dv", "x3dvz"], "model/x3d+xml": ["x3d", "x3dz"], "model/x3d-vrml": ["x3dv"], "text/cache-manifest": ["appcache", "manifest"], "text/calendar": ["ics", "ifb"], "text/coffeescript": ["coffee", "litcoffee"], "text/css": ["css"], "text/csv": ["csv"], "text/html": ["html", "htm", "shtml"], "text/jade": ["jade"], "text/jsx": ["jsx"], "text/less": ["less"], "text/markdown": ["markdown", "md"], "text/mathml": ["mml"], "text/mdx": ["mdx"], "text/n3": ["n3"], "text/plain": ["txt", "text", "conf", "def", "list", "log", "in", "ini"], "text/richtext": ["rtx"], "text/rtf": ["*rtf"], "text/sgml": ["sgml", "sgm"], "text/shex": ["shex"], "text/slim": ["slim", "slm"], "text/spdx": ["spdx"], "text/stylus": ["stylus", "styl"], "text/tab-separated-values": ["tsv"], "text/troff": ["t", "tr", "roff", "man", "me", "ms"], "text/turtle": ["ttl"], "text/uri-list": ["uri", "uris", "urls"], "text/vcard": ["vcard"], "text/vtt": ["vtt"], "text/xml": ["*xml"], "text/yaml": ["yaml", "yml"], "video/3gpp": ["3gp", "3gpp"], "video/3gpp2": ["3g2"], "video/h261": ["h261"], "video/h263": ["h263"], "video/h264": ["h264"], "video/iso.segment": ["m4s"], "video/jpeg": ["jpgv"], "video/jpm": ["*jpm", "jpgm"], "video/mj2": ["mj2", "mjp2"], "video/mp2t": ["ts"], "video/mp4": ["mp4", "mp4v", "mpg4"], "video/mpeg": ["mpeg", "mpg", "mpe", "m1v", "m2v"], "video/ogg": ["ogv"], "video/quicktime": ["qt", "mov"], "video/webm": ["webm"] };
  }
});

// ../../node_modules/.pnpm/mime@3.0.0/node_modules/mime/types/other.js
var require_other = __commonJS({
  "../../node_modules/.pnpm/mime@3.0.0/node_modules/mime/types/other.js"(exports2, module3) {
    init_import_meta_url();
    module3.exports = { "application/prs.cww": ["cww"], "application/vnd.1000minds.decision-model+xml": ["1km"], "application/vnd.3gpp.pic-bw-large": ["plb"], "application/vnd.3gpp.pic-bw-small": ["psb"], "application/vnd.3gpp.pic-bw-var": ["pvb"], "application/vnd.3gpp2.tcap": ["tcap"], "application/vnd.3m.post-it-notes": ["pwn"], "application/vnd.accpac.simply.aso": ["aso"], "application/vnd.accpac.simply.imp": ["imp"], "application/vnd.acucobol": ["acu"], "application/vnd.acucorp": ["atc", "acutc"], "application/vnd.adobe.air-application-installer-package+zip": ["air"], "application/vnd.adobe.formscentral.fcdt": ["fcdt"], "application/vnd.adobe.fxp": ["fxp", "fxpl"], "application/vnd.adobe.xdp+xml": ["xdp"], "application/vnd.adobe.xfdf": ["xfdf"], "application/vnd.ahead.space": ["ahead"], "application/vnd.airzip.filesecure.azf": ["azf"], "application/vnd.airzip.filesecure.azs": ["azs"], "application/vnd.amazon.ebook": ["azw"], "application/vnd.americandynamics.acc": ["acc"], "application/vnd.amiga.ami": ["ami"], "application/vnd.android.package-archive": ["apk"], "application/vnd.anser-web-certificate-issue-initiation": ["cii"], "application/vnd.anser-web-funds-transfer-initiation": ["fti"], "application/vnd.antix.game-component": ["atx"], "application/vnd.apple.installer+xml": ["mpkg"], "application/vnd.apple.keynote": ["key"], "application/vnd.apple.mpegurl": ["m3u8"], "application/vnd.apple.numbers": ["numbers"], "application/vnd.apple.pages": ["pages"], "application/vnd.apple.pkpass": ["pkpass"], "application/vnd.aristanetworks.swi": ["swi"], "application/vnd.astraea-software.iota": ["iota"], "application/vnd.audiograph": ["aep"], "application/vnd.balsamiq.bmml+xml": ["bmml"], "application/vnd.blueice.multipass": ["mpm"], "application/vnd.bmi": ["bmi"], "application/vnd.businessobjects": ["rep"], "application/vnd.chemdraw+xml": ["cdxml"], "application/vnd.chipnuts.karaoke-mmd": ["mmd"], "application/vnd.cinderella": ["cdy"], "application/vnd.citationstyles.style+xml": ["csl"], "application/vnd.claymore": ["cla"], "application/vnd.cloanto.rp9": ["rp9"], "application/vnd.clonk.c4group": ["c4g", "c4d", "c4f", "c4p", "c4u"], "application/vnd.cluetrust.cartomobile-config": ["c11amc"], "application/vnd.cluetrust.cartomobile-config-pkg": ["c11amz"], "application/vnd.commonspace": ["csp"], "application/vnd.contact.cmsg": ["cdbcmsg"], "application/vnd.cosmocaller": ["cmc"], "application/vnd.crick.clicker": ["clkx"], "application/vnd.crick.clicker.keyboard": ["clkk"], "application/vnd.crick.clicker.palette": ["clkp"], "application/vnd.crick.clicker.template": ["clkt"], "application/vnd.crick.clicker.wordbank": ["clkw"], "application/vnd.criticaltools.wbs+xml": ["wbs"], "application/vnd.ctc-posml": ["pml"], "application/vnd.cups-ppd": ["ppd"], "application/vnd.curl.car": ["car"], "application/vnd.curl.pcurl": ["pcurl"], "application/vnd.dart": ["dart"], "application/vnd.data-vision.rdz": ["rdz"], "application/vnd.dbf": ["dbf"], "application/vnd.dece.data": ["uvf", "uvvf", "uvd", "uvvd"], "application/vnd.dece.ttml+xml": ["uvt", "uvvt"], "application/vnd.dece.unspecified": ["uvx", "uvvx"], "application/vnd.dece.zip": ["uvz", "uvvz"], "application/vnd.denovo.fcselayout-link": ["fe_launch"], "application/vnd.dna": ["dna"], "application/vnd.dolby.mlp": ["mlp"], "application/vnd.dpgraph": ["dpg"], "application/vnd.dreamfactory": ["dfac"], "application/vnd.ds-keypoint": ["kpxx"], "application/vnd.dvb.ait": ["ait"], "application/vnd.dvb.service": ["svc"], "application/vnd.dynageo": ["geo"], "application/vnd.ecowin.chart": ["mag"], "application/vnd.enliven": ["nml"], "application/vnd.epson.esf": ["esf"], "application/vnd.epson.msf": ["msf"], "application/vnd.epson.quickanime": ["qam"], "application/vnd.epson.salt": ["slt"], "application/vnd.epson.ssf": ["ssf"], "application/vnd.eszigno3+xml": ["es3", "et3"], "application/vnd.ezpix-album": ["ez2"], "application/vnd.ezpix-package": ["ez3"], "application/vnd.fdf": ["fdf"], "application/vnd.fdsn.mseed": ["mseed"], "application/vnd.fdsn.seed": ["seed", "dataless"], "application/vnd.flographit": ["gph"], "application/vnd.fluxtime.clip": ["ftc"], "application/vnd.framemaker": ["fm", "frame", "maker", "book"], "application/vnd.frogans.fnc": ["fnc"], "application/vnd.frogans.ltf": ["ltf"], "application/vnd.fsc.weblaunch": ["fsc"], "application/vnd.fujitsu.oasys": ["oas"], "application/vnd.fujitsu.oasys2": ["oa2"], "application/vnd.fujitsu.oasys3": ["oa3"], "application/vnd.fujitsu.oasysgp": ["fg5"], "application/vnd.fujitsu.oasysprs": ["bh2"], "application/vnd.fujixerox.ddd": ["ddd"], "application/vnd.fujixerox.docuworks": ["xdw"], "application/vnd.fujixerox.docuworks.binder": ["xbd"], "application/vnd.fuzzysheet": ["fzs"], "application/vnd.genomatix.tuxedo": ["txd"], "application/vnd.geogebra.file": ["ggb"], "application/vnd.geogebra.tool": ["ggt"], "application/vnd.geometry-explorer": ["gex", "gre"], "application/vnd.geonext": ["gxt"], "application/vnd.geoplan": ["g2w"], "application/vnd.geospace": ["g3w"], "application/vnd.gmx": ["gmx"], "application/vnd.google-apps.document": ["gdoc"], "application/vnd.google-apps.presentation": ["gslides"], "application/vnd.google-apps.spreadsheet": ["gsheet"], "application/vnd.google-earth.kml+xml": ["kml"], "application/vnd.google-earth.kmz": ["kmz"], "application/vnd.grafeq": ["gqf", "gqs"], "application/vnd.groove-account": ["gac"], "application/vnd.groove-help": ["ghf"], "application/vnd.groove-identity-message": ["gim"], "application/vnd.groove-injector": ["grv"], "application/vnd.groove-tool-message": ["gtm"], "application/vnd.groove-tool-template": ["tpl"], "application/vnd.groove-vcard": ["vcg"], "application/vnd.hal+xml": ["hal"], "application/vnd.handheld-entertainment+xml": ["zmm"], "application/vnd.hbci": ["hbci"], "application/vnd.hhe.lesson-player": ["les"], "application/vnd.hp-hpgl": ["hpgl"], "application/vnd.hp-hpid": ["hpid"], "application/vnd.hp-hps": ["hps"], "application/vnd.hp-jlyt": ["jlt"], "application/vnd.hp-pcl": ["pcl"], "application/vnd.hp-pclxl": ["pclxl"], "application/vnd.hydrostatix.sof-data": ["sfd-hdstx"], "application/vnd.ibm.minipay": ["mpy"], "application/vnd.ibm.modcap": ["afp", "listafp", "list3820"], "application/vnd.ibm.rights-management": ["irm"], "application/vnd.ibm.secure-container": ["sc"], "application/vnd.iccprofile": ["icc", "icm"], "application/vnd.igloader": ["igl"], "application/vnd.immervision-ivp": ["ivp"], "application/vnd.immervision-ivu": ["ivu"], "application/vnd.insors.igm": ["igm"], "application/vnd.intercon.formnet": ["xpw", "xpx"], "application/vnd.intergeo": ["i2g"], "application/vnd.intu.qbo": ["qbo"], "application/vnd.intu.qfx": ["qfx"], "application/vnd.ipunplugged.rcprofile": ["rcprofile"], "application/vnd.irepository.package+xml": ["irp"], "application/vnd.is-xpr": ["xpr"], "application/vnd.isac.fcs": ["fcs"], "application/vnd.jam": ["jam"], "application/vnd.jcp.javame.midlet-rms": ["rms"], "application/vnd.jisp": ["jisp"], "application/vnd.joost.joda-archive": ["joda"], "application/vnd.kahootz": ["ktz", "ktr"], "application/vnd.kde.karbon": ["karbon"], "application/vnd.kde.kchart": ["chrt"], "application/vnd.kde.kformula": ["kfo"], "application/vnd.kde.kivio": ["flw"], "application/vnd.kde.kontour": ["kon"], "application/vnd.kde.kpresenter": ["kpr", "kpt"], "application/vnd.kde.kspread": ["ksp"], "application/vnd.kde.kword": ["kwd", "kwt"], "application/vnd.kenameaapp": ["htke"], "application/vnd.kidspiration": ["kia"], "application/vnd.kinar": ["kne", "knp"], "application/vnd.koan": ["skp", "skd", "skt", "skm"], "application/vnd.kodak-descriptor": ["sse"], "application/vnd.las.las+xml": ["lasxml"], "application/vnd.llamagraphics.life-balance.desktop": ["lbd"], "application/vnd.llamagraphics.life-balance.exchange+xml": ["lbe"], "application/vnd.lotus-1-2-3": ["123"], "application/vnd.lotus-approach": ["apr"], "application/vnd.lotus-freelance": ["pre"], "application/vnd.lotus-notes": ["nsf"], "application/vnd.lotus-organizer": ["org"], "application/vnd.lotus-screencam": ["scm"], "application/vnd.lotus-wordpro": ["lwp"], "application/vnd.macports.portpkg": ["portpkg"], "application/vnd.mapbox-vector-tile": ["mvt"], "application/vnd.mcd": ["mcd"], "application/vnd.medcalcdata": ["mc1"], "application/vnd.mediastation.cdkey": ["cdkey"], "application/vnd.mfer": ["mwf"], "application/vnd.mfmp": ["mfm"], "application/vnd.micrografx.flo": ["flo"], "application/vnd.micrografx.igx": ["igx"], "application/vnd.mif": ["mif"], "application/vnd.mobius.daf": ["daf"], "application/vnd.mobius.dis": ["dis"], "application/vnd.mobius.mbk": ["mbk"], "application/vnd.mobius.mqy": ["mqy"], "application/vnd.mobius.msl": ["msl"], "application/vnd.mobius.plc": ["plc"], "application/vnd.mobius.txf": ["txf"], "application/vnd.mophun.application": ["mpn"], "application/vnd.mophun.certificate": ["mpc"], "application/vnd.mozilla.xul+xml": ["xul"], "application/vnd.ms-artgalry": ["cil"], "application/vnd.ms-cab-compressed": ["cab"], "application/vnd.ms-excel": ["xls", "xlm", "xla", "xlc", "xlt", "xlw"], "application/vnd.ms-excel.addin.macroenabled.12": ["xlam"], "application/vnd.ms-excel.sheet.binary.macroenabled.12": ["xlsb"], "application/vnd.ms-excel.sheet.macroenabled.12": ["xlsm"], "application/vnd.ms-excel.template.macroenabled.12": ["xltm"], "application/vnd.ms-fontobject": ["eot"], "application/vnd.ms-htmlhelp": ["chm"], "application/vnd.ms-ims": ["ims"], "application/vnd.ms-lrm": ["lrm"], "application/vnd.ms-officetheme": ["thmx"], "application/vnd.ms-outlook": ["msg"], "application/vnd.ms-pki.seccat": ["cat"], "application/vnd.ms-pki.stl": ["*stl"], "application/vnd.ms-powerpoint": ["ppt", "pps", "pot"], "application/vnd.ms-powerpoint.addin.macroenabled.12": ["ppam"], "application/vnd.ms-powerpoint.presentation.macroenabled.12": ["pptm"], "application/vnd.ms-powerpoint.slide.macroenabled.12": ["sldm"], "application/vnd.ms-powerpoint.slideshow.macroenabled.12": ["ppsm"], "application/vnd.ms-powerpoint.template.macroenabled.12": ["potm"], "application/vnd.ms-project": ["mpp", "mpt"], "application/vnd.ms-word.document.macroenabled.12": ["docm"], "application/vnd.ms-word.template.macroenabled.12": ["dotm"], "application/vnd.ms-works": ["wps", "wks", "wcm", "wdb"], "application/vnd.ms-wpl": ["wpl"], "application/vnd.ms-xpsdocument": ["xps"], "application/vnd.mseq": ["mseq"], "application/vnd.musician": ["mus"], "application/vnd.muvee.style": ["msty"], "application/vnd.mynfc": ["taglet"], "application/vnd.neurolanguage.nlu": ["nlu"], "application/vnd.nitf": ["ntf", "nitf"], "application/vnd.noblenet-directory": ["nnd"], "application/vnd.noblenet-sealer": ["nns"], "application/vnd.noblenet-web": ["nnw"], "application/vnd.nokia.n-gage.ac+xml": ["*ac"], "application/vnd.nokia.n-gage.data": ["ngdat"], "application/vnd.nokia.n-gage.symbian.install": ["n-gage"], "application/vnd.nokia.radio-preset": ["rpst"], "application/vnd.nokia.radio-presets": ["rpss"], "application/vnd.novadigm.edm": ["edm"], "application/vnd.novadigm.edx": ["edx"], "application/vnd.novadigm.ext": ["ext"], "application/vnd.oasis.opendocument.chart": ["odc"], "application/vnd.oasis.opendocument.chart-template": ["otc"], "application/vnd.oasis.opendocument.database": ["odb"], "application/vnd.oasis.opendocument.formula": ["odf"], "application/vnd.oasis.opendocument.formula-template": ["odft"], "application/vnd.oasis.opendocument.graphics": ["odg"], "application/vnd.oasis.opendocument.graphics-template": ["otg"], "application/vnd.oasis.opendocument.image": ["odi"], "application/vnd.oasis.opendocument.image-template": ["oti"], "application/vnd.oasis.opendocument.presentation": ["odp"], "application/vnd.oasis.opendocument.presentation-template": ["otp"], "application/vnd.oasis.opendocument.spreadsheet": ["ods"], "application/vnd.oasis.opendocument.spreadsheet-template": ["ots"], "application/vnd.oasis.opendocument.text": ["odt"], "application/vnd.oasis.opendocument.text-master": ["odm"], "application/vnd.oasis.opendocument.text-template": ["ott"], "application/vnd.oasis.opendocument.text-web": ["oth"], "application/vnd.olpc-sugar": ["xo"], "application/vnd.oma.dd2+xml": ["dd2"], "application/vnd.openblox.game+xml": ["obgx"], "application/vnd.openofficeorg.extension": ["oxt"], "application/vnd.openstreetmap.data+xml": ["osm"], "application/vnd.openxmlformats-officedocument.presentationml.presentation": ["pptx"], "application/vnd.openxmlformats-officedocument.presentationml.slide": ["sldx"], "application/vnd.openxmlformats-officedocument.presentationml.slideshow": ["ppsx"], "application/vnd.openxmlformats-officedocument.presentationml.template": ["potx"], "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ["xlsx"], "application/vnd.openxmlformats-officedocument.spreadsheetml.template": ["xltx"], "application/vnd.openxmlformats-officedocument.wordprocessingml.document": ["docx"], "application/vnd.openxmlformats-officedocument.wordprocessingml.template": ["dotx"], "application/vnd.osgeo.mapguide.package": ["mgp"], "application/vnd.osgi.dp": ["dp"], "application/vnd.osgi.subsystem": ["esa"], "application/vnd.palm": ["pdb", "pqa", "oprc"], "application/vnd.pawaafile": ["paw"], "application/vnd.pg.format": ["str"], "application/vnd.pg.osasli": ["ei6"], "application/vnd.picsel": ["efif"], "application/vnd.pmi.widget": ["wg"], "application/vnd.pocketlearn": ["plf"], "application/vnd.powerbuilder6": ["pbd"], "application/vnd.previewsystems.box": ["box"], "application/vnd.proteus.magazine": ["mgz"], "application/vnd.publishare-delta-tree": ["qps"], "application/vnd.pvi.ptid1": ["ptid"], "application/vnd.quark.quarkxpress": ["qxd", "qxt", "qwd", "qwt", "qxl", "qxb"], "application/vnd.rar": ["rar"], "application/vnd.realvnc.bed": ["bed"], "application/vnd.recordare.musicxml": ["mxl"], "application/vnd.recordare.musicxml+xml": ["musicxml"], "application/vnd.rig.cryptonote": ["cryptonote"], "application/vnd.rim.cod": ["cod"], "application/vnd.rn-realmedia": ["rm"], "application/vnd.rn-realmedia-vbr": ["rmvb"], "application/vnd.route66.link66+xml": ["link66"], "application/vnd.sailingtracker.track": ["st"], "application/vnd.seemail": ["see"], "application/vnd.sema": ["sema"], "application/vnd.semd": ["semd"], "application/vnd.semf": ["semf"], "application/vnd.shana.informed.formdata": ["ifm"], "application/vnd.shana.informed.formtemplate": ["itp"], "application/vnd.shana.informed.interchange": ["iif"], "application/vnd.shana.informed.package": ["ipk"], "application/vnd.simtech-mindmapper": ["twd", "twds"], "application/vnd.smaf": ["mmf"], "application/vnd.smart.teacher": ["teacher"], "application/vnd.software602.filler.form+xml": ["fo"], "application/vnd.solent.sdkm+xml": ["sdkm", "sdkd"], "application/vnd.spotfire.dxp": ["dxp"], "application/vnd.spotfire.sfs": ["sfs"], "application/vnd.stardivision.calc": ["sdc"], "application/vnd.stardivision.draw": ["sda"], "application/vnd.stardivision.impress": ["sdd"], "application/vnd.stardivision.math": ["smf"], "application/vnd.stardivision.writer": ["sdw", "vor"], "application/vnd.stardivision.writer-global": ["sgl"], "application/vnd.stepmania.package": ["smzip"], "application/vnd.stepmania.stepchart": ["sm"], "application/vnd.sun.wadl+xml": ["wadl"], "application/vnd.sun.xml.calc": ["sxc"], "application/vnd.sun.xml.calc.template": ["stc"], "application/vnd.sun.xml.draw": ["sxd"], "application/vnd.sun.xml.draw.template": ["std"], "application/vnd.sun.xml.impress": ["sxi"], "application/vnd.sun.xml.impress.template": ["sti"], "application/vnd.sun.xml.math": ["sxm"], "application/vnd.sun.xml.writer": ["sxw"], "application/vnd.sun.xml.writer.global": ["sxg"], "application/vnd.sun.xml.writer.template": ["stw"], "application/vnd.sus-calendar": ["sus", "susp"], "application/vnd.svd": ["svd"], "application/vnd.symbian.install": ["sis", "sisx"], "application/vnd.syncml+xml": ["xsm"], "application/vnd.syncml.dm+wbxml": ["bdm"], "application/vnd.syncml.dm+xml": ["xdm"], "application/vnd.syncml.dmddf+xml": ["ddf"], "application/vnd.tao.intent-module-archive": ["tao"], "application/vnd.tcpdump.pcap": ["pcap", "cap", "dmp"], "application/vnd.tmobile-livetv": ["tmo"], "application/vnd.trid.tpt": ["tpt"], "application/vnd.triscape.mxs": ["mxs"], "application/vnd.trueapp": ["tra"], "application/vnd.ufdl": ["ufd", "ufdl"], "application/vnd.uiq.theme": ["utz"], "application/vnd.umajin": ["umj"], "application/vnd.unity": ["unityweb"], "application/vnd.uoml+xml": ["uoml"], "application/vnd.vcx": ["vcx"], "application/vnd.visio": ["vsd", "vst", "vss", "vsw"], "application/vnd.visionary": ["vis"], "application/vnd.vsf": ["vsf"], "application/vnd.wap.wbxml": ["wbxml"], "application/vnd.wap.wmlc": ["wmlc"], "application/vnd.wap.wmlscriptc": ["wmlsc"], "application/vnd.webturbo": ["wtb"], "application/vnd.wolfram.player": ["nbp"], "application/vnd.wordperfect": ["wpd"], "application/vnd.wqd": ["wqd"], "application/vnd.wt.stf": ["stf"], "application/vnd.xara": ["xar"], "application/vnd.xfdl": ["xfdl"], "application/vnd.yamaha.hv-dic": ["hvd"], "application/vnd.yamaha.hv-script": ["hvs"], "application/vnd.yamaha.hv-voice": ["hvp"], "application/vnd.yamaha.openscoreformat": ["osf"], "application/vnd.yamaha.openscoreformat.osfpvg+xml": ["osfpvg"], "application/vnd.yamaha.smaf-audio": ["saf"], "application/vnd.yamaha.smaf-phrase": ["spf"], "application/vnd.yellowriver-custom-menu": ["cmp"], "application/vnd.zul": ["zir", "zirz"], "application/vnd.zzazz.deck+xml": ["zaz"], "application/x-7z-compressed": ["7z"], "application/x-abiword": ["abw"], "application/x-ace-compressed": ["ace"], "application/x-apple-diskimage": ["*dmg"], "application/x-arj": ["arj"], "application/x-authorware-bin": ["aab", "x32", "u32", "vox"], "application/x-authorware-map": ["aam"], "application/x-authorware-seg": ["aas"], "application/x-bcpio": ["bcpio"], "application/x-bdoc": ["*bdoc"], "application/x-bittorrent": ["torrent"], "application/x-blorb": ["blb", "blorb"], "application/x-bzip": ["bz"], "application/x-bzip2": ["bz2", "boz"], "application/x-cbr": ["cbr", "cba", "cbt", "cbz", "cb7"], "application/x-cdlink": ["vcd"], "application/x-cfs-compressed": ["cfs"], "application/x-chat": ["chat"], "application/x-chess-pgn": ["pgn"], "application/x-chrome-extension": ["crx"], "application/x-cocoa": ["cco"], "application/x-conference": ["nsc"], "application/x-cpio": ["cpio"], "application/x-csh": ["csh"], "application/x-debian-package": ["*deb", "udeb"], "application/x-dgc-compressed": ["dgc"], "application/x-director": ["dir", "dcr", "dxr", "cst", "cct", "cxt", "w3d", "fgd", "swa"], "application/x-doom": ["wad"], "application/x-dtbncx+xml": ["ncx"], "application/x-dtbook+xml": ["dtb"], "application/x-dtbresource+xml": ["res"], "application/x-dvi": ["dvi"], "application/x-envoy": ["evy"], "application/x-eva": ["eva"], "application/x-font-bdf": ["bdf"], "application/x-font-ghostscript": ["gsf"], "application/x-font-linux-psf": ["psf"], "application/x-font-pcf": ["pcf"], "application/x-font-snf": ["snf"], "application/x-font-type1": ["pfa", "pfb", "pfm", "afm"], "application/x-freearc": ["arc"], "application/x-futuresplash": ["spl"], "application/x-gca-compressed": ["gca"], "application/x-glulx": ["ulx"], "application/x-gnumeric": ["gnumeric"], "application/x-gramps-xml": ["gramps"], "application/x-gtar": ["gtar"], "application/x-hdf": ["hdf"], "application/x-httpd-php": ["php"], "application/x-install-instructions": ["install"], "application/x-iso9660-image": ["*iso"], "application/x-iwork-keynote-sffkey": ["*key"], "application/x-iwork-numbers-sffnumbers": ["*numbers"], "application/x-iwork-pages-sffpages": ["*pages"], "application/x-java-archive-diff": ["jardiff"], "application/x-java-jnlp-file": ["jnlp"], "application/x-keepass2": ["kdbx"], "application/x-latex": ["latex"], "application/x-lua-bytecode": ["luac"], "application/x-lzh-compressed": ["lzh", "lha"], "application/x-makeself": ["run"], "application/x-mie": ["mie"], "application/x-mobipocket-ebook": ["prc", "mobi"], "application/x-ms-application": ["application"], "application/x-ms-shortcut": ["lnk"], "application/x-ms-wmd": ["wmd"], "application/x-ms-wmz": ["wmz"], "application/x-ms-xbap": ["xbap"], "application/x-msaccess": ["mdb"], "application/x-msbinder": ["obd"], "application/x-mscardfile": ["crd"], "application/x-msclip": ["clp"], "application/x-msdos-program": ["*exe"], "application/x-msdownload": ["*exe", "*dll", "com", "bat", "*msi"], "application/x-msmediaview": ["mvb", "m13", "m14"], "application/x-msmetafile": ["*wmf", "*wmz", "*emf", "emz"], "application/x-msmoney": ["mny"], "application/x-mspublisher": ["pub"], "application/x-msschedule": ["scd"], "application/x-msterminal": ["trm"], "application/x-mswrite": ["wri"], "application/x-netcdf": ["nc", "cdf"], "application/x-ns-proxy-autoconfig": ["pac"], "application/x-nzb": ["nzb"], "application/x-perl": ["pl", "pm"], "application/x-pilot": ["*prc", "*pdb"], "application/x-pkcs12": ["p12", "pfx"], "application/x-pkcs7-certificates": ["p7b", "spc"], "application/x-pkcs7-certreqresp": ["p7r"], "application/x-rar-compressed": ["*rar"], "application/x-redhat-package-manager": ["rpm"], "application/x-research-info-systems": ["ris"], "application/x-sea": ["sea"], "application/x-sh": ["sh"], "application/x-shar": ["shar"], "application/x-shockwave-flash": ["swf"], "application/x-silverlight-app": ["xap"], "application/x-sql": ["sql"], "application/x-stuffit": ["sit"], "application/x-stuffitx": ["sitx"], "application/x-subrip": ["srt"], "application/x-sv4cpio": ["sv4cpio"], "application/x-sv4crc": ["sv4crc"], "application/x-t3vm-image": ["t3"], "application/x-tads": ["gam"], "application/x-tar": ["tar"], "application/x-tcl": ["tcl", "tk"], "application/x-tex": ["tex"], "application/x-tex-tfm": ["tfm"], "application/x-texinfo": ["texinfo", "texi"], "application/x-tgif": ["*obj"], "application/x-ustar": ["ustar"], "application/x-virtualbox-hdd": ["hdd"], "application/x-virtualbox-ova": ["ova"], "application/x-virtualbox-ovf": ["ovf"], "application/x-virtualbox-vbox": ["vbox"], "application/x-virtualbox-vbox-extpack": ["vbox-extpack"], "application/x-virtualbox-vdi": ["vdi"], "application/x-virtualbox-vhd": ["vhd"], "application/x-virtualbox-vmdk": ["vmdk"], "application/x-wais-source": ["src"], "application/x-web-app-manifest+json": ["webapp"], "application/x-x509-ca-cert": ["der", "crt", "pem"], "application/x-xfig": ["fig"], "application/x-xliff+xml": ["*xlf"], "application/x-xpinstall": ["xpi"], "application/x-xz": ["xz"], "application/x-zmachine": ["z1", "z2", "z3", "z4", "z5", "z6", "z7", "z8"], "audio/vnd.dece.audio": ["uva", "uvva"], "audio/vnd.digital-winds": ["eol"], "audio/vnd.dra": ["dra"], "audio/vnd.dts": ["dts"], "audio/vnd.dts.hd": ["dtshd"], "audio/vnd.lucent.voice": ["lvp"], "audio/vnd.ms-playready.media.pya": ["pya"], "audio/vnd.nuera.ecelp4800": ["ecelp4800"], "audio/vnd.nuera.ecelp7470": ["ecelp7470"], "audio/vnd.nuera.ecelp9600": ["ecelp9600"], "audio/vnd.rip": ["rip"], "audio/x-aac": ["aac"], "audio/x-aiff": ["aif", "aiff", "aifc"], "audio/x-caf": ["caf"], "audio/x-flac": ["flac"], "audio/x-m4a": ["*m4a"], "audio/x-matroska": ["mka"], "audio/x-mpegurl": ["m3u"], "audio/x-ms-wax": ["wax"], "audio/x-ms-wma": ["wma"], "audio/x-pn-realaudio": ["ram", "ra"], "audio/x-pn-realaudio-plugin": ["rmp"], "audio/x-realaudio": ["*ra"], "audio/x-wav": ["*wav"], "chemical/x-cdx": ["cdx"], "chemical/x-cif": ["cif"], "chemical/x-cmdf": ["cmdf"], "chemical/x-cml": ["cml"], "chemical/x-csml": ["csml"], "chemical/x-xyz": ["xyz"], "image/prs.btif": ["btif"], "image/prs.pti": ["pti"], "image/vnd.adobe.photoshop": ["psd"], "image/vnd.airzip.accelerator.azv": ["azv"], "image/vnd.dece.graphic": ["uvi", "uvvi", "uvg", "uvvg"], "image/vnd.djvu": ["djvu", "djv"], "image/vnd.dvb.subtitle": ["*sub"], "image/vnd.dwg": ["dwg"], "image/vnd.dxf": ["dxf"], "image/vnd.fastbidsheet": ["fbs"], "image/vnd.fpx": ["fpx"], "image/vnd.fst": ["fst"], "image/vnd.fujixerox.edmics-mmr": ["mmr"], "image/vnd.fujixerox.edmics-rlc": ["rlc"], "image/vnd.microsoft.icon": ["ico"], "image/vnd.ms-dds": ["dds"], "image/vnd.ms-modi": ["mdi"], "image/vnd.ms-photo": ["wdp"], "image/vnd.net-fpx": ["npx"], "image/vnd.pco.b16": ["b16"], "image/vnd.tencent.tap": ["tap"], "image/vnd.valve.source.texture": ["vtf"], "image/vnd.wap.wbmp": ["wbmp"], "image/vnd.xiff": ["xif"], "image/vnd.zbrush.pcx": ["pcx"], "image/x-3ds": ["3ds"], "image/x-cmu-raster": ["ras"], "image/x-cmx": ["cmx"], "image/x-freehand": ["fh", "fhc", "fh4", "fh5", "fh7"], "image/x-icon": ["*ico"], "image/x-jng": ["jng"], "image/x-mrsid-image": ["sid"], "image/x-ms-bmp": ["*bmp"], "image/x-pcx": ["*pcx"], "image/x-pict": ["pic", "pct"], "image/x-portable-anymap": ["pnm"], "image/x-portable-bitmap": ["pbm"], "image/x-portable-graymap": ["pgm"], "image/x-portable-pixmap": ["ppm"], "image/x-rgb": ["rgb"], "image/x-tga": ["tga"], "image/x-xbitmap": ["xbm"], "image/x-xpixmap": ["xpm"], "image/x-xwindowdump": ["xwd"], "message/vnd.wfa.wsc": ["wsc"], "model/vnd.collada+xml": ["dae"], "model/vnd.dwf": ["dwf"], "model/vnd.gdl": ["gdl"], "model/vnd.gtw": ["gtw"], "model/vnd.mts": ["mts"], "model/vnd.opengex": ["ogex"], "model/vnd.parasolid.transmit.binary": ["x_b"], "model/vnd.parasolid.transmit.text": ["x_t"], "model/vnd.sap.vds": ["vds"], "model/vnd.usdz+zip": ["usdz"], "model/vnd.valve.source.compiled-map": ["bsp"], "model/vnd.vtu": ["vtu"], "text/prs.lines.tag": ["dsc"], "text/vnd.curl": ["curl"], "text/vnd.curl.dcurl": ["dcurl"], "text/vnd.curl.mcurl": ["mcurl"], "text/vnd.curl.scurl": ["scurl"], "text/vnd.dvb.subtitle": ["sub"], "text/vnd.fly": ["fly"], "text/vnd.fmi.flexstor": ["flx"], "text/vnd.graphviz": ["gv"], "text/vnd.in3d.3dml": ["3dml"], "text/vnd.in3d.spot": ["spot"], "text/vnd.sun.j2me.app-descriptor": ["jad"], "text/vnd.wap.wml": ["wml"], "text/vnd.wap.wmlscript": ["wmls"], "text/x-asm": ["s", "asm"], "text/x-c": ["c", "cc", "cxx", "cpp", "h", "hh", "dic"], "text/x-component": ["htc"], "text/x-fortran": ["f", "for", "f77", "f90"], "text/x-handlebars-template": ["hbs"], "text/x-java-source": ["java"], "text/x-lua": ["lua"], "text/x-markdown": ["mkd"], "text/x-nfo": ["nfo"], "text/x-opml": ["opml"], "text/x-org": ["*org"], "text/x-pascal": ["p", "pas"], "text/x-processing": ["pde"], "text/x-sass": ["sass"], "text/x-scss": ["scss"], "text/x-setext": ["etx"], "text/x-sfv": ["sfv"], "text/x-suse-ymp": ["ymp"], "text/x-uuencode": ["uu"], "text/x-vcalendar": ["vcs"], "text/x-vcard": ["vcf"], "video/vnd.dece.hd": ["uvh", "uvvh"], "video/vnd.dece.mobile": ["uvm", "uvvm"], "video/vnd.dece.pd": ["uvp", "uvvp"], "video/vnd.dece.sd": ["uvs", "uvvs"], "video/vnd.dece.video": ["uvv", "uvvv"], "video/vnd.dvb.file": ["dvb"], "video/vnd.fvt": ["fvt"], "video/vnd.mpegurl": ["mxu", "m4u"], "video/vnd.ms-playready.media.pyv": ["pyv"], "video/vnd.uvvu.mp4": ["uvu", "uvvu"], "video/vnd.vivo": ["viv"], "video/x-f4v": ["f4v"], "video/x-fli": ["fli"], "video/x-flv": ["flv"], "video/x-m4v": ["m4v"], "video/x-matroska": ["mkv", "mk3d", "mks"], "video/x-mng": ["mng"], "video/x-ms-asf": ["asf", "asx"], "video/x-ms-vob": ["vob"], "video/x-ms-wm": ["wm"], "video/x-ms-wmv": ["wmv"], "video/x-ms-wmx": ["wmx"], "video/x-ms-wvx": ["wvx"], "video/x-msvideo": ["avi"], "video/x-sgi-movie": ["movie"], "video/x-smv": ["smv"], "x-conference/x-cooltalk": ["ice"] };
  }
});

// ../../node_modules/.pnpm/mime@3.0.0/node_modules/mime/index.js
var require_mime2 = __commonJS({
  "../../node_modules/.pnpm/mime@3.0.0/node_modules/mime/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var Mime = require_Mime();
    module3.exports = new Mime(require_standard(), require_other());
  }
});

// src/pages/hash.ts
var import_node_fs12, import_node_path20, import_blake3_wasm, hashFile;
var init_hash = __esm({
  "src/pages/hash.ts"() {
    init_import_meta_url();
    import_node_fs12 = require("node:fs");
    import_node_path20 = require("node:path");
    import_blake3_wasm = require("blake3-wasm");
    hashFile = /* @__PURE__ */ __name((filepath) => {
      const contents = (0, import_node_fs12.readFileSync)(filepath);
      const base64Contents = contents.toString("base64");
      const extension = (0, import_node_path20.extname)(filepath).substring(1);
      return (0, import_blake3_wasm.hash)(base64Contents + extension).toString("hex").slice(0, 32);
    }, "hashFile");
  }
});

// ../pages-shared/environment-polyfills/index.ts
var polyfill;
var init_environment_polyfills = __esm({
  "../pages-shared/environment-polyfills/index.ts"() {
    init_import_meta_url();
    polyfill = /* @__PURE__ */ __name((environment) => {
      Object.entries(environment).map(([name, value]) => {
        Object.defineProperty(globalThis, name, {
          value,
          configurable: true,
          enumerable: true,
          writable: true
        });
      });
    }, "polyfill");
  }
});

// ../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/constants.js
var require_constants7 = __commonJS({
  "../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/constants.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var path67 = require("path");
    var WIN_SLASH = "\\\\/";
    var WIN_NO_SLASH = `[^${WIN_SLASH}]`;
    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 = {
      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"
    };
    module3.exports = {
      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: {
        "***": "*",
        "**/**": "**",
        "**/**/**": "**"
      },
      // 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: path67.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/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js
var require_utils6 = __commonJS({
  "../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var path67 = require("path");
    var win32 = process.platform === "win32";
    var {
      REGEX_BACKSLASH,
      REGEX_REMOVE_BACKSLASH,
      REGEX_SPECIAL_CHARS,
      REGEX_SPECIAL_CHARS_GLOBAL
    } = require_constants7();
    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 = (options29) => {
      if (options29 && typeof options29.windows === "boolean") {
        return options29.windows;
      }
      return win32 === true || path67.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 = {}, options29 = {}) => {
      const prepend = options29.contains ? "" : "^";
      const append = options29.contains ? "" : "$";
      let output = `${prepend}(?:${input})${append}`;
      if (state.negated === true) {
        output = `(?:^(?!${output}).*$)`;
      }
      return output;
    };
  }
});

// ../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/scan.js
var require_scan = __commonJS({
  "../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/scan.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var utils = require_utils6();
    var {
      CHAR_ASTERISK,
      /* * */
      CHAR_AT,
      /* @ */
      CHAR_BACKWARD_SLASH,
      /* \ */
      CHAR_COMMA: CHAR_COMMA2,
      /* , */
      CHAR_DOT,
      /* . */
      CHAR_EXCLAMATION_MARK,
      /* ! */
      CHAR_FORWARD_SLASH,
      /* / */
      CHAR_LEFT_CURLY_BRACE,
      /* { */
      CHAR_LEFT_PARENTHESES,
      /* ( */
      CHAR_LEFT_SQUARE_BRACKET,
      /* [ */
      CHAR_PLUS: CHAR_PLUS2,
      /* + */
      CHAR_QUESTION_MARK,
      /* ? */
      CHAR_RIGHT_CURLY_BRACE,
      /* } */
      CHAR_RIGHT_PARENTHESES,
      /* ) */
      CHAR_RIGHT_SQUARE_BRACKET
      /* ] */
    } = require_constants7();
    var isPathSeparator = /* @__PURE__ */ __name((code) => {
      return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
    }, "isPathSeparator");
    var depth = /* @__PURE__ */ __name((token) => {
      if (token.isPrefix !== true) {
        token.depth = token.isGlobstar ? Infinity : 1;
      }
    }, "depth");
    var scan = /* @__PURE__ */ __name((input, options29) => {
      const opts = options29 || {};
      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 = /* @__PURE__ */ __name(() => index >= length, "eos");
      const peek = /* @__PURE__ */ __name(() => str.charCodeAt(index + 1), "peek");
      const advance = /* @__PURE__ */ __name(() => {
        prev = code;
        return str.charCodeAt(++index);
      }, "advance");
      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_COMMA2) {
              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_PLUS2 || 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 n2 = prevIndex ? prevIndex + 1 : start;
          const i = slashes[idx];
          const value = input.slice(n2, 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;
    }, "scan");
    module3.exports = scan;
  }
});

// ../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/parse.js
var require_parse5 = __commonJS({
  "../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/parse.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var constants3 = require_constants7();
    var utils = require_utils6();
    var {
      MAX_LENGTH,
      POSIX_REGEX_SOURCE,
      REGEX_NON_SPECIAL_CHARS,
      REGEX_SPECIAL_CHARS_BACKREF,
      REPLACEMENTS
    } = constants3;
    var expandRange = /* @__PURE__ */ __name((args, options29) => {
      if (typeof options29.expandRange === "function") {
        return options29.expandRange(...args, options29);
      }
      args.sort();
      const value = `[${args.join("-")}]`;
      try {
        new RegExp(value);
      } catch (ex) {
        return args.map((v2) => utils.escapeRegex(v2)).join("..");
      }
      return value;
    }, "expandRange");
    var syntaxError = /* @__PURE__ */ __name((type, char) => {
      return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
    }, "syntaxError");
    var parse7 = /* @__PURE__ */ __name((input, options29) => {
      if (typeof input !== "string") {
        throw new TypeError("Expected a string");
      }
      input = REPLACEMENTS[input] || input;
      const opts = { ...options29 };
      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(options29);
      const PLATFORM_CHARS = constants3.globChars(win32);
      const EXTGLOB_CHARS = constants3.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 = /* @__PURE__ */ __name((opts2) => {
        return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
      }, "globstar");
      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 = /* @__PURE__ */ __name(() => state.index === len - 1, "eos");
      const peek = state.peek = (n2 = 1) => input[state.index + n2];
      const advance = state.advance = () => input[++state.index] || "";
      const remaining = /* @__PURE__ */ __name(() => input.slice(state.index + 1), "remaining");
      const consume = /* @__PURE__ */ __name((value2 = "", num = 0) => {
        state.consumed += value2;
        state.index += num;
      }, "consume");
      const append = /* @__PURE__ */ __name((token) => {
        state.output += token.output != null ? token.output : token.value;
        consume(token.value);
      }, "append");
      const negate = /* @__PURE__ */ __name(() => {
        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;
      }, "negate");
      const increment2 = /* @__PURE__ */ __name((type) => {
        state[type]++;
        stack.push(type);
      }, "increment");
      const decrement = /* @__PURE__ */ __name((type) => {
        state[type]--;
        stack.pop();
      }, "decrement");
      const push = /* @__PURE__ */ __name((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)
          append(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;
      }, "push");
      const extglobOpen = /* @__PURE__ */ __name((type, value2) => {
        const token = { ...EXTGLOB_CHARS[value2], conditions: 1, inner: "" };
        token.prev = prev;
        token.parens = state.parens;
        token.output = state.output;
        const output = (opts.capture ? "(" : "") + token.open;
        increment2("parens");
        push({ type, value: value2, output: state.output ? "" : ONE_CHAR });
        push({ type: "paren", extglob: true, value: advance(), output });
        extglobs.push(token);
      }, "extglobOpen");
      const extglobClose = /* @__PURE__ */ __name((token) => {
        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 = parse7(rest, { ...options29, 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");
      }, "extglobClose");
      if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
        let backslashes = false;
        let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m2, esc, chars, first, rest, index) => {
          if (first === "\\") {
            backslashes = true;
            return m2;
          }
          if (first === "?") {
            if (esc) {
              return esc + 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 (esc) {
              return esc + first + (rest ? star : "");
            }
            return star;
          }
          return esc ? m2 : `\\${m2}`;
        });
        if (backslashes === true) {
          if (opts.unescape === true) {
            output = output.replace(/\\/g, "");
          } else {
            output = output.replace(/\\+/g, (m2) => {
              return m2.length % 2 === 0 ? "\\\\" : m2 ? "\\" : "";
            });
          }
        }
        if (output === input && opts.contains === true) {
          state.output = input;
          return state;
        }
        state.output = utils.wrapOutput(output, state, options29);
        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 posix2 = POSIX_REGEX_SOURCE[rest2];
                if (posix2) {
                  prev.value = pre + posix2;
                  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;
          append({ value });
          continue;
        }
        if (state.quotes === 1 && value !== '"') {
          value = utils.escapeRegex(value);
          prev.value += value;
          append({ value });
          continue;
        }
        if (value === '"') {
          state.quotes = state.quotes === 1 ? 0 : 1;
          if (opts.keepQuotes === true) {
            push({ type: "text", value });
          }
          continue;
        }
        if (value === "(") {
          increment2("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 {
            increment2("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;
          append({ 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) {
          increment2("braces");
          const open3 = {
            type: "brace",
            value,
            output: "(",
            outputIndex: state.output.length,
            tokensIndex: state.tokens.length
          };
          braces.push(open3);
          push(open3);
          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 t3 of toks) {
              state.output += t3.output || t3.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;
    }, "parse");
    parse7.fastpaths = (input, options29) => {
      const opts = { ...options29 };
      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(options29);
      const {
        DOT_LITERAL,
        SLASH_LITERAL,
        ONE_CHAR,
        DOTS_SLASH,
        NO_DOT,
        NO_DOTS,
        NO_DOTS_SLASH,
        STAR,
        START_ANCHOR
      } = constants3.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 = /* @__PURE__ */ __name((opts2) => {
        if (opts2.noglobstar === true)
          return star;
        return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
      }, "globstar");
      const create2 = /* @__PURE__ */ __name((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 = create2(match[1]);
            if (!source2)
              return;
            return source2 + DOT_LITERAL + match[2];
          }
        }
      }, "create");
      const output = utils.removePrefix(input, state);
      let source = create2(output);
      if (source && opts.strictSlashes !== true) {
        source += `${SLASH_LITERAL}?`;
      }
      return source;
    };
    module3.exports = parse7;
  }
});

// ../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/picomatch.js
var require_picomatch = __commonJS({
  "../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/picomatch.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var path67 = require("path");
    var scan = require_scan();
    var parse7 = require_parse5();
    var utils = require_utils6();
    var constants3 = require_constants7();
    var isObject2 = /* @__PURE__ */ __name((val) => val && typeof val === "object" && !Array.isArray(val), "isObject");
    var picomatch = /* @__PURE__ */ __name((glob, options29, returnState = false) => {
      if (Array.isArray(glob)) {
        const fns = glob.map((input) => picomatch(input, options29, returnState));
        const arrayMatcher = /* @__PURE__ */ __name((str) => {
          for (const isMatch of fns) {
            const state2 = isMatch(str);
            if (state2)
              return state2;
          }
          return false;
        }, "arrayMatcher");
        return arrayMatcher;
      }
      const isState = isObject2(glob) && glob.tokens && glob.input;
      if (glob === "" || typeof glob !== "string" && !isState) {
        throw new TypeError("Expected pattern to be a non-empty string");
      }
      const opts = options29 || {};
      const posix2 = utils.isWindows(options29);
      const regex2 = isState ? picomatch.compileRe(glob, options29) : picomatch.makeRe(glob, options29, false, true);
      const state = regex2.state;
      delete regex2.state;
      let isIgnored = /* @__PURE__ */ __name(() => false, "isIgnored");
      if (opts.ignore) {
        const ignoreOpts = { ...options29, ignore: null, onMatch: null, onResult: null };
        isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
      }
      const matcher = /* @__PURE__ */ __name((input, returnObject = false) => {
        const { isMatch, match, output } = picomatch.test(input, regex2, options29, { glob, posix: posix2 });
        const result = { glob, state, regex: regex2, posix: posix2, 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;
      }, "matcher");
      if (returnState) {
        matcher.state = state;
      }
      return matcher;
    }, "picomatch");
    picomatch.test = (input, regex2, options29, { glob, posix: posix2 } = {}) => {
      if (typeof input !== "string") {
        throw new TypeError("Expected input to be a string");
      }
      if (input === "") {
        return { isMatch: false, output: "" };
      }
      const opts = options29 || {};
      const format10 = opts.format || (posix2 ? utils.toPosixSlashes : null);
      let match = input === glob;
      let output = match && format10 ? format10(input) : input;
      if (match === false) {
        output = format10 ? format10(input) : input;
        match = output === glob;
      }
      if (match === false || opts.capture === true) {
        if (opts.matchBase === true || opts.basename === true) {
          match = picomatch.matchBase(input, regex2, options29, posix2);
        } else {
          match = regex2.exec(output);
        }
      }
      return { isMatch: Boolean(match), match, output };
    };
    picomatch.matchBase = (input, glob, options29, posix2 = utils.isWindows(options29)) => {
      const regex2 = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options29);
      return regex2.test(path67.basename(input));
    };
    picomatch.isMatch = (str, patterns, options29) => picomatch(patterns, options29)(str);
    picomatch.parse = (pattern, options29) => {
      if (Array.isArray(pattern))
        return pattern.map((p2) => picomatch.parse(p2, options29));
      return parse7(pattern, { ...options29, fastpaths: false });
    };
    picomatch.scan = (input, options29) => scan(input, options29);
    picomatch.compileRe = (state, options29, returnOutput = false, returnState = false) => {
      if (returnOutput === true) {
        return state.output;
      }
      const opts = options29 || {};
      const prepend = opts.contains ? "" : "^";
      const append = opts.contains ? "" : "$";
      let source = `${prepend}(?:${state.output})${append}`;
      if (state && state.negated === true) {
        source = `^(?!${source}).*$`;
      }
      const regex2 = picomatch.toRegex(source, options29);
      if (returnState === true) {
        regex2.state = state;
      }
      return regex2;
    };
    picomatch.makeRe = (input, options29 = {}, returnOutput = false, returnState = false) => {
      if (!input || typeof input !== "string") {
        throw new TypeError("Expected a non-empty string");
      }
      let parsed = { negated: false, fastpaths: true };
      if (options29.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
        parsed.output = parse7.fastpaths(input, options29);
      }
      if (!parsed.output) {
        parsed = parse7(input, options29);
      }
      return picomatch.compileRe(parsed, options29, returnOutput, returnState);
    };
    picomatch.toRegex = (source, options29) => {
      try {
        const opts = options29 || {};
        return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
      } catch (err) {
        if (options29 && options29.debug === true)
          throw err;
        return /$^/;
      }
    };
    picomatch.constants = constants3;
    module3.exports = picomatch;
  }
});

// ../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/index.js
var require_picomatch2 = __commonJS({
  "../../node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = require_picomatch();
  }
});

// ../../node_modules/.pnpm/kleur@4.1.5/node_modules/kleur/colors.js
var require_colors2 = __commonJS({
  "../../node_modules/.pnpm/kleur@4.1.5/node_modules/kleur/colors.js"(exports2) {
    init_import_meta_url();
    var FORCE_COLOR;
    var NODE_DISABLE_COLORS;
    var NO_COLOR;
    var TERM;
    var isTTY = true;
    if (typeof process !== "undefined") {
      ({ FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env || {});
      isTTY = process.stdout && process.stdout.isTTY;
    }
    var $3 = exports2.$ = {
      enabled: !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== "dumb" && (FORCE_COLOR != null && FORCE_COLOR !== "0" || isTTY)
    };
    function init3(x2, y2) {
      let rgx = new RegExp(`\\x1b\\[${y2}m`, "g");
      let open3 = `\x1B[${x2}m`, close2 = `\x1B[${y2}m`;
      return function(txt) {
        if (!$3.enabled || txt == null)
          return txt;
        return open3 + (!!~("" + txt).indexOf(close2) ? txt.replace(rgx, close2 + open3) : txt) + close2;
      };
    }
    __name(init3, "init");
    exports2.reset = init3(0, 0);
    exports2.bold = init3(1, 22);
    exports2.dim = init3(2, 22);
    exports2.italic = init3(3, 23);
    exports2.underline = init3(4, 24);
    exports2.inverse = init3(7, 27);
    exports2.hidden = init3(8, 28);
    exports2.strikethrough = init3(9, 29);
    exports2.black = init3(30, 39);
    exports2.red = init3(31, 39);
    exports2.green = init3(32, 39);
    exports2.yellow = init3(33, 39);
    exports2.blue = init3(34, 39);
    exports2.magenta = init3(35, 39);
    exports2.cyan = init3(36, 39);
    exports2.white = init3(37, 39);
    exports2.gray = init3(90, 39);
    exports2.grey = init3(90, 39);
    exports2.bgBlack = init3(40, 49);
    exports2.bgRed = init3(41, 49);
    exports2.bgGreen = init3(42, 49);
    exports2.bgYellow = init3(43, 49);
    exports2.bgBlue = init3(44, 49);
    exports2.bgMagenta = init3(45, 49);
    exports2.bgCyan = init3(46, 49);
    exports2.bgWhite = init3(47, 49);
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/internal/constants.js
var require_constants8 = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/internal/constants.js"(exports2, module3) {
    init_import_meta_url();
    var SEMVER_SPEC_VERSION = "2.0.0";
    var MAX_LENGTH = 256;
    var MAX_SAFE_INTEGER = 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"
    ];
    module3.exports = {
      MAX_LENGTH,
      MAX_SAFE_COMPONENT_LENGTH,
      MAX_SAFE_BUILD_LENGTH,
      MAX_SAFE_INTEGER,
      RELEASE_TYPES,
      SEMVER_SPEC_VERSION,
      FLAG_INCLUDE_PRERELEASE: 1,
      FLAG_LOOSE: 2
    };
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/internal/debug.js
var require_debug3 = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/internal/debug.js"(exports2, module3) {
    init_import_meta_url();
    var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
    };
    module3.exports = debug;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/internal/re.js
var require_re = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/internal/re.js"(exports2, module3) {
    init_import_meta_url();
    var {
      MAX_SAFE_COMPONENT_LENGTH,
      MAX_SAFE_BUILD_LENGTH,
      MAX_LENGTH
    } = require_constants8();
    var debug = require_debug3();
    exports2 = module3.exports = {};
    var re = exports2.re = [];
    var safeRe = exports2.safeRe = [];
    var src = exports2.src = [];
    var t3 = exports2.t = {};
    var R2 = 0;
    var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
    var safeRegexReplacements = [
      ["\\s", 1],
      ["\\d", MAX_LENGTH],
      [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
    ];
    var makeSafeRegex = /* @__PURE__ */ __name((value) => {
      for (const [token, max] of safeRegexReplacements) {
        value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
      }
      return value;
    }, "makeSafeRegex");
    var createToken = /* @__PURE__ */ __name((name, value, isGlobal) => {
      const safe = makeSafeRegex(value);
      const index = R2++;
      debug(name, index, value);
      t3[name] = index;
      src[index] = value;
      re[index] = new RegExp(value, isGlobal ? "g" : void 0);
      safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
    }, "createToken");
    createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
    createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
    createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
    createToken("MAINVERSION", `(${src[t3.NUMERICIDENTIFIER]})\\.(${src[t3.NUMERICIDENTIFIER]})\\.(${src[t3.NUMERICIDENTIFIER]})`);
    createToken("MAINVERSIONLOOSE", `(${src[t3.NUMERICIDENTIFIERLOOSE]})\\.(${src[t3.NUMERICIDENTIFIERLOOSE]})\\.(${src[t3.NUMERICIDENTIFIERLOOSE]})`);
    createToken("PRERELEASEIDENTIFIER", `(?:${src[t3.NUMERICIDENTIFIER]}|${src[t3.NONNUMERICIDENTIFIER]})`);
    createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t3.NUMERICIDENTIFIERLOOSE]}|${src[t3.NONNUMERICIDENTIFIER]})`);
    createToken("PRERELEASE", `(?:-(${src[t3.PRERELEASEIDENTIFIER]}(?:\\.${src[t3.PRERELEASEIDENTIFIER]})*))`);
    createToken("PRERELEASELOOSE", `(?:-?(${src[t3.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t3.PRERELEASEIDENTIFIERLOOSE]})*))`);
    createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
    createToken("BUILD", `(?:\\+(${src[t3.BUILDIDENTIFIER]}(?:\\.${src[t3.BUILDIDENTIFIER]})*))`);
    createToken("FULLPLAIN", `v?${src[t3.MAINVERSION]}${src[t3.PRERELEASE]}?${src[t3.BUILD]}?`);
    createToken("FULL", `^${src[t3.FULLPLAIN]}$`);
    createToken("LOOSEPLAIN", `[v=\\s]*${src[t3.MAINVERSIONLOOSE]}${src[t3.PRERELEASELOOSE]}?${src[t3.BUILD]}?`);
    createToken("LOOSE", `^${src[t3.LOOSEPLAIN]}$`);
    createToken("GTLT", "((?:<|>)?=?)");
    createToken("XRANGEIDENTIFIERLOOSE", `${src[t3.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
    createToken("XRANGEIDENTIFIER", `${src[t3.NUMERICIDENTIFIER]}|x|X|\\*`);
    createToken("XRANGEPLAIN", `[v=\\s]*(${src[t3.XRANGEIDENTIFIER]})(?:\\.(${src[t3.XRANGEIDENTIFIER]})(?:\\.(${src[t3.XRANGEIDENTIFIER]})(?:${src[t3.PRERELEASE]})?${src[t3.BUILD]}?)?)?`);
    createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t3.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t3.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t3.XRANGEIDENTIFIERLOOSE]})(?:${src[t3.PRERELEASELOOSE]})?${src[t3.BUILD]}?)?)?`);
    createToken("XRANGE", `^${src[t3.GTLT]}\\s*${src[t3.XRANGEPLAIN]}$`);
    createToken("XRANGELOOSE", `^${src[t3.GTLT]}\\s*${src[t3.XRANGEPLAINLOOSE]}$`);
    createToken("COERCE", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:$|[^\\d])`);
    createToken("COERCERTL", src[t3.COERCE], true);
    createToken("LONETILDE", "(?:~>?)");
    createToken("TILDETRIM", `(\\s*)${src[t3.LONETILDE]}\\s+`, true);
    exports2.tildeTrimReplace = "$1~";
    createToken("TILDE", `^${src[t3.LONETILDE]}${src[t3.XRANGEPLAIN]}$`);
    createToken("TILDELOOSE", `^${src[t3.LONETILDE]}${src[t3.XRANGEPLAINLOOSE]}$`);
    createToken("LONECARET", "(?:\\^)");
    createToken("CARETTRIM", `(\\s*)${src[t3.LONECARET]}\\s+`, true);
    exports2.caretTrimReplace = "$1^";
    createToken("CARET", `^${src[t3.LONECARET]}${src[t3.XRANGEPLAIN]}$`);
    createToken("CARETLOOSE", `^${src[t3.LONECARET]}${src[t3.XRANGEPLAINLOOSE]}$`);
    createToken("COMPARATORLOOSE", `^${src[t3.GTLT]}\\s*(${src[t3.LOOSEPLAIN]})$|^$`);
    createToken("COMPARATOR", `^${src[t3.GTLT]}\\s*(${src[t3.FULLPLAIN]})$|^$`);
    createToken("COMPARATORTRIM", `(\\s*)${src[t3.GTLT]}\\s*(${src[t3.LOOSEPLAIN]}|${src[t3.XRANGEPLAIN]})`, true);
    exports2.comparatorTrimReplace = "$1$2$3";
    createToken("HYPHENRANGE", `^\\s*(${src[t3.XRANGEPLAIN]})\\s+-\\s+(${src[t3.XRANGEPLAIN]})\\s*$`);
    createToken("HYPHENRANGELOOSE", `^\\s*(${src[t3.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t3.XRANGEPLAINLOOSE]})\\s*$`);
    createToken("STAR", "(<|>)?=?\\s*\\*");
    createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
    createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/internal/parse-options.js
var require_parse_options = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/internal/parse-options.js"(exports2, module3) {
    init_import_meta_url();
    var looseOption = Object.freeze({ loose: true });
    var emptyOpts = Object.freeze({});
    var parseOptions = /* @__PURE__ */ __name((options29) => {
      if (!options29) {
        return emptyOpts;
      }
      if (typeof options29 !== "object") {
        return looseOption;
      }
      return options29;
    }, "parseOptions");
    module3.exports = parseOptions;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/internal/identifiers.js
var require_identifiers = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/internal/identifiers.js"(exports2, module3) {
    init_import_meta_url();
    var numeric = /^[0-9]+$/;
    var compareIdentifiers = /* @__PURE__ */ __name((a, b2) => {
      const anum = numeric.test(a);
      const bnum = numeric.test(b2);
      if (anum && bnum) {
        a = +a;
        b2 = +b2;
      }
      return a === b2 ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b2 ? -1 : 1;
    }, "compareIdentifiers");
    var rcompareIdentifiers = /* @__PURE__ */ __name((a, b2) => compareIdentifiers(b2, a), "rcompareIdentifiers");
    module3.exports = {
      compareIdentifiers,
      rcompareIdentifiers
    };
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/classes/semver.js
var require_semver = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/classes/semver.js"(exports2, module3) {
    init_import_meta_url();
    var debug = require_debug3();
    var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants8();
    var { safeRe: re, t: t3 } = require_re();
    var parseOptions = require_parse_options();
    var { compareIdentifiers } = require_identifiers();
    var SemVer = class {
      constructor(version3, options29) {
        options29 = parseOptions(options29);
        if (version3 instanceof SemVer) {
          if (version3.loose === !!options29.loose && version3.includePrerelease === !!options29.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, options29);
        this.options = options29;
        this.loose = !!options29.loose;
        this.includePrerelease = !!options29.includePrerelease;
        const m2 = version3.trim().match(options29.loose ? re[t3.LOOSE] : re[t3.FULL]);
        if (!m2) {
          throw new TypeError(`Invalid Version: ${version3}`);
        }
        this.raw = version3;
        this.major = +m2[1];
        this.minor = +m2[2];
        this.patch = +m2[3];
        if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
          throw new TypeError("Invalid major version");
        }
        if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
          throw new TypeError("Invalid minor version");
        }
        if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
          throw new TypeError("Invalid patch version");
        }
        if (!m2[4]) {
          this.prerelease = [];
        } else {
          this.prerelease = m2[4].split(".").map((id) => {
            if (/^[0-9]+$/.test(id)) {
              const num = +id;
              if (num >= 0 && num < MAX_SAFE_INTEGER) {
                return num;
              }
            }
            return id;
          });
        }
        this.build = m2[5] ? m2[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);
        }
        return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
      }
      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 b2 = other.prerelease[i];
          debug("prerelease compare", i, a, b2);
          if (a === void 0 && b2 === void 0) {
            return 0;
          } else if (b2 === void 0) {
            return 1;
          } else if (a === void 0) {
            return -1;
          } else if (a === b2) {
            continue;
          } else {
            return compareIdentifiers(a, b2);
          }
        } while (++i);
      }
      compareBuild(other) {
        if (!(other instanceof SemVer)) {
          other = new SemVer(other, this.options);
        }
        let i = 0;
        do {
          const a = this.build[i];
          const b2 = other.build[i];
          debug("prerelease compare", i, a, b2);
          if (a === void 0 && b2 === void 0) {
            return 0;
          } else if (b2 === void 0) {
            return 1;
          } else if (a === void 0) {
            return -1;
          } else if (a === b2) {
            continue;
          } else {
            return compareIdentifiers(a, b2);
          }
        } 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(release2, identifier, identifierBase) {
        switch (release2) {
          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;
          case "prerelease":
            if (this.prerelease.length === 0) {
              this.inc("patch", identifier, identifierBase);
            }
            this.inc("pre", identifier, identifierBase);
            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;
          case "pre": {
            const base = Number(identifierBase) ? 1 : 0;
            if (!identifier && identifierBase === false) {
              throw new Error("invalid increment argument: identifier is empty");
            }
            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: ${release2}`);
        }
        this.raw = this.format();
        if (this.build.length) {
          this.raw += `+${this.build.join(".")}`;
        }
        return this;
      }
    };
    __name(SemVer, "SemVer");
    module3.exports = SemVer;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/parse.js
var require_parse6 = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/parse.js"(exports2, module3) {
    init_import_meta_url();
    var SemVer = require_semver();
    var parse7 = /* @__PURE__ */ __name((version3, options29, throwErrors = false) => {
      if (version3 instanceof SemVer) {
        return version3;
      }
      try {
        return new SemVer(version3, options29);
      } catch (er) {
        if (!throwErrors) {
          return null;
        }
        throw er;
      }
    }, "parse");
    module3.exports = parse7;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/valid.js
var require_valid = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/valid.js"(exports2, module3) {
    init_import_meta_url();
    var parse7 = require_parse6();
    var valid = /* @__PURE__ */ __name((version3, options29) => {
      const v2 = parse7(version3, options29);
      return v2 ? v2.version : null;
    }, "valid");
    module3.exports = valid;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/clean.js
var require_clean = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/clean.js"(exports2, module3) {
    init_import_meta_url();
    var parse7 = require_parse6();
    var clean = /* @__PURE__ */ __name((version3, options29) => {
      const s = parse7(version3.trim().replace(/^[=v]+/, ""), options29);
      return s ? s.version : null;
    }, "clean");
    module3.exports = clean;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/inc.js
var require_inc = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/inc.js"(exports2, module3) {
    init_import_meta_url();
    var SemVer = require_semver();
    var inc = /* @__PURE__ */ __name((version3, release2, options29, identifier, identifierBase) => {
      if (typeof options29 === "string") {
        identifierBase = identifier;
        identifier = options29;
        options29 = void 0;
      }
      try {
        return new SemVer(
          version3 instanceof SemVer ? version3.version : version3,
          options29
        ).inc(release2, identifier, identifierBase).version;
      } catch (er) {
        return null;
      }
    }, "inc");
    module3.exports = inc;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/diff.js
var require_diff = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/diff.js"(exports2, module3) {
    init_import_meta_url();
    var parse7 = require_parse6();
    var diff = /* @__PURE__ */ __name((version1, version22) => {
      const v1 = parse7(version1, null, true);
      const v2 = parse7(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 (highVersion.patch) {
          return "patch";
        }
        if (highVersion.minor) {
          return "minor";
        }
        return "major";
      }
      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";
    }, "diff");
    module3.exports = diff;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/major.js
var require_major = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/major.js"(exports2, module3) {
    init_import_meta_url();
    var SemVer = require_semver();
    var major = /* @__PURE__ */ __name((a, loose) => new SemVer(a, loose).major, "major");
    module3.exports = major;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/minor.js
var require_minor = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/minor.js"(exports2, module3) {
    init_import_meta_url();
    var SemVer = require_semver();
    var minor = /* @__PURE__ */ __name((a, loose) => new SemVer(a, loose).minor, "minor");
    module3.exports = minor;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/patch.js
var require_patch = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/patch.js"(exports2, module3) {
    init_import_meta_url();
    var SemVer = require_semver();
    var patch = /* @__PURE__ */ __name((a, loose) => new SemVer(a, loose).patch, "patch");
    module3.exports = patch;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/prerelease.js
var require_prerelease = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/prerelease.js"(exports2, module3) {
    init_import_meta_url();
    var parse7 = require_parse6();
    var prerelease = /* @__PURE__ */ __name((version3, options29) => {
      const parsed = parse7(version3, options29);
      return parsed && parsed.prerelease.length ? parsed.prerelease : null;
    }, "prerelease");
    module3.exports = prerelease;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/compare.js
var require_compare = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/compare.js"(exports2, module3) {
    init_import_meta_url();
    var SemVer = require_semver();
    var compare = /* @__PURE__ */ __name((a, b2, loose) => new SemVer(a, loose).compare(new SemVer(b2, loose)), "compare");
    module3.exports = compare;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/rcompare.js
var require_rcompare = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/rcompare.js"(exports2, module3) {
    init_import_meta_url();
    var compare = require_compare();
    var rcompare = /* @__PURE__ */ __name((a, b2, loose) => compare(b2, a, loose), "rcompare");
    module3.exports = rcompare;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/compare-loose.js
var require_compare_loose = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/compare-loose.js"(exports2, module3) {
    init_import_meta_url();
    var compare = require_compare();
    var compareLoose = /* @__PURE__ */ __name((a, b2) => compare(a, b2, true), "compareLoose");
    module3.exports = compareLoose;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/compare-build.js
var require_compare_build = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/compare-build.js"(exports2, module3) {
    init_import_meta_url();
    var SemVer = require_semver();
    var compareBuild = /* @__PURE__ */ __name((a, b2, loose) => {
      const versionA = new SemVer(a, loose);
      const versionB = new SemVer(b2, loose);
      return versionA.compare(versionB) || versionA.compareBuild(versionB);
    }, "compareBuild");
    module3.exports = compareBuild;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/sort.js
var require_sort = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/sort.js"(exports2, module3) {
    init_import_meta_url();
    var compareBuild = require_compare_build();
    var sort = /* @__PURE__ */ __name((list, loose) => list.sort((a, b2) => compareBuild(a, b2, loose)), "sort");
    module3.exports = sort;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/rsort.js
var require_rsort = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/rsort.js"(exports2, module3) {
    init_import_meta_url();
    var compareBuild = require_compare_build();
    var rsort = /* @__PURE__ */ __name((list, loose) => list.sort((a, b2) => compareBuild(b2, a, loose)), "rsort");
    module3.exports = rsort;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/gt.js
var require_gt = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/gt.js"(exports2, module3) {
    init_import_meta_url();
    var compare = require_compare();
    var gt = /* @__PURE__ */ __name((a, b2, loose) => compare(a, b2, loose) > 0, "gt");
    module3.exports = gt;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/lt.js
var require_lt = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/lt.js"(exports2, module3) {
    init_import_meta_url();
    var compare = require_compare();
    var lt2 = /* @__PURE__ */ __name((a, b2, loose) => compare(a, b2, loose) < 0, "lt");
    module3.exports = lt2;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/eq.js
var require_eq = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/eq.js"(exports2, module3) {
    init_import_meta_url();
    var compare = require_compare();
    var eq = /* @__PURE__ */ __name((a, b2, loose) => compare(a, b2, loose) === 0, "eq");
    module3.exports = eq;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/neq.js
var require_neq = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/neq.js"(exports2, module3) {
    init_import_meta_url();
    var compare = require_compare();
    var neq = /* @__PURE__ */ __name((a, b2, loose) => compare(a, b2, loose) !== 0, "neq");
    module3.exports = neq;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/gte.js
var require_gte = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/gte.js"(exports2, module3) {
    init_import_meta_url();
    var compare = require_compare();
    var gte = /* @__PURE__ */ __name((a, b2, loose) => compare(a, b2, loose) >= 0, "gte");
    module3.exports = gte;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/lte.js
var require_lte = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/lte.js"(exports2, module3) {
    init_import_meta_url();
    var compare = require_compare();
    var lte = /* @__PURE__ */ __name((a, b2, loose) => compare(a, b2, loose) <= 0, "lte");
    module3.exports = lte;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/cmp.js
var require_cmp = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/cmp.js"(exports2, module3) {
    init_import_meta_url();
    var eq = require_eq();
    var neq = require_neq();
    var gt = require_gt();
    var gte = require_gte();
    var lt2 = require_lt();
    var lte = require_lte();
    var cmp = /* @__PURE__ */ __name((a, op, b2, loose) => {
      switch (op) {
        case "===":
          if (typeof a === "object") {
            a = a.version;
          }
          if (typeof b2 === "object") {
            b2 = b2.version;
          }
          return a === b2;
        case "!==":
          if (typeof a === "object") {
            a = a.version;
          }
          if (typeof b2 === "object") {
            b2 = b2.version;
          }
          return a !== b2;
        case "":
        case "=":
        case "==":
          return eq(a, b2, loose);
        case "!=":
          return neq(a, b2, loose);
        case ">":
          return gt(a, b2, loose);
        case ">=":
          return gte(a, b2, loose);
        case "<":
          return lt2(a, b2, loose);
        case "<=":
          return lte(a, b2, loose);
        default:
          throw new TypeError(`Invalid operator: ${op}`);
      }
    }, "cmp");
    module3.exports = cmp;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/coerce.js
var require_coerce = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/coerce.js"(exports2, module3) {
    init_import_meta_url();
    var SemVer = require_semver();
    var parse7 = require_parse6();
    var { safeRe: re, t: t3 } = require_re();
    var coerce = /* @__PURE__ */ __name((version3, options29) => {
      if (version3 instanceof SemVer) {
        return version3;
      }
      if (typeof version3 === "number") {
        version3 = String(version3);
      }
      if (typeof version3 !== "string") {
        return null;
      }
      options29 = options29 || {};
      let match = null;
      if (!options29.rtl) {
        match = version3.match(re[t3.COERCE]);
      } else {
        let next;
        while ((next = re[t3.COERCERTL].exec(version3)) && (!match || match.index + match[0].length !== version3.length)) {
          if (!match || next.index + next[0].length !== match.index + match[0].length) {
            match = next;
          }
          re[t3.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
        }
        re[t3.COERCERTL].lastIndex = -1;
      }
      if (match === null) {
        return null;
      }
      return parse7(`${match[2]}.${match[3] || "0"}.${match[4] || "0"}`, options29);
    }, "coerce");
    module3.exports = coerce;
  }
});

// ../../node_modules/.pnpm/yallist@4.0.0/node_modules/yallist/iterator.js
var require_iterator = __commonJS({
  "../../node_modules/.pnpm/yallist@4.0.0/node_modules/yallist/iterator.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = function(Yallist) {
      Yallist.prototype[Symbol.iterator] = function* () {
        for (let walker = this.head; walker; walker = walker.next) {
          yield walker.value;
        }
      };
    };
  }
});

// ../../node_modules/.pnpm/yallist@4.0.0/node_modules/yallist/yallist.js
var require_yallist = __commonJS({
  "../../node_modules/.pnpm/yallist@4.0.0/node_modules/yallist/yallist.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = Yallist;
    Yallist.Node = Node3;
    Yallist.create = Yallist;
    function Yallist(list) {
      var self2 = this;
      if (!(self2 instanceof Yallist)) {
        self2 = new Yallist();
      }
      self2.tail = null;
      self2.head = null;
      self2.length = 0;
      if (list && typeof list.forEach === "function") {
        list.forEach(function(item) {
          self2.push(item);
        });
      } else if (arguments.length > 0) {
        for (var i = 0, l2 = arguments.length; i < l2; i++) {
          self2.push(arguments[i]);
        }
      }
      return self2;
    }
    __name(Yallist, "Yallist");
    Yallist.prototype.removeNode = function(node2) {
      if (node2.list !== this) {
        throw new Error("removing node which does not belong to this list");
      }
      var next = node2.next;
      var prev = node2.prev;
      if (next) {
        next.prev = prev;
      }
      if (prev) {
        prev.next = next;
      }
      if (node2 === this.head) {
        this.head = next;
      }
      if (node2 === this.tail) {
        this.tail = prev;
      }
      node2.list.length--;
      node2.next = null;
      node2.prev = null;
      node2.list = null;
      return next;
    };
    Yallist.prototype.unshiftNode = function(node2) {
      if (node2 === this.head) {
        return;
      }
      if (node2.list) {
        node2.list.removeNode(node2);
      }
      var head = this.head;
      node2.list = this;
      node2.next = head;
      if (head) {
        head.prev = node2;
      }
      this.head = node2;
      if (!this.tail) {
        this.tail = node2;
      }
      this.length++;
    };
    Yallist.prototype.pushNode = function(node2) {
      if (node2 === this.tail) {
        return;
      }
      if (node2.list) {
        node2.list.removeNode(node2);
      }
      var tail = this.tail;
      node2.list = this;
      node2.prev = tail;
      if (tail) {
        tail.next = node2;
      }
      this.tail = node2;
      if (!this.head) {
        this.head = node2;
      }
      this.length++;
    };
    Yallist.prototype.push = function() {
      for (var i = 0, l2 = arguments.length; i < l2; i++) {
        push(this, arguments[i]);
      }
      return this.length;
    };
    Yallist.prototype.unshift = function() {
      for (var i = 0, l2 = arguments.length; i < l2; i++) {
        unshift(this, arguments[i]);
      }
      return this.length;
    };
    Yallist.prototype.pop = function() {
      if (!this.tail) {
        return void 0;
      }
      var res = this.tail.value;
      this.tail = this.tail.prev;
      if (this.tail) {
        this.tail.next = null;
      } else {
        this.head = null;
      }
      this.length--;
      return res;
    };
    Yallist.prototype.shift = function() {
      if (!this.head) {
        return void 0;
      }
      var res = this.head.value;
      this.head = this.head.next;
      if (this.head) {
        this.head.prev = null;
      } else {
        this.tail = null;
      }
      this.length--;
      return res;
    };
    Yallist.prototype.forEach = function(fn2, thisp) {
      thisp = thisp || this;
      for (var walker = this.head, i = 0; walker !== null; i++) {
        fn2.call(thisp, walker.value, i, this);
        walker = walker.next;
      }
    };
    Yallist.prototype.forEachReverse = function(fn2, thisp) {
      thisp = thisp || this;
      for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
        fn2.call(thisp, walker.value, i, this);
        walker = walker.prev;
      }
    };
    Yallist.prototype.get = function(n2) {
      for (var i = 0, walker = this.head; walker !== null && i < n2; i++) {
        walker = walker.next;
      }
      if (i === n2 && walker !== null) {
        return walker.value;
      }
    };
    Yallist.prototype.getReverse = function(n2) {
      for (var i = 0, walker = this.tail; walker !== null && i < n2; i++) {
        walker = walker.prev;
      }
      if (i === n2 && walker !== null) {
        return walker.value;
      }
    };
    Yallist.prototype.map = function(fn2, thisp) {
      thisp = thisp || this;
      var res = new Yallist();
      for (var walker = this.head; walker !== null; ) {
        res.push(fn2.call(thisp, walker.value, this));
        walker = walker.next;
      }
      return res;
    };
    Yallist.prototype.mapReverse = function(fn2, thisp) {
      thisp = thisp || this;
      var res = new Yallist();
      for (var walker = this.tail; walker !== null; ) {
        res.push(fn2.call(thisp, walker.value, this));
        walker = walker.prev;
      }
      return res;
    };
    Yallist.prototype.reduce = function(fn2, initial) {
      var acc;
      var walker = this.head;
      if (arguments.length > 1) {
        acc = initial;
      } else if (this.head) {
        walker = this.head.next;
        acc = this.head.value;
      } else {
        throw new TypeError("Reduce of empty list with no initial value");
      }
      for (var i = 0; walker !== null; i++) {
        acc = fn2(acc, walker.value, i);
        walker = walker.next;
      }
      return acc;
    };
    Yallist.prototype.reduceReverse = function(fn2, initial) {
      var acc;
      var walker = this.tail;
      if (arguments.length > 1) {
        acc = initial;
      } else if (this.tail) {
        walker = this.tail.prev;
        acc = this.tail.value;
      } else {
        throw new TypeError("Reduce of empty list with no initial value");
      }
      for (var i = this.length - 1; walker !== null; i--) {
        acc = fn2(acc, walker.value, i);
        walker = walker.prev;
      }
      return acc;
    };
    Yallist.prototype.toArray = function() {
      var arr = new Array(this.length);
      for (var i = 0, walker = this.head; walker !== null; i++) {
        arr[i] = walker.value;
        walker = walker.next;
      }
      return arr;
    };
    Yallist.prototype.toArrayReverse = function() {
      var arr = new Array(this.length);
      for (var i = 0, walker = this.tail; walker !== null; i++) {
        arr[i] = walker.value;
        walker = walker.prev;
      }
      return arr;
    };
    Yallist.prototype.slice = function(from, to) {
      to = to || this.length;
      if (to < 0) {
        to += this.length;
      }
      from = from || 0;
      if (from < 0) {
        from += this.length;
      }
      var ret = new Yallist();
      if (to < from || to < 0) {
        return ret;
      }
      if (from < 0) {
        from = 0;
      }
      if (to > this.length) {
        to = this.length;
      }
      for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
        walker = walker.next;
      }
      for (; walker !== null && i < to; i++, walker = walker.next) {
        ret.push(walker.value);
      }
      return ret;
    };
    Yallist.prototype.sliceReverse = function(from, to) {
      to = to || this.length;
      if (to < 0) {
        to += this.length;
      }
      from = from || 0;
      if (from < 0) {
        from += this.length;
      }
      var ret = new Yallist();
      if (to < from || to < 0) {
        return ret;
      }
      if (from < 0) {
        from = 0;
      }
      if (to > this.length) {
        to = this.length;
      }
      for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
        walker = walker.prev;
      }
      for (; walker !== null && i > from; i--, walker = walker.prev) {
        ret.push(walker.value);
      }
      return ret;
    };
    Yallist.prototype.splice = function(start, deleteCount, ...nodes) {
      if (start > this.length) {
        start = this.length - 1;
      }
      if (start < 0) {
        start = this.length + start;
      }
      for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
        walker = walker.next;
      }
      var ret = [];
      for (var i = 0; walker && i < deleteCount; i++) {
        ret.push(walker.value);
        walker = this.removeNode(walker);
      }
      if (walker === null) {
        walker = this.tail;
      }
      if (walker !== this.head && walker !== this.tail) {
        walker = walker.prev;
      }
      for (var i = 0; i < nodes.length; i++) {
        walker = insert(this, walker, nodes[i]);
      }
      return ret;
    };
    Yallist.prototype.reverse = function() {
      var head = this.head;
      var tail = this.tail;
      for (var walker = head; walker !== null; walker = walker.prev) {
        var p2 = walker.prev;
        walker.prev = walker.next;
        walker.next = p2;
      }
      this.head = tail;
      this.tail = head;
      return this;
    };
    function insert(self2, node2, value) {
      var inserted = node2 === self2.head ? new Node3(value, null, node2, self2) : new Node3(value, node2, node2.next, self2);
      if (inserted.next === null) {
        self2.tail = inserted;
      }
      if (inserted.prev === null) {
        self2.head = inserted;
      }
      self2.length++;
      return inserted;
    }
    __name(insert, "insert");
    function push(self2, item) {
      self2.tail = new Node3(item, self2.tail, null, self2);
      if (!self2.head) {
        self2.head = self2.tail;
      }
      self2.length++;
    }
    __name(push, "push");
    function unshift(self2, item) {
      self2.head = new Node3(item, null, self2.head, self2);
      if (!self2.tail) {
        self2.tail = self2.head;
      }
      self2.length++;
    }
    __name(unshift, "unshift");
    function Node3(value, prev, next, list) {
      if (!(this instanceof Node3)) {
        return new Node3(value, prev, next, list);
      }
      this.list = list;
      this.value = value;
      if (prev) {
        prev.next = this;
        this.prev = prev;
      } else {
        this.prev = null;
      }
      if (next) {
        next.prev = this;
        this.next = next;
      } else {
        this.next = null;
      }
    }
    __name(Node3, "Node");
    try {
      require_iterator()(Yallist);
    } catch (er) {
    }
  }
});

// ../../node_modules/.pnpm/lru-cache@6.0.0/node_modules/lru-cache/index.js
var require_lru_cache = __commonJS({
  "../../node_modules/.pnpm/lru-cache@6.0.0/node_modules/lru-cache/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var Yallist = require_yallist();
    var MAX = Symbol("max");
    var LENGTH = Symbol("length");
    var LENGTH_CALCULATOR = Symbol("lengthCalculator");
    var ALLOW_STALE = Symbol("allowStale");
    var MAX_AGE = Symbol("maxAge");
    var DISPOSE = Symbol("dispose");
    var NO_DISPOSE_ON_SET = Symbol("noDisposeOnSet");
    var LRU_LIST = Symbol("lruList");
    var CACHE = Symbol("cache");
    var UPDATE_AGE_ON_GET = Symbol("updateAgeOnGet");
    var naiveLength = /* @__PURE__ */ __name(() => 1, "naiveLength");
    var LRUCache = class {
      constructor(options29) {
        if (typeof options29 === "number")
          options29 = { max: options29 };
        if (!options29)
          options29 = {};
        if (options29.max && (typeof options29.max !== "number" || options29.max < 0))
          throw new TypeError("max must be a non-negative number");
        const max = this[MAX] = options29.max || Infinity;
        const lc = options29.length || naiveLength;
        this[LENGTH_CALCULATOR] = typeof lc !== "function" ? naiveLength : lc;
        this[ALLOW_STALE] = options29.stale || false;
        if (options29.maxAge && typeof options29.maxAge !== "number")
          throw new TypeError("maxAge must be a number");
        this[MAX_AGE] = options29.maxAge || 0;
        this[DISPOSE] = options29.dispose;
        this[NO_DISPOSE_ON_SET] = options29.noDisposeOnSet || false;
        this[UPDATE_AGE_ON_GET] = options29.updateAgeOnGet || false;
        this.reset();
      }
      // resize the cache when the max changes.
      set max(mL) {
        if (typeof mL !== "number" || mL < 0)
          throw new TypeError("max must be a non-negative number");
        this[MAX] = mL || Infinity;
        trim(this);
      }
      get max() {
        return this[MAX];
      }
      set allowStale(allowStale) {
        this[ALLOW_STALE] = !!allowStale;
      }
      get allowStale() {
        return this[ALLOW_STALE];
      }
      set maxAge(mA) {
        if (typeof mA !== "number")
          throw new TypeError("maxAge must be a non-negative number");
        this[MAX_AGE] = mA;
        trim(this);
      }
      get maxAge() {
        return this[MAX_AGE];
      }
      // resize the cache when the lengthCalculator changes.
      set lengthCalculator(lC) {
        if (typeof lC !== "function")
          lC = naiveLength;
        if (lC !== this[LENGTH_CALCULATOR]) {
          this[LENGTH_CALCULATOR] = lC;
          this[LENGTH] = 0;
          this[LRU_LIST].forEach((hit) => {
            hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key);
            this[LENGTH] += hit.length;
          });
        }
        trim(this);
      }
      get lengthCalculator() {
        return this[LENGTH_CALCULATOR];
      }
      get length() {
        return this[LENGTH];
      }
      get itemCount() {
        return this[LRU_LIST].length;
      }
      rforEach(fn2, thisp) {
        thisp = thisp || this;
        for (let walker = this[LRU_LIST].tail; walker !== null; ) {
          const prev = walker.prev;
          forEachStep(this, fn2, walker, thisp);
          walker = prev;
        }
      }
      forEach(fn2, thisp) {
        thisp = thisp || this;
        for (let walker = this[LRU_LIST].head; walker !== null; ) {
          const next = walker.next;
          forEachStep(this, fn2, walker, thisp);
          walker = next;
        }
      }
      keys() {
        return this[LRU_LIST].toArray().map((k2) => k2.key);
      }
      values() {
        return this[LRU_LIST].toArray().map((k2) => k2.value);
      }
      reset() {
        if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) {
          this[LRU_LIST].forEach((hit) => this[DISPOSE](hit.key, hit.value));
        }
        this[CACHE] = /* @__PURE__ */ new Map();
        this[LRU_LIST] = new Yallist();
        this[LENGTH] = 0;
      }
      dump() {
        return this[LRU_LIST].map((hit) => isStale(this, hit) ? false : {
          k: hit.key,
          v: hit.value,
          e: hit.now + (hit.maxAge || 0)
        }).toArray().filter((h2) => h2);
      }
      dumpLru() {
        return this[LRU_LIST];
      }
      set(key, value, maxAge) {
        maxAge = maxAge || this[MAX_AGE];
        if (maxAge && typeof maxAge !== "number")
          throw new TypeError("maxAge must be a number");
        const now = maxAge ? Date.now() : 0;
        const len = this[LENGTH_CALCULATOR](value, key);
        if (this[CACHE].has(key)) {
          if (len > this[MAX]) {
            del(this, this[CACHE].get(key));
            return false;
          }
          const node2 = this[CACHE].get(key);
          const item = node2.value;
          if (this[DISPOSE]) {
            if (!this[NO_DISPOSE_ON_SET])
              this[DISPOSE](key, item.value);
          }
          item.now = now;
          item.maxAge = maxAge;
          item.value = value;
          this[LENGTH] += len - item.length;
          item.length = len;
          this.get(key);
          trim(this);
          return true;
        }
        const hit = new Entry(key, value, len, now, maxAge);
        if (hit.length > this[MAX]) {
          if (this[DISPOSE])
            this[DISPOSE](key, value);
          return false;
        }
        this[LENGTH] += hit.length;
        this[LRU_LIST].unshift(hit);
        this[CACHE].set(key, this[LRU_LIST].head);
        trim(this);
        return true;
      }
      has(key) {
        if (!this[CACHE].has(key))
          return false;
        const hit = this[CACHE].get(key).value;
        return !isStale(this, hit);
      }
      get(key) {
        return get(this, key, true);
      }
      peek(key) {
        return get(this, key, false);
      }
      pop() {
        const node2 = this[LRU_LIST].tail;
        if (!node2)
          return null;
        del(this, node2);
        return node2.value;
      }
      del(key) {
        del(this, this[CACHE].get(key));
      }
      load(arr) {
        this.reset();
        const now = Date.now();
        for (let l2 = arr.length - 1; l2 >= 0; l2--) {
          const hit = arr[l2];
          const expiresAt = hit.e || 0;
          if (expiresAt === 0)
            this.set(hit.k, hit.v);
          else {
            const maxAge = expiresAt - now;
            if (maxAge > 0) {
              this.set(hit.k, hit.v, maxAge);
            }
          }
        }
      }
      prune() {
        this[CACHE].forEach((value, key) => get(this, key, false));
      }
    };
    __name(LRUCache, "LRUCache");
    var get = /* @__PURE__ */ __name((self2, key, doUse) => {
      const node2 = self2[CACHE].get(key);
      if (node2) {
        const hit = node2.value;
        if (isStale(self2, hit)) {
          del(self2, node2);
          if (!self2[ALLOW_STALE])
            return void 0;
        } else {
          if (doUse) {
            if (self2[UPDATE_AGE_ON_GET])
              node2.value.now = Date.now();
            self2[LRU_LIST].unshiftNode(node2);
          }
        }
        return hit.value;
      }
    }, "get");
    var isStale = /* @__PURE__ */ __name((self2, hit) => {
      if (!hit || !hit.maxAge && !self2[MAX_AGE])
        return false;
      const diff = Date.now() - hit.now;
      return hit.maxAge ? diff > hit.maxAge : self2[MAX_AGE] && diff > self2[MAX_AGE];
    }, "isStale");
    var trim = /* @__PURE__ */ __name((self2) => {
      if (self2[LENGTH] > self2[MAX]) {
        for (let walker = self2[LRU_LIST].tail; self2[LENGTH] > self2[MAX] && walker !== null; ) {
          const prev = walker.prev;
          del(self2, walker);
          walker = prev;
        }
      }
    }, "trim");
    var del = /* @__PURE__ */ __name((self2, node2) => {
      if (node2) {
        const hit = node2.value;
        if (self2[DISPOSE])
          self2[DISPOSE](hit.key, hit.value);
        self2[LENGTH] -= hit.length;
        self2[CACHE].delete(hit.key);
        self2[LRU_LIST].removeNode(node2);
      }
    }, "del");
    var Entry = class {
      constructor(key, value, length, now, maxAge) {
        this.key = key;
        this.value = value;
        this.length = length;
        this.now = now;
        this.maxAge = maxAge || 0;
      }
    };
    __name(Entry, "Entry");
    var forEachStep = /* @__PURE__ */ __name((self2, fn2, node2, thisp) => {
      let hit = node2.value;
      if (isStale(self2, hit)) {
        del(self2, node2);
        if (!self2[ALLOW_STALE])
          hit = void 0;
      }
      if (hit)
        fn2.call(thisp, hit.value, hit.key, self2);
    }, "forEachStep");
    module3.exports = LRUCache;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/classes/range.js
var require_range = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/classes/range.js"(exports2, module3) {
    init_import_meta_url();
    var Range = class {
      constructor(range, options29) {
        options29 = parseOptions(options29);
        if (range instanceof Range) {
          if (range.loose === !!options29.loose && range.includePrerelease === !!options29.includePrerelease) {
            return range;
          } else {
            return new Range(range.raw, options29);
          }
        }
        if (range instanceof Comparator) {
          this.raw = range.value;
          this.set = [[range]];
          this.format();
          return this;
        }
        this.options = options29;
        this.loose = !!options29.loose;
        this.includePrerelease = !!options29.includePrerelease;
        this.raw = range.trim().split(/\s+/).join(" ");
        this.set = this.raw.split("||").map((r3) => this.parseRange(r3.trim())).filter((c2) => c2.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((c2) => !isNullSet(c2[0]));
          if (this.set.length === 0) {
            this.set = [first];
          } else if (this.set.length > 1) {
            for (const c2 of this.set) {
              if (c2.length === 1 && isAny(c2[0])) {
                this.set = [c2];
                break;
              }
            }
          }
        }
        this.format();
      }
      format() {
        this.range = this.set.map((comps) => comps.join(" ").trim()).join("||").trim();
        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 cached = cache2.get(memoKey);
        if (cached) {
          return cached;
        }
        const loose = this.options.loose;
        const hr = loose ? re[t3.HYPHENRANGELOOSE] : re[t3.HYPHENRANGE];
        range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
        debug("hyphen replace", range);
        range = range.replace(re[t3.COMPARATORTRIM], comparatorTrimReplace);
        debug("comparator trim", range);
        range = range.replace(re[t3.TILDETRIM], tildeTrimReplace);
        debug("tilde trim", range);
        range = range.replace(re[t3.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(re[t3.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()];
        cache2.set(memoKey, result);
        return result;
      }
      intersects(range, options29) {
        if (!(range instanceof Range)) {
          throw new TypeError("a Range is required");
        }
        return this.set.some((thisComparators) => {
          return isSatisfiable(thisComparators, options29) && range.set.some((rangeComparators) => {
            return isSatisfiable(rangeComparators, options29) && thisComparators.every((thisComparator) => {
              return rangeComparators.every((rangeComparator) => {
                return thisComparator.intersects(rangeComparator, options29);
              });
            });
          });
        });
      }
      // 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;
      }
    };
    __name(Range, "Range");
    module3.exports = Range;
    var LRU = require_lru_cache();
    var cache2 = new LRU({ max: 1e3 });
    var parseOptions = require_parse_options();
    var Comparator = require_comparator();
    var debug = require_debug3();
    var SemVer = require_semver();
    var {
      safeRe: re,
      t: t3,
      comparatorTrimReplace,
      tildeTrimReplace,
      caretTrimReplace
    } = require_re();
    var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants8();
    var isNullSet = /* @__PURE__ */ __name((c2) => c2.value === "<0.0.0-0", "isNullSet");
    var isAny = /* @__PURE__ */ __name((c2) => c2.value === "", "isAny");
    var isSatisfiable = /* @__PURE__ */ __name((comparators, options29) => {
      let result = true;
      const remainingComparators = comparators.slice();
      let testComparator = remainingComparators.pop();
      while (result && remainingComparators.length) {
        result = remainingComparators.every((otherComparator) => {
          return testComparator.intersects(otherComparator, options29);
        });
        testComparator = remainingComparators.pop();
      }
      return result;
    }, "isSatisfiable");
    var parseComparator = /* @__PURE__ */ __name((comp, options29) => {
      debug("comp", comp, options29);
      comp = replaceCarets(comp, options29);
      debug("caret", comp);
      comp = replaceTildes(comp, options29);
      debug("tildes", comp);
      comp = replaceXRanges(comp, options29);
      debug("xrange", comp);
      comp = replaceStars(comp, options29);
      debug("stars", comp);
      return comp;
    }, "parseComparator");
    var isX = /* @__PURE__ */ __name((id) => !id || id.toLowerCase() === "x" || id === "*", "isX");
    var replaceTildes = /* @__PURE__ */ __name((comp, options29) => {
      return comp.trim().split(/\s+/).map((c2) => replaceTilde(c2, options29)).join(" ");
    }, "replaceTildes");
    var replaceTilde = /* @__PURE__ */ __name((comp, options29) => {
      const r3 = options29.loose ? re[t3.TILDELOOSE] : re[t3.TILDE];
      return comp.replace(r3, (_3, M2, m2, p2, pr) => {
        debug("tilde", comp, _3, M2, m2, p2, pr);
        let ret;
        if (isX(M2)) {
          ret = "";
        } else if (isX(m2)) {
          ret = `>=${M2}.0.0 <${+M2 + 1}.0.0-0`;
        } else if (isX(p2)) {
          ret = `>=${M2}.${m2}.0 <${M2}.${+m2 + 1}.0-0`;
        } else if (pr) {
          debug("replaceTilde pr", pr);
          ret = `>=${M2}.${m2}.${p2}-${pr} <${M2}.${+m2 + 1}.0-0`;
        } else {
          ret = `>=${M2}.${m2}.${p2} <${M2}.${+m2 + 1}.0-0`;
        }
        debug("tilde return", ret);
        return ret;
      });
    }, "replaceTilde");
    var replaceCarets = /* @__PURE__ */ __name((comp, options29) => {
      return comp.trim().split(/\s+/).map((c2) => replaceCaret(c2, options29)).join(" ");
    }, "replaceCarets");
    var replaceCaret = /* @__PURE__ */ __name((comp, options29) => {
      debug("caret", comp, options29);
      const r3 = options29.loose ? re[t3.CARETLOOSE] : re[t3.CARET];
      const z2 = options29.includePrerelease ? "-0" : "";
      return comp.replace(r3, (_3, M2, m2, p2, pr) => {
        debug("caret", comp, _3, M2, m2, p2, pr);
        let ret;
        if (isX(M2)) {
          ret = "";
        } else if (isX(m2)) {
          ret = `>=${M2}.0.0${z2} <${+M2 + 1}.0.0-0`;
        } else if (isX(p2)) {
          if (M2 === "0") {
            ret = `>=${M2}.${m2}.0${z2} <${M2}.${+m2 + 1}.0-0`;
          } else {
            ret = `>=${M2}.${m2}.0${z2} <${+M2 + 1}.0.0-0`;
          }
        } else if (pr) {
          debug("replaceCaret pr", pr);
          if (M2 === "0") {
            if (m2 === "0") {
              ret = `>=${M2}.${m2}.${p2}-${pr} <${M2}.${m2}.${+p2 + 1}-0`;
            } else {
              ret = `>=${M2}.${m2}.${p2}-${pr} <${M2}.${+m2 + 1}.0-0`;
            }
          } else {
            ret = `>=${M2}.${m2}.${p2}-${pr} <${+M2 + 1}.0.0-0`;
          }
        } else {
          debug("no pr");
          if (M2 === "0") {
            if (m2 === "0") {
              ret = `>=${M2}.${m2}.${p2}${z2} <${M2}.${m2}.${+p2 + 1}-0`;
            } else {
              ret = `>=${M2}.${m2}.${p2}${z2} <${M2}.${+m2 + 1}.0-0`;
            }
          } else {
            ret = `>=${M2}.${m2}.${p2} <${+M2 + 1}.0.0-0`;
          }
        }
        debug("caret return", ret);
        return ret;
      });
    }, "replaceCaret");
    var replaceXRanges = /* @__PURE__ */ __name((comp, options29) => {
      debug("replaceXRanges", comp, options29);
      return comp.split(/\s+/).map((c2) => replaceXRange(c2, options29)).join(" ");
    }, "replaceXRanges");
    var replaceXRange = /* @__PURE__ */ __name((comp, options29) => {
      comp = comp.trim();
      const r3 = options29.loose ? re[t3.XRANGELOOSE] : re[t3.XRANGE];
      return comp.replace(r3, (ret, gtlt, M2, m2, p2, pr) => {
        debug("xRange", comp, ret, gtlt, M2, m2, p2, pr);
        const xM = isX(M2);
        const xm = xM || isX(m2);
        const xp = xm || isX(p2);
        const anyX = xp;
        if (gtlt === "=" && anyX) {
          gtlt = "";
        }
        pr = options29.includePrerelease ? "-0" : "";
        if (xM) {
          if (gtlt === ">" || gtlt === "<") {
            ret = "<0.0.0-0";
          } else {
            ret = "*";
          }
        } else if (gtlt && anyX) {
          if (xm) {
            m2 = 0;
          }
          p2 = 0;
          if (gtlt === ">") {
            gtlt = ">=";
            if (xm) {
              M2 = +M2 + 1;
              m2 = 0;
              p2 = 0;
            } else {
              m2 = +m2 + 1;
              p2 = 0;
            }
          } else if (gtlt === "<=") {
            gtlt = "<";
            if (xm) {
              M2 = +M2 + 1;
            } else {
              m2 = +m2 + 1;
            }
          }
          if (gtlt === "<") {
            pr = "-0";
          }
          ret = `${gtlt + M2}.${m2}.${p2}${pr}`;
        } else if (xm) {
          ret = `>=${M2}.0.0${pr} <${+M2 + 1}.0.0-0`;
        } else if (xp) {
          ret = `>=${M2}.${m2}.0${pr} <${M2}.${+m2 + 1}.0-0`;
        }
        debug("xRange return", ret);
        return ret;
      });
    }, "replaceXRange");
    var replaceStars = /* @__PURE__ */ __name((comp, options29) => {
      debug("replaceStars", comp, options29);
      return comp.trim().replace(re[t3.STAR], "");
    }, "replaceStars");
    var replaceGTE0 = /* @__PURE__ */ __name((comp, options29) => {
      debug("replaceGTE0", comp, options29);
      return comp.trim().replace(re[options29.includePrerelease ? t3.GTE0PRE : t3.GTE0], "");
    }, "replaceGTE0");
    var hyphenReplace = /* @__PURE__ */ __name((incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) => {
      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();
    }, "hyphenReplace");
    var testSet = /* @__PURE__ */ __name((set, version3, options29) => {
      for (let i = 0; i < set.length; i++) {
        if (!set[i].test(version3)) {
          return false;
        }
      }
      if (version3.prerelease.length && !options29.includePrerelease) {
        for (let i = 0; i < set.length; i++) {
          debug(set[i].semver);
          if (set[i].semver === Comparator.ANY) {
            continue;
          }
          if (set[i].semver.prerelease.length > 0) {
            const allowed = set[i].semver;
            if (allowed.major === version3.major && allowed.minor === version3.minor && allowed.patch === version3.patch) {
              return true;
            }
          }
        }
        return false;
      }
      return true;
    }, "testSet");
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/classes/comparator.js
var require_comparator = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/classes/comparator.js"(exports2, module3) {
    init_import_meta_url();
    var ANY = Symbol("SemVer ANY");
    var Comparator = class {
      static get ANY() {
        return ANY;
      }
      constructor(comp, options29) {
        options29 = parseOptions(options29);
        if (comp instanceof Comparator) {
          if (comp.loose === !!options29.loose) {
            return comp;
          } else {
            comp = comp.value;
          }
        }
        comp = comp.trim().split(/\s+/).join(" ");
        debug("comparator", comp, options29);
        this.options = options29;
        this.loose = !!options29.loose;
        this.parse(comp);
        if (this.semver === ANY) {
          this.value = "";
        } else {
          this.value = this.operator + this.semver.version;
        }
        debug("comp", this);
      }
      parse(comp) {
        const r3 = this.options.loose ? re[t3.COMPARATORLOOSE] : re[t3.COMPARATOR];
        const m2 = comp.match(r3);
        if (!m2) {
          throw new TypeError(`Invalid comparator: ${comp}`);
        }
        this.operator = m2[1] !== void 0 ? m2[1] : "";
        if (this.operator === "=") {
          this.operator = "";
        }
        if (!m2[2]) {
          this.semver = ANY;
        } else {
          this.semver = new SemVer(m2[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, options29) {
        if (!(comp instanceof Comparator)) {
          throw new TypeError("a Comparator is required");
        }
        if (this.operator === "") {
          if (this.value === "") {
            return true;
          }
          return new Range(comp.value, options29).test(this.value);
        } else if (comp.operator === "") {
          if (comp.value === "") {
            return true;
          }
          return new Range(this.value, options29).test(comp.semver);
        }
        options29 = parseOptions(options29);
        if (options29.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
          return false;
        }
        if (!options29.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, options29) && this.operator.startsWith(">") && comp.operator.startsWith("<")) {
          return true;
        }
        if (cmp(this.semver, ">", comp.semver, options29) && this.operator.startsWith("<") && comp.operator.startsWith(">")) {
          return true;
        }
        return false;
      }
    };
    __name(Comparator, "Comparator");
    module3.exports = Comparator;
    var parseOptions = require_parse_options();
    var { safeRe: re, t: t3 } = require_re();
    var cmp = require_cmp();
    var debug = require_debug3();
    var SemVer = require_semver();
    var Range = require_range();
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/satisfies.js
var require_satisfies = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/functions/satisfies.js"(exports2, module3) {
    init_import_meta_url();
    var Range = require_range();
    var satisfies = /* @__PURE__ */ __name((version3, range, options29) => {
      try {
        range = new Range(range, options29);
      } catch (er) {
        return false;
      }
      return range.test(version3);
    }, "satisfies");
    module3.exports = satisfies;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/ranges/to-comparators.js
var require_to_comparators = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/ranges/to-comparators.js"(exports2, module3) {
    init_import_meta_url();
    var Range = require_range();
    var toComparators = /* @__PURE__ */ __name((range, options29) => new Range(range, options29).set.map((comp) => comp.map((c2) => c2.value).join(" ").trim().split(" ")), "toComparators");
    module3.exports = toComparators;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/ranges/max-satisfying.js
var require_max_satisfying = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/ranges/max-satisfying.js"(exports2, module3) {
    init_import_meta_url();
    var SemVer = require_semver();
    var Range = require_range();
    var maxSatisfying = /* @__PURE__ */ __name((versions, range, options29) => {
      let max = null;
      let maxSV = null;
      let rangeObj = null;
      try {
        rangeObj = new Range(range, options29);
      } catch (er) {
        return null;
      }
      versions.forEach((v2) => {
        if (rangeObj.test(v2)) {
          if (!max || maxSV.compare(v2) === -1) {
            max = v2;
            maxSV = new SemVer(max, options29);
          }
        }
      });
      return max;
    }, "maxSatisfying");
    module3.exports = maxSatisfying;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/ranges/min-satisfying.js
var require_min_satisfying = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/ranges/min-satisfying.js"(exports2, module3) {
    init_import_meta_url();
    var SemVer = require_semver();
    var Range = require_range();
    var minSatisfying = /* @__PURE__ */ __name((versions, range, options29) => {
      let min = null;
      let minSV = null;
      let rangeObj = null;
      try {
        rangeObj = new Range(range, options29);
      } catch (er) {
        return null;
      }
      versions.forEach((v2) => {
        if (rangeObj.test(v2)) {
          if (!min || minSV.compare(v2) === 1) {
            min = v2;
            minSV = new SemVer(min, options29);
          }
        }
      });
      return min;
    }, "minSatisfying");
    module3.exports = minSatisfying;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/ranges/min-version.js
var require_min_version = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/ranges/min-version.js"(exports2, module3) {
    init_import_meta_url();
    var SemVer = require_semver();
    var Range = require_range();
    var gt = require_gt();
    var minVersion = /* @__PURE__ */ __name((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();
            case "":
            case ">=":
              if (!setMin || gt(compver, setMin)) {
                setMin = compver;
              }
              break;
            case "<":
            case "<=":
              break;
            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;
    }, "minVersion");
    module3.exports = minVersion;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/ranges/valid.js
var require_valid2 = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/ranges/valid.js"(exports2, module3) {
    init_import_meta_url();
    var Range = require_range();
    var validRange = /* @__PURE__ */ __name((range, options29) => {
      try {
        return new Range(range, options29).range || "*";
      } catch (er) {
        return null;
      }
    }, "validRange");
    module3.exports = validRange;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/ranges/outside.js
var require_outside = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/ranges/outside.js"(exports2, module3) {
    init_import_meta_url();
    var SemVer = require_semver();
    var Comparator = require_comparator();
    var { ANY } = Comparator;
    var Range = require_range();
    var satisfies = require_satisfies();
    var gt = require_gt();
    var lt2 = require_lt();
    var lte = require_lte();
    var gte = require_gte();
    var outside = /* @__PURE__ */ __name((version3, range, hilo, options29) => {
      version3 = new SemVer(version3, options29);
      range = new Range(range, options29);
      let gtfn, ltefn, ltfn, comp, ecomp;
      switch (hilo) {
        case ">":
          gtfn = gt;
          ltefn = lte;
          ltfn = lt2;
          comp = ">";
          ecomp = ">=";
          break;
        case "<":
          gtfn = lt2;
          ltefn = gte;
          ltfn = gt;
          comp = "<";
          ecomp = "<=";
          break;
        default:
          throw new TypeError('Must provide a hilo val of "<" or ">"');
      }
      if (satisfies(version3, range, options29)) {
        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, options29)) {
            high = comparator;
          } else if (ltfn(comparator.semver, low.semver, options29)) {
            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;
    }, "outside");
    module3.exports = outside;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/ranges/gtr.js
var require_gtr = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/ranges/gtr.js"(exports2, module3) {
    init_import_meta_url();
    var outside = require_outside();
    var gtr = /* @__PURE__ */ __name((version3, range, options29) => outside(version3, range, ">", options29), "gtr");
    module3.exports = gtr;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/ranges/ltr.js
var require_ltr = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/ranges/ltr.js"(exports2, module3) {
    init_import_meta_url();
    var outside = require_outside();
    var ltr = /* @__PURE__ */ __name((version3, range, options29) => outside(version3, range, "<", options29), "ltr");
    module3.exports = ltr;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/ranges/intersects.js
var require_intersects = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/ranges/intersects.js"(exports2, module3) {
    init_import_meta_url();
    var Range = require_range();
    var intersects = /* @__PURE__ */ __name((r1, r23, options29) => {
      r1 = new Range(r1, options29);
      r23 = new Range(r23, options29);
      return r1.intersects(r23, options29);
    }, "intersects");
    module3.exports = intersects;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/ranges/simplify.js
var require_simplify = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/ranges/simplify.js"(exports2, module3) {
    init_import_meta_url();
    var satisfies = require_satisfies();
    var compare = require_compare();
    module3.exports = (versions, range, options29) => {
      const set = [];
      let first = null;
      let prev = null;
      const v2 = versions.sort((a, b2) => compare(a, b2, options29));
      for (const version3 of v2) {
        const included = satisfies(version3, range, options29);
        if (included) {
          prev = version3;
          if (!first) {
            first = version3;
          }
        } else {
          if (prev) {
            set.push([first, prev]);
          }
          prev = null;
          first = null;
        }
      }
      if (first) {
        set.push([first, null]);
      }
      const ranges = [];
      for (const [min, max] of set) {
        if (min === max) {
          ranges.push(min);
        } else if (!max && min === v2[0]) {
          ranges.push("*");
        } else if (!max) {
          ranges.push(`>=${min}`);
        } else if (min === v2[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/.pnpm/semver@7.5.4/node_modules/semver/ranges/subset.js
var require_subset = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/ranges/subset.js"(exports2, module3) {
    init_import_meta_url();
    var Range = require_range();
    var Comparator = require_comparator();
    var { ANY } = Comparator;
    var satisfies = require_satisfies();
    var compare = require_compare();
    var subset = /* @__PURE__ */ __name((sub, dom, options29 = {}) => {
      if (sub === dom) {
        return true;
      }
      sub = new Range(sub, options29);
      dom = new Range(dom, options29);
      let sawNonNull = false;
      OUTER:
        for (const simpleSub of sub.set) {
          for (const simpleDom of dom.set) {
            const isSub = simpleSubset(simpleSub, simpleDom, options29);
            sawNonNull = sawNonNull || isSub !== null;
            if (isSub) {
              continue OUTER;
            }
          }
          if (sawNonNull) {
            return false;
          }
        }
      return true;
    }, "subset");
    var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
    var minimumVersion = [new Comparator(">=0.0.0")];
    var simpleSubset = /* @__PURE__ */ __name((sub, dom, options29) => {
      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 (options29.includePrerelease) {
          sub = minimumVersionWithPreRelease;
        } else {
          sub = minimumVersion;
        }
      }
      if (dom.length === 1 && dom[0].semver === ANY) {
        if (options29.includePrerelease) {
          return true;
        } else {
          dom = minimumVersion;
        }
      }
      const eqSet = /* @__PURE__ */ new Set();
      let gt, lt2;
      for (const c2 of sub) {
        if (c2.operator === ">" || c2.operator === ">=") {
          gt = higherGT(gt, c2, options29);
        } else if (c2.operator === "<" || c2.operator === "<=") {
          lt2 = lowerLT(lt2, c2, options29);
        } else {
          eqSet.add(c2.semver);
        }
      }
      if (eqSet.size > 1) {
        return null;
      }
      let gtltComp;
      if (gt && lt2) {
        gtltComp = compare(gt.semver, lt2.semver, options29);
        if (gtltComp > 0) {
          return null;
        } else if (gtltComp === 0 && (gt.operator !== ">=" || lt2.operator !== "<=")) {
          return null;
        }
      }
      for (const eq of eqSet) {
        if (gt && !satisfies(eq, String(gt), options29)) {
          return null;
        }
        if (lt2 && !satisfies(eq, String(lt2), options29)) {
          return null;
        }
        for (const c2 of dom) {
          if (!satisfies(eq, String(c2), options29)) {
            return false;
          }
        }
        return true;
      }
      let higher, lower;
      let hasDomLT, hasDomGT;
      let needDomLTPre = lt2 && !options29.includePrerelease && lt2.semver.prerelease.length ? lt2.semver : false;
      let needDomGTPre = gt && !options29.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
      if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt2.operator === "<" && needDomLTPre.prerelease[0] === 0) {
        needDomLTPre = false;
      }
      for (const c2 of dom) {
        hasDomGT = hasDomGT || c2.operator === ">" || c2.operator === ">=";
        hasDomLT = hasDomLT || c2.operator === "<" || c2.operator === "<=";
        if (gt) {
          if (needDomGTPre) {
            if (c2.semver.prerelease && c2.semver.prerelease.length && c2.semver.major === needDomGTPre.major && c2.semver.minor === needDomGTPre.minor && c2.semver.patch === needDomGTPre.patch) {
              needDomGTPre = false;
            }
          }
          if (c2.operator === ">" || c2.operator === ">=") {
            higher = higherGT(gt, c2, options29);
            if (higher === c2 && higher !== gt) {
              return false;
            }
          } else if (gt.operator === ">=" && !satisfies(gt.semver, String(c2), options29)) {
            return false;
          }
        }
        if (lt2) {
          if (needDomLTPre) {
            if (c2.semver.prerelease && c2.semver.prerelease.length && c2.semver.major === needDomLTPre.major && c2.semver.minor === needDomLTPre.minor && c2.semver.patch === needDomLTPre.patch) {
              needDomLTPre = false;
            }
          }
          if (c2.operator === "<" || c2.operator === "<=") {
            lower = lowerLT(lt2, c2, options29);
            if (lower === c2 && lower !== lt2) {
              return false;
            }
          } else if (lt2.operator === "<=" && !satisfies(lt2.semver, String(c2), options29)) {
            return false;
          }
        }
        if (!c2.operator && (lt2 || gt) && gtltComp !== 0) {
          return false;
        }
      }
      if (gt && hasDomLT && !lt2 && gtltComp !== 0) {
        return false;
      }
      if (lt2 && hasDomGT && !gt && gtltComp !== 0) {
        return false;
      }
      if (needDomGTPre || needDomLTPre) {
        return false;
      }
      return true;
    }, "simpleSubset");
    var higherGT = /* @__PURE__ */ __name((a, b2, options29) => {
      if (!a) {
        return b2;
      }
      const comp = compare(a.semver, b2.semver, options29);
      return comp > 0 ? a : comp < 0 ? b2 : b2.operator === ">" && a.operator === ">=" ? b2 : a;
    }, "higherGT");
    var lowerLT = /* @__PURE__ */ __name((a, b2, options29) => {
      if (!a) {
        return b2;
      }
      const comp = compare(a.semver, b2.semver, options29);
      return comp < 0 ? a : comp > 0 ? b2 : b2.operator === "<" && a.operator === "<=" ? b2 : a;
    }, "lowerLT");
    module3.exports = subset;
  }
});

// ../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/index.js
var require_semver2 = __commonJS({
  "../../node_modules/.pnpm/semver@7.5.4/node_modules/semver/index.js"(exports2, module3) {
    init_import_meta_url();
    var internalRe = require_re();
    var constants3 = require_constants8();
    var SemVer = require_semver();
    var identifiers = require_identifiers();
    var parse7 = require_parse6();
    var valid = require_valid();
    var clean = require_clean();
    var inc = require_inc();
    var diff = require_diff();
    var major = 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 lt2 = require_lt();
    var eq = require_eq();
    var neq = require_neq();
    var gte = require_gte();
    var lte = require_lte();
    var cmp = require_cmp();
    var coerce = require_coerce();
    var Comparator = require_comparator();
    var Range = require_range();
    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();
    module3.exports = {
      parse: parse7,
      valid,
      clean,
      inc,
      diff,
      major,
      minor,
      patch,
      prerelease,
      compare,
      rcompare,
      compareLoose,
      compareBuild,
      sort,
      rsort,
      gt,
      lt: lt2,
      eq,
      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: constants3.SEMVER_SPEC_VERSION,
      RELEASE_TYPES: constants3.RELEASE_TYPES,
      compareIdentifiers: identifiers.compareIdentifiers,
      rcompareIdentifiers: identifiers.rcompareIdentifiers
    };
  }
});

// ../../node_modules/.pnpm/parse-package-name@1.0.0/node_modules/parse-package-name/dist/index.mjs
function parse5(input) {
  const m2 = RE_SCOPED.exec(input) || RE_NON_SCOPED.exec(input);
  if (!m2) {
    throw new Error(`[parse-package-name] invalid package name: ${input}`);
  }
  return {
    name: m2[1] || "",
    version: m2[2] || "latest",
    path: m2[3] || ""
  };
}
var RE_SCOPED, RE_NON_SCOPED;
var init_dist = __esm({
  "../../node_modules/.pnpm/parse-package-name@1.0.0/node_modules/parse-package-name/dist/index.mjs"() {
    init_import_meta_url();
    RE_SCOPED = /^(@[^\/]+\/[^@\/]+)(?:@([^\/]+))?(\/.*)?$/;
    RE_NON_SCOPED = /^([^@\/]+)(?:@([^\/]+))?(\/.*)?$/;
    __name(parse5, "parse");
  }
});

// ../../node_modules/.pnpm/builtins@5.0.1/node_modules/builtins/index.js
var require_builtins = __commonJS({
  "../../node_modules/.pnpm/builtins@5.0.1/node_modules/builtins/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var semver2 = require_semver2();
    var permanentModules = [
      "assert",
      "buffer",
      "child_process",
      "cluster",
      "console",
      "constants",
      "crypto",
      "dgram",
      "dns",
      "domain",
      "events",
      "fs",
      "http",
      "https",
      "module",
      "net",
      "os",
      "path",
      "punycode",
      "querystring",
      "readline",
      "repl",
      "stream",
      "string_decoder",
      "sys",
      "timers",
      "tls",
      "tty",
      "url",
      "util",
      "vm",
      "zlib"
    ];
    var versionLockedModules = {
      freelist: "<6.0.0",
      v8: ">=1.0.0",
      process: ">=1.1.0",
      inspector: ">=8.0.0",
      async_hooks: ">=8.1.0",
      http2: ">=8.4.0",
      perf_hooks: ">=8.5.0",
      trace_events: ">=10.0.0",
      worker_threads: ">=12.0.0",
      "node:test": ">=18.0.0"
    };
    var experimentalModules = {
      worker_threads: ">=10.5.0",
      wasi: ">=12.16.0",
      diagnostics_channel: "^14.17.0 || >=15.1.0"
    };
    module3.exports = ({ version: version3 = process.version, experimental: experimental2 = false } = {}) => {
      const builtins = [...permanentModules];
      for (const [name, semverRange] of Object.entries(versionLockedModules)) {
        if (version3 === "*" || semver2.satisfies(version3, semverRange)) {
          builtins.push(name);
        }
      }
      if (experimental2) {
        for (const [name, semverRange] of Object.entries(experimentalModules)) {
          if (!builtins.includes(name) && (version3 === "*" || semver2.satisfies(version3, semverRange))) {
            builtins.push(name);
          }
        }
      }
      return builtins;
    };
  }
});

// ../../node_modules/.pnpm/validate-npm-package-name@4.0.0/node_modules/validate-npm-package-name/lib/index.js
var require_lib5 = __commonJS({
  "../../node_modules/.pnpm/validate-npm-package-name@4.0.0/node_modules/validate-npm-package-name/lib/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var scopedPackagePattern = new RegExp("^(?:@([^/]+?)[/])?([^/]+?)$");
    var builtins = require_builtins();
    var blacklist = [
      "node_modules",
      "favicon.ico"
    ];
    function validate2(name) {
      var warnings = [];
      var errors = [];
      if (name === null) {
        errors.push("name cannot be null");
        return done(warnings, errors);
      }
      if (name === void 0) {
        errors.push("name cannot be undefined");
        return done(warnings, errors);
      }
      if (typeof name !== "string") {
        errors.push("name must be a string");
        return done(warnings, errors);
      }
      if (!name.length) {
        errors.push("name length must be greater than zero");
      }
      if (name.match(/^\./)) {
        errors.push("name cannot start with a period");
      }
      if (name.match(/^_/)) {
        errors.push("name cannot start with an underscore");
      }
      if (name.trim() !== name) {
        errors.push("name cannot contain leading or trailing spaces");
      }
      blacklist.forEach(function(blacklistedName) {
        if (name.toLowerCase() === blacklistedName) {
          errors.push(blacklistedName + " is a blacklisted name");
        }
      });
      builtins({ version: "*" }).forEach(function(builtin) {
        if (name.toLowerCase() === builtin) {
          warnings.push(builtin + " is a core module name");
        }
      });
      if (name.length > 214) {
        warnings.push("name can no longer contain more than 214 characters");
      }
      if (name.toLowerCase() !== name) {
        warnings.push("name can no longer contain capital letters");
      }
      if (/[~'!()*]/.test(name.split("/").slice(-1)[0])) {
        warnings.push(`name can no longer contain special characters ("~'!()*")`);
      }
      if (encodeURIComponent(name) !== name) {
        var nameMatch = name.match(scopedPackagePattern);
        if (nameMatch) {
          var user = nameMatch[1];
          var pkg = nameMatch[2];
          if (encodeURIComponent(user) === user && encodeURIComponent(pkg) === pkg) {
            return done(warnings, errors);
          }
        }
        errors.push("name can only contain URL-friendly characters");
      }
      return done(warnings, errors);
    }
    __name(validate2, "validate");
    var done = /* @__PURE__ */ __name(function(warnings, errors) {
      var result = {
        validForNewPackages: errors.length === 0 && warnings.length === 0,
        validForOldPackages: errors.length === 0,
        warnings,
        errors
      };
      if (!result.warnings.length) {
        delete result.warnings;
      }
      if (!result.errors.length) {
        delete result.errors;
      }
      return result;
    }, "done");
    module3.exports = validate2;
  }
});

// ../../node_modules/.pnpm/npx-import@1.1.4/node_modules/npx-import/lib/utils.js
async function _import(packageWithPath) {
  return await import(packageWithPath);
}
async function _importRelative(installDir, packageWithPath) {
  return await import((0, import_node_url11.pathToFileURL)(_resolveRelative(installDir, packageWithPath)).href);
}
function _resolve(packageWithPath) {
  const require2 = (0, import_node_module2.createRequire)(import_meta_url);
  return require2.resolve(packageWithPath);
}
function _resolveRelative(installDir, packageWithPath) {
  return (0, import_node_module2.createRequire)((0, import_node_url11.pathToFileURL)(installDir).href).resolve(packageWithPath);
}
var import_node_url11, import_node_module2;
var init_utils = __esm({
  "../../node_modules/.pnpm/npx-import@1.1.4/node_modules/npx-import/lib/utils.js"() {
    init_import_meta_url();
    import_node_url11 = require("node:url");
    import_node_module2 = require("node:module");
    __name(_import, "_import");
    __name(_importRelative, "_importRelative");
    __name(_resolve, "_resolve");
    __name(_resolveRelative, "_resolveRelative");
  }
});

// ../../node_modules/.pnpm/npx-import@1.1.4/node_modules/npx-import/lib/index.js
var lib_exports = {};
__export(lib_exports, {
  getPackageManager: () => getPackageManager,
  npxImport: () => npxImport,
  npxResolve: () => npxResolve
});
async function npxImport(pkg, logger3 = DEFAULT_LOGGER) {
  const packages = await checkPackagesAvailableLocally(pkg);
  const allPackages = Object.values(packages);
  const localPackages = allPackages.filter((p2) => p2.imported !== NOT_IMPORTABLE);
  const missingPackages = allPackages.filter((p2) => p2.imported === NOT_IMPORTABLE);
  if (missingPackages.length > 0) {
    logger3(`${missingPackages.length > 1 ? `Packages ${missingPackages.map((p2) => p2.packageWithPath).join(", ")}` : missingPackages[0].packageWithPath} not available locally. Attempting to use npx to install temporarily.`);
    try {
      await checkNpxVersion();
      const installDir = await installAndReturnDir(missingPackages, logger3);
      for (const pkg2 of missingPackages) {
        packages[pkg2.name].imported = await _importRelative(installDir, pkg2.packageWithPath);
        INSTALL_CACHE[pkg2.name] = installDir;
      }
    } catch (e3) {
      throw new Error(`npx-import failed for ${missingPackages.map((p2) => p2.packageWithPath).join(",")} with message:
    ${e3.message}

You should install ${missingPackages.map((p2) => p2.name).join(", ")} locally: 
    ` + installInstructions(missingPackages) + `

`);
    }
  }
  for (const pkg2 of localPackages) {
    INSTALL_CACHE[pkg2.name] = INSTALLED_LOCALLY;
  }
  const results = allPackages.map((p2) => p2.imported);
  return Array.isArray(pkg) ? results : results[0];
}
function npxResolve(pkg) {
  const { name, path: path67 } = parse5(pkg);
  const packageWithPath = [name, path67].join("");
  const cachedDir = INSTALL_CACHE[name];
  if (!cachedDir) {
    throw new Error(`You must call npxImport for a package before calling npxResolve. Got: ${pkg}`);
  } else if (cachedDir === INSTALLED_LOCALLY) {
    return _resolve(packageWithPath);
  } else {
    return _resolveRelative(cachedDir, packageWithPath);
  }
}
async function checkPackagesAvailableLocally(pkg) {
  const packages = {};
  for (const p2 of Array.isArray(pkg) ? pkg : [pkg]) {
    const { name, version: version3, path: path67, exact } = parseAndValidate(p2);
    if (packages[name])
      throw new Error(`npx-import cannot import the same package twice! Got: '${p2}' but already saw '${name}' earlier!`);
    const packageWithPath = [name, path67].join("");
    const imported = await tryImport(packageWithPath);
    packages[name] = {
      name,
      packageWithPath,
      version: version3,
      exact,
      path: path67,
      imported,
      local: imported !== NOT_IMPORTABLE
    };
  }
  return packages;
}
function parseAndValidate(p2) {
  if (p2.match(/^[.\/]/)) {
    throw new Error(`npx-import can only import packages, not relative paths: got ${p2}`);
  }
  const { name, version: version3, path: path67 } = parse5(p2);
  const validation2 = (0, import_validate_npm_package_name.default)(name);
  if (!validation2.validForNewPackages) {
    if (validation2.warnings?.some((w2) => w2.match(/is a core module name/)))
      throw new Error(`npx-import can only import NPM packages, got core module '${name}' from '${p2}'`);
    else
      throw new Error(`npx-import can't import invalid package name: parsed name '${name}' from '${p2}'`);
  }
  return { name, version: version3, path: path67, exact: import_semver.default.parse(version3) !== null };
}
async function tryImport(packageWithPath) {
  try {
    return await _import(packageWithPath);
  } catch (e3) {
    return NOT_IMPORTABLE;
  }
}
async function checkNpxVersion() {
  const versionCmd = `npx --version`;
  const { failed, stdout: npmVersion } = await execaCommand(versionCmd);
  if (failed) {
    throw new Error(`Couldn't execute ${versionCmd}. Is npm installed and up-to-date?`);
  }
  if (!import_semver.default.gte(npmVersion, "7.0.0")) {
    throw new Error(`Require npm version 7+. Got '${npmVersion}' when running '${versionCmd}'`);
  }
}
async function installAndReturnDir(packages, logger3) {
  const offline = packages.every((p2) => p2.exact);
  const installPackage = `npx --prefer-${offline ? "offline" : "online"} -y ${packages.map((p2) => `-p ${formatForCLI(p2)}`).join(" ")}`;
  logger3(`Installing... (${installPackage})`);
  const emitPath = WINDOWS ? `set PATH` : `printenv PATH`;
  const fullCmd = `${installPackage} ${emitPath}`;
  const { failed, stdout: stdout2 } = await execaCommand(fullCmd, {
    shell: true
  });
  if (failed) {
    throw new Error(`Failed installing ${packages.map((p2) => p2.name).join(",")} using: ${installPackage}.`);
  }
  const tempPath = getTempPath(stdout2);
  const nodeModulesPath = import_node_path21.default.resolve(tempPath, "..");
  if (!nodeModulesPath.endsWith("node_modules")) {
    throw new Error(`Found NPX temporary path of '${tempPath}' but expected to be able to find a node_modules directory by looking in '..'.`);
  }
  logger3(`Installed into ${nodeModulesPath}.`);
  logger3(`To skip this step in future, run: ${installInstructions(packages)}`);
  return nodeModulesPath;
}
function installInstructions(packages) {
  return INSTRUCTIONS[getPackageManager()](packages.map(formatForCLI).join(" "));
}
function getPackageManager() {
  const userAgent = process.env.npm_config_user_agent;
  if (userAgent) {
    if (userAgent.startsWith("pnpm"))
      return "pnpm";
    if (userAgent.startsWith("yarn"))
      return "yarn";
    if (userAgent.startsWith("npm"))
      return "npm";
  }
  const execpath = process.env.npm_execpath;
  if (execpath) {
    if (/np[xm]-cli\.js$/.exec(execpath))
      return "npm";
    if (/yarn$/.exec(execpath))
      return "yarn";
  }
  const mainModulePath = process.mainModule?.path;
  if (mainModulePath) {
    if (/\/\.?pnpm\//.exec(mainModulePath))
      return "pnpm";
    if (/\/\.?yarn\//.exec(mainModulePath))
      return "yarn";
  }
  return "npm";
}
function getTempPath(stdout2) {
  if (WINDOWS) {
    const paths = stdout2.replace(/^PATH=/i, "").replace(/\\\\\\\\/g, "\\\\").replace(/\\r\\n/g, ";").split(";");
    const tempPath = paths.find((p2) => /\\npm[-\\]+cache\\_npx\\/.exec(p2));
    if (!tempPath)
      throw new Error(`Failed to find temporary install directory. Looking for paths matching '\\npm-cache\\_npx\\' in:
${JSON.stringify(paths)}`);
    return tempPath;
  } else {
    const paths = stdout2.split(":");
    const tempPath = paths.find((p2) => /\/\.npm\/_npx\//.exec(p2));
    if (!tempPath)
      throw new Error(`Failed to find temporary install directory. Looking for paths matching '/.npm/_npx/' in:
${JSON.stringify(paths)}`);
    return tempPath;
  }
}
var import_node_os6, import_node_path21, import_semver, import_validate_npm_package_name, WINDOWS, NOT_IMPORTABLE, INSTALLED_LOCALLY, INSTALL_CACHE, DEFAULT_LOGGER, INSTRUCTIONS, formatForCLI;
var init_lib = __esm({
  "../../node_modules/.pnpm/npx-import@1.1.4/node_modules/npx-import/lib/index.js"() {
    init_import_meta_url();
    import_node_os6 = __toESM(require("node:os"), 1);
    import_node_path21 = __toESM(require("node:path"), 1);
    import_semver = __toESM(require_semver2(), 1);
    init_dist();
    init_execa();
    import_validate_npm_package_name = __toESM(require_lib5(), 1);
    init_utils();
    WINDOWS = import_node_os6.default.platform() === "win32";
    NOT_IMPORTABLE = Symbol();
    INSTALLED_LOCALLY = Symbol();
    INSTALL_CACHE = {};
    DEFAULT_LOGGER = process.env.NPX_IMPORT_QUIET ? () => {
    } : (message) => console.log(`[NPXI] ${message}`);
    __name(npxImport, "npxImport");
    __name(npxResolve, "npxResolve");
    __name(checkPackagesAvailableLocally, "checkPackagesAvailableLocally");
    __name(parseAndValidate, "parseAndValidate");
    __name(tryImport, "tryImport");
    __name(checkNpxVersion, "checkNpxVersion");
    __name(installAndReturnDir, "installAndReturnDir");
    INSTRUCTIONS = {
      npm: (packageName) => `npm install --save-dev ${packageName}`,
      pnpm: (packageName) => `pnpm add -D ${packageName}`,
      yarn: (packageName) => `yarn add -D ${packageName}`
    };
    __name(installInstructions, "installInstructions");
    __name(getPackageManager, "getPackageManager");
    formatForCLI = /* @__PURE__ */ __name((p2) => {
      const unescaped = `${p2.name}@${p2.version}`;
      return unescaped.match(/[<>*]/) ? `'${unescaped}'` : unescaped;
    }, "formatForCLI");
    __name(getTempPath, "getTempPath");
  }
});

// ../../node_modules/.pnpm/@miniflare+shared@2.14.2/node_modules/@miniflare/shared/dist/src/index.js
var require_src6 = __commonJS({
  "../../node_modules/.pnpm/@miniflare+shared@2.14.2/node_modules/@miniflare/shared/dist/src/index.js"(exports2) {
    init_import_meta_url();
    var __create2 = Object.create;
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __getProtoOf2 = Object.getPrototypeOf;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __markAsModule = /* @__PURE__ */ __name((target) => __defProp2(target, "__esModule", { value: true }), "__markAsModule");
    var __export2 = /* @__PURE__ */ __name((target, all2) => {
      __markAsModule(target);
      for (var name in all2)
        __defProp2(target, name, { get: all2[name], enumerable: true });
    }, "__export");
    var __reExport2 = /* @__PURE__ */ __name((target, module22, desc) => {
      if (module22 && typeof module22 === "object" || typeof module22 === "function") {
        for (let key of __getOwnPropNames2(module22))
          if (!__hasOwnProp2.call(target, key) && key !== "default")
            __defProp2(target, key, { get: () => module22[key], enumerable: !(desc = __getOwnPropDesc2(module22, key)) || desc.enumerable });
      }
      return target;
    }, "__reExport");
    var __toModule = /* @__PURE__ */ __name((module22) => {
      return __reExport2(__markAsModule(__defProp2(module22 != null ? __create2(__getProtoOf2(module22)) : {}, "default", module22 && module22.__esModule && "default" in module22 ? { get: () => module22.default, enumerable: true } : { value: module22, enumerable: true })), module22);
    }, "__toModule");
    __export2(exports2, {
      Compatibility: () => Compatibility,
      EXTERNAL_SUBREQUEST_LIMIT_BUNDLED: () => EXTERNAL_SUBREQUEST_LIMIT_BUNDLED,
      EXTERNAL_SUBREQUEST_LIMIT_UNBOUND: () => EXTERNAL_SUBREQUEST_LIMIT_UNBOUND,
      INTERNAL_SUBREQUEST_LIMIT: () => INTERNAL_SUBREQUEST_LIMIT,
      InputGate: () => InputGate,
      InputGatedEventTarget: () => InputGatedEventTarget,
      Log: () => Log2,
      LogLevel: () => LogLevel3,
      MiniflareError: () => MiniflareError,
      Mutex: () => Mutex4,
      NoOpLog: () => NoOpLog,
      Option: () => Option,
      OptionType: () => OptionType,
      OutputGate: () => OutputGate,
      Plugin: () => Plugin,
      RequestContext: () => RequestContext,
      SITES_NO_CACHE_PREFIX: () => SITES_NO_CACHE_PREFIX,
      STRING_SCRIPT_PATH: () => STRING_SCRIPT_PATH,
      Storage: () => Storage,
      ThrowingEventTarget: () => ThrowingEventTarget,
      TypedEventTarget: () => TypedEventTarget2,
      addAll: () => addAll,
      arrayCompare: () => arrayCompare,
      assertInRequest: () => assertInRequest,
      base64Decode: () => base64Decode,
      base64Encode: () => base64Encode,
      createSQLiteDB: () => createSQLiteDB,
      defaultClock: () => defaultClock,
      getRequestContext: () => getRequestContext,
      getSQLiteNativeBindingLocation: () => getSQLiteNativeBindingLocation,
      globsToMatcher: () => globsToMatcher,
      kGetConsumer: () => kGetConsumer,
      kSetConsumer: () => kSetConsumer,
      kWrapListener: () => kWrapListener,
      kebabCase: () => kebabCase,
      lexicographicCompare: () => lexicographicCompare,
      logOptions: () => logOptions,
      millisToSeconds: () => millisToSeconds,
      nonCircularClone: () => nonCircularClone,
      numericCompare: () => numericCompare,
      parseRange: () => parseRange,
      prefixError: () => prefixError,
      randomHex: () => randomHex,
      resolveStoragePersist: () => resolveStoragePersist,
      runWithInputGateClosed: () => runWithInputGateClosed,
      sanitisePath: () => sanitisePath,
      spaceCase: () => spaceCase,
      structuredCloneImpl: () => structuredCloneImpl,
      titleCase: () => titleCase,
      usageModelExternalSubrequestLimit: () => usageModelExternalSubrequestLimit,
      viewToArray: () => viewToArray,
      viewToBuffer: () => viewToBuffer,
      waitForOpenInputGate: () => waitForOpenInputGate,
      waitForOpenOutputGate: () => waitForOpenOutputGate,
      waitUntilOnOutputGate: () => waitUntilOnOutputGate
    });
    var import_assert6 = __toModule(require("assert"));
    var import_path18 = __toModule(require("path"));
    var import_util8 = __toModule(require("util"));
    var import_worker_threads = __toModule(require("worker_threads"));
    var import_picomatch = __toModule(require_picomatch2());
    var encoder = new import_util8.TextEncoder();
    var numericCompare = new Intl.Collator(void 0, { numeric: true }).compare;
    function arrayCompare(a, b2) {
      const minLength = Math.min(a.length, b2.length);
      for (let i = 0; i < minLength; i++) {
        const aElement = a[i];
        const bElement = b2[i];
        if (aElement < bElement)
          return -1;
        if (aElement > bElement)
          return 1;
      }
      return a.length - b2.length;
    }
    __name(arrayCompare, "arrayCompare");
    function lexicographicCompare(x2, y2) {
      const xEncoded = encoder.encode(x2);
      const yEncoded = encoder.encode(y2);
      return arrayCompare(xEncoded, yEncoded);
    }
    __name(lexicographicCompare, "lexicographicCompare");
    function nonCircularClone(value) {
      return JSON.parse(JSON.stringify(value));
    }
    __name(nonCircularClone, "nonCircularClone");
    var channel;
    function structuredCloneImpl(value, options29) {
      channel ??= new import_worker_threads.MessageChannel();
      channel.port1.unref();
      channel.port2.unref();
      channel.port1.postMessage(value, options29?.transfer);
      const message = (0, import_worker_threads.receiveMessageOnPort)(channel.port2);
      (0, import_assert6.default)(message !== void 0);
      return message.message;
    }
    __name(structuredCloneImpl, "structuredCloneImpl");
    function addAll(set, values) {
      for (const value of values)
        set.add(value);
    }
    __name(addAll, "addAll");
    function viewToArray(view) {
      return new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
    }
    __name(viewToArray, "viewToArray");
    function viewToBuffer(view) {
      return view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength);
    }
    __name(viewToBuffer, "viewToBuffer");
    function base64Encode(value) {
      return Buffer.from(value, "utf8").toString("base64");
    }
    __name(base64Encode, "base64Encode");
    function base64Decode(encoded) {
      return Buffer.from(encoded, "base64").toString("utf8");
    }
    __name(base64Decode, "base64Decode");
    function randomHex(digits = 8) {
      return Array.from(Array(digits)).map(() => Math.floor(Math.random() * 16).toString(16)).join("");
    }
    __name(randomHex, "randomHex");
    var SITES_NO_CACHE_PREFIX = "$__MINIFLARE_SITES__$/";
    function globsToMatcher(globs = []) {
      const matchGlobs = [];
      const ignoreGlobs = [];
      for (const glob of globs) {
        if (glob.startsWith("!")) {
          ignoreGlobs.push(glob.slice(1));
        } else {
          matchGlobs.push(glob);
        }
      }
      const isMatch = (0, import_picomatch.default)(matchGlobs, {
        dot: true,
        bash: true,
        contains: true,
        ignore: ignoreGlobs
      });
      return {
        test: (string) => isMatch(string),
        toString: () => globs.join(", ")
      };
    }
    __name(globsToMatcher, "globsToMatcher");
    function kebabCase(s) {
      return s.replace(/[A-Z]/g, (sub) => `-${sub.toLowerCase()}`);
    }
    __name(kebabCase, "kebabCase");
    function spaceCase(s) {
      s = s.replace(/(.)([A-Z][a-z]+)/g, "$1 $2");
      return s.replace(/([a-z0-9])([A-Z])/g, "$1 $2");
    }
    __name(spaceCase, "spaceCase");
    function titleCase(s) {
      return spaceCase(s).split(" ").map((s2) => s2 ? s2[0].toUpperCase() + s2.substring(1) : s2).join(" ");
    }
    __name(titleCase, "titleCase");
    var urlRegexp = /^([a-z]+:)?\/\//i;
    function resolveStoragePersist(rootPath, persist) {
      if (typeof persist === "string") {
        if (urlRegexp.test(persist))
          return persist;
        return import_path18.default.resolve(rootPath, persist);
      }
      return persist;
    }
    __name(resolveStoragePersist, "resolveStoragePersist");
    var namespaceRegexp = /[/\\:|]/g;
    var dotRegexp = /(^|\/|\\)(\.+)(\/|\\|$)/g;
    var illegalRegexp = /[?<>*"'^\x00-\x1f\x80-\x9f]/g;
    var windowsReservedRegexp = /^(con|prn|aux|nul|com[0-9]|lpt[0-9])(\..*)?$/i;
    var leadingRegexp = /^[ /\\]+/;
    var trailingRegexp = /[ /\\]+$/;
    function dotReplacement(match, g1, g2, g3) {
      return `${g1}${"".padStart(g2.length, "_")}${g3}`;
    }
    __name(dotReplacement, "dotReplacement");
    function underscoreReplacement(match) {
      return "".padStart(match.length, "_");
    }
    __name(underscoreReplacement, "underscoreReplacement");
    function sanitisePath(unsafe) {
      return unsafe.replace(namespaceRegexp, import_path18.default.sep).replace(dotRegexp, dotReplacement).replace(dotRegexp, dotReplacement).replace(illegalRegexp, "_").replace(windowsReservedRegexp, "_").replace(leadingRegexp, underscoreReplacement).replace(trailingRegexp, underscoreReplacement).substring(0, 255);
    }
    __name(sanitisePath, "sanitisePath");
    var FEATURES = [
      {
        enableFlag: "nodejs_compat"
      },
      {
        defaultAsOf: "2022-11-30",
        enableFlag: "streams_enable_constructors",
        disableFlag: "streams_disable_constructors"
      },
      {
        defaultAsOf: "2022-11-30",
        enableFlag: "transformstream_enable_standard_constructor",
        disableFlag: "transformstream_disable_standard_constructor"
      },
      {
        defaultAsOf: "2022-10-31",
        enableFlag: "export_commonjs_default",
        disableFlag: "export_commonjs_namespace"
      },
      {
        defaultAsOf: "2022-08-04",
        enableFlag: "r2_list_honor_include"
      },
      {
        defaultAsOf: "2022-03-21",
        enableFlag: "global_navigator",
        disableFlag: "no_global_navigator"
      },
      {
        defaultAsOf: "2021-11-10",
        enableFlag: "durable_object_fetch_requires_full_url",
        disableFlag: "durable_object_fetch_allows_relative_url"
      },
      {
        defaultAsOf: "2021-11-10",
        enableFlag: "fetch_refuses_unknown_protocols",
        disableFlag: "fetch_treats_unknown_protocols_as_http"
      },
      {
        defaultAsOf: "2021-11-03",
        enableFlag: "formdata_parser_supports_files",
        disableFlag: "formdata_parser_converts_files_to_strings"
      },
      {
        enableFlag: "html_rewriter_treats_esi_include_as_void_tag"
      },
      {
        enableFlag: "experimental"
      }
    ];
    var Compatibility = /* @__PURE__ */ __name(class {
      constructor(compatibilityDate = "1970-01-01", compatibilityFlags = []) {
        this.compatibilityDate = compatibilityDate;
        this.compatibilityFlags = compatibilityFlags;
        this.#rebuildEnabled();
      }
      #enabled = /* @__PURE__ */ new Set();
      #rebuildEnabled() {
        this.#enabled.clear();
        const flags = new Set(this.compatibilityFlags);
        for (const { defaultAsOf, enableFlag, disableFlag } of FEATURES) {
          const disabledExplicitly = disableFlag && flags.has(disableFlag);
          if (disabledExplicitly)
            continue;
          const enabledExplicitly = flags.has(enableFlag);
          const enabledAutomatically = defaultAsOf && numericCompare(defaultAsOf, this.compatibilityDate) <= 0;
          if (enabledExplicitly || enabledAutomatically) {
            this.#enabled.add(enableFlag);
          }
        }
      }
      isEnabled(flag) {
        return this.#enabled.has(flag);
      }
      update(compatibilityDate = "1970-01-01", compatibilityFlags = []) {
        if (this.compatibilityDate === compatibilityDate && this.compatibilityFlags.length === compatibilityFlags.length && this.compatibilityFlags.every((flag, i) => compatibilityFlags[i] === flag)) {
          return false;
        }
        this.compatibilityDate = compatibilityDate;
        this.compatibilityFlags = compatibilityFlags;
        this.#rebuildEnabled();
        return true;
      }
      get enabled() {
        return [...this.#enabled];
      }
    }, "Compatibility");
    var import_assert22 = __toModule(require("assert"));
    var import_async_hooks = __toModule(require("async_hooks"));
    function parseSubrequestOverride(limit) {
      const parsed = parseInt(limit);
      if (Number.isNaN(parsed))
        return void 0;
      if (parsed < 0)
        return false;
      return parsed;
    }
    __name(parseSubrequestOverride, "parseSubrequestOverride");
    var EXTERNAL_SUBREQUEST_LIMIT_OVERRIDE = parseSubrequestOverride(process.env.MINIFLARE_SUBREQUEST_LIMIT);
    var INTERNAL_SUBREQUEST_LIMIT_OVERRIDE = parseSubrequestOverride(process.env.MINIFLARE_INTERNAL_SUBREQUEST_LIMIT);
    var EXTERNAL_SUBREQUEST_LIMIT_BUNDLED = 50;
    var EXTERNAL_SUBREQUEST_LIMIT_UNBOUND = 1e3;
    var INTERNAL_SUBREQUEST_LIMIT = 1e3;
    function usageModelExternalSubrequestLimit(model) {
      return model === "unbound" ? EXTERNAL_SUBREQUEST_LIMIT_UNBOUND : EXTERNAL_SUBREQUEST_LIMIT_BUNDLED;
    }
    __name(usageModelExternalSubrequestLimit, "usageModelExternalSubrequestLimit");
    var MAX_REQUEST_DEPTH = 16;
    var MAX_PIPELINE_DEPTH = 32;
    var depthError = "Subrequest depth limit exceeded. This request recursed through Workers too many times. This can happen e.g. if you have a Worker or Durable Object that calls other Workers or objects recursively.";
    var requestContextStorage = new import_async_hooks.AsyncLocalStorage();
    function getRequestContext() {
      return requestContextStorage.getStore();
    }
    __name(getRequestContext, "getRequestContext");
    function assertInRequest() {
      if (!getRequestContext()) {
        throw new Error("Some functionality, such as asynchronous I/O (fetch, Cache API, KV), timeouts (setTimeout, setInterval), and generating random values (crypto.getRandomValues, crypto.subtle.generateKey), can only be performed while handling a request.");
      }
    }
    __name(assertInRequest, "assertInRequest");
    var RequestContext = /* @__PURE__ */ __name(class {
      requestDepth;
      pipelineDepth;
      durableObject;
      externalSubrequestLimit;
      internalSubrequestLimit;
      #internalSubrequests = 0;
      #externalSubrequests = 0;
      #currentTime;
      constructor({
        requestDepth = 1,
        pipelineDepth = 1,
        durableObject = false,
        externalSubrequestLimit = EXTERNAL_SUBREQUEST_LIMIT_BUNDLED,
        internalSubrequestLimit = INTERNAL_SUBREQUEST_LIMIT
      } = {}) {
        (0, import_assert22.default)(requestDepth >= 1);
        (0, import_assert22.default)(pipelineDepth >= 1);
        if (requestDepth > MAX_REQUEST_DEPTH) {
          throw new Error(`${depthError}
Workers and objects can recurse up to ${MAX_REQUEST_DEPTH} times.
If you're trying to fetch from an origin server, make sure you've set the \`upstream\` option.`);
        }
        if (pipelineDepth > MAX_PIPELINE_DEPTH) {
          throw new Error(`${depthError}
Service bindings can recurse up to ${MAX_PIPELINE_DEPTH} times.`);
        }
        this.requestDepth = requestDepth;
        this.pipelineDepth = pipelineDepth;
        this.durableObject = durableObject;
        this.externalSubrequestLimit = EXTERNAL_SUBREQUEST_LIMIT_OVERRIDE !== void 0 ? EXTERNAL_SUBREQUEST_LIMIT_OVERRIDE : externalSubrequestLimit;
        this.internalSubrequestLimit = INTERNAL_SUBREQUEST_LIMIT_OVERRIDE !== void 0 ? INTERNAL_SUBREQUEST_LIMIT_OVERRIDE : internalSubrequestLimit;
        this.#currentTime = Date.now();
      }
      runWith(closure) {
        return requestContextStorage.run(this, closure);
      }
      get externalSubrequests() {
        return this.#externalSubrequests;
      }
      get internalSubrequests() {
        return this.#internalSubrequests;
      }
      incrementExternalSubrequests(count = 1) {
        this.#externalSubrequests += count;
        if (this.externalSubrequestLimit !== false && this.#externalSubrequests > this.externalSubrequestLimit) {
          throw new Error(`Too many subrequests. Workers can make up to ${this.externalSubrequestLimit} subrequests per request.
A subrequest is a call to fetch(), a redirect, or a call to any Cache API method.`);
        }
      }
      incrementInternalSubrequests(count = 1) {
        this.#internalSubrequests += count;
        if (this.internalSubrequestLimit !== false && this.#internalSubrequests > this.internalSubrequestLimit) {
          throw new Error(`Too many API requests by single worker invocation. Workers can make up to ${this.internalSubrequestLimit} KV and Durable Object requests per invocation.`);
        }
      }
      get currentTime() {
        return this.#currentTime;
      }
      advanceCurrentTime() {
        this.#currentTime = Date.now();
      }
    }, "RequestContext");
    var MiniflareError = /* @__PURE__ */ __name(class extends Error {
      constructor(code, message, cause) {
        super(message);
        this.code = code;
        this.cause = cause;
        Object.setPrototypeOf(this, new.target.prototype);
        this.name = `${new.target.name} [${code}]`;
      }
    }, "MiniflareError");
    function prefixError(prefix, e3) {
      if (e3.stack) {
        return new Proxy(e3, {
          get(target, propertyKey, receiver) {
            return propertyKey === "stack" ? `${prefix}: ${target.stack}` : Reflect.get(target, propertyKey, receiver);
          }
        });
      }
      return e3;
    }
    __name(prefixError, "prefixError");
    var kWrapListener = Symbol("kWrapListener");
    var TypedEventTarget2 = /* @__PURE__ */ __name(class extends EventTarget {
      #wrappedListeners = /* @__PURE__ */ new WeakMap();
      #wrap(listener) {
        if (!listener)
          return null;
        let wrappedListener = this.#wrappedListeners.get(listener);
        if (wrappedListener)
          return wrappedListener;
        wrappedListener = this[kWrapListener]((event) => {
          if (typeof listener === "function") {
            listener(event);
          } else {
            listener.handleEvent(event);
          }
        });
        this.#wrappedListeners.set(listener, wrappedListener);
        return wrappedListener;
      }
      addEventListener(type, listener, options29) {
        super.addEventListener(type, this[kWrapListener] ? this.#wrap(listener) : listener, options29);
      }
      removeEventListener(type, listener, options29) {
        super.removeEventListener(type, this[kWrapListener] ? this.#wrap(listener) : listener, options29);
      }
      dispatchEvent(event) {
        return super.dispatchEvent(event);
      }
    }, "TypedEventTarget");
    var ThrowingEventTarget = /* @__PURE__ */ __name(class extends TypedEventTarget2 {
      #wrappedError;
      [kWrapListener](listener) {
        return (event) => {
          try {
            listener(event);
          } catch (error2) {
            event.stopImmediatePropagation();
            this.#wrappedError = error2;
          }
        };
      }
      dispatchEvent(event) {
        this.#wrappedError = void 0;
        const result = super.dispatchEvent(event);
        if (this.#wrappedError !== void 0)
          throw this.#wrappedError;
        return result;
      }
    }, "ThrowingEventTarget");
    var import_path22 = __toModule(require("path"));
    var import_colors14 = __toModule(require_colors2());
    var cwd2 = process.cwd();
    var cwdNodeModules = import_path22.default.join(cwd2, "node_modules");
    var LogLevel3;
    (function(LogLevel22) {
      LogLevel22[LogLevel22["NONE"] = 0] = "NONE";
      LogLevel22[LogLevel22["ERROR"] = 1] = "ERROR";
      LogLevel22[LogLevel22["WARN"] = 2] = "WARN";
      LogLevel22[LogLevel22["INFO"] = 3] = "INFO";
      LogLevel22[LogLevel22["DEBUG"] = 4] = "DEBUG";
      LogLevel22[LogLevel22["VERBOSE"] = 5] = "VERBOSE";
    })(LogLevel3 || (LogLevel3 = {}));
    var LEVEL_PREFIX = {
      [0]: "",
      [1]: "err",
      [2]: "wrn",
      [3]: "inf",
      [4]: "dbg",
      [5]: "vrb"
    };
    var LEVEL_COLOUR = {
      [0]: import_colors14.reset,
      [1]: import_colors14.red,
      [2]: import_colors14.yellow,
      [3]: import_colors14.green,
      [4]: import_colors14.grey,
      [5]: (input) => (0, import_colors14.dim)((0, import_colors14.grey)(input))
    };
    function dimInternalStackLine(line) {
      if (line.startsWith("    at") && (!line.includes(cwd2) || line.includes(cwdNodeModules))) {
        return (0, import_colors14.dim)(line);
      }
      return line;
    }
    __name(dimInternalStackLine, "dimInternalStackLine");
    var Log2 = /* @__PURE__ */ __name(class {
      constructor(level = 3, opts = {}) {
        this.level = level;
        const prefix = opts.prefix ?? "mf";
        const suffix = opts.suffix ?? "";
        this.#prefix = prefix ? prefix + ":" : "";
        this.#suffix = suffix ? ":" + suffix : "";
      }
      #prefix;
      #suffix;
      log(message) {
        console.log(message);
      }
      logWithLevel(level, message) {
        if (level <= this.level) {
          const prefix = `[${this.#prefix}${LEVEL_PREFIX[level]}${this.#suffix}]`;
          this.log(LEVEL_COLOUR[level](`${prefix} ${message}`));
        }
      }
      error(message) {
        if (this.level < 1) {
          throw message;
        } else if (message.stack) {
          const lines = message.stack.split("\n").map(dimInternalStackLine);
          this.logWithLevel(1, lines.join("\n"));
        } else {
          this.logWithLevel(1, message.toString());
        }
        if (message.cause) {
          this.error(prefixError("Cause", message.cause));
        }
      }
      warn(message) {
        this.logWithLevel(2, message);
      }
      info(message) {
        this.logWithLevel(3, message);
      }
      debug(message) {
        this.logWithLevel(4, message);
      }
      verbose(message) {
        this.logWithLevel(5, message);
      }
    }, "Log");
    var NoOpLog = /* @__PURE__ */ __name(class extends Log2 {
      log() {
      }
      error(message) {
        throw message;
      }
    }, "NoOpLog");
    var OptionType;
    (function(OptionType2) {
      OptionType2[OptionType2["NONE"] = 0] = "NONE";
      OptionType2[OptionType2["BOOLEAN"] = 1] = "BOOLEAN";
      OptionType2[OptionType2["NUMBER"] = 2] = "NUMBER";
      OptionType2[OptionType2["STRING"] = 3] = "STRING";
      OptionType2[OptionType2["STRING_POSITIONAL"] = 4] = "STRING_POSITIONAL";
      OptionType2[OptionType2["BOOLEAN_STRING"] = 5] = "BOOLEAN_STRING";
      OptionType2[OptionType2["BOOLEAN_NUMBER"] = 6] = "BOOLEAN_NUMBER";
      OptionType2[OptionType2["ARRAY"] = 7] = "ARRAY";
      OptionType2[OptionType2["OBJECT"] = 8] = "OBJECT";
    })(OptionType || (OptionType = {}));
    function Option(metadata) {
      return function(prototype, key) {
        (prototype.opts ??= /* @__PURE__ */ new Map()).set(key, metadata);
      };
    }
    __name(Option, "Option");
    var Plugin = /* @__PURE__ */ __name(class {
      constructor(ctx) {
        this.ctx = ctx;
        this.opts = new.target.prototype.opts;
      }
      #phantom;
      opts;
      assignOptions(options29) {
        if (options29 === void 0 || this.opts === void 0)
          return;
        for (const key of this.opts.keys()) {
          this[key] = options29[key];
        }
      }
    }, "Plugin");
    function logOptions(plugins, log2, options29) {
      log2.debug("Options:");
      for (const [name, plugin] of plugins) {
        const pluginOptions = options29[name];
        for (const [key, meta] of plugin.prototype.opts?.entries() ?? []) {
          const value = pluginOptions[key];
          if (value === void 0 || meta.type === 0)
            continue;
          const keyName = meta?.logName ?? titleCase(typeof key === "symbol" ? "<symbol>" : key);
          let str;
          if (meta.logValue) {
            str = meta.logValue(value);
            if (str === void 0)
              continue;
          } else if (meta.type === 8) {
            str = Object.keys(value).join(", ");
          } else if (meta.type === 7) {
            str = value.join(", ");
          } else {
            str = value.toString();
          }
          log2.debug(`- ${keyName}: ${str}`);
        }
      }
    }
    __name(logOptions, "logOptions");
    var kGetConsumer = Symbol("kGetConsumer");
    var kSetConsumer = Symbol("kSetConsumer");
    var STRING_SCRIPT_PATH = "<script>";
    function parseRange({ offset, length, suffix }, size) {
      if (suffix !== void 0) {
        if (suffix <= 0) {
          throw new Error("Suffix must be > 0");
        }
        if (suffix > size)
          suffix = size;
        offset = size - suffix;
        length = size - offset;
      }
      if (offset === void 0)
        offset = 0;
      if (length === void 0)
        length = size - offset;
      if (offset < 0)
        throw new Error("Offset must be >= 0");
      if (offset > size)
        throw new Error("Offset must be < size");
      if (length <= 0)
        throw new Error("Length must be > 0");
      if (offset + length > size)
        length = size - offset;
      return { offset, length };
    }
    __name(parseRange, "parseRange");
    var Storage = /* @__PURE__ */ __name(class {
      async getSqliteDatabase() {
        throw new Error("D1 not implemented for this Storage class");
      }
      async hasMany(keys) {
        const results = keys.map(this.has.bind(this));
        let count = 0;
        for (const result of await Promise.all(results))
          if (result)
            count++;
        return count;
      }
      getMany(keys, skipMetadata) {
        return Promise.all(keys.map((key) => this.get(key, skipMetadata)));
      }
      async putMany(data) {
        await Promise.all(data.map(([key, value]) => this.put(key, value)));
      }
      async deleteMany(keys) {
        const results = keys.map(this.delete.bind(this));
        let count = 0;
        for (const result of await Promise.all(results))
          if (result)
            count++;
        return count;
      }
    }, "Storage");
    var defaultClock = /* @__PURE__ */ __name(() => Date.now(), "defaultClock");
    function millisToSeconds(millis) {
      return Math.floor(millis / 1e3);
    }
    __name(millisToSeconds, "millisToSeconds");
    var import_assert32 = __toModule(require("assert"));
    var import_async_hooks2 = __toModule(require("async_hooks"));
    var import_timers = __toModule(require("timers"));
    var import_promises21 = __toModule(require("timers/promises"));
    var inputGateStorage = new import_async_hooks2.AsyncLocalStorage();
    var outputGateStorage = new import_async_hooks2.AsyncLocalStorage();
    function waitForOpenInputGate() {
      const inputGate = inputGateStorage.getStore();
      return inputGate?.waitForOpen();
    }
    __name(waitForOpenInputGate, "waitForOpenInputGate");
    function runWithInputGateClosed(closure, allowConcurrency = false) {
      if (allowConcurrency)
        return closure();
      const inputGate = inputGateStorage.getStore();
      if (inputGate === void 0)
        return closure();
      return inputGate.runWithClosed(closure);
    }
    __name(runWithInputGateClosed, "runWithInputGateClosed");
    function waitForOpenOutputGate() {
      const outputGate = outputGateStorage.getStore();
      return outputGate?.waitForOpen();
    }
    __name(waitForOpenOutputGate, "waitForOpenOutputGate");
    function waitUntilOnOutputGate(promise, allowUnconfirmed = false) {
      if (allowUnconfirmed)
        return promise;
      const outputGate = outputGateStorage.getStore();
      outputGate?.waitUntil(promise);
      return promise;
    }
    __name(waitUntilOnOutputGate, "waitUntilOnOutputGate");
    var InputGate = /* @__PURE__ */ __name(class {
      #lockCount = 0;
      #resolveQueue = [];
      #parent;
      constructor(parent) {
        this.#parent = parent;
      }
      async runWith(closure) {
        await this.waitForOpen();
        return inputGateStorage.run(this, closure);
      }
      async waitForOpen() {
        await (0, import_promises21.setImmediate)();
        if (this.#lockCount === 0)
          return;
        return new Promise((resolve19) => this.#resolveQueue.push(resolve19));
      }
      async runWithClosed(closure) {
        this.#lock();
        await Promise.resolve();
        const childInputGate = new InputGate(this);
        try {
          return await inputGateStorage.run(childInputGate, closure);
        } finally {
          (0, import_timers.setImmediate)(this.#unlock);
        }
      }
      #lock() {
        this.#lockCount++;
        if (this.#parent)
          this.#parent.#lock();
      }
      #unlock = async () => {
        (0, import_assert32.default)(this.#lockCount > 0);
        this.#lockCount--;
        while (this.#lockCount === 0 && this.#resolveQueue.length) {
          this.#resolveQueue.shift()();
          await (0, import_promises21.setImmediate)();
        }
        if (this.#parent)
          return this.#parent.#unlock();
      };
    }, "InputGate");
    var OutputGate = /* @__PURE__ */ __name(class {
      #waitUntil = [];
      async runWith(closure) {
        try {
          return await outputGateStorage.run(this, closure);
        } finally {
          await this.waitForOpen();
        }
      }
      async waitForOpen() {
        await Promise.all(this.#waitUntil);
      }
      waitUntil(promise) {
        this.#waitUntil.push(promise);
      }
    }, "OutputGate");
    var InputGatedEventTarget = /* @__PURE__ */ __name(class extends TypedEventTarget2 {
      [kWrapListener](listener) {
        const inputGate = inputGateStorage.getStore();
        return inputGate ? async (event) => {
          await inputGate.waitForOpen();
          listener(event);
        } : listener;
      }
    }, "InputGatedEventTarget");
    var import_assert42 = __toModule(require("assert"));
    var Mutex4 = /* @__PURE__ */ __name(class {
      locked = false;
      resolveQueue = [];
      lock() {
        if (!this.locked) {
          this.locked = true;
          return;
        }
        return new Promise((resolve19) => this.resolveQueue.push(resolve19));
      }
      unlock() {
        (0, import_assert42.default)(this.locked);
        if (this.resolveQueue.length > 0) {
          this.resolveQueue.shift()?.();
        } else {
          this.locked = false;
        }
      }
      get hasWaiting() {
        return this.resolveQueue.length > 0;
      }
      async runWith(closure) {
        const acquireAwaitable = this.lock();
        if (acquireAwaitable instanceof Promise)
          await acquireAwaitable;
        try {
          const awaitable = closure();
          if (awaitable instanceof Promise)
            return await awaitable;
          return awaitable;
        } finally {
          this.unlock();
        }
      }
    }, "Mutex");
    var import_node_path60 = __toModule(require("node:path"));
    async function createSQLiteDB(dbPath) {
      const { npxImport: npxImport2, npxResolve: npxResolve2 } = await Promise.resolve().then(() => (init_lib(), lib_exports));
      const { default: DatabaseConstructor } = await npxImport2("better-sqlite3@8.0.1");
      return new DatabaseConstructor(dbPath, {
        nativeBinding: getSQLiteNativeBindingLocation(npxResolve2("better-sqlite3"))
      });
    }
    __name(createSQLiteDB, "createSQLiteDB");
    function getSQLiteNativeBindingLocation(sqliteResolvePath) {
      return import_node_path60.default.resolve(import_node_path60.default.dirname(sqliteResolvePath), "../build/Release/better_sqlite3.node");
    }
    __name(getSQLiteNativeBindingLocation, "getSQLiteNativeBindingLocation");
  }
});

// ../../node_modules/.pnpm/dotenv@10.0.0/node_modules/dotenv/lib/main.js
var require_main4 = __commonJS({
  "../../node_modules/.pnpm/dotenv@10.0.0/node_modules/dotenv/lib/main.js"(exports2, module3) {
    init_import_meta_url();
    var fs26 = require("fs");
    var path67 = require("path");
    var os11 = require("os");
    function log2(message) {
      console.log(`[dotenv][DEBUG] ${message}`);
    }
    __name(log2, "log");
    var NEWLINE = "\n";
    var RE_INI_KEY_VAL = /^\s*([\w.-]+)\s*=\s*(.*)?\s*$/;
    var RE_NEWLINES = /\\n/g;
    var NEWLINES_MATCH = /\r\n|\n|\r/;
    function parse7(src, options29) {
      const debug = Boolean(options29 && options29.debug);
      const obj = {};
      src.toString().split(NEWLINES_MATCH).forEach(function(line, idx) {
        const keyValueArr = line.match(RE_INI_KEY_VAL);
        if (keyValueArr != null) {
          const key = keyValueArr[1];
          let val = keyValueArr[2] || "";
          const end = val.length - 1;
          const isDoubleQuoted = val[0] === '"' && val[end] === '"';
          const isSingleQuoted = val[0] === "'" && val[end] === "'";
          if (isSingleQuoted || isDoubleQuoted) {
            val = val.substring(1, end);
            if (isDoubleQuoted) {
              val = val.replace(RE_NEWLINES, NEWLINE);
            }
          } else {
            val = val.trim();
          }
          obj[key] = val;
        } else if (debug) {
          log2(`did not match key and value when parsing line ${idx + 1}: ${line}`);
        }
      });
      return obj;
    }
    __name(parse7, "parse");
    function resolveHome(envPath) {
      return envPath[0] === "~" ? path67.join(os11.homedir(), envPath.slice(1)) : envPath;
    }
    __name(resolveHome, "resolveHome");
    function config(options29) {
      let dotenvPath = path67.resolve(process.cwd(), ".env");
      let encoding = "utf8";
      let debug = false;
      if (options29) {
        if (options29.path != null) {
          dotenvPath = resolveHome(options29.path);
        }
        if (options29.encoding != null) {
          encoding = options29.encoding;
        }
        if (options29.debug != null) {
          debug = true;
        }
      }
      try {
        const parsed = parse7(fs26.readFileSync(dotenvPath, { encoding }), { debug });
        Object.keys(parsed).forEach(function(key) {
          if (!Object.prototype.hasOwnProperty.call(process.env, key)) {
            process.env[key] = parsed[key];
          } else if (debug) {
            log2(`"${key}" is already defined in \`process.env\` and will not be overwritten`);
          }
        });
        return { parsed };
      } catch (e3) {
        return { error: e3 };
      }
    }
    __name(config, "config");
    module3.exports.config = config;
    module3.exports.parse = parse7;
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/core/symbols.js
var require_symbols6 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/core/symbols.js"(exports2, module3) {
    init_import_meta_url();
    module3.exports = {
      kClose: Symbol("close"),
      kDestroy: Symbol("destroy"),
      kDispatch: Symbol("dispatch"),
      kUrl: Symbol("url"),
      kWriting: Symbol("writing"),
      kResuming: Symbol("resuming"),
      kQueue: Symbol("queue"),
      kConnect: Symbol("connect"),
      kConnecting: Symbol("connecting"),
      kHeadersList: Symbol("headers list"),
      kKeepAliveDefaultTimeout: Symbol("default keep alive timeout"),
      kKeepAliveMaxTimeout: Symbol("max keep alive timeout"),
      kKeepAliveTimeoutThreshold: Symbol("keep alive timeout threshold"),
      kKeepAliveTimeoutValue: Symbol("keep alive timeout"),
      kKeepAlive: Symbol("keep alive"),
      kHeadersTimeout: Symbol("headers timeout"),
      kBodyTimeout: Symbol("body timeout"),
      kServerName: Symbol("server name"),
      kLocalAddress: Symbol("local address"),
      kHost: Symbol("host"),
      kNoRef: Symbol("no ref"),
      kBodyUsed: Symbol("used"),
      kRunning: Symbol("running"),
      kBlocking: Symbol("blocking"),
      kPending: Symbol("pending"),
      kSize: Symbol("size"),
      kBusy: Symbol("busy"),
      kQueued: Symbol("queued"),
      kFree: Symbol("free"),
      kConnected: Symbol("connected"),
      kClosed: Symbol("closed"),
      kNeedDrain: Symbol("need drain"),
      kReset: Symbol("reset"),
      kDestroyed: Symbol.for("nodejs.stream.destroyed"),
      kMaxHeadersSize: Symbol("max headers size"),
      kRunningIdx: Symbol("running index"),
      kPendingIdx: Symbol("pending index"),
      kError: Symbol("error"),
      kClients: Symbol("clients"),
      kClient: Symbol("client"),
      kParser: Symbol("parser"),
      kOnDestroyed: Symbol("destroy callbacks"),
      kPipelining: Symbol("pipelining"),
      kSocket: Symbol("socket"),
      kHostHeader: Symbol("host header"),
      kConnector: Symbol("connector"),
      kStrictContentLength: Symbol("strict content length"),
      kMaxRedirections: Symbol("maxRedirections"),
      kMaxRequests: Symbol("maxRequestsPerClient"),
      kProxy: Symbol("proxy agent options"),
      kCounter: Symbol("socket request counter"),
      kInterceptors: Symbol("dispatch interceptors"),
      kMaxResponseSize: Symbol("max response size"),
      kHTTP2Session: Symbol("http2Session"),
      kHTTP2SessionState: Symbol("http2Session state"),
      kHTTP2BuildRequest: Symbol("http2 build request"),
      kHTTP1BuildRequest: Symbol("http1 build request"),
      kHTTP2CopyHeaders: Symbol("http2 copy headers"),
      kHTTPConnVersion: Symbol("http connection version"),
      kRetryHandlerDefaultRetry: Symbol("retry agent default retry"),
      kConstruct: Symbol("constructable")
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/core/errors.js
var require_errors2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/core/errors.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var UndiciError = class extends Error {
      constructor(message) {
        super(message);
        this.name = "UndiciError";
        this.code = "UND_ERR";
      }
    };
    __name(UndiciError, "UndiciError");
    var ConnectTimeoutError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, ConnectTimeoutError);
        this.name = "ConnectTimeoutError";
        this.message = message || "Connect Timeout Error";
        this.code = "UND_ERR_CONNECT_TIMEOUT";
      }
    };
    __name(ConnectTimeoutError, "ConnectTimeoutError");
    var HeadersTimeoutError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, HeadersTimeoutError);
        this.name = "HeadersTimeoutError";
        this.message = message || "Headers Timeout Error";
        this.code = "UND_ERR_HEADERS_TIMEOUT";
      }
    };
    __name(HeadersTimeoutError, "HeadersTimeoutError");
    var HeadersOverflowError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, HeadersOverflowError);
        this.name = "HeadersOverflowError";
        this.message = message || "Headers Overflow Error";
        this.code = "UND_ERR_HEADERS_OVERFLOW";
      }
    };
    __name(HeadersOverflowError, "HeadersOverflowError");
    var BodyTimeoutError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, BodyTimeoutError);
        this.name = "BodyTimeoutError";
        this.message = message || "Body Timeout Error";
        this.code = "UND_ERR_BODY_TIMEOUT";
      }
    };
    __name(BodyTimeoutError, "BodyTimeoutError");
    var ResponseStatusCodeError = class extends UndiciError {
      constructor(message, statusCode, headers, body) {
        super(message);
        Error.captureStackTrace(this, ResponseStatusCodeError);
        this.name = "ResponseStatusCodeError";
        this.message = message || "Response Status Code Error";
        this.code = "UND_ERR_RESPONSE_STATUS_CODE";
        this.body = body;
        this.status = statusCode;
        this.statusCode = statusCode;
        this.headers = headers;
      }
    };
    __name(ResponseStatusCodeError, "ResponseStatusCodeError");
    var InvalidArgumentError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, InvalidArgumentError);
        this.name = "InvalidArgumentError";
        this.message = message || "Invalid Argument Error";
        this.code = "UND_ERR_INVALID_ARG";
      }
    };
    __name(InvalidArgumentError, "InvalidArgumentError");
    var InvalidReturnValueError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, InvalidReturnValueError);
        this.name = "InvalidReturnValueError";
        this.message = message || "Invalid Return Value Error";
        this.code = "UND_ERR_INVALID_RETURN_VALUE";
      }
    };
    __name(InvalidReturnValueError, "InvalidReturnValueError");
    var RequestAbortedError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, RequestAbortedError);
        this.name = "AbortError";
        this.message = message || "Request aborted";
        this.code = "UND_ERR_ABORTED";
      }
    };
    __name(RequestAbortedError, "RequestAbortedError");
    var InformationalError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, InformationalError);
        this.name = "InformationalError";
        this.message = message || "Request information";
        this.code = "UND_ERR_INFO";
      }
    };
    __name(InformationalError, "InformationalError");
    var RequestContentLengthMismatchError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, RequestContentLengthMismatchError);
        this.name = "RequestContentLengthMismatchError";
        this.message = message || "Request body length does not match content-length header";
        this.code = "UND_ERR_REQ_CONTENT_LENGTH_MISMATCH";
      }
    };
    __name(RequestContentLengthMismatchError, "RequestContentLengthMismatchError");
    var ResponseContentLengthMismatchError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, ResponseContentLengthMismatchError);
        this.name = "ResponseContentLengthMismatchError";
        this.message = message || "Response body length does not match content-length header";
        this.code = "UND_ERR_RES_CONTENT_LENGTH_MISMATCH";
      }
    };
    __name(ResponseContentLengthMismatchError, "ResponseContentLengthMismatchError");
    var ClientDestroyedError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, ClientDestroyedError);
        this.name = "ClientDestroyedError";
        this.message = message || "The client is destroyed";
        this.code = "UND_ERR_DESTROYED";
      }
    };
    __name(ClientDestroyedError, "ClientDestroyedError");
    var ClientClosedError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, ClientClosedError);
        this.name = "ClientClosedError";
        this.message = message || "The client is closed";
        this.code = "UND_ERR_CLOSED";
      }
    };
    __name(ClientClosedError, "ClientClosedError");
    var SocketError = class extends UndiciError {
      constructor(message, socket) {
        super(message);
        Error.captureStackTrace(this, SocketError);
        this.name = "SocketError";
        this.message = message || "Socket error";
        this.code = "UND_ERR_SOCKET";
        this.socket = socket;
      }
    };
    __name(SocketError, "SocketError");
    var NotSupportedError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, NotSupportedError);
        this.name = "NotSupportedError";
        this.message = message || "Not supported error";
        this.code = "UND_ERR_NOT_SUPPORTED";
      }
    };
    __name(NotSupportedError, "NotSupportedError");
    var BalancedPoolMissingUpstreamError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, NotSupportedError);
        this.name = "MissingUpstreamError";
        this.message = message || "No upstream has been added to the BalancedPool";
        this.code = "UND_ERR_BPL_MISSING_UPSTREAM";
      }
    };
    __name(BalancedPoolMissingUpstreamError, "BalancedPoolMissingUpstreamError");
    var HTTPParserError = class extends Error {
      constructor(message, code, data) {
        super(message);
        Error.captureStackTrace(this, HTTPParserError);
        this.name = "HTTPParserError";
        this.code = code ? `HPE_${code}` : void 0;
        this.data = data ? data.toString() : void 0;
      }
    };
    __name(HTTPParserError, "HTTPParserError");
    var ResponseExceededMaxSizeError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, ResponseExceededMaxSizeError);
        this.name = "ResponseExceededMaxSizeError";
        this.message = message || "Response content exceeded max size";
        this.code = "UND_ERR_RES_EXCEEDED_MAX_SIZE";
      }
    };
    __name(ResponseExceededMaxSizeError, "ResponseExceededMaxSizeError");
    var RequestRetryError = class extends UndiciError {
      constructor(message, code, { headers, data }) {
        super(message);
        Error.captureStackTrace(this, RequestRetryError);
        this.name = "RequestRetryError";
        this.message = message || "Request retry error";
        this.code = "UND_ERR_REQ_RETRY";
        this.statusCode = code;
        this.data = data;
        this.headers = headers;
      }
    };
    __name(RequestRetryError, "RequestRetryError");
    module3.exports = {
      HTTPParserError,
      UndiciError,
      HeadersTimeoutError,
      HeadersOverflowError,
      BodyTimeoutError,
      RequestContentLengthMismatchError,
      ConnectTimeoutError,
      ResponseStatusCodeError,
      InvalidArgumentError,
      InvalidReturnValueError,
      RequestAbortedError,
      ClientDestroyedError,
      ClientClosedError,
      InformationalError,
      SocketError,
      NotSupportedError,
      ResponseContentLengthMismatchError,
      BalancedPoolMissingUpstreamError,
      ResponseExceededMaxSizeError,
      RequestRetryError
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/core/util.js
var require_util12 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/core/util.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var assert27 = require("assert");
    var { kDestroyed, kBodyUsed } = require_symbols6();
    var { IncomingMessage } = require("http");
    var stream2 = require("stream");
    var net3 = require("net");
    var { InvalidArgumentError } = require_errors2();
    var { Blob: Blob6 } = require("buffer");
    var nodeUtil = require("util");
    var { stringify } = require("querystring");
    var [nodeMajor, nodeMinor] = process.versions.node.split(".").map((v2) => Number(v2));
    function nop() {
    }
    __name(nop, "nop");
    function isStream2(obj) {
      return obj && typeof obj === "object" && typeof obj.pipe === "function" && typeof obj.on === "function";
    }
    __name(isStream2, "isStream");
    function isBlobLike(object) {
      return Blob6 && object instanceof Blob6 || object && typeof object === "object" && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && /^(Blob|File)$/.test(object[Symbol.toStringTag]);
    }
    __name(isBlobLike, "isBlobLike");
    function buildURL(url4, queryParams) {
      if (url4.includes("?") || url4.includes("#")) {
        throw new Error('Query params cannot be passed when url already contains "?" or "#".');
      }
      const stringified = stringify(queryParams);
      if (stringified) {
        url4 += "?" + stringified;
      }
      return url4;
    }
    __name(buildURL, "buildURL");
    function parseURL(url4) {
      if (typeof url4 === "string") {
        url4 = new URL(url4);
        if (!/^https?:/.test(url4.origin || url4.protocol)) {
          throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
        }
        return url4;
      }
      if (!url4 || typeof url4 !== "object") {
        throw new InvalidArgumentError("Invalid URL: The URL argument must be a non-null object.");
      }
      if (!/^https?:/.test(url4.origin || url4.protocol)) {
        throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
      }
      if (!(url4 instanceof URL)) {
        if (url4.port != null && url4.port !== "" && !Number.isFinite(parseInt(url4.port))) {
          throw new InvalidArgumentError("Invalid URL: port must be a valid integer or a string representation of an integer.");
        }
        if (url4.path != null && typeof url4.path !== "string") {
          throw new InvalidArgumentError("Invalid URL path: the path must be a string or null/undefined.");
        }
        if (url4.pathname != null && typeof url4.pathname !== "string") {
          throw new InvalidArgumentError("Invalid URL pathname: the pathname must be a string or null/undefined.");
        }
        if (url4.hostname != null && typeof url4.hostname !== "string") {
          throw new InvalidArgumentError("Invalid URL hostname: the hostname must be a string or null/undefined.");
        }
        if (url4.origin != null && typeof url4.origin !== "string") {
          throw new InvalidArgumentError("Invalid URL origin: the origin must be a string or null/undefined.");
        }
        const port2 = url4.port != null ? url4.port : url4.protocol === "https:" ? 443 : 80;
        let origin = url4.origin != null ? url4.origin : `${url4.protocol}//${url4.hostname}:${port2}`;
        let path67 = url4.path != null ? url4.path : `${url4.pathname || ""}${url4.search || ""}`;
        if (origin.endsWith("/")) {
          origin = origin.substring(0, origin.length - 1);
        }
        if (path67 && !path67.startsWith("/")) {
          path67 = `/${path67}`;
        }
        url4 = new URL(origin + path67);
      }
      return url4;
    }
    __name(parseURL, "parseURL");
    function parseOrigin(url4) {
      url4 = parseURL(url4);
      if (url4.pathname !== "/" || url4.search || url4.hash) {
        throw new InvalidArgumentError("invalid url");
      }
      return url4;
    }
    __name(parseOrigin, "parseOrigin");
    function getHostname(host) {
      if (host[0] === "[") {
        const idx2 = host.indexOf("]");
        assert27(idx2 !== -1);
        return host.substring(1, idx2);
      }
      const idx = host.indexOf(":");
      if (idx === -1)
        return host;
      return host.substring(0, idx);
    }
    __name(getHostname, "getHostname");
    function getServerName(host) {
      if (!host) {
        return null;
      }
      assert27.strictEqual(typeof host, "string");
      const servername = getHostname(host);
      if (net3.isIP(servername)) {
        return "";
      }
      return servername;
    }
    __name(getServerName, "getServerName");
    function deepClone(obj) {
      return JSON.parse(JSON.stringify(obj));
    }
    __name(deepClone, "deepClone");
    function isAsyncIterable(obj) {
      return !!(obj != null && typeof obj[Symbol.asyncIterator] === "function");
    }
    __name(isAsyncIterable, "isAsyncIterable");
    function isIterable(obj) {
      return !!(obj != null && (typeof obj[Symbol.iterator] === "function" || typeof obj[Symbol.asyncIterator] === "function"));
    }
    __name(isIterable, "isIterable");
    function bodyLength(body) {
      if (body == null) {
        return 0;
      } else if (isStream2(body)) {
        const state = body._readableState;
        return state && state.objectMode === false && state.ended === true && Number.isFinite(state.length) ? state.length : null;
      } else if (isBlobLike(body)) {
        return body.size != null ? body.size : null;
      } else if (isBuffer(body)) {
        return body.byteLength;
      }
      return null;
    }
    __name(bodyLength, "bodyLength");
    function isDestroyed(stream3) {
      return !stream3 || !!(stream3.destroyed || stream3[kDestroyed]);
    }
    __name(isDestroyed, "isDestroyed");
    function isReadableAborted(stream3) {
      const state = stream3 && stream3._readableState;
      return isDestroyed(stream3) && state && !state.endEmitted;
    }
    __name(isReadableAborted, "isReadableAborted");
    function destroy(stream3, err) {
      if (stream3 == null || !isStream2(stream3) || isDestroyed(stream3)) {
        return;
      }
      if (typeof stream3.destroy === "function") {
        if (Object.getPrototypeOf(stream3).constructor === IncomingMessage) {
          stream3.socket = null;
        }
        stream3.destroy(err);
      } else if (err) {
        process.nextTick((stream4, err2) => {
          stream4.emit("error", err2);
        }, stream3, err);
      }
      if (stream3.destroyed !== true) {
        stream3[kDestroyed] = true;
      }
    }
    __name(destroy, "destroy");
    var KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/;
    function parseKeepAliveTimeout(val) {
      const m2 = val.toString().match(KEEPALIVE_TIMEOUT_EXPR);
      return m2 ? parseInt(m2[1], 10) * 1e3 : null;
    }
    __name(parseKeepAliveTimeout, "parseKeepAliveTimeout");
    function parseHeaders2(headers, obj = {}) {
      if (!Array.isArray(headers))
        return headers;
      for (let i = 0; i < headers.length; i += 2) {
        const key = headers[i].toString().toLowerCase();
        let val = obj[key];
        if (!val) {
          if (Array.isArray(headers[i + 1])) {
            obj[key] = headers[i + 1].map((x2) => x2.toString("utf8"));
          } else {
            obj[key] = headers[i + 1].toString("utf8");
          }
        } else {
          if (!Array.isArray(val)) {
            val = [val];
            obj[key] = val;
          }
          val.push(headers[i + 1].toString("utf8"));
        }
      }
      if ("content-length" in obj && "content-disposition" in obj) {
        obj["content-disposition"] = Buffer.from(obj["content-disposition"]).toString("latin1");
      }
      return obj;
    }
    __name(parseHeaders2, "parseHeaders");
    function parseRawHeaders(headers) {
      const ret = [];
      let hasContentLength = false;
      let contentDispositionIdx = -1;
      for (let n2 = 0; n2 < headers.length; n2 += 2) {
        const key = headers[n2 + 0].toString();
        const val = headers[n2 + 1].toString("utf8");
        if (key.length === 14 && (key === "content-length" || key.toLowerCase() === "content-length")) {
          ret.push(key, val);
          hasContentLength = true;
        } else if (key.length === 19 && (key === "content-disposition" || key.toLowerCase() === "content-disposition")) {
          contentDispositionIdx = ret.push(key, val) - 1;
        } else {
          ret.push(key, val);
        }
      }
      if (hasContentLength && contentDispositionIdx !== -1) {
        ret[contentDispositionIdx] = Buffer.from(ret[contentDispositionIdx]).toString("latin1");
      }
      return ret;
    }
    __name(parseRawHeaders, "parseRawHeaders");
    function isBuffer(buffer) {
      return buffer instanceof Uint8Array || Buffer.isBuffer(buffer);
    }
    __name(isBuffer, "isBuffer");
    function validateHandler(handler30, method, upgrade) {
      if (!handler30 || typeof handler30 !== "object") {
        throw new InvalidArgumentError("handler must be an object");
      }
      if (typeof handler30.onConnect !== "function") {
        throw new InvalidArgumentError("invalid onConnect method");
      }
      if (typeof handler30.onError !== "function") {
        throw new InvalidArgumentError("invalid onError method");
      }
      if (typeof handler30.onBodySent !== "function" && handler30.onBodySent !== void 0) {
        throw new InvalidArgumentError("invalid onBodySent method");
      }
      if (upgrade || method === "CONNECT") {
        if (typeof handler30.onUpgrade !== "function") {
          throw new InvalidArgumentError("invalid onUpgrade method");
        }
      } else {
        if (typeof handler30.onHeaders !== "function") {
          throw new InvalidArgumentError("invalid onHeaders method");
        }
        if (typeof handler30.onData !== "function") {
          throw new InvalidArgumentError("invalid onData method");
        }
        if (typeof handler30.onComplete !== "function") {
          throw new InvalidArgumentError("invalid onComplete method");
        }
      }
    }
    __name(validateHandler, "validateHandler");
    function isDisturbed(body) {
      return !!(body && (stream2.isDisturbed ? stream2.isDisturbed(body) || body[kBodyUsed] : body[kBodyUsed] || body.readableDidRead || body._readableState && body._readableState.dataEmitted || isReadableAborted(body)));
    }
    __name(isDisturbed, "isDisturbed");
    function isErrored(body) {
      return !!(body && (stream2.isErrored ? stream2.isErrored(body) : /state: 'errored'/.test(
        nodeUtil.inspect(body)
      )));
    }
    __name(isErrored, "isErrored");
    function isReadable(body) {
      return !!(body && (stream2.isReadable ? stream2.isReadable(body) : /state: 'readable'/.test(
        nodeUtil.inspect(body)
      )));
    }
    __name(isReadable, "isReadable");
    function getSocketInfo(socket) {
      return {
        localAddress: socket.localAddress,
        localPort: socket.localPort,
        remoteAddress: socket.remoteAddress,
        remotePort: socket.remotePort,
        remoteFamily: socket.remoteFamily,
        timeout: socket.timeout,
        bytesWritten: socket.bytesWritten,
        bytesRead: socket.bytesRead
      };
    }
    __name(getSocketInfo, "getSocketInfo");
    async function* convertIterableToBuffer(iterable) {
      for await (const chunk of iterable) {
        yield Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
      }
    }
    __name(convertIterableToBuffer, "convertIterableToBuffer");
    var ReadableStream2;
    function ReadableStreamFrom(iterable) {
      if (!ReadableStream2) {
        ReadableStream2 = require("stream/web").ReadableStream;
      }
      if (ReadableStream2.from) {
        return ReadableStream2.from(convertIterableToBuffer(iterable));
      }
      let iterator;
      return new ReadableStream2(
        {
          async start() {
            iterator = iterable[Symbol.asyncIterator]();
          },
          async pull(controller) {
            const { done, value } = await iterator.next();
            if (done) {
              queueMicrotask(() => {
                controller.close();
              });
            } else {
              const buf = Buffer.isBuffer(value) ? value : Buffer.from(value);
              controller.enqueue(new Uint8Array(buf));
            }
            return controller.desiredSize > 0;
          },
          async cancel(reason) {
            await iterator.return();
          }
        },
        0
      );
    }
    __name(ReadableStreamFrom, "ReadableStreamFrom");
    function isFormDataLike(object) {
      return object && typeof object === "object" && typeof object.append === "function" && typeof object.delete === "function" && typeof object.get === "function" && typeof object.getAll === "function" && typeof object.has === "function" && typeof object.set === "function" && object[Symbol.toStringTag] === "FormData";
    }
    __name(isFormDataLike, "isFormDataLike");
    function throwIfAborted(signal) {
      if (!signal) {
        return;
      }
      if (typeof signal.throwIfAborted === "function") {
        signal.throwIfAborted();
      } else {
        if (signal.aborted) {
          const err = new Error("The operation was aborted");
          err.name = "AbortError";
          throw err;
        }
      }
    }
    __name(throwIfAborted, "throwIfAborted");
    function addAbortListener(signal, listener) {
      if ("addEventListener" in signal) {
        signal.addEventListener("abort", listener, { once: true });
        return () => signal.removeEventListener("abort", listener);
      }
      signal.addListener("abort", listener);
      return () => signal.removeListener("abort", listener);
    }
    __name(addAbortListener, "addAbortListener");
    var hasToWellFormed = !!String.prototype.toWellFormed;
    function toUSVString(val) {
      if (hasToWellFormed) {
        return `${val}`.toWellFormed();
      } else if (nodeUtil.toUSVString) {
        return nodeUtil.toUSVString(val);
      }
      return `${val}`;
    }
    __name(toUSVString, "toUSVString");
    function parseRangeHeader(range) {
      if (range == null || range === "")
        return { start: 0, end: null, size: null };
      const m2 = range ? range.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null;
      return m2 ? {
        start: parseInt(m2[1]),
        end: m2[2] ? parseInt(m2[2]) : null,
        size: m2[3] ? parseInt(m2[3]) : null
      } : null;
    }
    __name(parseRangeHeader, "parseRangeHeader");
    var kEnumerableProperty = /* @__PURE__ */ Object.create(null);
    kEnumerableProperty.enumerable = true;
    module3.exports = {
      kEnumerableProperty,
      nop,
      isDisturbed,
      isErrored,
      isReadable,
      toUSVString,
      isReadableAborted,
      isBlobLike,
      parseOrigin,
      parseURL,
      getServerName,
      isStream: isStream2,
      isIterable,
      isAsyncIterable,
      isDestroyed,
      parseRawHeaders,
      parseHeaders: parseHeaders2,
      parseKeepAliveTimeout,
      destroy,
      bodyLength,
      deepClone,
      ReadableStreamFrom,
      isBuffer,
      validateHandler,
      getSocketInfo,
      isFormDataLike,
      buildURL,
      throwIfAborted,
      addAbortListener,
      parseRangeHeader,
      nodeMajor,
      nodeMinor,
      nodeHasAutoSelectFamily: nodeMajor > 18 || nodeMajor === 18 && nodeMinor >= 13,
      safeHTTPMethods: ["GET", "HEAD", "OPTIONS", "TRACE"]
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/timers.js
var require_timers2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/timers.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var fastNow = Date.now();
    var fastNowTimeout;
    var fastTimers = [];
    function onTimeout() {
      fastNow = Date.now();
      let len = fastTimers.length;
      let idx = 0;
      while (idx < len) {
        const timer = fastTimers[idx];
        if (timer.state === 0) {
          timer.state = fastNow + timer.delay;
        } else if (timer.state > 0 && fastNow >= timer.state) {
          timer.state = -1;
          timer.callback(timer.opaque);
        }
        if (timer.state === -1) {
          timer.state = -2;
          if (idx !== len - 1) {
            fastTimers[idx] = fastTimers.pop();
          } else {
            fastTimers.pop();
          }
          len -= 1;
        } else {
          idx += 1;
        }
      }
      if (fastTimers.length > 0) {
        refreshTimeout();
      }
    }
    __name(onTimeout, "onTimeout");
    function refreshTimeout() {
      if (fastNowTimeout && fastNowTimeout.refresh) {
        fastNowTimeout.refresh();
      } else {
        clearTimeout(fastNowTimeout);
        fastNowTimeout = setTimeout(onTimeout, 1e3);
        if (fastNowTimeout.unref) {
          fastNowTimeout.unref();
        }
      }
    }
    __name(refreshTimeout, "refreshTimeout");
    var Timeout = class {
      constructor(callback, delay, opaque) {
        this.callback = callback;
        this.delay = delay;
        this.opaque = opaque;
        this.state = -2;
        this.refresh();
      }
      refresh() {
        if (this.state === -2) {
          fastTimers.push(this);
          if (!fastNowTimeout || fastTimers.length === 1) {
            refreshTimeout();
          }
        }
        this.state = 0;
      }
      clear() {
        this.state = -1;
      }
    };
    __name(Timeout, "Timeout");
    module3.exports = {
      setTimeout(callback, delay, opaque) {
        return delay < 1e3 ? setTimeout(callback, delay, opaque) : new Timeout(callback, delay, opaque);
      },
      clearTimeout(timeout) {
        if (timeout instanceof Timeout) {
          timeout.clear();
        } else {
          clearTimeout(timeout);
        }
      }
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/constants.js
var require_constants9 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/constants.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { MessageChannel: MessageChannel2, receiveMessageOnPort } = require("worker_threads");
    var corsSafeListedMethods = ["GET", "HEAD", "POST"];
    var corsSafeListedMethodsSet = new Set(corsSafeListedMethods);
    var nullBodyStatus = [101, 204, 205, 304];
    var redirectStatus = [301, 302, 303, 307, 308];
    var redirectStatusSet = new Set(redirectStatus);
    var badPorts = [
      "1",
      "7",
      "9",
      "11",
      "13",
      "15",
      "17",
      "19",
      "20",
      "21",
      "22",
      "23",
      "25",
      "37",
      "42",
      "43",
      "53",
      "69",
      "77",
      "79",
      "87",
      "95",
      "101",
      "102",
      "103",
      "104",
      "109",
      "110",
      "111",
      "113",
      "115",
      "117",
      "119",
      "123",
      "135",
      "137",
      "139",
      "143",
      "161",
      "179",
      "389",
      "427",
      "465",
      "512",
      "513",
      "514",
      "515",
      "526",
      "530",
      "531",
      "532",
      "540",
      "548",
      "554",
      "556",
      "563",
      "587",
      "601",
      "636",
      "989",
      "990",
      "993",
      "995",
      "1719",
      "1720",
      "1723",
      "2049",
      "3659",
      "4045",
      "5060",
      "5061",
      "6000",
      "6566",
      "6665",
      "6666",
      "6667",
      "6668",
      "6669",
      "6697",
      "10080"
    ];
    var badPortsSet = new Set(badPorts);
    var referrerPolicy = [
      "",
      "no-referrer",
      "no-referrer-when-downgrade",
      "same-origin",
      "origin",
      "strict-origin",
      "origin-when-cross-origin",
      "strict-origin-when-cross-origin",
      "unsafe-url"
    ];
    var referrerPolicySet = new Set(referrerPolicy);
    var requestRedirect = ["follow", "manual", "error"];
    var safeMethods = ["GET", "HEAD", "OPTIONS", "TRACE"];
    var safeMethodsSet = new Set(safeMethods);
    var requestMode = ["navigate", "same-origin", "no-cors", "cors"];
    var requestCredentials = ["omit", "same-origin", "include"];
    var requestCache = [
      "default",
      "no-store",
      "reload",
      "no-cache",
      "force-cache",
      "only-if-cached"
    ];
    var requestBodyHeader = [
      "content-encoding",
      "content-language",
      "content-location",
      "content-type",
      // See https://github.com/nodejs/undici/issues/2021
      // 'Content-Length' is a forbidden header name, which is typically
      // removed in the Headers implementation. However, undici doesn't
      // filter out headers, so we add it here.
      "content-length"
    ];
    var requestDuplex = [
      "half"
    ];
    var forbiddenMethods = ["CONNECT", "TRACE", "TRACK"];
    var forbiddenMethodsSet = new Set(forbiddenMethods);
    var subresource = [
      "audio",
      "audioworklet",
      "font",
      "image",
      "manifest",
      "paintworklet",
      "script",
      "style",
      "track",
      "video",
      "xslt",
      ""
    ];
    var subresourceSet = new Set(subresource);
    var DOMException2 = globalThis.DOMException ?? (() => {
      try {
        atob("~");
      } catch (err) {
        return Object.getPrototypeOf(err).constructor;
      }
    })();
    var channel;
    var structuredClone = globalThis.structuredClone ?? // https://github.com/nodejs/node/blob/b27ae24dcc4251bad726d9d84baf678d1f707fed/lib/internal/structured_clone.js
    // structuredClone was added in v17.0.0, but fetch supports v16.8
    /* @__PURE__ */ __name(function structuredClone2(value, options29 = void 0) {
      if (arguments.length === 0) {
        throw new TypeError("missing argument");
      }
      if (!channel) {
        channel = new MessageChannel2();
      }
      channel.port1.unref();
      channel.port2.unref();
      channel.port1.postMessage(value, options29?.transfer);
      return receiveMessageOnPort(channel.port2).message;
    }, "structuredClone");
    module3.exports = {
      DOMException: DOMException2,
      structuredClone,
      subresource,
      forbiddenMethods,
      requestBodyHeader,
      referrerPolicy,
      requestRedirect,
      requestMode,
      requestCredentials,
      requestCache,
      redirectStatus,
      corsSafeListedMethods,
      nullBodyStatus,
      safeMethods,
      badPorts,
      requestDuplex,
      subresourceSet,
      badPortsSet,
      redirectStatusSet,
      corsSafeListedMethodsSet,
      safeMethodsSet,
      forbiddenMethodsSet,
      referrerPolicySet
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/global.js
var require_global3 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/global.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var globalOrigin = Symbol.for("undici.globalOrigin.1");
    function getGlobalOrigin() {
      return globalThis[globalOrigin];
    }
    __name(getGlobalOrigin, "getGlobalOrigin");
    function setGlobalOrigin(newOrigin) {
      if (newOrigin === void 0) {
        Object.defineProperty(globalThis, globalOrigin, {
          value: void 0,
          writable: true,
          enumerable: false,
          configurable: false
        });
        return;
      }
      const parsedURL = new URL(newOrigin);
      if (parsedURL.protocol !== "http:" && parsedURL.protocol !== "https:") {
        throw new TypeError(`Only http & https urls are allowed, received ${parsedURL.protocol}`);
      }
      Object.defineProperty(globalThis, globalOrigin, {
        value: parsedURL,
        writable: true,
        enumerable: false,
        configurable: false
      });
    }
    __name(setGlobalOrigin, "setGlobalOrigin");
    module3.exports = {
      getGlobalOrigin,
      setGlobalOrigin
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/util.js
var require_util13 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/util.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = require_constants9();
    var { getGlobalOrigin } = require_global3();
    var { performance: performance2 } = require("perf_hooks");
    var { isBlobLike, toUSVString, ReadableStreamFrom } = require_util12();
    var assert27 = require("assert");
    var { isUint8Array } = require("util/types");
    var crypto5;
    try {
      crypto5 = require("crypto");
    } catch {
    }
    function responseURL(response) {
      const urlList = response.urlList;
      const length = urlList.length;
      return length === 0 ? null : urlList[length - 1].toString();
    }
    __name(responseURL, "responseURL");
    function responseLocationURL(response, requestFragment) {
      if (!redirectStatusSet.has(response.status)) {
        return null;
      }
      let location = response.headersList.get("location");
      if (location !== null && isValidHeaderValue(location)) {
        location = new URL(location, responseURL(response));
      }
      if (location && !location.hash) {
        location.hash = requestFragment;
      }
      return location;
    }
    __name(responseLocationURL, "responseLocationURL");
    function requestCurrentURL(request3) {
      return request3.urlList[request3.urlList.length - 1];
    }
    __name(requestCurrentURL, "requestCurrentURL");
    function requestBadPort(request3) {
      const url4 = requestCurrentURL(request3);
      if (urlIsHttpHttpsScheme(url4) && badPortsSet.has(url4.port)) {
        return "blocked";
      }
      return "allowed";
    }
    __name(requestBadPort, "requestBadPort");
    function isErrorLike(object) {
      return object instanceof Error || (object?.constructor?.name === "Error" || object?.constructor?.name === "DOMException");
    }
    __name(isErrorLike, "isErrorLike");
    function isValidReasonPhrase(statusText) {
      for (let i = 0; i < statusText.length; ++i) {
        const c2 = statusText.charCodeAt(i);
        if (!(c2 === 9 || // HTAB
        c2 >= 32 && c2 <= 126 || // SP / VCHAR
        c2 >= 128 && c2 <= 255)) {
          return false;
        }
      }
      return true;
    }
    __name(isValidReasonPhrase, "isValidReasonPhrase");
    function isTokenCharCode(c2) {
      switch (c2) {
        case 34:
        case 40:
        case 41:
        case 44:
        case 47:
        case 58:
        case 59:
        case 60:
        case 61:
        case 62:
        case 63:
        case 64:
        case 91:
        case 92:
        case 93:
        case 123:
        case 125:
          return false;
        default:
          return c2 >= 33 && c2 <= 126;
      }
    }
    __name(isTokenCharCode, "isTokenCharCode");
    function isValidHTTPToken(characters) {
      if (characters.length === 0) {
        return false;
      }
      for (let i = 0; i < characters.length; ++i) {
        if (!isTokenCharCode(characters.charCodeAt(i))) {
          return false;
        }
      }
      return true;
    }
    __name(isValidHTTPToken, "isValidHTTPToken");
    function isValidHeaderName(potentialValue) {
      return isValidHTTPToken(potentialValue);
    }
    __name(isValidHeaderName, "isValidHeaderName");
    function isValidHeaderValue(potentialValue) {
      if (potentialValue.startsWith("	") || potentialValue.startsWith(" ") || potentialValue.endsWith("	") || potentialValue.endsWith(" ")) {
        return false;
      }
      if (potentialValue.includes("\0") || potentialValue.includes("\r") || potentialValue.includes("\n")) {
        return false;
      }
      return true;
    }
    __name(isValidHeaderValue, "isValidHeaderValue");
    function setRequestReferrerPolicyOnRedirect(request3, actualResponse) {
      const { headersList } = actualResponse;
      const policyHeader = (headersList.get("referrer-policy") ?? "").split(",");
      let policy = "";
      if (policyHeader.length > 0) {
        for (let i = policyHeader.length; i !== 0; i--) {
          const token = policyHeader[i - 1].trim();
          if (referrerPolicyTokens.has(token)) {
            policy = token;
            break;
          }
        }
      }
      if (policy !== "") {
        request3.referrerPolicy = policy;
      }
    }
    __name(setRequestReferrerPolicyOnRedirect, "setRequestReferrerPolicyOnRedirect");
    function crossOriginResourcePolicyCheck() {
      return "allowed";
    }
    __name(crossOriginResourcePolicyCheck, "crossOriginResourcePolicyCheck");
    function corsCheck() {
      return "success";
    }
    __name(corsCheck, "corsCheck");
    function TAOCheck() {
      return "success";
    }
    __name(TAOCheck, "TAOCheck");
    function appendFetchMetadata(httpRequest) {
      let header = null;
      header = httpRequest.mode;
      httpRequest.headersList.set("sec-fetch-mode", header);
    }
    __name(appendFetchMetadata, "appendFetchMetadata");
    function appendRequestOriginHeader(request3) {
      let serializedOrigin = request3.origin;
      if (request3.responseTainting === "cors" || request3.mode === "websocket") {
        if (serializedOrigin) {
          request3.headersList.append("origin", serializedOrigin);
        }
      } else if (request3.method !== "GET" && request3.method !== "HEAD") {
        switch (request3.referrerPolicy) {
          case "no-referrer":
            serializedOrigin = null;
            break;
          case "no-referrer-when-downgrade":
          case "strict-origin":
          case "strict-origin-when-cross-origin":
            if (request3.origin && urlHasHttpsScheme(request3.origin) && !urlHasHttpsScheme(requestCurrentURL(request3))) {
              serializedOrigin = null;
            }
            break;
          case "same-origin":
            if (!sameOrigin(request3, requestCurrentURL(request3))) {
              serializedOrigin = null;
            }
            break;
          default:
        }
        if (serializedOrigin) {
          request3.headersList.append("origin", serializedOrigin);
        }
      }
    }
    __name(appendRequestOriginHeader, "appendRequestOriginHeader");
    function coarsenedSharedCurrentTime(crossOriginIsolatedCapability) {
      return performance2.now();
    }
    __name(coarsenedSharedCurrentTime, "coarsenedSharedCurrentTime");
    function createOpaqueTimingInfo(timingInfo) {
      return {
        startTime: timingInfo.startTime ?? 0,
        redirectStartTime: 0,
        redirectEndTime: 0,
        postRedirectStartTime: timingInfo.startTime ?? 0,
        finalServiceWorkerStartTime: 0,
        finalNetworkResponseStartTime: 0,
        finalNetworkRequestStartTime: 0,
        endTime: 0,
        encodedBodySize: 0,
        decodedBodySize: 0,
        finalConnectionTimingInfo: null
      };
    }
    __name(createOpaqueTimingInfo, "createOpaqueTimingInfo");
    function makePolicyContainer() {
      return {
        referrerPolicy: "strict-origin-when-cross-origin"
      };
    }
    __name(makePolicyContainer, "makePolicyContainer");
    function clonePolicyContainer(policyContainer) {
      return {
        referrerPolicy: policyContainer.referrerPolicy
      };
    }
    __name(clonePolicyContainer, "clonePolicyContainer");
    function determineRequestsReferrer(request3) {
      const policy = request3.referrerPolicy;
      assert27(policy);
      let referrerSource = null;
      if (request3.referrer === "client") {
        const globalOrigin = getGlobalOrigin();
        if (!globalOrigin || globalOrigin.origin === "null") {
          return "no-referrer";
        }
        referrerSource = new URL(globalOrigin);
      } else if (request3.referrer instanceof URL) {
        referrerSource = request3.referrer;
      }
      let referrerURL = stripURLForReferrer(referrerSource);
      const referrerOrigin = stripURLForReferrer(referrerSource, true);
      if (referrerURL.toString().length > 4096) {
        referrerURL = referrerOrigin;
      }
      const areSameOrigin = sameOrigin(request3, referrerURL);
      const isNonPotentiallyTrustWorthy = isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(request3.url);
      switch (policy) {
        case "origin":
          return referrerOrigin != null ? referrerOrigin : stripURLForReferrer(referrerSource, true);
        case "unsafe-url":
          return referrerURL;
        case "same-origin":
          return areSameOrigin ? referrerOrigin : "no-referrer";
        case "origin-when-cross-origin":
          return areSameOrigin ? referrerURL : referrerOrigin;
        case "strict-origin-when-cross-origin": {
          const currentURL = requestCurrentURL(request3);
          if (sameOrigin(referrerURL, currentURL)) {
            return referrerURL;
          }
          if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) {
            return "no-referrer";
          }
          return referrerOrigin;
        }
        case "strict-origin":
        case "no-referrer-when-downgrade":
        default:
          return isNonPotentiallyTrustWorthy ? "no-referrer" : referrerOrigin;
      }
    }
    __name(determineRequestsReferrer, "determineRequestsReferrer");
    function stripURLForReferrer(url4, originOnly) {
      assert27(url4 instanceof URL);
      if (url4.protocol === "file:" || url4.protocol === "about:" || url4.protocol === "blank:") {
        return "no-referrer";
      }
      url4.username = "";
      url4.password = "";
      url4.hash = "";
      if (originOnly) {
        url4.pathname = "";
        url4.search = "";
      }
      return url4;
    }
    __name(stripURLForReferrer, "stripURLForReferrer");
    function isURLPotentiallyTrustworthy(url4) {
      if (!(url4 instanceof URL)) {
        return false;
      }
      if (url4.href === "about:blank" || url4.href === "about:srcdoc") {
        return true;
      }
      if (url4.protocol === "data:")
        return true;
      if (url4.protocol === "file:")
        return true;
      return isOriginPotentiallyTrustworthy(url4.origin);
      function isOriginPotentiallyTrustworthy(origin) {
        if (origin == null || origin === "null")
          return false;
        const originAsURL = new URL(origin);
        if (originAsURL.protocol === "https:" || originAsURL.protocol === "wss:") {
          return true;
        }
        if (/^127(?:\.[0-9]+){0,2}\.[0-9]+$|^\[(?:0*:)*?:?0*1\]$/.test(originAsURL.hostname) || (originAsURL.hostname === "localhost" || originAsURL.hostname.includes("localhost.")) || originAsURL.hostname.endsWith(".localhost")) {
          return true;
        }
        return false;
      }
      __name(isOriginPotentiallyTrustworthy, "isOriginPotentiallyTrustworthy");
    }
    __name(isURLPotentiallyTrustworthy, "isURLPotentiallyTrustworthy");
    function bytesMatch(bytes, metadataList) {
      if (crypto5 === void 0) {
        return true;
      }
      const parsedMetadata = parseMetadata(metadataList);
      if (parsedMetadata === "no metadata") {
        return true;
      }
      if (parsedMetadata.length === 0) {
        return true;
      }
      const list = parsedMetadata.sort((c2, d2) => d2.algo.localeCompare(c2.algo));
      const strongest = list[0].algo;
      const metadata = list.filter((item) => item.algo === strongest);
      for (const item of metadata) {
        const algorithm = item.algo;
        let expectedValue = item.hash;
        if (expectedValue.endsWith("==")) {
          expectedValue = expectedValue.slice(0, -2);
        }
        let actualValue = crypto5.createHash(algorithm).update(bytes).digest("base64");
        if (actualValue.endsWith("==")) {
          actualValue = actualValue.slice(0, -2);
        }
        if (actualValue === expectedValue) {
          return true;
        }
        let actualBase64URL = crypto5.createHash(algorithm).update(bytes).digest("base64url");
        if (actualBase64URL.endsWith("==")) {
          actualBase64URL = actualBase64URL.slice(0, -2);
        }
        if (actualBase64URL === expectedValue) {
          return true;
        }
      }
      return false;
    }
    __name(bytesMatch, "bytesMatch");
    var parseHashWithOptions = /((?<algo>sha256|sha384|sha512)-(?<hash>[A-z0-9+/]{1}.*={0,2}))( +[\x21-\x7e]?)?/i;
    function parseMetadata(metadata) {
      const result = [];
      let empty2 = true;
      const supportedHashes = crypto5.getHashes();
      for (const token of metadata.split(" ")) {
        empty2 = false;
        const parsedToken = parseHashWithOptions.exec(token);
        if (parsedToken === null || parsedToken.groups === void 0) {
          continue;
        }
        const algorithm = parsedToken.groups.algo;
        if (supportedHashes.includes(algorithm.toLowerCase())) {
          result.push(parsedToken.groups);
        }
      }
      if (empty2 === true) {
        return "no metadata";
      }
      return result;
    }
    __name(parseMetadata, "parseMetadata");
    function tryUpgradeRequestToAPotentiallyTrustworthyURL(request3) {
    }
    __name(tryUpgradeRequestToAPotentiallyTrustworthyURL, "tryUpgradeRequestToAPotentiallyTrustworthyURL");
    function sameOrigin(A2, B2) {
      if (A2.origin === B2.origin && A2.origin === "null") {
        return true;
      }
      if (A2.protocol === B2.protocol && A2.hostname === B2.hostname && A2.port === B2.port) {
        return true;
      }
      return false;
    }
    __name(sameOrigin, "sameOrigin");
    function createDeferredPromise() {
      let res;
      let rej;
      const promise = new Promise((resolve19, reject) => {
        res = resolve19;
        rej = reject;
      });
      return { promise, resolve: res, reject: rej };
    }
    __name(createDeferredPromise, "createDeferredPromise");
    function isAborted(fetchParams) {
      return fetchParams.controller.state === "aborted";
    }
    __name(isAborted, "isAborted");
    function isCancelled(fetchParams) {
      return fetchParams.controller.state === "aborted" || fetchParams.controller.state === "terminated";
    }
    __name(isCancelled, "isCancelled");
    var normalizeMethodRecord = {
      delete: "DELETE",
      DELETE: "DELETE",
      get: "GET",
      GET: "GET",
      head: "HEAD",
      HEAD: "HEAD",
      options: "OPTIONS",
      OPTIONS: "OPTIONS",
      post: "POST",
      POST: "POST",
      put: "PUT",
      PUT: "PUT"
    };
    Object.setPrototypeOf(normalizeMethodRecord, null);
    function normalizeMethod(method) {
      return normalizeMethodRecord[method.toLowerCase()] ?? method;
    }
    __name(normalizeMethod, "normalizeMethod");
    function serializeJavascriptValueToJSONString(value) {
      const result = JSON.stringify(value);
      if (result === void 0) {
        throw new TypeError("Value is not JSON serializable");
      }
      assert27(typeof result === "string");
      return result;
    }
    __name(serializeJavascriptValueToJSONString, "serializeJavascriptValueToJSONString");
    var esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
    function makeIterator(iterator, name, kind) {
      const object = {
        index: 0,
        kind,
        target: iterator
      };
      const i = {
        next() {
          if (Object.getPrototypeOf(this) !== i) {
            throw new TypeError(
              `'next' called on an object that does not implement interface ${name} Iterator.`
            );
          }
          const { index, kind: kind2, target } = object;
          const values = target();
          const len = values.length;
          if (index >= len) {
            return { value: void 0, done: true };
          }
          const pair = values[index];
          object.index = index + 1;
          return iteratorResult(pair, kind2);
        },
        // The class string of an iterator prototype object for a given interface is the
        // result of concatenating the identifier of the interface and the string " Iterator".
        [Symbol.toStringTag]: `${name} Iterator`
      };
      Object.setPrototypeOf(i, esIteratorPrototype);
      return Object.setPrototypeOf({}, i);
    }
    __name(makeIterator, "makeIterator");
    function iteratorResult(pair, kind) {
      let result;
      switch (kind) {
        case "key": {
          result = pair[0];
          break;
        }
        case "value": {
          result = pair[1];
          break;
        }
        case "key+value": {
          result = pair;
          break;
        }
      }
      return { value: result, done: false };
    }
    __name(iteratorResult, "iteratorResult");
    async function fullyReadBody(body, processBody, processBodyError) {
      const successSteps = processBody;
      const errorSteps = processBodyError;
      let reader;
      try {
        reader = body.stream.getReader();
      } catch (e3) {
        errorSteps(e3);
        return;
      }
      try {
        const result = await readAllBytes(reader);
        successSteps(result);
      } catch (e3) {
        errorSteps(e3);
      }
    }
    __name(fullyReadBody, "fullyReadBody");
    var ReadableStream2 = globalThis.ReadableStream;
    function isReadableStreamLike(stream2) {
      if (!ReadableStream2) {
        ReadableStream2 = require("stream/web").ReadableStream;
      }
      return stream2 instanceof ReadableStream2 || stream2[Symbol.toStringTag] === "ReadableStream" && typeof stream2.tee === "function";
    }
    __name(isReadableStreamLike, "isReadableStreamLike");
    var MAXIMUM_ARGUMENT_LENGTH = 65535;
    function isomorphicDecode(input) {
      if (input.length < MAXIMUM_ARGUMENT_LENGTH) {
        return String.fromCharCode(...input);
      }
      return input.reduce((previous, current) => previous + String.fromCharCode(current), "");
    }
    __name(isomorphicDecode, "isomorphicDecode");
    function readableStreamClose(controller) {
      try {
        controller.close();
      } catch (err) {
        if (!err.message.includes("Controller is already closed")) {
          throw err;
        }
      }
    }
    __name(readableStreamClose, "readableStreamClose");
    function isomorphicEncode(input) {
      for (let i = 0; i < input.length; i++) {
        assert27(input.charCodeAt(i) <= 255);
      }
      return input;
    }
    __name(isomorphicEncode, "isomorphicEncode");
    async function readAllBytes(reader) {
      const bytes = [];
      let byteLength = 0;
      while (true) {
        const { done, value: chunk } = await reader.read();
        if (done) {
          return Buffer.concat(bytes, byteLength);
        }
        if (!isUint8Array(chunk)) {
          throw new TypeError("Received non-Uint8Array chunk");
        }
        bytes.push(chunk);
        byteLength += chunk.length;
      }
    }
    __name(readAllBytes, "readAllBytes");
    function urlIsLocal(url4) {
      assert27("protocol" in url4);
      const protocol = url4.protocol;
      return protocol === "about:" || protocol === "blob:" || protocol === "data:";
    }
    __name(urlIsLocal, "urlIsLocal");
    function urlHasHttpsScheme(url4) {
      if (typeof url4 === "string") {
        return url4.startsWith("https:");
      }
      return url4.protocol === "https:";
    }
    __name(urlHasHttpsScheme, "urlHasHttpsScheme");
    function urlIsHttpHttpsScheme(url4) {
      assert27("protocol" in url4);
      const protocol = url4.protocol;
      return protocol === "http:" || protocol === "https:";
    }
    __name(urlIsHttpHttpsScheme, "urlIsHttpHttpsScheme");
    var hasOwn = Object.hasOwn || ((dict, key) => Object.prototype.hasOwnProperty.call(dict, key));
    module3.exports = {
      isAborted,
      isCancelled,
      createDeferredPromise,
      ReadableStreamFrom,
      toUSVString,
      tryUpgradeRequestToAPotentiallyTrustworthyURL,
      coarsenedSharedCurrentTime,
      determineRequestsReferrer,
      makePolicyContainer,
      clonePolicyContainer,
      appendFetchMetadata,
      appendRequestOriginHeader,
      TAOCheck,
      corsCheck,
      crossOriginResourcePolicyCheck,
      createOpaqueTimingInfo,
      setRequestReferrerPolicyOnRedirect,
      isValidHTTPToken,
      requestBadPort,
      requestCurrentURL,
      responseURL,
      responseLocationURL,
      isBlobLike,
      isURLPotentiallyTrustworthy,
      isValidReasonPhrase,
      sameOrigin,
      normalizeMethod,
      serializeJavascriptValueToJSONString,
      makeIterator,
      isValidHeaderName,
      isValidHeaderValue,
      hasOwn,
      isErrorLike,
      fullyReadBody,
      bytesMatch,
      isReadableStreamLike,
      readableStreamClose,
      isomorphicEncode,
      isomorphicDecode,
      urlIsLocal,
      urlHasHttpsScheme,
      urlIsHttpHttpsScheme,
      readAllBytes,
      normalizeMethodRecord
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/symbols.js
var require_symbols7 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/symbols.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = {
      kUrl: Symbol("url"),
      kHeaders: Symbol("headers"),
      kSignal: Symbol("signal"),
      kState: Symbol("state"),
      kGuard: Symbol("guard"),
      kRealm: Symbol("realm")
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/webidl.js
var require_webidl2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/webidl.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { types } = require("util");
    var { hasOwn, toUSVString } = require_util13();
    var webidl = {};
    webidl.converters = {};
    webidl.util = {};
    webidl.errors = {};
    webidl.errors.exception = function(message) {
      return new TypeError(`${message.header}: ${message.message}`);
    };
    webidl.errors.conversionFailed = function(context2) {
      const plural2 = context2.types.length === 1 ? "" : " one of";
      const message = `${context2.argument} could not be converted to${plural2}: ${context2.types.join(", ")}.`;
      return webidl.errors.exception({
        header: context2.prefix,
        message
      });
    };
    webidl.errors.invalidArgument = function(context2) {
      return webidl.errors.exception({
        header: context2.prefix,
        message: `"${context2.value}" is an invalid ${context2.type}.`
      });
    };
    webidl.brandCheck = function(V2, I2, opts = void 0) {
      if (opts?.strict !== false && !(V2 instanceof I2)) {
        throw new TypeError("Illegal invocation");
      } else {
        return V2?.[Symbol.toStringTag] === I2.prototype[Symbol.toStringTag];
      }
    };
    webidl.argumentLengthCheck = function({ length }, min, ctx) {
      if (length < min) {
        throw webidl.errors.exception({
          message: `${min} argument${min !== 1 ? "s" : ""} required, but${length ? " only" : ""} ${length} found.`,
          ...ctx
        });
      }
    };
    webidl.illegalConstructor = function() {
      throw webidl.errors.exception({
        header: "TypeError",
        message: "Illegal constructor"
      });
    };
    webidl.util.Type = function(V2) {
      switch (typeof V2) {
        case "undefined":
          return "Undefined";
        case "boolean":
          return "Boolean";
        case "string":
          return "String";
        case "symbol":
          return "Symbol";
        case "number":
          return "Number";
        case "bigint":
          return "BigInt";
        case "function":
        case "object": {
          if (V2 === null) {
            return "Null";
          }
          return "Object";
        }
      }
    };
    webidl.util.ConvertToInt = function(V2, bitLength, signedness, opts = {}) {
      let upperBound;
      let lowerBound2;
      if (bitLength === 64) {
        upperBound = Math.pow(2, 53) - 1;
        if (signedness === "unsigned") {
          lowerBound2 = 0;
        } else {
          lowerBound2 = Math.pow(-2, 53) + 1;
        }
      } else if (signedness === "unsigned") {
        lowerBound2 = 0;
        upperBound = Math.pow(2, bitLength) - 1;
      } else {
        lowerBound2 = Math.pow(-2, bitLength) - 1;
        upperBound = Math.pow(2, bitLength - 1) - 1;
      }
      let x2 = Number(V2);
      if (x2 === 0) {
        x2 = 0;
      }
      if (opts.enforceRange === true) {
        if (Number.isNaN(x2) || x2 === Number.POSITIVE_INFINITY || x2 === Number.NEGATIVE_INFINITY) {
          throw webidl.errors.exception({
            header: "Integer conversion",
            message: `Could not convert ${V2} to an integer.`
          });
        }
        x2 = webidl.util.IntegerPart(x2);
        if (x2 < lowerBound2 || x2 > upperBound) {
          throw webidl.errors.exception({
            header: "Integer conversion",
            message: `Value must be between ${lowerBound2}-${upperBound}, got ${x2}.`
          });
        }
        return x2;
      }
      if (!Number.isNaN(x2) && opts.clamp === true) {
        x2 = Math.min(Math.max(x2, lowerBound2), upperBound);
        if (Math.floor(x2) % 2 === 0) {
          x2 = Math.floor(x2);
        } else {
          x2 = Math.ceil(x2);
        }
        return x2;
      }
      if (Number.isNaN(x2) || x2 === 0 && Object.is(0, x2) || x2 === Number.POSITIVE_INFINITY || x2 === Number.NEGATIVE_INFINITY) {
        return 0;
      }
      x2 = webidl.util.IntegerPart(x2);
      x2 = x2 % Math.pow(2, bitLength);
      if (signedness === "signed" && x2 >= Math.pow(2, bitLength) - 1) {
        return x2 - Math.pow(2, bitLength);
      }
      return x2;
    };
    webidl.util.IntegerPart = function(n2) {
      const r3 = Math.floor(Math.abs(n2));
      if (n2 < 0) {
        return -1 * r3;
      }
      return r3;
    };
    webidl.sequenceConverter = function(converter) {
      return (V2) => {
        if (webidl.util.Type(V2) !== "Object") {
          throw webidl.errors.exception({
            header: "Sequence",
            message: `Value of type ${webidl.util.Type(V2)} is not an Object.`
          });
        }
        const method = V2?.[Symbol.iterator]?.();
        const seq = [];
        if (method === void 0 || typeof method.next !== "function") {
          throw webidl.errors.exception({
            header: "Sequence",
            message: "Object is not an iterator."
          });
        }
        while (true) {
          const { done, value } = method.next();
          if (done) {
            break;
          }
          seq.push(converter(value));
        }
        return seq;
      };
    };
    webidl.recordConverter = function(keyConverter, valueConverter) {
      return (O2) => {
        if (webidl.util.Type(O2) !== "Object") {
          throw webidl.errors.exception({
            header: "Record",
            message: `Value of type ${webidl.util.Type(O2)} is not an Object.`
          });
        }
        const result = {};
        if (!types.isProxy(O2)) {
          const keys2 = Object.keys(O2);
          for (const key of keys2) {
            const typedKey = keyConverter(key);
            const typedValue = valueConverter(O2[key]);
            result[typedKey] = typedValue;
          }
          return result;
        }
        const keys = Reflect.ownKeys(O2);
        for (const key of keys) {
          const desc = Reflect.getOwnPropertyDescriptor(O2, key);
          if (desc?.enumerable) {
            const typedKey = keyConverter(key);
            const typedValue = valueConverter(O2[key]);
            result[typedKey] = typedValue;
          }
        }
        return result;
      };
    };
    webidl.interfaceConverter = function(i) {
      return (V2, opts = {}) => {
        if (opts.strict !== false && !(V2 instanceof i)) {
          throw webidl.errors.exception({
            header: i.name,
            message: `Expected ${V2} to be an instance of ${i.name}.`
          });
        }
        return V2;
      };
    };
    webidl.dictionaryConverter = function(converters) {
      return (dictionary) => {
        const type = webidl.util.Type(dictionary);
        const dict = {};
        if (type === "Null" || type === "Undefined") {
          return dict;
        } else if (type !== "Object") {
          throw webidl.errors.exception({
            header: "Dictionary",
            message: `Expected ${dictionary} to be one of: Null, Undefined, Object.`
          });
        }
        for (const options29 of converters) {
          const { key, defaultValue, required, converter } = options29;
          if (required === true) {
            if (!hasOwn(dictionary, key)) {
              throw webidl.errors.exception({
                header: "Dictionary",
                message: `Missing required key "${key}".`
              });
            }
          }
          let value = dictionary[key];
          const hasDefault = hasOwn(options29, "defaultValue");
          if (hasDefault && value !== null) {
            value = value ?? defaultValue;
          }
          if (required || hasDefault || value !== void 0) {
            value = converter(value);
            if (options29.allowedValues && !options29.allowedValues.includes(value)) {
              throw webidl.errors.exception({
                header: "Dictionary",
                message: `${value} is not an accepted type. Expected one of ${options29.allowedValues.join(", ")}.`
              });
            }
            dict[key] = value;
          }
        }
        return dict;
      };
    };
    webidl.nullableConverter = function(converter) {
      return (V2) => {
        if (V2 === null) {
          return V2;
        }
        return converter(V2);
      };
    };
    webidl.converters.DOMString = function(V2, opts = {}) {
      if (V2 === null && opts.legacyNullToEmptyString) {
        return "";
      }
      if (typeof V2 === "symbol") {
        throw new TypeError("Could not convert argument of type symbol to string.");
      }
      return String(V2);
    };
    webidl.converters.ByteString = function(V2) {
      const x2 = webidl.converters.DOMString(V2);
      for (let index = 0; index < x2.length; index++) {
        if (x2.charCodeAt(index) > 255) {
          throw new TypeError(
            `Cannot convert argument to a ByteString because the character at index ${index} has a value of ${x2.charCodeAt(index)} which is greater than 255.`
          );
        }
      }
      return x2;
    };
    webidl.converters.USVString = toUSVString;
    webidl.converters.boolean = function(V2) {
      const x2 = Boolean(V2);
      return x2;
    };
    webidl.converters.any = function(V2) {
      return V2;
    };
    webidl.converters["long long"] = function(V2) {
      const x2 = webidl.util.ConvertToInt(V2, 64, "signed");
      return x2;
    };
    webidl.converters["unsigned long long"] = function(V2) {
      const x2 = webidl.util.ConvertToInt(V2, 64, "unsigned");
      return x2;
    };
    webidl.converters["unsigned long"] = function(V2) {
      const x2 = webidl.util.ConvertToInt(V2, 32, "unsigned");
      return x2;
    };
    webidl.converters["unsigned short"] = function(V2, opts) {
      const x2 = webidl.util.ConvertToInt(V2, 16, "unsigned", opts);
      return x2;
    };
    webidl.converters.ArrayBuffer = function(V2, opts = {}) {
      if (webidl.util.Type(V2) !== "Object" || !types.isAnyArrayBuffer(V2)) {
        throw webidl.errors.conversionFailed({
          prefix: `${V2}`,
          argument: `${V2}`,
          types: ["ArrayBuffer"]
        });
      }
      if (opts.allowShared === false && types.isSharedArrayBuffer(V2)) {
        throw webidl.errors.exception({
          header: "ArrayBuffer",
          message: "SharedArrayBuffer is not allowed."
        });
      }
      return V2;
    };
    webidl.converters.TypedArray = function(V2, T2, opts = {}) {
      if (webidl.util.Type(V2) !== "Object" || !types.isTypedArray(V2) || V2.constructor.name !== T2.name) {
        throw webidl.errors.conversionFailed({
          prefix: `${T2.name}`,
          argument: `${V2}`,
          types: [T2.name]
        });
      }
      if (opts.allowShared === false && types.isSharedArrayBuffer(V2.buffer)) {
        throw webidl.errors.exception({
          header: "ArrayBuffer",
          message: "SharedArrayBuffer is not allowed."
        });
      }
      return V2;
    };
    webidl.converters.DataView = function(V2, opts = {}) {
      if (webidl.util.Type(V2) !== "Object" || !types.isDataView(V2)) {
        throw webidl.errors.exception({
          header: "DataView",
          message: "Object is not a DataView."
        });
      }
      if (opts.allowShared === false && types.isSharedArrayBuffer(V2.buffer)) {
        throw webidl.errors.exception({
          header: "ArrayBuffer",
          message: "SharedArrayBuffer is not allowed."
        });
      }
      return V2;
    };
    webidl.converters.BufferSource = function(V2, opts = {}) {
      if (types.isAnyArrayBuffer(V2)) {
        return webidl.converters.ArrayBuffer(V2, opts);
      }
      if (types.isTypedArray(V2)) {
        return webidl.converters.TypedArray(V2, V2.constructor);
      }
      if (types.isDataView(V2)) {
        return webidl.converters.DataView(V2, opts);
      }
      throw new TypeError(`Could not convert ${V2} to a BufferSource.`);
    };
    webidl.converters["sequence<ByteString>"] = webidl.sequenceConverter(
      webidl.converters.ByteString
    );
    webidl.converters["sequence<sequence<ByteString>>"] = webidl.sequenceConverter(
      webidl.converters["sequence<ByteString>"]
    );
    webidl.converters["record<ByteString, ByteString>"] = webidl.recordConverter(
      webidl.converters.ByteString,
      webidl.converters.ByteString
    );
    module3.exports = {
      webidl
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/dataURL.js
var require_dataURL2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/dataURL.js"(exports2, module3) {
    init_import_meta_url();
    var assert27 = require("assert");
    var { atob: atob2 } = require("buffer");
    var { isomorphicDecode } = require_util13();
    var encoder = new TextEncoder();
    var HTTP_TOKEN_CODEPOINTS = /^[!#$%&'*+-.^_|~A-Za-z0-9]+$/;
    var HTTP_WHITESPACE_REGEX = /(\u000A|\u000D|\u0009|\u0020)/;
    var HTTP_QUOTED_STRING_TOKENS = /[\u0009|\u0020-\u007E|\u0080-\u00FF]/;
    function dataURLProcessor(dataURL) {
      assert27(dataURL.protocol === "data:");
      let input = URLSerializer(dataURL, true);
      input = input.slice(5);
      const position = { position: 0 };
      let mimeType = collectASequenceOfCodePointsFast(
        ",",
        input,
        position
      );
      const mimeTypeLength = mimeType.length;
      mimeType = removeASCIIWhitespace(mimeType, true, true);
      if (position.position >= input.length) {
        return "failure";
      }
      position.position++;
      const encodedBody = input.slice(mimeTypeLength + 1);
      let body = stringPercentDecode(encodedBody);
      if (/;(\u0020){0,}base64$/i.test(mimeType)) {
        const stringBody = isomorphicDecode(body);
        body = forgivingBase64(stringBody);
        if (body === "failure") {
          return "failure";
        }
        mimeType = mimeType.slice(0, -6);
        mimeType = mimeType.replace(/(\u0020)+$/, "");
        mimeType = mimeType.slice(0, -1);
      }
      if (mimeType.startsWith(";")) {
        mimeType = "text/plain" + mimeType;
      }
      let mimeTypeRecord = parseMIMEType(mimeType);
      if (mimeTypeRecord === "failure") {
        mimeTypeRecord = parseMIMEType("text/plain;charset=US-ASCII");
      }
      return { mimeType: mimeTypeRecord, body };
    }
    __name(dataURLProcessor, "dataURLProcessor");
    function URLSerializer(url4, excludeFragment = false) {
      if (!excludeFragment) {
        return url4.href;
      }
      const href = url4.href;
      const hashLength = url4.hash.length;
      return hashLength === 0 ? href : href.substring(0, href.length - hashLength);
    }
    __name(URLSerializer, "URLSerializer");
    function collectASequenceOfCodePoints(condition, input, position) {
      let result = "";
      while (position.position < input.length && condition(input[position.position])) {
        result += input[position.position];
        position.position++;
      }
      return result;
    }
    __name(collectASequenceOfCodePoints, "collectASequenceOfCodePoints");
    function collectASequenceOfCodePointsFast(char, input, position) {
      const idx = input.indexOf(char, position.position);
      const start = position.position;
      if (idx === -1) {
        position.position = input.length;
        return input.slice(start);
      }
      position.position = idx;
      return input.slice(start, position.position);
    }
    __name(collectASequenceOfCodePointsFast, "collectASequenceOfCodePointsFast");
    function stringPercentDecode(input) {
      const bytes = encoder.encode(input);
      return percentDecode(bytes);
    }
    __name(stringPercentDecode, "stringPercentDecode");
    function percentDecode(input) {
      const output = [];
      for (let i = 0; i < input.length; i++) {
        const byte = input[i];
        if (byte !== 37) {
          output.push(byte);
        } else if (byte === 37 && !/^[0-9A-Fa-f]{2}$/i.test(String.fromCharCode(input[i + 1], input[i + 2]))) {
          output.push(37);
        } else {
          const nextTwoBytes = String.fromCharCode(input[i + 1], input[i + 2]);
          const bytePoint = Number.parseInt(nextTwoBytes, 16);
          output.push(bytePoint);
          i += 2;
        }
      }
      return Uint8Array.from(output);
    }
    __name(percentDecode, "percentDecode");
    function parseMIMEType(input) {
      input = removeHTTPWhitespace(input, true, true);
      const position = { position: 0 };
      const type = collectASequenceOfCodePointsFast(
        "/",
        input,
        position
      );
      if (type.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(type)) {
        return "failure";
      }
      if (position.position > input.length) {
        return "failure";
      }
      position.position++;
      let subtype = collectASequenceOfCodePointsFast(
        ";",
        input,
        position
      );
      subtype = removeHTTPWhitespace(subtype, false, true);
      if (subtype.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(subtype)) {
        return "failure";
      }
      const typeLowercase = type.toLowerCase();
      const subtypeLowercase = subtype.toLowerCase();
      const mimeType = {
        type: typeLowercase,
        subtype: subtypeLowercase,
        /** @type {Map<string, string>} */
        parameters: /* @__PURE__ */ new Map(),
        // https://mimesniff.spec.whatwg.org/#mime-type-essence
        essence: `${typeLowercase}/${subtypeLowercase}`
      };
      while (position.position < input.length) {
        position.position++;
        collectASequenceOfCodePoints(
          // https://fetch.spec.whatwg.org/#http-whitespace
          (char) => HTTP_WHITESPACE_REGEX.test(char),
          input,
          position
        );
        let parameterName = collectASequenceOfCodePoints(
          (char) => char !== ";" && char !== "=",
          input,
          position
        );
        parameterName = parameterName.toLowerCase();
        if (position.position < input.length) {
          if (input[position.position] === ";") {
            continue;
          }
          position.position++;
        }
        if (position.position > input.length) {
          break;
        }
        let parameterValue = null;
        if (input[position.position] === '"') {
          parameterValue = collectAnHTTPQuotedString(input, position, true);
          collectASequenceOfCodePointsFast(
            ";",
            input,
            position
          );
        } else {
          parameterValue = collectASequenceOfCodePointsFast(
            ";",
            input,
            position
          );
          parameterValue = removeHTTPWhitespace(parameterValue, false, true);
          if (parameterValue.length === 0) {
            continue;
          }
        }
        if (parameterName.length !== 0 && HTTP_TOKEN_CODEPOINTS.test(parameterName) && (parameterValue.length === 0 || HTTP_QUOTED_STRING_TOKENS.test(parameterValue)) && !mimeType.parameters.has(parameterName)) {
          mimeType.parameters.set(parameterName, parameterValue);
        }
      }
      return mimeType;
    }
    __name(parseMIMEType, "parseMIMEType");
    function forgivingBase64(data) {
      data = data.replace(/[\u0009\u000A\u000C\u000D\u0020]/g, "");
      if (data.length % 4 === 0) {
        data = data.replace(/=?=$/, "");
      }
      if (data.length % 4 === 1) {
        return "failure";
      }
      if (/[^+/0-9A-Za-z]/.test(data)) {
        return "failure";
      }
      const binary = atob2(data);
      const bytes = new Uint8Array(binary.length);
      for (let byte = 0; byte < binary.length; byte++) {
        bytes[byte] = binary.charCodeAt(byte);
      }
      return bytes;
    }
    __name(forgivingBase64, "forgivingBase64");
    function collectAnHTTPQuotedString(input, position, extractValue) {
      const positionStart = position.position;
      let value = "";
      assert27(input[position.position] === '"');
      position.position++;
      while (true) {
        value += collectASequenceOfCodePoints(
          (char) => char !== '"' && char !== "\\",
          input,
          position
        );
        if (position.position >= input.length) {
          break;
        }
        const quoteOrBackslash = input[position.position];
        position.position++;
        if (quoteOrBackslash === "\\") {
          if (position.position >= input.length) {
            value += "\\";
            break;
          }
          value += input[position.position];
          position.position++;
        } else {
          assert27(quoteOrBackslash === '"');
          break;
        }
      }
      if (extractValue) {
        return value;
      }
      return input.slice(positionStart, position.position);
    }
    __name(collectAnHTTPQuotedString, "collectAnHTTPQuotedString");
    function serializeAMimeType(mimeType) {
      assert27(mimeType !== "failure");
      const { parameters, essence } = mimeType;
      let serialization = essence;
      for (let [name, value] of parameters.entries()) {
        serialization += ";";
        serialization += name;
        serialization += "=";
        if (!HTTP_TOKEN_CODEPOINTS.test(value)) {
          value = value.replace(/(\\|")/g, "\\$1");
          value = '"' + value;
          value += '"';
        }
        serialization += value;
      }
      return serialization;
    }
    __name(serializeAMimeType, "serializeAMimeType");
    function isHTTPWhiteSpace(char) {
      return char === "\r" || char === "\n" || char === "	" || char === " ";
    }
    __name(isHTTPWhiteSpace, "isHTTPWhiteSpace");
    function removeHTTPWhitespace(str, leading = true, trailing = true) {
      let lead = 0;
      let trail = str.length - 1;
      if (leading) {
        for (; lead < str.length && isHTTPWhiteSpace(str[lead]); lead++)
          ;
      }
      if (trailing) {
        for (; trail > 0 && isHTTPWhiteSpace(str[trail]); trail--)
          ;
      }
      return str.slice(lead, trail + 1);
    }
    __name(removeHTTPWhitespace, "removeHTTPWhitespace");
    function isASCIIWhitespace(char) {
      return char === "\r" || char === "\n" || char === "	" || char === "\f" || char === " ";
    }
    __name(isASCIIWhitespace, "isASCIIWhitespace");
    function removeASCIIWhitespace(str, leading = true, trailing = true) {
      let lead = 0;
      let trail = str.length - 1;
      if (leading) {
        for (; lead < str.length && isASCIIWhitespace(str[lead]); lead++)
          ;
      }
      if (trailing) {
        for (; trail > 0 && isASCIIWhitespace(str[trail]); trail--)
          ;
      }
      return str.slice(lead, trail + 1);
    }
    __name(removeASCIIWhitespace, "removeASCIIWhitespace");
    module3.exports = {
      dataURLProcessor,
      URLSerializer,
      collectASequenceOfCodePoints,
      collectASequenceOfCodePointsFast,
      stringPercentDecode,
      parseMIMEType,
      collectAnHTTPQuotedString,
      serializeAMimeType
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/file.js
var require_file2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/file.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { Blob: Blob6, File: NativeFile } = require("buffer");
    var { types } = require("util");
    var { kState } = require_symbols7();
    var { isBlobLike } = require_util13();
    var { webidl } = require_webidl2();
    var { parseMIMEType, serializeAMimeType } = require_dataURL2();
    var { kEnumerableProperty } = require_util12();
    var encoder = new TextEncoder();
    var File6 = class extends Blob6 {
      constructor(fileBits, fileName, options29 = {}) {
        webidl.argumentLengthCheck(arguments, 2, { header: "File constructor" });
        fileBits = webidl.converters["sequence<BlobPart>"](fileBits);
        fileName = webidl.converters.USVString(fileName);
        options29 = webidl.converters.FilePropertyBag(options29);
        const n2 = fileName;
        let t3 = options29.type;
        let d2;
        substep: {
          if (t3) {
            t3 = parseMIMEType(t3);
            if (t3 === "failure") {
              t3 = "";
              break substep;
            }
            t3 = serializeAMimeType(t3).toLowerCase();
          }
          d2 = options29.lastModified;
        }
        super(processBlobParts(fileBits, options29), { type: t3 });
        this[kState] = {
          name: n2,
          lastModified: d2,
          type: t3
        };
      }
      get name() {
        webidl.brandCheck(this, File6);
        return this[kState].name;
      }
      get lastModified() {
        webidl.brandCheck(this, File6);
        return this[kState].lastModified;
      }
      get type() {
        webidl.brandCheck(this, File6);
        return this[kState].type;
      }
    };
    __name(File6, "File");
    var FileLike = class {
      constructor(blobLike, fileName, options29 = {}) {
        const n2 = fileName;
        const t3 = options29.type;
        const d2 = options29.lastModified ?? Date.now();
        this[kState] = {
          blobLike,
          name: n2,
          type: t3,
          lastModified: d2
        };
      }
      stream(...args) {
        webidl.brandCheck(this, FileLike);
        return this[kState].blobLike.stream(...args);
      }
      arrayBuffer(...args) {
        webidl.brandCheck(this, FileLike);
        return this[kState].blobLike.arrayBuffer(...args);
      }
      slice(...args) {
        webidl.brandCheck(this, FileLike);
        return this[kState].blobLike.slice(...args);
      }
      text(...args) {
        webidl.brandCheck(this, FileLike);
        return this[kState].blobLike.text(...args);
      }
      get size() {
        webidl.brandCheck(this, FileLike);
        return this[kState].blobLike.size;
      }
      get type() {
        webidl.brandCheck(this, FileLike);
        return this[kState].blobLike.type;
      }
      get name() {
        webidl.brandCheck(this, FileLike);
        return this[kState].name;
      }
      get lastModified() {
        webidl.brandCheck(this, FileLike);
        return this[kState].lastModified;
      }
      get [Symbol.toStringTag]() {
        return "File";
      }
    };
    __name(FileLike, "FileLike");
    Object.defineProperties(File6.prototype, {
      [Symbol.toStringTag]: {
        value: "File",
        configurable: true
      },
      name: kEnumerableProperty,
      lastModified: kEnumerableProperty
    });
    webidl.converters.Blob = webidl.interfaceConverter(Blob6);
    webidl.converters.BlobPart = function(V2, opts) {
      if (webidl.util.Type(V2) === "Object") {
        if (isBlobLike(V2)) {
          return webidl.converters.Blob(V2, { strict: false });
        }
        if (ArrayBuffer.isView(V2) || types.isAnyArrayBuffer(V2)) {
          return webidl.converters.BufferSource(V2, opts);
        }
      }
      return webidl.converters.USVString(V2, opts);
    };
    webidl.converters["sequence<BlobPart>"] = webidl.sequenceConverter(
      webidl.converters.BlobPart
    );
    webidl.converters.FilePropertyBag = webidl.dictionaryConverter([
      {
        key: "lastModified",
        converter: webidl.converters["long long"],
        get defaultValue() {
          return Date.now();
        }
      },
      {
        key: "type",
        converter: webidl.converters.DOMString,
        defaultValue: ""
      },
      {
        key: "endings",
        converter: (value) => {
          value = webidl.converters.DOMString(value);
          value = value.toLowerCase();
          if (value !== "native") {
            value = "transparent";
          }
          return value;
        },
        defaultValue: "transparent"
      }
    ]);
    function processBlobParts(parts, options29) {
      const bytes = [];
      for (const element of parts) {
        if (typeof element === "string") {
          let s = element;
          if (options29.endings === "native") {
            s = convertLineEndingsNative(s);
          }
          bytes.push(encoder.encode(s));
        } else if (types.isAnyArrayBuffer(element) || types.isTypedArray(element)) {
          if (!element.buffer) {
            bytes.push(new Uint8Array(element));
          } else {
            bytes.push(
              new Uint8Array(element.buffer, element.byteOffset, element.byteLength)
            );
          }
        } else if (isBlobLike(element)) {
          bytes.push(element);
        }
      }
      return bytes;
    }
    __name(processBlobParts, "processBlobParts");
    function convertLineEndingsNative(s) {
      let nativeLineEnding = "\n";
      if (process.platform === "win32") {
        nativeLineEnding = "\r\n";
      }
      return s.replace(/\r?\n/g, nativeLineEnding);
    }
    __name(convertLineEndingsNative, "convertLineEndingsNative");
    function isFileLike(object) {
      return NativeFile && object instanceof NativeFile || object instanceof File6 || object && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && object[Symbol.toStringTag] === "File";
    }
    __name(isFileLike, "isFileLike");
    module3.exports = { File: File6, FileLike, isFileLike };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/formdata.js
var require_formdata2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/formdata.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { isBlobLike, toUSVString, makeIterator } = require_util13();
    var { kState } = require_symbols7();
    var { File: UndiciFile, FileLike, isFileLike } = require_file2();
    var { webidl } = require_webidl2();
    var { Blob: Blob6, File: NativeFile } = require("buffer");
    var File6 = NativeFile ?? UndiciFile;
    var FormData10 = class {
      constructor(form) {
        if (form !== void 0) {
          throw webidl.errors.conversionFailed({
            prefix: "FormData constructor",
            argument: "Argument 1",
            types: ["undefined"]
          });
        }
        this[kState] = [];
      }
      append(name, value, filename = void 0) {
        webidl.brandCheck(this, FormData10);
        webidl.argumentLengthCheck(arguments, 2, { header: "FormData.append" });
        if (arguments.length === 3 && !isBlobLike(value)) {
          throw new TypeError(
            "Failed to execute 'append' on 'FormData': parameter 2 is not of type 'Blob'"
          );
        }
        name = webidl.converters.USVString(name);
        value = isBlobLike(value) ? webidl.converters.Blob(value, { strict: false }) : webidl.converters.USVString(value);
        filename = arguments.length === 3 ? webidl.converters.USVString(filename) : void 0;
        const entry = makeEntry(name, value, filename);
        this[kState].push(entry);
      }
      delete(name) {
        webidl.brandCheck(this, FormData10);
        webidl.argumentLengthCheck(arguments, 1, { header: "FormData.delete" });
        name = webidl.converters.USVString(name);
        this[kState] = this[kState].filter((entry) => entry.name !== name);
      }
      get(name) {
        webidl.brandCheck(this, FormData10);
        webidl.argumentLengthCheck(arguments, 1, { header: "FormData.get" });
        name = webidl.converters.USVString(name);
        const idx = this[kState].findIndex((entry) => entry.name === name);
        if (idx === -1) {
          return null;
        }
        return this[kState][idx].value;
      }
      getAll(name) {
        webidl.brandCheck(this, FormData10);
        webidl.argumentLengthCheck(arguments, 1, { header: "FormData.getAll" });
        name = webidl.converters.USVString(name);
        return this[kState].filter((entry) => entry.name === name).map((entry) => entry.value);
      }
      has(name) {
        webidl.brandCheck(this, FormData10);
        webidl.argumentLengthCheck(arguments, 1, { header: "FormData.has" });
        name = webidl.converters.USVString(name);
        return this[kState].findIndex((entry) => entry.name === name) !== -1;
      }
      set(name, value, filename = void 0) {
        webidl.brandCheck(this, FormData10);
        webidl.argumentLengthCheck(arguments, 2, { header: "FormData.set" });
        if (arguments.length === 3 && !isBlobLike(value)) {
          throw new TypeError(
            "Failed to execute 'set' on 'FormData': parameter 2 is not of type 'Blob'"
          );
        }
        name = webidl.converters.USVString(name);
        value = isBlobLike(value) ? webidl.converters.Blob(value, { strict: false }) : webidl.converters.USVString(value);
        filename = arguments.length === 3 ? toUSVString(filename) : void 0;
        const entry = makeEntry(name, value, filename);
        const idx = this[kState].findIndex((entry2) => entry2.name === name);
        if (idx !== -1) {
          this[kState] = [
            ...this[kState].slice(0, idx),
            entry,
            ...this[kState].slice(idx + 1).filter((entry2) => entry2.name !== name)
          ];
        } else {
          this[kState].push(entry);
        }
      }
      entries() {
        webidl.brandCheck(this, FormData10);
        return makeIterator(
          () => this[kState].map((pair) => [pair.name, pair.value]),
          "FormData",
          "key+value"
        );
      }
      keys() {
        webidl.brandCheck(this, FormData10);
        return makeIterator(
          () => this[kState].map((pair) => [pair.name, pair.value]),
          "FormData",
          "key"
        );
      }
      values() {
        webidl.brandCheck(this, FormData10);
        return makeIterator(
          () => this[kState].map((pair) => [pair.name, pair.value]),
          "FormData",
          "value"
        );
      }
      /**
       * @param {(value: string, key: string, self: FormData) => void} callbackFn
       * @param {unknown} thisArg
       */
      forEach(callbackFn, thisArg = globalThis) {
        webidl.brandCheck(this, FormData10);
        webidl.argumentLengthCheck(arguments, 1, { header: "FormData.forEach" });
        if (typeof callbackFn !== "function") {
          throw new TypeError(
            "Failed to execute 'forEach' on 'FormData': parameter 1 is not of type 'Function'."
          );
        }
        for (const [key, value] of this) {
          callbackFn.apply(thisArg, [value, key, this]);
        }
      }
    };
    __name(FormData10, "FormData");
    FormData10.prototype[Symbol.iterator] = FormData10.prototype.entries;
    Object.defineProperties(FormData10.prototype, {
      [Symbol.toStringTag]: {
        value: "FormData",
        configurable: true
      }
    });
    function makeEntry(name, value, filename) {
      name = Buffer.from(name).toString("utf8");
      if (typeof value === "string") {
        value = Buffer.from(value).toString("utf8");
      } else {
        if (!isFileLike(value)) {
          value = value instanceof Blob6 ? new File6([value], "blob", { type: value.type }) : new FileLike(value, "blob", { type: value.type });
        }
        if (filename !== void 0) {
          const options29 = {
            type: value.type,
            lastModified: value.lastModified
          };
          value = NativeFile && value instanceof NativeFile || value instanceof UndiciFile ? new File6([value], filename, options29) : new FileLike(value, filename, options29);
        }
      }
      return { name, value };
    }
    __name(makeEntry, "makeEntry");
    module3.exports = { FormData: FormData10 };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/body.js
var require_body2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/body.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var Busboy = require_main();
    var util4 = require_util12();
    var {
      ReadableStreamFrom,
      isBlobLike,
      isReadableStreamLike,
      readableStreamClose,
      createDeferredPromise,
      fullyReadBody
    } = require_util13();
    var { FormData: FormData10 } = require_formdata2();
    var { kState } = require_symbols7();
    var { webidl } = require_webidl2();
    var { DOMException: DOMException2, structuredClone } = require_constants9();
    var { Blob: Blob6, File: NativeFile } = require("buffer");
    var { kBodyUsed } = require_symbols6();
    var assert27 = require("assert");
    var { isErrored } = require_util12();
    var { isUint8Array, isArrayBuffer } = require("util/types");
    var { File: UndiciFile } = require_file2();
    var { parseMIMEType, serializeAMimeType } = require_dataURL2();
    var ReadableStream2 = globalThis.ReadableStream;
    var File6 = NativeFile ?? UndiciFile;
    var textEncoder = new TextEncoder();
    var textDecoder = new TextDecoder();
    function extractBody(object, keepalive = false) {
      if (!ReadableStream2) {
        ReadableStream2 = require("stream/web").ReadableStream;
      }
      let stream2 = null;
      if (object instanceof ReadableStream2) {
        stream2 = object;
      } else if (isBlobLike(object)) {
        stream2 = object.stream();
      } else {
        stream2 = new ReadableStream2({
          async pull(controller) {
            controller.enqueue(
              typeof source === "string" ? textEncoder.encode(source) : source
            );
            queueMicrotask(() => readableStreamClose(controller));
          },
          start() {
          },
          type: void 0
        });
      }
      assert27(isReadableStreamLike(stream2));
      let action = null;
      let source = null;
      let length = null;
      let type = null;
      if (typeof object === "string") {
        source = object;
        type = "text/plain;charset=UTF-8";
      } else if (object instanceof URLSearchParams) {
        source = object.toString();
        type = "application/x-www-form-urlencoded;charset=UTF-8";
      } else if (isArrayBuffer(object)) {
        source = new Uint8Array(object.slice());
      } else if (ArrayBuffer.isView(object)) {
        source = new Uint8Array(object.buffer.slice(object.byteOffset, object.byteOffset + object.byteLength));
      } else if (util4.isFormDataLike(object)) {
        const boundary = `----formdata-undici-0${`${Math.floor(Math.random() * 1e11)}`.padStart(11, "0")}`;
        const prefix = `--${boundary}\r
Content-Disposition: form-data`;
        const escape2 = /* @__PURE__ */ __name((str) => str.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22"), "escape");
        const normalizeLinefeeds = /* @__PURE__ */ __name((value) => value.replace(/\r?\n|\r/g, "\r\n"), "normalizeLinefeeds");
        const blobParts = [];
        const rn = new Uint8Array([13, 10]);
        length = 0;
        let hasUnknownSizeValue = false;
        for (const [name, value] of object) {
          if (typeof value === "string") {
            const chunk2 = textEncoder.encode(prefix + `; name="${escape2(normalizeLinefeeds(name))}"\r
\r
${normalizeLinefeeds(value)}\r
`);
            blobParts.push(chunk2);
            length += chunk2.byteLength;
          } else {
            const chunk2 = textEncoder.encode(`${prefix}; name="${escape2(normalizeLinefeeds(name))}"` + (value.name ? `; filename="${escape2(value.name)}"` : "") + `\r
Content-Type: ${value.type || "application/octet-stream"}\r
\r
`);
            blobParts.push(chunk2, value, rn);
            if (typeof value.size === "number") {
              length += chunk2.byteLength + value.size + rn.byteLength;
            } else {
              hasUnknownSizeValue = true;
            }
          }
        }
        const chunk = textEncoder.encode(`--${boundary}--`);
        blobParts.push(chunk);
        length += chunk.byteLength;
        if (hasUnknownSizeValue) {
          length = null;
        }
        source = object;
        action = /* @__PURE__ */ __name(async function* () {
          for (const part of blobParts) {
            if (part.stream) {
              yield* part.stream();
            } else {
              yield part;
            }
          }
        }, "action");
        type = "multipart/form-data; boundary=" + boundary;
      } else if (isBlobLike(object)) {
        source = object;
        length = object.size;
        if (object.type) {
          type = object.type;
        }
      } else if (typeof object[Symbol.asyncIterator] === "function") {
        if (keepalive) {
          throw new TypeError("keepalive");
        }
        if (util4.isDisturbed(object) || object.locked) {
          throw new TypeError(
            "Response body object should not be disturbed or locked"
          );
        }
        stream2 = object instanceof ReadableStream2 ? object : ReadableStreamFrom(object);
      }
      if (typeof source === "string" || util4.isBuffer(source)) {
        length = Buffer.byteLength(source);
      }
      if (action != null) {
        let iterator;
        stream2 = new ReadableStream2({
          async start() {
            iterator = action(object)[Symbol.asyncIterator]();
          },
          async pull(controller) {
            const { value, done } = await iterator.next();
            if (done) {
              queueMicrotask(() => {
                controller.close();
              });
            } else {
              if (!isErrored(stream2)) {
                controller.enqueue(new Uint8Array(value));
              }
            }
            return controller.desiredSize > 0;
          },
          async cancel(reason) {
            await iterator.return();
          },
          type: void 0
        });
      }
      const body = { stream: stream2, source, length };
      return [body, type];
    }
    __name(extractBody, "extractBody");
    function safelyExtractBody(object, keepalive = false) {
      if (!ReadableStream2) {
        ReadableStream2 = require("stream/web").ReadableStream;
      }
      if (object instanceof ReadableStream2) {
        assert27(!util4.isDisturbed(object), "The body has already been consumed.");
        assert27(!object.locked, "The stream is locked.");
      }
      return extractBody(object, keepalive);
    }
    __name(safelyExtractBody, "safelyExtractBody");
    function cloneBody(body) {
      const [out1, out2] = body.stream.tee();
      const out2Clone = structuredClone(out2, { transfer: [out2] });
      const [, finalClone] = out2Clone.tee();
      body.stream = out1;
      return {
        stream: finalClone,
        length: body.length,
        source: body.source
      };
    }
    __name(cloneBody, "cloneBody");
    async function* consumeBody(body) {
      if (body) {
        if (isUint8Array(body)) {
          yield body;
        } else {
          const stream2 = body.stream;
          if (util4.isDisturbed(stream2)) {
            throw new TypeError("The body has already been consumed.");
          }
          if (stream2.locked) {
            throw new TypeError("The stream is locked.");
          }
          stream2[kBodyUsed] = true;
          yield* stream2;
        }
      }
    }
    __name(consumeBody, "consumeBody");
    function throwIfAborted(state) {
      if (state.aborted) {
        throw new DOMException2("The operation was aborted.", "AbortError");
      }
    }
    __name(throwIfAborted, "throwIfAborted");
    function bodyMixinMethods(instance) {
      const methods = {
        blob() {
          return specConsumeBody(this, (bytes) => {
            let mimeType = bodyMimeType(this);
            if (mimeType === "failure") {
              mimeType = "";
            } else if (mimeType) {
              mimeType = serializeAMimeType(mimeType);
            }
            return new Blob6([bytes], { type: mimeType });
          }, instance);
        },
        arrayBuffer() {
          return specConsumeBody(this, (bytes) => {
            return new Uint8Array(bytes).buffer;
          }, instance);
        },
        text() {
          return specConsumeBody(this, utf8DecodeBytes, instance);
        },
        json() {
          return specConsumeBody(this, parseJSONFromBytes, instance);
        },
        async formData() {
          webidl.brandCheck(this, instance);
          throwIfAborted(this[kState]);
          const contentType = this.headers.get("Content-Type");
          if (/multipart\/form-data/.test(contentType)) {
            const headers = {};
            for (const [key, value] of this.headers)
              headers[key.toLowerCase()] = value;
            const responseFormData = new FormData10();
            let busboy;
            try {
              busboy = new Busboy({
                headers,
                preservePath: true
              });
            } catch (err) {
              throw new DOMException2(`${err}`, "AbortError");
            }
            busboy.on("field", (name, value) => {
              responseFormData.append(name, value);
            });
            busboy.on("file", (name, value, filename, encoding, mimeType) => {
              const chunks = [];
              if (encoding === "base64" || encoding.toLowerCase() === "base64") {
                let base64chunk = "";
                value.on("data", (chunk) => {
                  base64chunk += chunk.toString().replace(/[\r\n]/gm, "");
                  const end = base64chunk.length - base64chunk.length % 4;
                  chunks.push(Buffer.from(base64chunk.slice(0, end), "base64"));
                  base64chunk = base64chunk.slice(end);
                });
                value.on("end", () => {
                  chunks.push(Buffer.from(base64chunk, "base64"));
                  responseFormData.append(name, new File6(chunks, filename, { type: mimeType }));
                });
              } else {
                value.on("data", (chunk) => {
                  chunks.push(chunk);
                });
                value.on("end", () => {
                  responseFormData.append(name, new File6(chunks, filename, { type: mimeType }));
                });
              }
            });
            const busboyResolve = new Promise((resolve19, reject) => {
              busboy.on("finish", resolve19);
              busboy.on("error", (err) => reject(new TypeError(err)));
            });
            if (this.body !== null)
              for await (const chunk of consumeBody(this[kState].body))
                busboy.write(chunk);
            busboy.end();
            await busboyResolve;
            return responseFormData;
          } else if (/application\/x-www-form-urlencoded/.test(contentType)) {
            let entries;
            try {
              let text = "";
              const streamingDecoder = new TextDecoder("utf-8", { ignoreBOM: true });
              for await (const chunk of consumeBody(this[kState].body)) {
                if (!isUint8Array(chunk)) {
                  throw new TypeError("Expected Uint8Array chunk");
                }
                text += streamingDecoder.decode(chunk, { stream: true });
              }
              text += streamingDecoder.decode();
              entries = new URLSearchParams(text);
            } catch (err) {
              throw Object.assign(new TypeError(), { cause: err });
            }
            const formData = new FormData10();
            for (const [name, value] of entries) {
              formData.append(name, value);
            }
            return formData;
          } else {
            await Promise.resolve();
            throwIfAborted(this[kState]);
            throw webidl.errors.exception({
              header: `${instance.name}.formData`,
              message: "Could not parse content as FormData."
            });
          }
        }
      };
      return methods;
    }
    __name(bodyMixinMethods, "bodyMixinMethods");
    function mixinBody(prototype) {
      Object.assign(prototype.prototype, bodyMixinMethods(prototype));
    }
    __name(mixinBody, "mixinBody");
    async function specConsumeBody(object, convertBytesToJSValue, instance) {
      webidl.brandCheck(object, instance);
      throwIfAborted(object[kState]);
      if (bodyUnusable(object[kState].body)) {
        throw new TypeError("Body is unusable");
      }
      const promise = createDeferredPromise();
      const errorSteps = /* @__PURE__ */ __name((error2) => promise.reject(error2), "errorSteps");
      const successSteps = /* @__PURE__ */ __name((data) => {
        try {
          promise.resolve(convertBytesToJSValue(data));
        } catch (e3) {
          errorSteps(e3);
        }
      }, "successSteps");
      if (object[kState].body == null) {
        successSteps(new Uint8Array());
        return promise.promise;
      }
      await fullyReadBody(object[kState].body, successSteps, errorSteps);
      return promise.promise;
    }
    __name(specConsumeBody, "specConsumeBody");
    function bodyUnusable(body) {
      return body != null && (body.stream.locked || util4.isDisturbed(body.stream));
    }
    __name(bodyUnusable, "bodyUnusable");
    function utf8DecodeBytes(buffer) {
      if (buffer.length === 0) {
        return "";
      }
      if (buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) {
        buffer = buffer.subarray(3);
      }
      const output = textDecoder.decode(buffer);
      return output;
    }
    __name(utf8DecodeBytes, "utf8DecodeBytes");
    function parseJSONFromBytes(bytes) {
      return JSON.parse(utf8DecodeBytes(bytes));
    }
    __name(parseJSONFromBytes, "parseJSONFromBytes");
    function bodyMimeType(object) {
      const { headersList } = object[kState];
      const contentType = headersList.get("content-type");
      if (contentType === null) {
        return "failure";
      }
      return parseMIMEType(contentType);
    }
    __name(bodyMimeType, "bodyMimeType");
    module3.exports = {
      extractBody,
      safelyExtractBody,
      cloneBody,
      mixinBody
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/core/request.js
var require_request4 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/core/request.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var {
      InvalidArgumentError,
      NotSupportedError
    } = require_errors2();
    var assert27 = require("assert");
    var { kHTTP2BuildRequest, kHTTP2CopyHeaders, kHTTP1BuildRequest } = require_symbols6();
    var util4 = require_util12();
    var tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/;
    var headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
    var invalidPathRegex = /[^\u0021-\u00ff]/;
    var kHandler = Symbol("handler");
    var channels = {};
    var extractBody;
    try {
      const diagnosticsChannel = require("diagnostics_channel");
      channels.create = diagnosticsChannel.channel("undici:request:create");
      channels.bodySent = diagnosticsChannel.channel("undici:request:bodySent");
      channels.headers = diagnosticsChannel.channel("undici:request:headers");
      channels.trailers = diagnosticsChannel.channel("undici:request:trailers");
      channels.error = diagnosticsChannel.channel("undici:request:error");
    } catch {
      channels.create = { hasSubscribers: false };
      channels.bodySent = { hasSubscribers: false };
      channels.headers = { hasSubscribers: false };
      channels.trailers = { hasSubscribers: false };
      channels.error = { hasSubscribers: false };
    }
    var Request3 = class {
      constructor(origin, {
        path: path67,
        method,
        body,
        headers,
        query,
        idempotent,
        blocking,
        upgrade,
        headersTimeout,
        bodyTimeout,
        reset,
        throwOnError,
        expectContinue
      }, handler30) {
        if (typeof path67 !== "string") {
          throw new InvalidArgumentError("path must be a string");
        } else if (path67[0] !== "/" && !(path67.startsWith("http://") || path67.startsWith("https://")) && method !== "CONNECT") {
          throw new InvalidArgumentError("path must be an absolute URL or start with a slash");
        } else if (invalidPathRegex.exec(path67) !== null) {
          throw new InvalidArgumentError("invalid request path");
        }
        if (typeof method !== "string") {
          throw new InvalidArgumentError("method must be a string");
        } else if (tokenRegExp.exec(method) === null) {
          throw new InvalidArgumentError("invalid request method");
        }
        if (upgrade && typeof upgrade !== "string") {
          throw new InvalidArgumentError("upgrade must be a string");
        }
        if (headersTimeout != null && (!Number.isFinite(headersTimeout) || headersTimeout < 0)) {
          throw new InvalidArgumentError("invalid headersTimeout");
        }
        if (bodyTimeout != null && (!Number.isFinite(bodyTimeout) || bodyTimeout < 0)) {
          throw new InvalidArgumentError("invalid bodyTimeout");
        }
        if (reset != null && typeof reset !== "boolean") {
          throw new InvalidArgumentError("invalid reset");
        }
        if (expectContinue != null && typeof expectContinue !== "boolean") {
          throw new InvalidArgumentError("invalid expectContinue");
        }
        this.headersTimeout = headersTimeout;
        this.bodyTimeout = bodyTimeout;
        this.throwOnError = throwOnError === true;
        this.method = method;
        this.abort = null;
        if (body == null) {
          this.body = null;
        } else if (util4.isStream(body)) {
          this.body = body;
          const rState = this.body._readableState;
          if (!rState || !rState.autoDestroy) {
            this.endHandler = /* @__PURE__ */ __name(function autoDestroy() {
              util4.destroy(this);
            }, "autoDestroy");
            this.body.on("end", this.endHandler);
          }
          this.errorHandler = (err) => {
            if (this.abort) {
              this.abort(err);
            } else {
              this.error = err;
            }
          };
          this.body.on("error", this.errorHandler);
        } else if (util4.isBuffer(body)) {
          this.body = body.byteLength ? body : null;
        } else if (ArrayBuffer.isView(body)) {
          this.body = body.buffer.byteLength ? Buffer.from(body.buffer, body.byteOffset, body.byteLength) : null;
        } else if (body instanceof ArrayBuffer) {
          this.body = body.byteLength ? Buffer.from(body) : null;
        } else if (typeof body === "string") {
          this.body = body.length ? Buffer.from(body) : null;
        } else if (util4.isFormDataLike(body) || util4.isIterable(body) || util4.isBlobLike(body)) {
          this.body = body;
        } else {
          throw new InvalidArgumentError("body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable");
        }
        this.completed = false;
        this.aborted = false;
        this.upgrade = upgrade || null;
        this.path = query ? util4.buildURL(path67, query) : path67;
        this.origin = origin;
        this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent;
        this.blocking = blocking == null ? false : blocking;
        this.reset = reset == null ? null : reset;
        this.host = null;
        this.contentLength = null;
        this.contentType = null;
        this.headers = "";
        this.expectContinue = expectContinue != null ? expectContinue : false;
        if (Array.isArray(headers)) {
          if (headers.length % 2 !== 0) {
            throw new InvalidArgumentError("headers array must be even");
          }
          for (let i = 0; i < headers.length; i += 2) {
            processHeader(this, headers[i], headers[i + 1]);
          }
        } else if (headers && typeof headers === "object") {
          const keys = Object.keys(headers);
          for (let i = 0; i < keys.length; i++) {
            const key = keys[i];
            processHeader(this, key, headers[key]);
          }
        } else if (headers != null) {
          throw new InvalidArgumentError("headers must be an object or an array");
        }
        if (util4.isFormDataLike(this.body)) {
          if (util4.nodeMajor < 16 || util4.nodeMajor === 16 && util4.nodeMinor < 8) {
            throw new InvalidArgumentError("Form-Data bodies are only supported in node v16.8 and newer.");
          }
          if (!extractBody) {
            extractBody = require_body2().extractBody;
          }
          const [bodyStream, contentType] = extractBody(body);
          if (this.contentType == null) {
            this.contentType = contentType;
            this.headers += `content-type: ${contentType}\r
`;
          }
          this.body = bodyStream.stream;
          this.contentLength = bodyStream.length;
        } else if (util4.isBlobLike(body) && this.contentType == null && body.type) {
          this.contentType = body.type;
          this.headers += `content-type: ${body.type}\r
`;
        }
        util4.validateHandler(handler30, method, upgrade);
        this.servername = util4.getServerName(this.host);
        this[kHandler] = handler30;
        if (channels.create.hasSubscribers) {
          channels.create.publish({ request: this });
        }
      }
      onBodySent(chunk) {
        if (this[kHandler].onBodySent) {
          try {
            return this[kHandler].onBodySent(chunk);
          } catch (err) {
            this.abort(err);
          }
        }
      }
      onRequestSent() {
        if (channels.bodySent.hasSubscribers) {
          channels.bodySent.publish({ request: this });
        }
        if (this[kHandler].onRequestSent) {
          try {
            return this[kHandler].onRequestSent();
          } catch (err) {
            this.abort(err);
          }
        }
      }
      onConnect(abort) {
        assert27(!this.aborted);
        assert27(!this.completed);
        if (this.error) {
          abort(this.error);
        } else {
          this.abort = abort;
          return this[kHandler].onConnect(abort);
        }
      }
      onHeaders(statusCode, headers, resume, statusText) {
        assert27(!this.aborted);
        assert27(!this.completed);
        if (channels.headers.hasSubscribers) {
          channels.headers.publish({ request: this, response: { statusCode, headers, statusText } });
        }
        try {
          return this[kHandler].onHeaders(statusCode, headers, resume, statusText);
        } catch (err) {
          this.abort(err);
        }
      }
      onData(chunk) {
        assert27(!this.aborted);
        assert27(!this.completed);
        try {
          return this[kHandler].onData(chunk);
        } catch (err) {
          this.abort(err);
          return false;
        }
      }
      onUpgrade(statusCode, headers, socket) {
        assert27(!this.aborted);
        assert27(!this.completed);
        return this[kHandler].onUpgrade(statusCode, headers, socket);
      }
      onComplete(trailers) {
        this.onFinally();
        assert27(!this.aborted);
        this.completed = true;
        if (channels.trailers.hasSubscribers) {
          channels.trailers.publish({ request: this, trailers });
        }
        try {
          return this[kHandler].onComplete(trailers);
        } catch (err) {
          this.onError(err);
        }
      }
      onError(error2) {
        this.onFinally();
        if (channels.error.hasSubscribers) {
          channels.error.publish({ request: this, error: error2 });
        }
        if (this.aborted) {
          return;
        }
        this.aborted = true;
        return this[kHandler].onError(error2);
      }
      onFinally() {
        if (this.errorHandler) {
          this.body.off("error", this.errorHandler);
          this.errorHandler = null;
        }
        if (this.endHandler) {
          this.body.off("end", this.endHandler);
          this.endHandler = null;
        }
      }
      // TODO: adjust to support H2
      addHeader(key, value) {
        processHeader(this, key, value);
        return this;
      }
      static [kHTTP1BuildRequest](origin, opts, handler30) {
        return new Request3(origin, opts, handler30);
      }
      static [kHTTP2BuildRequest](origin, opts, handler30) {
        const headers = opts.headers;
        opts = { ...opts, headers: null };
        const request3 = new Request3(origin, opts, handler30);
        request3.headers = {};
        if (Array.isArray(headers)) {
          if (headers.length % 2 !== 0) {
            throw new InvalidArgumentError("headers array must be even");
          }
          for (let i = 0; i < headers.length; i += 2) {
            processHeader(request3, headers[i], headers[i + 1], true);
          }
        } else if (headers && typeof headers === "object") {
          const keys = Object.keys(headers);
          for (let i = 0; i < keys.length; i++) {
            const key = keys[i];
            processHeader(request3, key, headers[key], true);
          }
        } else if (headers != null) {
          throw new InvalidArgumentError("headers must be an object or an array");
        }
        return request3;
      }
      static [kHTTP2CopyHeaders](raw) {
        const rawHeaders = raw.split("\r\n");
        const headers = {};
        for (const header of rawHeaders) {
          const [key, value] = header.split(": ");
          if (value == null || value.length === 0)
            continue;
          if (headers[key])
            headers[key] += `,${value}`;
          else
            headers[key] = value;
        }
        return headers;
      }
    };
    __name(Request3, "Request");
    function processHeaderValue(key, val, skipAppend) {
      if (val && typeof val === "object") {
        throw new InvalidArgumentError(`invalid ${key} header`);
      }
      val = val != null ? `${val}` : "";
      if (headerCharRegex.exec(val) !== null) {
        throw new InvalidArgumentError(`invalid ${key} header`);
      }
      return skipAppend ? val : `${key}: ${val}\r
`;
    }
    __name(processHeaderValue, "processHeaderValue");
    function processHeader(request3, key, val, skipAppend = false) {
      if (val && (typeof val === "object" && !Array.isArray(val))) {
        throw new InvalidArgumentError(`invalid ${key} header`);
      } else if (val === void 0) {
        return;
      }
      if (request3.host === null && key.length === 4 && key.toLowerCase() === "host") {
        if (headerCharRegex.exec(val) !== null) {
          throw new InvalidArgumentError(`invalid ${key} header`);
        }
        request3.host = val;
      } else if (request3.contentLength === null && key.length === 14 && key.toLowerCase() === "content-length") {
        request3.contentLength = parseInt(val, 10);
        if (!Number.isFinite(request3.contentLength)) {
          throw new InvalidArgumentError("invalid content-length header");
        }
      } else if (request3.contentType === null && key.length === 12 && key.toLowerCase() === "content-type") {
        request3.contentType = val;
        if (skipAppend)
          request3.headers[key] = processHeaderValue(key, val, skipAppend);
        else
          request3.headers += processHeaderValue(key, val);
      } else if (key.length === 17 && key.toLowerCase() === "transfer-encoding") {
        throw new InvalidArgumentError("invalid transfer-encoding header");
      } else if (key.length === 10 && key.toLowerCase() === "connection") {
        const value = typeof val === "string" ? val.toLowerCase() : null;
        if (value !== "close" && value !== "keep-alive") {
          throw new InvalidArgumentError("invalid connection header");
        } else if (value === "close") {
          request3.reset = true;
        }
      } else if (key.length === 10 && key.toLowerCase() === "keep-alive") {
        throw new InvalidArgumentError("invalid keep-alive header");
      } else if (key.length === 7 && key.toLowerCase() === "upgrade") {
        throw new InvalidArgumentError("invalid upgrade header");
      } else if (key.length === 6 && key.toLowerCase() === "expect") {
        throw new NotSupportedError("expect header not supported");
      } else if (tokenRegExp.exec(key) === null) {
        throw new InvalidArgumentError("invalid header key");
      } else {
        if (Array.isArray(val)) {
          for (let i = 0; i < val.length; i++) {
            if (skipAppend) {
              if (request3.headers[key])
                request3.headers[key] += `,${processHeaderValue(key, val[i], skipAppend)}`;
              else
                request3.headers[key] = processHeaderValue(key, val[i], skipAppend);
            } else {
              request3.headers += processHeaderValue(key, val[i]);
            }
          }
        } else {
          if (skipAppend)
            request3.headers[key] = processHeaderValue(key, val, skipAppend);
          else
            request3.headers += processHeaderValue(key, val);
        }
      }
    }
    __name(processHeader, "processHeader");
    module3.exports = Request3;
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/dispatcher.js
var require_dispatcher2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/dispatcher.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var EventEmitter7 = require("events");
    var Dispatcher2 = class extends EventEmitter7 {
      dispatch() {
        throw new Error("not implemented");
      }
      close() {
        throw new Error("not implemented");
      }
      destroy() {
        throw new Error("not implemented");
      }
    };
    __name(Dispatcher2, "Dispatcher");
    module3.exports = Dispatcher2;
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/dispatcher-base.js
var require_dispatcher_base2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/dispatcher-base.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var Dispatcher2 = require_dispatcher2();
    var {
      ClientDestroyedError,
      ClientClosedError,
      InvalidArgumentError
    } = require_errors2();
    var { kDestroy, kClose, kDispatch, kInterceptors } = require_symbols6();
    var kDestroyed = Symbol("destroyed");
    var kClosed = Symbol("closed");
    var kOnDestroyed = Symbol("onDestroyed");
    var kOnClosed = Symbol("onClosed");
    var kInterceptedDispatch = Symbol("Intercepted Dispatch");
    var DispatcherBase = class extends Dispatcher2 {
      constructor() {
        super();
        this[kDestroyed] = false;
        this[kOnDestroyed] = null;
        this[kClosed] = false;
        this[kOnClosed] = [];
      }
      get destroyed() {
        return this[kDestroyed];
      }
      get closed() {
        return this[kClosed];
      }
      get interceptors() {
        return this[kInterceptors];
      }
      set interceptors(newInterceptors) {
        if (newInterceptors) {
          for (let i = newInterceptors.length - 1; i >= 0; i--) {
            const interceptor = this[kInterceptors][i];
            if (typeof interceptor !== "function") {
              throw new InvalidArgumentError("interceptor must be an function");
            }
          }
        }
        this[kInterceptors] = newInterceptors;
      }
      close(callback) {
        if (callback === void 0) {
          return new Promise((resolve19, reject) => {
            this.close((err, data) => {
              return err ? reject(err) : resolve19(data);
            });
          });
        }
        if (typeof callback !== "function") {
          throw new InvalidArgumentError("invalid callback");
        }
        if (this[kDestroyed]) {
          queueMicrotask(() => callback(new ClientDestroyedError(), null));
          return;
        }
        if (this[kClosed]) {
          if (this[kOnClosed]) {
            this[kOnClosed].push(callback);
          } else {
            queueMicrotask(() => callback(null, null));
          }
          return;
        }
        this[kClosed] = true;
        this[kOnClosed].push(callback);
        const onClosed = /* @__PURE__ */ __name(() => {
          const callbacks = this[kOnClosed];
          this[kOnClosed] = null;
          for (let i = 0; i < callbacks.length; i++) {
            callbacks[i](null, null);
          }
        }, "onClosed");
        this[kClose]().then(() => this.destroy()).then(() => {
          queueMicrotask(onClosed);
        });
      }
      destroy(err, callback) {
        if (typeof err === "function") {
          callback = err;
          err = null;
        }
        if (callback === void 0) {
          return new Promise((resolve19, reject) => {
            this.destroy(err, (err2, data) => {
              return err2 ? (
                /* istanbul ignore next: should never error */
                reject(err2)
              ) : resolve19(data);
            });
          });
        }
        if (typeof callback !== "function") {
          throw new InvalidArgumentError("invalid callback");
        }
        if (this[kDestroyed]) {
          if (this[kOnDestroyed]) {
            this[kOnDestroyed].push(callback);
          } else {
            queueMicrotask(() => callback(null, null));
          }
          return;
        }
        if (!err) {
          err = new ClientDestroyedError();
        }
        this[kDestroyed] = true;
        this[kOnDestroyed] = this[kOnDestroyed] || [];
        this[kOnDestroyed].push(callback);
        const onDestroyed = /* @__PURE__ */ __name(() => {
          const callbacks = this[kOnDestroyed];
          this[kOnDestroyed] = null;
          for (let i = 0; i < callbacks.length; i++) {
            callbacks[i](null, null);
          }
        }, "onDestroyed");
        this[kDestroy](err).then(() => {
          queueMicrotask(onDestroyed);
        });
      }
      [kInterceptedDispatch](opts, handler30) {
        if (!this[kInterceptors] || this[kInterceptors].length === 0) {
          this[kInterceptedDispatch] = this[kDispatch];
          return this[kDispatch](opts, handler30);
        }
        let dispatch = this[kDispatch].bind(this);
        for (let i = this[kInterceptors].length - 1; i >= 0; i--) {
          dispatch = this[kInterceptors][i](dispatch);
        }
        this[kInterceptedDispatch] = dispatch;
        return dispatch(opts, handler30);
      }
      dispatch(opts, handler30) {
        if (!handler30 || typeof handler30 !== "object") {
          throw new InvalidArgumentError("handler must be an object");
        }
        try {
          if (!opts || typeof opts !== "object") {
            throw new InvalidArgumentError("opts must be an object.");
          }
          if (this[kDestroyed] || this[kOnDestroyed]) {
            throw new ClientDestroyedError();
          }
          if (this[kClosed]) {
            throw new ClientClosedError();
          }
          return this[kInterceptedDispatch](opts, handler30);
        } catch (err) {
          if (typeof handler30.onError !== "function") {
            throw new InvalidArgumentError("invalid onError method");
          }
          handler30.onError(err);
          return false;
        }
      }
    };
    __name(DispatcherBase, "DispatcherBase");
    module3.exports = DispatcherBase;
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/core/connect.js
var require_connect2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/core/connect.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var net3 = require("net");
    var assert27 = require("assert");
    var util4 = require_util12();
    var { InvalidArgumentError, ConnectTimeoutError } = require_errors2();
    var tls;
    var SessionCache;
    if (global.FinalizationRegistry && !process.env.NODE_V8_COVERAGE) {
      SessionCache = /* @__PURE__ */ __name(class WeakSessionCache {
        constructor(maxCachedSessions) {
          this._maxCachedSessions = maxCachedSessions;
          this._sessionCache = /* @__PURE__ */ new Map();
          this._sessionRegistry = new global.FinalizationRegistry((key) => {
            if (this._sessionCache.size < this._maxCachedSessions) {
              return;
            }
            const ref = this._sessionCache.get(key);
            if (ref !== void 0 && ref.deref() === void 0) {
              this._sessionCache.delete(key);
            }
          });
        }
        get(sessionKey) {
          const ref = this._sessionCache.get(sessionKey);
          return ref ? ref.deref() : null;
        }
        set(sessionKey, session) {
          if (this._maxCachedSessions === 0) {
            return;
          }
          this._sessionCache.set(sessionKey, new WeakRef(session));
          this._sessionRegistry.register(session, sessionKey);
        }
      }, "WeakSessionCache");
    } else {
      SessionCache = /* @__PURE__ */ __name(class SimpleSessionCache {
        constructor(maxCachedSessions) {
          this._maxCachedSessions = maxCachedSessions;
          this._sessionCache = /* @__PURE__ */ new Map();
        }
        get(sessionKey) {
          return this._sessionCache.get(sessionKey);
        }
        set(sessionKey, session) {
          if (this._maxCachedSessions === 0) {
            return;
          }
          if (this._sessionCache.size >= this._maxCachedSessions) {
            const { value: oldestKey } = this._sessionCache.keys().next();
            this._sessionCache.delete(oldestKey);
          }
          this._sessionCache.set(sessionKey, session);
        }
      }, "SimpleSessionCache");
    }
    function buildConnector({ allowH2, maxCachedSessions, socketPath, timeout, ...opts }) {
      if (maxCachedSessions != null && (!Number.isInteger(maxCachedSessions) || maxCachedSessions < 0)) {
        throw new InvalidArgumentError("maxCachedSessions must be a positive integer or zero");
      }
      const options29 = { path: socketPath, ...opts };
      const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions);
      timeout = timeout == null ? 1e4 : timeout;
      allowH2 = allowH2 != null ? allowH2 : false;
      return /* @__PURE__ */ __name(function connect2({ hostname: hostname2, host, protocol, port: port2, servername, localAddress, httpSocket }, callback) {
        let socket;
        if (protocol === "https:") {
          if (!tls) {
            tls = require("tls");
          }
          servername = servername || options29.servername || util4.getServerName(host) || null;
          const sessionKey = servername || hostname2;
          const session = sessionCache.get(sessionKey) || null;
          assert27(sessionKey);
          socket = tls.connect({
            highWaterMark: 16384,
            // TLS in node can't have bigger HWM anyway...
            ...options29,
            servername,
            session,
            localAddress,
            // TODO(HTTP/2): Add support for h2c
            ALPNProtocols: allowH2 ? ["http/1.1", "h2"] : ["http/1.1"],
            socket: httpSocket,
            // upgrade socket connection
            port: port2 || 443,
            host: hostname2
          });
          socket.on("session", function(session2) {
            sessionCache.set(sessionKey, session2);
          });
        } else {
          assert27(!httpSocket, "httpSocket can only be sent on TLS update");
          socket = net3.connect({
            highWaterMark: 64 * 1024,
            // Same as nodejs fs streams.
            ...options29,
            localAddress,
            port: port2 || 80,
            host: hostname2
          });
        }
        if (options29.keepAlive == null || options29.keepAlive) {
          const keepAliveInitialDelay = options29.keepAliveInitialDelay === void 0 ? 6e4 : options29.keepAliveInitialDelay;
          socket.setKeepAlive(true, keepAliveInitialDelay);
        }
        const cancelTimeout = setupTimeout2(() => onConnectTimeout(socket), timeout);
        socket.setNoDelay(true).once(protocol === "https:" ? "secureConnect" : "connect", function() {
          cancelTimeout();
          if (callback) {
            const cb = callback;
            callback = null;
            cb(null, this);
          }
        }).on("error", function(err) {
          cancelTimeout();
          if (callback) {
            const cb = callback;
            callback = null;
            cb(err);
          }
        });
        return socket;
      }, "connect");
    }
    __name(buildConnector, "buildConnector");
    function setupTimeout2(onConnectTimeout2, timeout) {
      if (!timeout) {
        return () => {
        };
      }
      let s1 = null;
      let s2 = null;
      const timeoutId = setTimeout(() => {
        s1 = setImmediate(() => {
          if (process.platform === "win32") {
            s2 = setImmediate(() => onConnectTimeout2());
          } else {
            onConnectTimeout2();
          }
        });
      }, timeout);
      return () => {
        clearTimeout(timeoutId);
        clearImmediate(s1);
        clearImmediate(s2);
      };
    }
    __name(setupTimeout2, "setupTimeout");
    function onConnectTimeout(socket) {
      util4.destroy(socket, new ConnectTimeoutError());
    }
    __name(onConnectTimeout, "onConnectTimeout");
    module3.exports = buildConnector;
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/llhttp/utils.js
var require_utils7 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/llhttp/utils.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.enumToMap = void 0;
    function enumToMap(obj) {
      const res = {};
      Object.keys(obj).forEach((key) => {
        const value = obj[key];
        if (typeof value === "number") {
          res[key] = value;
        }
      });
      return res;
    }
    __name(enumToMap, "enumToMap");
    exports2.enumToMap = enumToMap;
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/llhttp/constants.js
var require_constants10 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/llhttp/constants.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.SPECIAL_HEADERS = exports2.HEADER_STATE = exports2.MINOR = exports2.MAJOR = exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS = exports2.TOKEN = exports2.STRICT_TOKEN = exports2.HEX = exports2.URL_CHAR = exports2.STRICT_URL_CHAR = exports2.USERINFO_CHARS = exports2.MARK = exports2.ALPHANUM = exports2.NUM = exports2.HEX_MAP = exports2.NUM_MAP = exports2.ALPHA = exports2.FINISH = exports2.H_METHOD_MAP = exports2.METHOD_MAP = exports2.METHODS_RTSP = exports2.METHODS_ICE = exports2.METHODS_HTTP = exports2.METHODS = exports2.LENIENT_FLAGS = exports2.FLAGS = exports2.TYPE = exports2.ERROR = void 0;
    var utils_1 = require_utils7();
    var ERROR;
    (function(ERROR2) {
      ERROR2[ERROR2["OK"] = 0] = "OK";
      ERROR2[ERROR2["INTERNAL"] = 1] = "INTERNAL";
      ERROR2[ERROR2["STRICT"] = 2] = "STRICT";
      ERROR2[ERROR2["LF_EXPECTED"] = 3] = "LF_EXPECTED";
      ERROR2[ERROR2["UNEXPECTED_CONTENT_LENGTH"] = 4] = "UNEXPECTED_CONTENT_LENGTH";
      ERROR2[ERROR2["CLOSED_CONNECTION"] = 5] = "CLOSED_CONNECTION";
      ERROR2[ERROR2["INVALID_METHOD"] = 6] = "INVALID_METHOD";
      ERROR2[ERROR2["INVALID_URL"] = 7] = "INVALID_URL";
      ERROR2[ERROR2["INVALID_CONSTANT"] = 8] = "INVALID_CONSTANT";
      ERROR2[ERROR2["INVALID_VERSION"] = 9] = "INVALID_VERSION";
      ERROR2[ERROR2["INVALID_HEADER_TOKEN"] = 10] = "INVALID_HEADER_TOKEN";
      ERROR2[ERROR2["INVALID_CONTENT_LENGTH"] = 11] = "INVALID_CONTENT_LENGTH";
      ERROR2[ERROR2["INVALID_CHUNK_SIZE"] = 12] = "INVALID_CHUNK_SIZE";
      ERROR2[ERROR2["INVALID_STATUS"] = 13] = "INVALID_STATUS";
      ERROR2[ERROR2["INVALID_EOF_STATE"] = 14] = "INVALID_EOF_STATE";
      ERROR2[ERROR2["INVALID_TRANSFER_ENCODING"] = 15] = "INVALID_TRANSFER_ENCODING";
      ERROR2[ERROR2["CB_MESSAGE_BEGIN"] = 16] = "CB_MESSAGE_BEGIN";
      ERROR2[ERROR2["CB_HEADERS_COMPLETE"] = 17] = "CB_HEADERS_COMPLETE";
      ERROR2[ERROR2["CB_MESSAGE_COMPLETE"] = 18] = "CB_MESSAGE_COMPLETE";
      ERROR2[ERROR2["CB_CHUNK_HEADER"] = 19] = "CB_CHUNK_HEADER";
      ERROR2[ERROR2["CB_CHUNK_COMPLETE"] = 20] = "CB_CHUNK_COMPLETE";
      ERROR2[ERROR2["PAUSED"] = 21] = "PAUSED";
      ERROR2[ERROR2["PAUSED_UPGRADE"] = 22] = "PAUSED_UPGRADE";
      ERROR2[ERROR2["PAUSED_H2_UPGRADE"] = 23] = "PAUSED_H2_UPGRADE";
      ERROR2[ERROR2["USER"] = 24] = "USER";
    })(ERROR = exports2.ERROR || (exports2.ERROR = {}));
    var TYPE;
    (function(TYPE2) {
      TYPE2[TYPE2["BOTH"] = 0] = "BOTH";
      TYPE2[TYPE2["REQUEST"] = 1] = "REQUEST";
      TYPE2[TYPE2["RESPONSE"] = 2] = "RESPONSE";
    })(TYPE = exports2.TYPE || (exports2.TYPE = {}));
    var FLAGS;
    (function(FLAGS2) {
      FLAGS2[FLAGS2["CONNECTION_KEEP_ALIVE"] = 1] = "CONNECTION_KEEP_ALIVE";
      FLAGS2[FLAGS2["CONNECTION_CLOSE"] = 2] = "CONNECTION_CLOSE";
      FLAGS2[FLAGS2["CONNECTION_UPGRADE"] = 4] = "CONNECTION_UPGRADE";
      FLAGS2[FLAGS2["CHUNKED"] = 8] = "CHUNKED";
      FLAGS2[FLAGS2["UPGRADE"] = 16] = "UPGRADE";
      FLAGS2[FLAGS2["CONTENT_LENGTH"] = 32] = "CONTENT_LENGTH";
      FLAGS2[FLAGS2["SKIPBODY"] = 64] = "SKIPBODY";
      FLAGS2[FLAGS2["TRAILING"] = 128] = "TRAILING";
      FLAGS2[FLAGS2["TRANSFER_ENCODING"] = 512] = "TRANSFER_ENCODING";
    })(FLAGS = exports2.FLAGS || (exports2.FLAGS = {}));
    var LENIENT_FLAGS;
    (function(LENIENT_FLAGS2) {
      LENIENT_FLAGS2[LENIENT_FLAGS2["HEADERS"] = 1] = "HEADERS";
      LENIENT_FLAGS2[LENIENT_FLAGS2["CHUNKED_LENGTH"] = 2] = "CHUNKED_LENGTH";
      LENIENT_FLAGS2[LENIENT_FLAGS2["KEEP_ALIVE"] = 4] = "KEEP_ALIVE";
    })(LENIENT_FLAGS = exports2.LENIENT_FLAGS || (exports2.LENIENT_FLAGS = {}));
    var METHODS;
    (function(METHODS2) {
      METHODS2[METHODS2["DELETE"] = 0] = "DELETE";
      METHODS2[METHODS2["GET"] = 1] = "GET";
      METHODS2[METHODS2["HEAD"] = 2] = "HEAD";
      METHODS2[METHODS2["POST"] = 3] = "POST";
      METHODS2[METHODS2["PUT"] = 4] = "PUT";
      METHODS2[METHODS2["CONNECT"] = 5] = "CONNECT";
      METHODS2[METHODS2["OPTIONS"] = 6] = "OPTIONS";
      METHODS2[METHODS2["TRACE"] = 7] = "TRACE";
      METHODS2[METHODS2["COPY"] = 8] = "COPY";
      METHODS2[METHODS2["LOCK"] = 9] = "LOCK";
      METHODS2[METHODS2["MKCOL"] = 10] = "MKCOL";
      METHODS2[METHODS2["MOVE"] = 11] = "MOVE";
      METHODS2[METHODS2["PROPFIND"] = 12] = "PROPFIND";
      METHODS2[METHODS2["PROPPATCH"] = 13] = "PROPPATCH";
      METHODS2[METHODS2["SEARCH"] = 14] = "SEARCH";
      METHODS2[METHODS2["UNLOCK"] = 15] = "UNLOCK";
      METHODS2[METHODS2["BIND"] = 16] = "BIND";
      METHODS2[METHODS2["REBIND"] = 17] = "REBIND";
      METHODS2[METHODS2["UNBIND"] = 18] = "UNBIND";
      METHODS2[METHODS2["ACL"] = 19] = "ACL";
      METHODS2[METHODS2["REPORT"] = 20] = "REPORT";
      METHODS2[METHODS2["MKACTIVITY"] = 21] = "MKACTIVITY";
      METHODS2[METHODS2["CHECKOUT"] = 22] = "CHECKOUT";
      METHODS2[METHODS2["MERGE"] = 23] = "MERGE";
      METHODS2[METHODS2["M-SEARCH"] = 24] = "M-SEARCH";
      METHODS2[METHODS2["NOTIFY"] = 25] = "NOTIFY";
      METHODS2[METHODS2["SUBSCRIBE"] = 26] = "SUBSCRIBE";
      METHODS2[METHODS2["UNSUBSCRIBE"] = 27] = "UNSUBSCRIBE";
      METHODS2[METHODS2["PATCH"] = 28] = "PATCH";
      METHODS2[METHODS2["PURGE"] = 29] = "PURGE";
      METHODS2[METHODS2["MKCALENDAR"] = 30] = "MKCALENDAR";
      METHODS2[METHODS2["LINK"] = 31] = "LINK";
      METHODS2[METHODS2["UNLINK"] = 32] = "UNLINK";
      METHODS2[METHODS2["SOURCE"] = 33] = "SOURCE";
      METHODS2[METHODS2["PRI"] = 34] = "PRI";
      METHODS2[METHODS2["DESCRIBE"] = 35] = "DESCRIBE";
      METHODS2[METHODS2["ANNOUNCE"] = 36] = "ANNOUNCE";
      METHODS2[METHODS2["SETUP"] = 37] = "SETUP";
      METHODS2[METHODS2["PLAY"] = 38] = "PLAY";
      METHODS2[METHODS2["PAUSE"] = 39] = "PAUSE";
      METHODS2[METHODS2["TEARDOWN"] = 40] = "TEARDOWN";
      METHODS2[METHODS2["GET_PARAMETER"] = 41] = "GET_PARAMETER";
      METHODS2[METHODS2["SET_PARAMETER"] = 42] = "SET_PARAMETER";
      METHODS2[METHODS2["REDIRECT"] = 43] = "REDIRECT";
      METHODS2[METHODS2["RECORD"] = 44] = "RECORD";
      METHODS2[METHODS2["FLUSH"] = 45] = "FLUSH";
    })(METHODS = exports2.METHODS || (exports2.METHODS = {}));
    exports2.METHODS_HTTP = [
      METHODS.DELETE,
      METHODS.GET,
      METHODS.HEAD,
      METHODS.POST,
      METHODS.PUT,
      METHODS.CONNECT,
      METHODS.OPTIONS,
      METHODS.TRACE,
      METHODS.COPY,
      METHODS.LOCK,
      METHODS.MKCOL,
      METHODS.MOVE,
      METHODS.PROPFIND,
      METHODS.PROPPATCH,
      METHODS.SEARCH,
      METHODS.UNLOCK,
      METHODS.BIND,
      METHODS.REBIND,
      METHODS.UNBIND,
      METHODS.ACL,
      METHODS.REPORT,
      METHODS.MKACTIVITY,
      METHODS.CHECKOUT,
      METHODS.MERGE,
      METHODS["M-SEARCH"],
      METHODS.NOTIFY,
      METHODS.SUBSCRIBE,
      METHODS.UNSUBSCRIBE,
      METHODS.PATCH,
      METHODS.PURGE,
      METHODS.MKCALENDAR,
      METHODS.LINK,
      METHODS.UNLINK,
      METHODS.PRI,
      // TODO(indutny): should we allow it with HTTP?
      METHODS.SOURCE
    ];
    exports2.METHODS_ICE = [
      METHODS.SOURCE
    ];
    exports2.METHODS_RTSP = [
      METHODS.OPTIONS,
      METHODS.DESCRIBE,
      METHODS.ANNOUNCE,
      METHODS.SETUP,
      METHODS.PLAY,
      METHODS.PAUSE,
      METHODS.TEARDOWN,
      METHODS.GET_PARAMETER,
      METHODS.SET_PARAMETER,
      METHODS.REDIRECT,
      METHODS.RECORD,
      METHODS.FLUSH,
      // For AirPlay
      METHODS.GET,
      METHODS.POST
    ];
    exports2.METHOD_MAP = utils_1.enumToMap(METHODS);
    exports2.H_METHOD_MAP = {};
    Object.keys(exports2.METHOD_MAP).forEach((key) => {
      if (/^H/.test(key)) {
        exports2.H_METHOD_MAP[key] = exports2.METHOD_MAP[key];
      }
    });
    var FINISH;
    (function(FINISH2) {
      FINISH2[FINISH2["SAFE"] = 0] = "SAFE";
      FINISH2[FINISH2["SAFE_WITH_CB"] = 1] = "SAFE_WITH_CB";
      FINISH2[FINISH2["UNSAFE"] = 2] = "UNSAFE";
    })(FINISH = exports2.FINISH || (exports2.FINISH = {}));
    exports2.ALPHA = [];
    for (let i = "A".charCodeAt(0); i <= "Z".charCodeAt(0); i++) {
      exports2.ALPHA.push(String.fromCharCode(i));
      exports2.ALPHA.push(String.fromCharCode(i + 32));
    }
    exports2.NUM_MAP = {
      0: 0,
      1: 1,
      2: 2,
      3: 3,
      4: 4,
      5: 5,
      6: 6,
      7: 7,
      8: 8,
      9: 9
    };
    exports2.HEX_MAP = {
      0: 0,
      1: 1,
      2: 2,
      3: 3,
      4: 4,
      5: 5,
      6: 6,
      7: 7,
      8: 8,
      9: 9,
      A: 10,
      B: 11,
      C: 12,
      D: 13,
      E: 14,
      F: 15,
      a: 10,
      b: 11,
      c: 12,
      d: 13,
      e: 14,
      f: 15
    };
    exports2.NUM = [
      "0",
      "1",
      "2",
      "3",
      "4",
      "5",
      "6",
      "7",
      "8",
      "9"
    ];
    exports2.ALPHANUM = exports2.ALPHA.concat(exports2.NUM);
    exports2.MARK = ["-", "_", ".", "!", "~", "*", "'", "(", ")"];
    exports2.USERINFO_CHARS = exports2.ALPHANUM.concat(exports2.MARK).concat(["%", ";", ":", "&", "=", "+", "$", ","]);
    exports2.STRICT_URL_CHAR = [
      "!",
      '"',
      "$",
      "%",
      "&",
      "'",
      "(",
      ")",
      "*",
      "+",
      ",",
      "-",
      ".",
      "/",
      ":",
      ";",
      "<",
      "=",
      ">",
      "@",
      "[",
      "\\",
      "]",
      "^",
      "_",
      "`",
      "{",
      "|",
      "}",
      "~"
    ].concat(exports2.ALPHANUM);
    exports2.URL_CHAR = exports2.STRICT_URL_CHAR.concat(["	", "\f"]);
    for (let i = 128; i <= 255; i++) {
      exports2.URL_CHAR.push(i);
    }
    exports2.HEX = exports2.NUM.concat(["a", "b", "c", "d", "e", "f", "A", "B", "C", "D", "E", "F"]);
    exports2.STRICT_TOKEN = [
      "!",
      "#",
      "$",
      "%",
      "&",
      "'",
      "*",
      "+",
      "-",
      ".",
      "^",
      "_",
      "`",
      "|",
      "~"
    ].concat(exports2.ALPHANUM);
    exports2.TOKEN = exports2.STRICT_TOKEN.concat([" "]);
    exports2.HEADER_CHARS = ["	"];
    for (let i = 32; i <= 255; i++) {
      if (i !== 127) {
        exports2.HEADER_CHARS.push(i);
      }
    }
    exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS.filter((c2) => c2 !== 44);
    exports2.MAJOR = exports2.NUM_MAP;
    exports2.MINOR = exports2.MAJOR;
    var HEADER_STATE;
    (function(HEADER_STATE2) {
      HEADER_STATE2[HEADER_STATE2["GENERAL"] = 0] = "GENERAL";
      HEADER_STATE2[HEADER_STATE2["CONNECTION"] = 1] = "CONNECTION";
      HEADER_STATE2[HEADER_STATE2["CONTENT_LENGTH"] = 2] = "CONTENT_LENGTH";
      HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING"] = 3] = "TRANSFER_ENCODING";
      HEADER_STATE2[HEADER_STATE2["UPGRADE"] = 4] = "UPGRADE";
      HEADER_STATE2[HEADER_STATE2["CONNECTION_KEEP_ALIVE"] = 5] = "CONNECTION_KEEP_ALIVE";
      HEADER_STATE2[HEADER_STATE2["CONNECTION_CLOSE"] = 6] = "CONNECTION_CLOSE";
      HEADER_STATE2[HEADER_STATE2["CONNECTION_UPGRADE"] = 7] = "CONNECTION_UPGRADE";
      HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING_CHUNKED"] = 8] = "TRANSFER_ENCODING_CHUNKED";
    })(HEADER_STATE = exports2.HEADER_STATE || (exports2.HEADER_STATE = {}));
    exports2.SPECIAL_HEADERS = {
      "connection": HEADER_STATE.CONNECTION,
      "content-length": HEADER_STATE.CONTENT_LENGTH,
      "proxy-connection": HEADER_STATE.CONNECTION,
      "transfer-encoding": HEADER_STATE.TRANSFER_ENCODING,
      "upgrade": HEADER_STATE.UPGRADE
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/handler/RedirectHandler.js
var require_RedirectHandler2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/handler/RedirectHandler.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var util4 = require_util12();
    var { kBodyUsed } = require_symbols6();
    var assert27 = require("assert");
    var { InvalidArgumentError } = require_errors2();
    var EE = require("events");
    var redirectableStatusCodes = [300, 301, 302, 303, 307, 308];
    var kBody = Symbol("body");
    var BodyAsyncIterable = class {
      constructor(body) {
        this[kBody] = body;
        this[kBodyUsed] = false;
      }
      async *[Symbol.asyncIterator]() {
        assert27(!this[kBodyUsed], "disturbed");
        this[kBodyUsed] = true;
        yield* this[kBody];
      }
    };
    __name(BodyAsyncIterable, "BodyAsyncIterable");
    var RedirectHandler = class {
      constructor(dispatch, maxRedirections, opts, handler30) {
        if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
          throw new InvalidArgumentError("maxRedirections must be a positive number");
        }
        util4.validateHandler(handler30, opts.method, opts.upgrade);
        this.dispatch = dispatch;
        this.location = null;
        this.abort = null;
        this.opts = { ...opts, maxRedirections: 0 };
        this.maxRedirections = maxRedirections;
        this.handler = handler30;
        this.history = [];
        if (util4.isStream(this.opts.body)) {
          if (util4.bodyLength(this.opts.body) === 0) {
            this.opts.body.on("data", function() {
              assert27(false);
            });
          }
          if (typeof this.opts.body.readableDidRead !== "boolean") {
            this.opts.body[kBodyUsed] = false;
            EE.prototype.on.call(this.opts.body, "data", function() {
              this[kBodyUsed] = true;
            });
          }
        } else if (this.opts.body && typeof this.opts.body.pipeTo === "function") {
          this.opts.body = new BodyAsyncIterable(this.opts.body);
        } else if (this.opts.body && typeof this.opts.body !== "string" && !ArrayBuffer.isView(this.opts.body) && util4.isIterable(this.opts.body)) {
          this.opts.body = new BodyAsyncIterable(this.opts.body);
        }
      }
      onConnect(abort) {
        this.abort = abort;
        this.handler.onConnect(abort, { history: this.history });
      }
      onUpgrade(statusCode, headers, socket) {
        this.handler.onUpgrade(statusCode, headers, socket);
      }
      onError(error2) {
        this.handler.onError(error2);
      }
      onHeaders(statusCode, headers, resume, statusText) {
        this.location = this.history.length >= this.maxRedirections || util4.isDisturbed(this.opts.body) ? null : parseLocation(statusCode, headers);
        if (this.opts.origin) {
          this.history.push(new URL(this.opts.path, this.opts.origin));
        }
        if (!this.location) {
          return this.handler.onHeaders(statusCode, headers, resume, statusText);
        }
        const { origin, pathname, search } = util4.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)));
        const path67 = search ? `${pathname}${search}` : pathname;
        this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin);
        this.opts.path = path67;
        this.opts.origin = origin;
        this.opts.maxRedirections = 0;
        this.opts.query = null;
        if (statusCode === 303 && this.opts.method !== "HEAD") {
          this.opts.method = "GET";
          this.opts.body = null;
        }
      }
      onData(chunk) {
        if (this.location) {
        } else {
          return this.handler.onData(chunk);
        }
      }
      onComplete(trailers) {
        if (this.location) {
          this.location = null;
          this.abort = null;
          this.dispatch(this.opts, this);
        } else {
          this.handler.onComplete(trailers);
        }
      }
      onBodySent(chunk) {
        if (this.handler.onBodySent) {
          this.handler.onBodySent(chunk);
        }
      }
    };
    __name(RedirectHandler, "RedirectHandler");
    function parseLocation(statusCode, headers) {
      if (redirectableStatusCodes.indexOf(statusCode) === -1) {
        return null;
      }
      for (let i = 0; i < headers.length; i += 2) {
        if (headers[i].toString().toLowerCase() === "location") {
          return headers[i + 1];
        }
      }
    }
    __name(parseLocation, "parseLocation");
    function shouldRemoveHeader(header, removeContent, unknownOrigin) {
      return header.length === 4 && header.toString().toLowerCase() === "host" || removeContent && header.toString().toLowerCase().indexOf("content-") === 0 || unknownOrigin && header.length === 13 && header.toString().toLowerCase() === "authorization" || unknownOrigin && header.length === 6 && header.toString().toLowerCase() === "cookie";
    }
    __name(shouldRemoveHeader, "shouldRemoveHeader");
    function cleanRequestHeaders(headers, removeContent, unknownOrigin) {
      const ret = [];
      if (Array.isArray(headers)) {
        for (let i = 0; i < headers.length; i += 2) {
          if (!shouldRemoveHeader(headers[i], removeContent, unknownOrigin)) {
            ret.push(headers[i], headers[i + 1]);
          }
        }
      } else if (headers && typeof headers === "object") {
        for (const key of Object.keys(headers)) {
          if (!shouldRemoveHeader(key, removeContent, unknownOrigin)) {
            ret.push(key, headers[key]);
          }
        }
      } else {
        assert27(headers == null, "headers must be an object or an array");
      }
      return ret;
    }
    __name(cleanRequestHeaders, "cleanRequestHeaders");
    module3.exports = RedirectHandler;
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/interceptor/redirectInterceptor.js
var require_redirectInterceptor2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/interceptor/redirectInterceptor.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var RedirectHandler = require_RedirectHandler2();
    function createRedirectInterceptor({ maxRedirections: defaultMaxRedirections }) {
      return (dispatch) => {
        return /* @__PURE__ */ __name(function Intercept(opts, handler30) {
          const { maxRedirections = defaultMaxRedirections } = opts;
          if (!maxRedirections) {
            return dispatch(opts, handler30);
          }
          const redirectHandler = new RedirectHandler(dispatch, maxRedirections, opts, handler30);
          opts = { ...opts, maxRedirections: 0 };
          return dispatch(opts, redirectHandler);
        }, "Intercept");
      };
    }
    __name(createRedirectInterceptor, "createRedirectInterceptor");
    module3.exports = createRedirectInterceptor;
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/llhttp/llhttp-wasm.js
var require_llhttp_wasm2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/llhttp/llhttp-wasm.js"(exports2, module3) {
    init_import_meta_url();
    module3.exports = "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";
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/llhttp/llhttp_simd-wasm.js
var require_llhttp_simd_wasm2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/llhttp/llhttp_simd-wasm.js"(exports2, module3) {
    init_import_meta_url();
    module3.exports = "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";
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/client.js
var require_client2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/client.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var assert27 = require("assert");
    var net3 = require("net");
    var http4 = require("http");
    var { pipeline } = require("stream");
    var util4 = require_util12();
    var timers = require_timers2();
    var Request3 = require_request4();
    var DispatcherBase = require_dispatcher_base2();
    var {
      RequestContentLengthMismatchError,
      ResponseContentLengthMismatchError,
      InvalidArgumentError,
      RequestAbortedError,
      HeadersTimeoutError,
      HeadersOverflowError,
      SocketError,
      InformationalError,
      BodyTimeoutError,
      HTTPParserError,
      ResponseExceededMaxSizeError,
      ClientDestroyedError
    } = require_errors2();
    var buildConnector = require_connect2();
    var {
      kUrl,
      kReset: kReset2,
      kServerName,
      kClient,
      kBusy,
      kParser,
      kConnect,
      kBlocking,
      kResuming,
      kRunning,
      kPending,
      kSize,
      kWriting,
      kQueue,
      kConnected,
      kConnecting,
      kNeedDrain,
      kNoRef,
      kKeepAliveDefaultTimeout,
      kHostHeader,
      kPendingIdx,
      kRunningIdx,
      kError,
      kPipelining,
      kSocket,
      kKeepAliveTimeoutValue,
      kMaxHeadersSize,
      kKeepAliveMaxTimeout,
      kKeepAliveTimeoutThreshold,
      kHeadersTimeout,
      kBodyTimeout,
      kStrictContentLength,
      kConnector,
      kMaxRedirections,
      kMaxRequests,
      kCounter,
      kClose,
      kDestroy,
      kDispatch,
      kInterceptors,
      kLocalAddress,
      kMaxResponseSize,
      kHTTPConnVersion,
      // HTTP2
      kHost,
      kHTTP2Session,
      kHTTP2SessionState,
      kHTTP2BuildRequest,
      kHTTP2CopyHeaders,
      kHTTP1BuildRequest
    } = require_symbols6();
    var http22;
    try {
      http22 = require("http2");
    } catch {
      http22 = { constants: {} };
    }
    var {
      constants: {
        HTTP2_HEADER_AUTHORITY,
        HTTP2_HEADER_METHOD,
        HTTP2_HEADER_PATH,
        HTTP2_HEADER_SCHEME,
        HTTP2_HEADER_CONTENT_LENGTH,
        HTTP2_HEADER_EXPECT,
        HTTP2_HEADER_STATUS
      }
    } = http22;
    var h2ExperimentalWarned = false;
    var FastBuffer = Buffer[Symbol.species];
    var kClosedResolve = Symbol("kClosedResolve");
    var channels = {};
    try {
      const diagnosticsChannel = require("diagnostics_channel");
      channels.sendHeaders = diagnosticsChannel.channel("undici:client:sendHeaders");
      channels.beforeConnect = diagnosticsChannel.channel("undici:client:beforeConnect");
      channels.connectError = diagnosticsChannel.channel("undici:client:connectError");
      channels.connected = diagnosticsChannel.channel("undici:client:connected");
    } catch {
      channels.sendHeaders = { hasSubscribers: false };
      channels.beforeConnect = { hasSubscribers: false };
      channels.connectError = { hasSubscribers: false };
      channels.connected = { hasSubscribers: false };
    }
    var Client = class extends DispatcherBase {
      /**
       *
       * @param {string|URL} url
       * @param {import('../types/client').Client.Options} options
       */
      constructor(url4, {
        interceptors,
        maxHeaderSize,
        headersTimeout,
        socketTimeout,
        requestTimeout,
        connectTimeout,
        bodyTimeout,
        idleTimeout,
        keepAlive,
        keepAliveTimeout,
        maxKeepAliveTimeout,
        keepAliveMaxTimeout,
        keepAliveTimeoutThreshold,
        socketPath,
        pipelining,
        tls,
        strictContentLength,
        maxCachedSessions,
        maxRedirections,
        connect: connect3,
        maxRequestsPerClient,
        localAddress,
        maxResponseSize,
        autoSelectFamily,
        autoSelectFamilyAttemptTimeout,
        // h2
        allowH2,
        maxConcurrentStreams
      } = {}) {
        super();
        if (keepAlive !== void 0) {
          throw new InvalidArgumentError("unsupported keepAlive, use pipelining=0 instead");
        }
        if (socketTimeout !== void 0) {
          throw new InvalidArgumentError("unsupported socketTimeout, use headersTimeout & bodyTimeout instead");
        }
        if (requestTimeout !== void 0) {
          throw new InvalidArgumentError("unsupported requestTimeout, use headersTimeout & bodyTimeout instead");
        }
        if (idleTimeout !== void 0) {
          throw new InvalidArgumentError("unsupported idleTimeout, use keepAliveTimeout instead");
        }
        if (maxKeepAliveTimeout !== void 0) {
          throw new InvalidArgumentError("unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead");
        }
        if (maxHeaderSize != null && !Number.isFinite(maxHeaderSize)) {
          throw new InvalidArgumentError("invalid maxHeaderSize");
        }
        if (socketPath != null && typeof socketPath !== "string") {
          throw new InvalidArgumentError("invalid socketPath");
        }
        if (connectTimeout != null && (!Number.isFinite(connectTimeout) || connectTimeout < 0)) {
          throw new InvalidArgumentError("invalid connectTimeout");
        }
        if (keepAliveTimeout != null && (!Number.isFinite(keepAliveTimeout) || keepAliveTimeout <= 0)) {
          throw new InvalidArgumentError("invalid keepAliveTimeout");
        }
        if (keepAliveMaxTimeout != null && (!Number.isFinite(keepAliveMaxTimeout) || keepAliveMaxTimeout <= 0)) {
          throw new InvalidArgumentError("invalid keepAliveMaxTimeout");
        }
        if (keepAliveTimeoutThreshold != null && !Number.isFinite(keepAliveTimeoutThreshold)) {
          throw new InvalidArgumentError("invalid keepAliveTimeoutThreshold");
        }
        if (headersTimeout != null && (!Number.isInteger(headersTimeout) || headersTimeout < 0)) {
          throw new InvalidArgumentError("headersTimeout must be a positive integer or zero");
        }
        if (bodyTimeout != null && (!Number.isInteger(bodyTimeout) || bodyTimeout < 0)) {
          throw new InvalidArgumentError("bodyTimeout must be a positive integer or zero");
        }
        if (connect3 != null && typeof connect3 !== "function" && typeof connect3 !== "object") {
          throw new InvalidArgumentError("connect must be a function or an object");
        }
        if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
          throw new InvalidArgumentError("maxRedirections must be a positive number");
        }
        if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0)) {
          throw new InvalidArgumentError("maxRequestsPerClient must be a positive number");
        }
        if (localAddress != null && (typeof localAddress !== "string" || net3.isIP(localAddress) === 0)) {
          throw new InvalidArgumentError("localAddress must be valid string IP address");
        }
        if (maxResponseSize != null && (!Number.isInteger(maxResponseSize) || maxResponseSize < -1)) {
          throw new InvalidArgumentError("maxResponseSize must be a positive number");
        }
        if (autoSelectFamilyAttemptTimeout != null && (!Number.isInteger(autoSelectFamilyAttemptTimeout) || autoSelectFamilyAttemptTimeout < -1)) {
          throw new InvalidArgumentError("autoSelectFamilyAttemptTimeout must be a positive number");
        }
        if (allowH2 != null && typeof allowH2 !== "boolean") {
          throw new InvalidArgumentError("allowH2 must be a valid boolean value");
        }
        if (maxConcurrentStreams != null && (typeof maxConcurrentStreams !== "number" || maxConcurrentStreams < 1)) {
          throw new InvalidArgumentError("maxConcurrentStreams must be a possitive integer, greater than 0");
        }
        if (typeof connect3 !== "function") {
          connect3 = buildConnector({
            ...tls,
            maxCachedSessions,
            allowH2,
            socketPath,
            timeout: connectTimeout,
            ...util4.nodeHasAutoSelectFamily && autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
            ...connect3
          });
        }
        this[kInterceptors] = interceptors && interceptors.Client && Array.isArray(interceptors.Client) ? interceptors.Client : [createRedirectInterceptor({ maxRedirections })];
        this[kUrl] = util4.parseOrigin(url4);
        this[kConnector] = connect3;
        this[kSocket] = null;
        this[kPipelining] = pipelining != null ? pipelining : 1;
        this[kMaxHeadersSize] = maxHeaderSize || http4.maxHeaderSize;
        this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4e3 : keepAliveTimeout;
        this[kKeepAliveMaxTimeout] = keepAliveMaxTimeout == null ? 6e5 : keepAliveMaxTimeout;
        this[kKeepAliveTimeoutThreshold] = keepAliveTimeoutThreshold == null ? 1e3 : keepAliveTimeoutThreshold;
        this[kKeepAliveTimeoutValue] = this[kKeepAliveDefaultTimeout];
        this[kServerName] = null;
        this[kLocalAddress] = localAddress != null ? localAddress : null;
        this[kResuming] = 0;
        this[kNeedDrain] = 0;
        this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}\r
`;
        this[kBodyTimeout] = bodyTimeout != null ? bodyTimeout : 3e5;
        this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 3e5;
        this[kStrictContentLength] = strictContentLength == null ? true : strictContentLength;
        this[kMaxRedirections] = maxRedirections;
        this[kMaxRequests] = maxRequestsPerClient;
        this[kClosedResolve] = null;
        this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1;
        this[kHTTPConnVersion] = "h1";
        this[kHTTP2Session] = null;
        this[kHTTP2SessionState] = !allowH2 ? null : {
          // streams: null, // Fixed queue of streams - For future support of `push`
          openStreams: 0,
          // Keep track of them to decide wether or not unref the session
          maxConcurrentStreams: maxConcurrentStreams != null ? maxConcurrentStreams : 100
          // Max peerConcurrentStreams for a Node h2 server
        };
        this[kHost] = `${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}`;
        this[kQueue] = [];
        this[kRunningIdx] = 0;
        this[kPendingIdx] = 0;
      }
      get pipelining() {
        return this[kPipelining];
      }
      set pipelining(value) {
        this[kPipelining] = value;
        resume(this, true);
      }
      get [kPending]() {
        return this[kQueue].length - this[kPendingIdx];
      }
      get [kRunning]() {
        return this[kPendingIdx] - this[kRunningIdx];
      }
      get [kSize]() {
        return this[kQueue].length - this[kRunningIdx];
      }
      get [kConnected]() {
        return !!this[kSocket] && !this[kConnecting] && !this[kSocket].destroyed;
      }
      get [kBusy]() {
        const socket = this[kSocket];
        return socket && (socket[kReset2] || socket[kWriting] || socket[kBlocking]) || this[kSize] >= (this[kPipelining] || 1) || this[kPending] > 0;
      }
      /* istanbul ignore: only used for test */
      [kConnect](cb) {
        connect2(this);
        this.once("connect", cb);
      }
      [kDispatch](opts, handler30) {
        const origin = opts.origin || this[kUrl].origin;
        const request3 = this[kHTTPConnVersion] === "h2" ? Request3[kHTTP2BuildRequest](origin, opts, handler30) : Request3[kHTTP1BuildRequest](origin, opts, handler30);
        this[kQueue].push(request3);
        if (this[kResuming]) {
        } else if (util4.bodyLength(request3.body) == null && util4.isIterable(request3.body)) {
          this[kResuming] = 1;
          process.nextTick(resume, this);
        } else {
          resume(this, true);
        }
        if (this[kResuming] && this[kNeedDrain] !== 2 && this[kBusy]) {
          this[kNeedDrain] = 2;
        }
        return this[kNeedDrain] < 2;
      }
      async [kClose]() {
        return new Promise((resolve19) => {
          if (!this[kSize]) {
            resolve19(null);
          } else {
            this[kClosedResolve] = resolve19;
          }
        });
      }
      async [kDestroy](err) {
        return new Promise((resolve19) => {
          const requests = this[kQueue].splice(this[kPendingIdx]);
          for (let i = 0; i < requests.length; i++) {
            const request3 = requests[i];
            errorRequest(this, request3, err);
          }
          const callback = /* @__PURE__ */ __name(() => {
            if (this[kClosedResolve]) {
              this[kClosedResolve]();
              this[kClosedResolve] = null;
            }
            resolve19();
          }, "callback");
          if (this[kHTTP2Session] != null) {
            util4.destroy(this[kHTTP2Session], err);
            this[kHTTP2Session] = null;
            this[kHTTP2SessionState] = null;
          }
          if (!this[kSocket]) {
            queueMicrotask(callback);
          } else {
            util4.destroy(this[kSocket].on("close", callback), err);
          }
          resume(this);
        });
      }
    };
    __name(Client, "Client");
    function onHttp2SessionError(err) {
      assert27(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
      this[kSocket][kError] = err;
      onError(this[kClient], err);
    }
    __name(onHttp2SessionError, "onHttp2SessionError");
    function onHttp2FrameError(type, code, id) {
      const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`);
      if (id === 0) {
        this[kSocket][kError] = err;
        onError(this[kClient], err);
      }
    }
    __name(onHttp2FrameError, "onHttp2FrameError");
    function onHttp2SessionEnd() {
      util4.destroy(this, new SocketError("other side closed"));
      util4.destroy(this[kSocket], new SocketError("other side closed"));
    }
    __name(onHttp2SessionEnd, "onHttp2SessionEnd");
    function onHTTP2GoAway(code) {
      const client = this[kClient];
      const err = new InformationalError(`HTTP/2: "GOAWAY" frame received with code ${code}`);
      client[kSocket] = null;
      client[kHTTP2Session] = null;
      if (client.destroyed) {
        assert27(this[kPending] === 0);
        const requests = client[kQueue].splice(client[kRunningIdx]);
        for (let i = 0; i < requests.length; i++) {
          const request3 = requests[i];
          errorRequest(this, request3, err);
        }
      } else if (client[kRunning] > 0) {
        const request3 = client[kQueue][client[kRunningIdx]];
        client[kQueue][client[kRunningIdx]++] = null;
        errorRequest(client, request3, err);
      }
      client[kPendingIdx] = client[kRunningIdx];
      assert27(client[kRunning] === 0);
      client.emit(
        "disconnect",
        client[kUrl],
        [client],
        err
      );
      resume(client);
    }
    __name(onHTTP2GoAway, "onHTTP2GoAway");
    var constants3 = require_constants10();
    var createRedirectInterceptor = require_redirectInterceptor2();
    var EMPTY_BUF = Buffer.alloc(0);
    async function lazyllhttp() {
      const llhttpWasmData = process.env.JEST_WORKER_ID ? require_llhttp_wasm2() : void 0;
      let mod;
      try {
        mod = await WebAssembly.compile(Buffer.from(require_llhttp_simd_wasm2(), "base64"));
      } catch (e3) {
        mod = await WebAssembly.compile(Buffer.from(llhttpWasmData || require_llhttp_wasm2(), "base64"));
      }
      return await WebAssembly.instantiate(mod, {
        env: {
          /* eslint-disable camelcase */
          wasm_on_url: (p2, at, len) => {
            return 0;
          },
          wasm_on_status: (p2, at, len) => {
            assert27.strictEqual(currentParser.ptr, p2);
            const start = at - currentBufferPtr + currentBufferRef.byteOffset;
            return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
          },
          wasm_on_message_begin: (p2) => {
            assert27.strictEqual(currentParser.ptr, p2);
            return currentParser.onMessageBegin() || 0;
          },
          wasm_on_header_field: (p2, at, len) => {
            assert27.strictEqual(currentParser.ptr, p2);
            const start = at - currentBufferPtr + currentBufferRef.byteOffset;
            return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
          },
          wasm_on_header_value: (p2, at, len) => {
            assert27.strictEqual(currentParser.ptr, p2);
            const start = at - currentBufferPtr + currentBufferRef.byteOffset;
            return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
          },
          wasm_on_headers_complete: (p2, statusCode, upgrade, shouldKeepAlive) => {
            assert27.strictEqual(currentParser.ptr, p2);
            return currentParser.onHeadersComplete(statusCode, Boolean(upgrade), Boolean(shouldKeepAlive)) || 0;
          },
          wasm_on_body: (p2, at, len) => {
            assert27.strictEqual(currentParser.ptr, p2);
            const start = at - currentBufferPtr + currentBufferRef.byteOffset;
            return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
          },
          wasm_on_message_complete: (p2) => {
            assert27.strictEqual(currentParser.ptr, p2);
            return currentParser.onMessageComplete() || 0;
          }
          /* eslint-enable camelcase */
        }
      });
    }
    __name(lazyllhttp, "lazyllhttp");
    var llhttpInstance = null;
    var llhttpPromise = lazyllhttp();
    llhttpPromise.catch();
    var currentParser = null;
    var currentBufferRef = null;
    var currentBufferSize = 0;
    var currentBufferPtr = null;
    var TIMEOUT_HEADERS = 1;
    var TIMEOUT_BODY = 2;
    var TIMEOUT_IDLE = 3;
    var Parser2 = class {
      constructor(client, socket, { exports: exports3 }) {
        assert27(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0);
        this.llhttp = exports3;
        this.ptr = this.llhttp.llhttp_alloc(constants3.TYPE.RESPONSE);
        this.client = client;
        this.socket = socket;
        this.timeout = null;
        this.timeoutValue = null;
        this.timeoutType = null;
        this.statusCode = null;
        this.statusText = "";
        this.upgrade = false;
        this.headers = [];
        this.headersSize = 0;
        this.headersMaxSize = client[kMaxHeadersSize];
        this.shouldKeepAlive = false;
        this.paused = false;
        this.resume = this.resume.bind(this);
        this.bytesRead = 0;
        this.keepAlive = "";
        this.contentLength = "";
        this.connection = "";
        this.maxResponseSize = client[kMaxResponseSize];
      }
      setTimeout(value, type) {
        this.timeoutType = type;
        if (value !== this.timeoutValue) {
          timers.clearTimeout(this.timeout);
          if (value) {
            this.timeout = timers.setTimeout(onParserTimeout, value, this);
            if (this.timeout.unref) {
              this.timeout.unref();
            }
          } else {
            this.timeout = null;
          }
          this.timeoutValue = value;
        } else if (this.timeout) {
          if (this.timeout.refresh) {
            this.timeout.refresh();
          }
        }
      }
      resume() {
        if (this.socket.destroyed || !this.paused) {
          return;
        }
        assert27(this.ptr != null);
        assert27(currentParser == null);
        this.llhttp.llhttp_resume(this.ptr);
        assert27(this.timeoutType === TIMEOUT_BODY);
        if (this.timeout) {
          if (this.timeout.refresh) {
            this.timeout.refresh();
          }
        }
        this.paused = false;
        this.execute(this.socket.read() || EMPTY_BUF);
        this.readMore();
      }
      readMore() {
        while (!this.paused && this.ptr) {
          const chunk = this.socket.read();
          if (chunk === null) {
            break;
          }
          this.execute(chunk);
        }
      }
      execute(data) {
        assert27(this.ptr != null);
        assert27(currentParser == null);
        assert27(!this.paused);
        const { socket, llhttp } = this;
        if (data.length > currentBufferSize) {
          if (currentBufferPtr) {
            llhttp.free(currentBufferPtr);
          }
          currentBufferSize = Math.ceil(data.length / 4096) * 4096;
          currentBufferPtr = llhttp.malloc(currentBufferSize);
        }
        new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize).set(data);
        try {
          let ret;
          try {
            currentBufferRef = data;
            currentParser = this;
            ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, data.length);
          } catch (err) {
            throw err;
          } finally {
            currentParser = null;
            currentBufferRef = null;
          }
          const offset = llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr;
          if (ret === constants3.ERROR.PAUSED_UPGRADE) {
            this.onUpgrade(data.slice(offset));
          } else if (ret === constants3.ERROR.PAUSED) {
            this.paused = true;
            socket.unshift(data.slice(offset));
          } else if (ret !== constants3.ERROR.OK) {
            const ptr = llhttp.llhttp_get_error_reason(this.ptr);
            let message = "";
            if (ptr) {
              const len = new Uint8Array(llhttp.memory.buffer, ptr).indexOf(0);
              message = "Response does not match the HTTP/1.1 protocol (" + Buffer.from(llhttp.memory.buffer, ptr, len).toString() + ")";
            }
            throw new HTTPParserError(message, constants3.ERROR[ret], data.slice(offset));
          }
        } catch (err) {
          util4.destroy(socket, err);
        }
      }
      destroy() {
        assert27(this.ptr != null);
        assert27(currentParser == null);
        this.llhttp.llhttp_free(this.ptr);
        this.ptr = null;
        timers.clearTimeout(this.timeout);
        this.timeout = null;
        this.timeoutValue = null;
        this.timeoutType = null;
        this.paused = false;
      }
      onStatus(buf) {
        this.statusText = buf.toString();
      }
      onMessageBegin() {
        const { socket, client } = this;
        if (socket.destroyed) {
          return -1;
        }
        const request3 = client[kQueue][client[kRunningIdx]];
        if (!request3) {
          return -1;
        }
      }
      onHeaderField(buf) {
        const len = this.headers.length;
        if ((len & 1) === 0) {
          this.headers.push(buf);
        } else {
          this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]);
        }
        this.trackHeader(buf.length);
      }
      onHeaderValue(buf) {
        let len = this.headers.length;
        if ((len & 1) === 1) {
          this.headers.push(buf);
          len += 1;
        } else {
          this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]);
        }
        const key = this.headers[len - 2];
        if (key.length === 10 && key.toString().toLowerCase() === "keep-alive") {
          this.keepAlive += buf.toString();
        } else if (key.length === 10 && key.toString().toLowerCase() === "connection") {
          this.connection += buf.toString();
        } else if (key.length === 14 && key.toString().toLowerCase() === "content-length") {
          this.contentLength += buf.toString();
        }
        this.trackHeader(buf.length);
      }
      trackHeader(len) {
        this.headersSize += len;
        if (this.headersSize >= this.headersMaxSize) {
          util4.destroy(this.socket, new HeadersOverflowError());
        }
      }
      onUpgrade(head) {
        const { upgrade, client, socket, headers, statusCode } = this;
        assert27(upgrade);
        const request3 = client[kQueue][client[kRunningIdx]];
        assert27(request3);
        assert27(!socket.destroyed);
        assert27(socket === client[kSocket]);
        assert27(!this.paused);
        assert27(request3.upgrade || request3.method === "CONNECT");
        this.statusCode = null;
        this.statusText = "";
        this.shouldKeepAlive = null;
        assert27(this.headers.length % 2 === 0);
        this.headers = [];
        this.headersSize = 0;
        socket.unshift(head);
        socket[kParser].destroy();
        socket[kParser] = null;
        socket[kClient] = null;
        socket[kError] = null;
        socket.removeListener("error", onSocketError).removeListener("readable", onSocketReadable).removeListener("end", onSocketEnd).removeListener("close", onSocketClose);
        client[kSocket] = null;
        client[kQueue][client[kRunningIdx]++] = null;
        client.emit("disconnect", client[kUrl], [client], new InformationalError("upgrade"));
        try {
          request3.onUpgrade(statusCode, headers, socket);
        } catch (err) {
          util4.destroy(socket, err);
        }
        resume(client);
      }
      onHeadersComplete(statusCode, upgrade, shouldKeepAlive) {
        const { client, socket, headers, statusText } = this;
        if (socket.destroyed) {
          return -1;
        }
        const request3 = client[kQueue][client[kRunningIdx]];
        if (!request3) {
          return -1;
        }
        assert27(!this.upgrade);
        assert27(this.statusCode < 200);
        if (statusCode === 100) {
          util4.destroy(socket, new SocketError("bad response", util4.getSocketInfo(socket)));
          return -1;
        }
        if (upgrade && !request3.upgrade) {
          util4.destroy(socket, new SocketError("bad upgrade", util4.getSocketInfo(socket)));
          return -1;
        }
        assert27.strictEqual(this.timeoutType, TIMEOUT_HEADERS);
        this.statusCode = statusCode;
        this.shouldKeepAlive = shouldKeepAlive || // Override llhttp value which does not allow keepAlive for HEAD.
        request3.method === "HEAD" && !socket[kReset2] && this.connection.toLowerCase() === "keep-alive";
        if (this.statusCode >= 200) {
          const bodyTimeout = request3.bodyTimeout != null ? request3.bodyTimeout : client[kBodyTimeout];
          this.setTimeout(bodyTimeout, TIMEOUT_BODY);
        } else if (this.timeout) {
          if (this.timeout.refresh) {
            this.timeout.refresh();
          }
        }
        if (request3.method === "CONNECT") {
          assert27(client[kRunning] === 1);
          this.upgrade = true;
          return 2;
        }
        if (upgrade) {
          assert27(client[kRunning] === 1);
          this.upgrade = true;
          return 2;
        }
        assert27(this.headers.length % 2 === 0);
        this.headers = [];
        this.headersSize = 0;
        if (this.shouldKeepAlive && client[kPipelining]) {
          const keepAliveTimeout = this.keepAlive ? util4.parseKeepAliveTimeout(this.keepAlive) : null;
          if (keepAliveTimeout != null) {
            const timeout = Math.min(
              keepAliveTimeout - client[kKeepAliveTimeoutThreshold],
              client[kKeepAliveMaxTimeout]
            );
            if (timeout <= 0) {
              socket[kReset2] = true;
            } else {
              client[kKeepAliveTimeoutValue] = timeout;
            }
          } else {
            client[kKeepAliveTimeoutValue] = client[kKeepAliveDefaultTimeout];
          }
        } else {
          socket[kReset2] = true;
        }
        const pause = request3.onHeaders(statusCode, headers, this.resume, statusText) === false;
        if (request3.aborted) {
          return -1;
        }
        if (request3.method === "HEAD") {
          return 1;
        }
        if (statusCode < 200) {
          return 1;
        }
        if (socket[kBlocking]) {
          socket[kBlocking] = false;
          resume(client);
        }
        return pause ? constants3.ERROR.PAUSED : 0;
      }
      onBody(buf) {
        const { client, socket, statusCode, maxResponseSize } = this;
        if (socket.destroyed) {
          return -1;
        }
        const request3 = client[kQueue][client[kRunningIdx]];
        assert27(request3);
        assert27.strictEqual(this.timeoutType, TIMEOUT_BODY);
        if (this.timeout) {
          if (this.timeout.refresh) {
            this.timeout.refresh();
          }
        }
        assert27(statusCode >= 200);
        if (maxResponseSize > -1 && this.bytesRead + buf.length > maxResponseSize) {
          util4.destroy(socket, new ResponseExceededMaxSizeError());
          return -1;
        }
        this.bytesRead += buf.length;
        if (request3.onData(buf) === false) {
          return constants3.ERROR.PAUSED;
        }
      }
      onMessageComplete() {
        const { client, socket, statusCode, upgrade, headers, contentLength, bytesRead, shouldKeepAlive } = this;
        if (socket.destroyed && (!statusCode || shouldKeepAlive)) {
          return -1;
        }
        if (upgrade) {
          return;
        }
        const request3 = client[kQueue][client[kRunningIdx]];
        assert27(request3);
        assert27(statusCode >= 100);
        this.statusCode = null;
        this.statusText = "";
        this.bytesRead = 0;
        this.contentLength = "";
        this.keepAlive = "";
        this.connection = "";
        assert27(this.headers.length % 2 === 0);
        this.headers = [];
        this.headersSize = 0;
        if (statusCode < 200) {
          return;
        }
        if (request3.method !== "HEAD" && contentLength && bytesRead !== parseInt(contentLength, 10)) {
          util4.destroy(socket, new ResponseContentLengthMismatchError());
          return -1;
        }
        request3.onComplete(headers);
        client[kQueue][client[kRunningIdx]++] = null;
        if (socket[kWriting]) {
          assert27.strictEqual(client[kRunning], 0);
          util4.destroy(socket, new InformationalError("reset"));
          return constants3.ERROR.PAUSED;
        } else if (!shouldKeepAlive) {
          util4.destroy(socket, new InformationalError("reset"));
          return constants3.ERROR.PAUSED;
        } else if (socket[kReset2] && client[kRunning] === 0) {
          util4.destroy(socket, new InformationalError("reset"));
          return constants3.ERROR.PAUSED;
        } else if (client[kPipelining] === 1) {
          setImmediate(resume, client);
        } else {
          resume(client);
        }
      }
    };
    __name(Parser2, "Parser");
    function onParserTimeout(parser2) {
      const { socket, timeoutType, client } = parser2;
      if (timeoutType === TIMEOUT_HEADERS) {
        if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) {
          assert27(!parser2.paused, "cannot be paused while waiting for headers");
          util4.destroy(socket, new HeadersTimeoutError());
        }
      } else if (timeoutType === TIMEOUT_BODY) {
        if (!parser2.paused) {
          util4.destroy(socket, new BodyTimeoutError());
        }
      } else if (timeoutType === TIMEOUT_IDLE) {
        assert27(client[kRunning] === 0 && client[kKeepAliveTimeoutValue]);
        util4.destroy(socket, new InformationalError("socket idle timeout"));
      }
    }
    __name(onParserTimeout, "onParserTimeout");
    function onSocketReadable() {
      const { [kParser]: parser2 } = this;
      if (parser2) {
        parser2.readMore();
      }
    }
    __name(onSocketReadable, "onSocketReadable");
    function onSocketError(err) {
      const { [kClient]: client, [kParser]: parser2 } = this;
      assert27(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
      if (client[kHTTPConnVersion] !== "h2") {
        if (err.code === "ECONNRESET" && parser2.statusCode && !parser2.shouldKeepAlive) {
          parser2.onMessageComplete();
          return;
        }
      }
      this[kError] = err;
      onError(this[kClient], err);
    }
    __name(onSocketError, "onSocketError");
    function onError(client, err) {
      if (client[kRunning] === 0 && err.code !== "UND_ERR_INFO" && err.code !== "UND_ERR_SOCKET") {
        assert27(client[kPendingIdx] === client[kRunningIdx]);
        const requests = client[kQueue].splice(client[kRunningIdx]);
        for (let i = 0; i < requests.length; i++) {
          const request3 = requests[i];
          errorRequest(client, request3, err);
        }
        assert27(client[kSize] === 0);
      }
    }
    __name(onError, "onError");
    function onSocketEnd() {
      const { [kParser]: parser2, [kClient]: client } = this;
      if (client[kHTTPConnVersion] !== "h2") {
        if (parser2.statusCode && !parser2.shouldKeepAlive) {
          parser2.onMessageComplete();
          return;
        }
      }
      util4.destroy(this, new SocketError("other side closed", util4.getSocketInfo(this)));
    }
    __name(onSocketEnd, "onSocketEnd");
    function onSocketClose() {
      const { [kClient]: client, [kParser]: parser2 } = this;
      if (client[kHTTPConnVersion] === "h1" && parser2) {
        if (!this[kError] && parser2.statusCode && !parser2.shouldKeepAlive) {
          parser2.onMessageComplete();
        }
        this[kParser].destroy();
        this[kParser] = null;
      }
      const err = this[kError] || new SocketError("closed", util4.getSocketInfo(this));
      client[kSocket] = null;
      if (client.destroyed) {
        assert27(client[kPending] === 0);
        const requests = client[kQueue].splice(client[kRunningIdx]);
        for (let i = 0; i < requests.length; i++) {
          const request3 = requests[i];
          errorRequest(client, request3, err);
        }
      } else if (client[kRunning] > 0 && err.code !== "UND_ERR_INFO") {
        const request3 = client[kQueue][client[kRunningIdx]];
        client[kQueue][client[kRunningIdx]++] = null;
        errorRequest(client, request3, err);
      }
      client[kPendingIdx] = client[kRunningIdx];
      assert27(client[kRunning] === 0);
      client.emit("disconnect", client[kUrl], [client], err);
      resume(client);
    }
    __name(onSocketClose, "onSocketClose");
    async function connect2(client) {
      assert27(!client[kConnecting]);
      assert27(!client[kSocket]);
      let { host, hostname: hostname2, protocol, port: port2 } = client[kUrl];
      if (hostname2[0] === "[") {
        const idx = hostname2.indexOf("]");
        assert27(idx !== -1);
        const ip2 = hostname2.substring(1, idx);
        assert27(net3.isIP(ip2));
        hostname2 = ip2;
      }
      client[kConnecting] = true;
      if (channels.beforeConnect.hasSubscribers) {
        channels.beforeConnect.publish({
          connectParams: {
            host,
            hostname: hostname2,
            protocol,
            port: port2,
            servername: client[kServerName],
            localAddress: client[kLocalAddress]
          },
          connector: client[kConnector]
        });
      }
      try {
        const socket = await new Promise((resolve19, reject) => {
          client[kConnector]({
            host,
            hostname: hostname2,
            protocol,
            port: port2,
            servername: client[kServerName],
            localAddress: client[kLocalAddress]
          }, (err, socket2) => {
            if (err) {
              reject(err);
            } else {
              resolve19(socket2);
            }
          });
        });
        if (client.destroyed) {
          util4.destroy(socket.on("error", () => {
          }), new ClientDestroyedError());
          return;
        }
        client[kConnecting] = false;
        assert27(socket);
        const isH2 = socket.alpnProtocol === "h2";
        if (isH2) {
          if (!h2ExperimentalWarned) {
            h2ExperimentalWarned = true;
            process.emitWarning("H2 support is experimental, expect them to change at any time.", {
              code: "UNDICI-H2"
            });
          }
          const session = http22.connect(client[kUrl], {
            createConnection: () => socket,
            peerMaxConcurrentStreams: client[kHTTP2SessionState].maxConcurrentStreams
          });
          client[kHTTPConnVersion] = "h2";
          session[kClient] = client;
          session[kSocket] = socket;
          session.on("error", onHttp2SessionError);
          session.on("frameError", onHttp2FrameError);
          session.on("end", onHttp2SessionEnd);
          session.on("goaway", onHTTP2GoAway);
          session.on("close", onSocketClose);
          session.unref();
          client[kHTTP2Session] = session;
          socket[kHTTP2Session] = session;
        } else {
          if (!llhttpInstance) {
            llhttpInstance = await llhttpPromise;
            llhttpPromise = null;
          }
          socket[kNoRef] = false;
          socket[kWriting] = false;
          socket[kReset2] = false;
          socket[kBlocking] = false;
          socket[kParser] = new Parser2(client, socket, llhttpInstance);
        }
        socket[kCounter] = 0;
        socket[kMaxRequests] = client[kMaxRequests];
        socket[kClient] = client;
        socket[kError] = null;
        socket.on("error", onSocketError).on("readable", onSocketReadable).on("end", onSocketEnd).on("close", onSocketClose);
        client[kSocket] = socket;
        if (channels.connected.hasSubscribers) {
          channels.connected.publish({
            connectParams: {
              host,
              hostname: hostname2,
              protocol,
              port: port2,
              servername: client[kServerName],
              localAddress: client[kLocalAddress]
            },
            connector: client[kConnector],
            socket
          });
        }
        client.emit("connect", client[kUrl], [client]);
      } catch (err) {
        if (client.destroyed) {
          return;
        }
        client[kConnecting] = false;
        if (channels.connectError.hasSubscribers) {
          channels.connectError.publish({
            connectParams: {
              host,
              hostname: hostname2,
              protocol,
              port: port2,
              servername: client[kServerName],
              localAddress: client[kLocalAddress]
            },
            connector: client[kConnector],
            error: err
          });
        }
        if (err.code === "ERR_TLS_CERT_ALTNAME_INVALID") {
          assert27(client[kRunning] === 0);
          while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) {
            const request3 = client[kQueue][client[kPendingIdx]++];
            errorRequest(client, request3, err);
          }
        } else {
          onError(client, err);
        }
        client.emit("connectionError", client[kUrl], [client], err);
      }
      resume(client);
    }
    __name(connect2, "connect");
    function emitDrain(client) {
      client[kNeedDrain] = 0;
      client.emit("drain", client[kUrl], [client]);
    }
    __name(emitDrain, "emitDrain");
    function resume(client, sync) {
      if (client[kResuming] === 2) {
        return;
      }
      client[kResuming] = 2;
      _resume(client, sync);
      client[kResuming] = 0;
      if (client[kRunningIdx] > 256) {
        client[kQueue].splice(0, client[kRunningIdx]);
        client[kPendingIdx] -= client[kRunningIdx];
        client[kRunningIdx] = 0;
      }
    }
    __name(resume, "resume");
    function _resume(client, sync) {
      while (true) {
        if (client.destroyed) {
          assert27(client[kPending] === 0);
          return;
        }
        if (client[kClosedResolve] && !client[kSize]) {
          client[kClosedResolve]();
          client[kClosedResolve] = null;
          return;
        }
        const socket = client[kSocket];
        if (socket && !socket.destroyed && socket.alpnProtocol !== "h2") {
          if (client[kSize] === 0) {
            if (!socket[kNoRef] && socket.unref) {
              socket.unref();
              socket[kNoRef] = true;
            }
          } else if (socket[kNoRef] && socket.ref) {
            socket.ref();
            socket[kNoRef] = false;
          }
          if (client[kSize] === 0) {
            if (socket[kParser].timeoutType !== TIMEOUT_IDLE) {
              socket[kParser].setTimeout(client[kKeepAliveTimeoutValue], TIMEOUT_IDLE);
            }
          } else if (client[kRunning] > 0 && socket[kParser].statusCode < 200) {
            if (socket[kParser].timeoutType !== TIMEOUT_HEADERS) {
              const request4 = client[kQueue][client[kRunningIdx]];
              const headersTimeout = request4.headersTimeout != null ? request4.headersTimeout : client[kHeadersTimeout];
              socket[kParser].setTimeout(headersTimeout, TIMEOUT_HEADERS);
            }
          }
        }
        if (client[kBusy]) {
          client[kNeedDrain] = 2;
        } else if (client[kNeedDrain] === 2) {
          if (sync) {
            client[kNeedDrain] = 1;
            process.nextTick(emitDrain, client);
          } else {
            emitDrain(client);
          }
          continue;
        }
        if (client[kPending] === 0) {
          return;
        }
        if (client[kRunning] >= (client[kPipelining] || 1)) {
          return;
        }
        const request3 = client[kQueue][client[kPendingIdx]];
        if (client[kUrl].protocol === "https:" && client[kServerName] !== request3.servername) {
          if (client[kRunning] > 0) {
            return;
          }
          client[kServerName] = request3.servername;
          if (socket && socket.servername !== request3.servername) {
            util4.destroy(socket, new InformationalError("servername changed"));
            return;
          }
        }
        if (client[kConnecting]) {
          return;
        }
        if (!socket && !client[kHTTP2Session]) {
          connect2(client);
          return;
        }
        if (socket.destroyed || socket[kWriting] || socket[kReset2] || socket[kBlocking]) {
          return;
        }
        if (client[kRunning] > 0 && !request3.idempotent) {
          return;
        }
        if (client[kRunning] > 0 && (request3.upgrade || request3.method === "CONNECT")) {
          return;
        }
        if (client[kRunning] > 0 && util4.bodyLength(request3.body) !== 0 && (util4.isStream(request3.body) || util4.isAsyncIterable(request3.body))) {
          return;
        }
        if (!request3.aborted && write(client, request3)) {
          client[kPendingIdx]++;
        } else {
          client[kQueue].splice(client[kPendingIdx], 1);
        }
      }
    }
    __name(_resume, "_resume");
    function shouldSendContentLength(method) {
      return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT";
    }
    __name(shouldSendContentLength, "shouldSendContentLength");
    function write(client, request3) {
      if (client[kHTTPConnVersion] === "h2") {
        writeH2(client, client[kHTTP2Session], request3);
        return;
      }
      const { body, method, path: path67, host, upgrade, headers, blocking, reset } = request3;
      const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
      if (body && typeof body.read === "function") {
        body.read(0);
      }
      const bodyLength = util4.bodyLength(body);
      let contentLength = bodyLength;
      if (contentLength === null) {
        contentLength = request3.contentLength;
      }
      if (contentLength === 0 && !expectsPayload) {
        contentLength = null;
      }
      if (shouldSendContentLength(method) && contentLength > 0 && request3.contentLength !== null && request3.contentLength !== contentLength) {
        if (client[kStrictContentLength]) {
          errorRequest(client, request3, new RequestContentLengthMismatchError());
          return false;
        }
        process.emitWarning(new RequestContentLengthMismatchError());
      }
      const socket = client[kSocket];
      try {
        request3.onConnect((err) => {
          if (request3.aborted || request3.completed) {
            return;
          }
          errorRequest(client, request3, err || new RequestAbortedError());
          util4.destroy(socket, new InformationalError("aborted"));
        });
      } catch (err) {
        errorRequest(client, request3, err);
      }
      if (request3.aborted) {
        return false;
      }
      if (method === "HEAD") {
        socket[kReset2] = true;
      }
      if (upgrade || method === "CONNECT") {
        socket[kReset2] = true;
      }
      if (reset != null) {
        socket[kReset2] = reset;
      }
      if (client[kMaxRequests] && socket[kCounter]++ >= client[kMaxRequests]) {
        socket[kReset2] = true;
      }
      if (blocking) {
        socket[kBlocking] = true;
      }
      let header = `${method} ${path67} HTTP/1.1\r
`;
      if (typeof host === "string") {
        header += `host: ${host}\r
`;
      } else {
        header += client[kHostHeader];
      }
      if (upgrade) {
        header += `connection: upgrade\r
upgrade: ${upgrade}\r
`;
      } else if (client[kPipelining] && !socket[kReset2]) {
        header += "connection: keep-alive\r\n";
      } else {
        header += "connection: close\r\n";
      }
      if (headers) {
        header += headers;
      }
      if (channels.sendHeaders.hasSubscribers) {
        channels.sendHeaders.publish({ request: request3, headers: header, socket });
      }
      if (!body || bodyLength === 0) {
        if (contentLength === 0) {
          socket.write(`${header}content-length: 0\r
\r
`, "latin1");
        } else {
          assert27(contentLength === null, "no body must not have content length");
          socket.write(`${header}\r
`, "latin1");
        }
        request3.onRequestSent();
      } else if (util4.isBuffer(body)) {
        assert27(contentLength === body.byteLength, "buffer body must have content length");
        socket.cork();
        socket.write(`${header}content-length: ${contentLength}\r
\r
`, "latin1");
        socket.write(body);
        socket.uncork();
        request3.onBodySent(body);
        request3.onRequestSent();
        if (!expectsPayload) {
          socket[kReset2] = true;
        }
      } else if (util4.isBlobLike(body)) {
        if (typeof body.stream === "function") {
          writeIterable({ body: body.stream(), client, request: request3, socket, contentLength, header, expectsPayload });
        } else {
          writeBlob({ body, client, request: request3, socket, contentLength, header, expectsPayload });
        }
      } else if (util4.isStream(body)) {
        writeStream({ body, client, request: request3, socket, contentLength, header, expectsPayload });
      } else if (util4.isIterable(body)) {
        writeIterable({ body, client, request: request3, socket, contentLength, header, expectsPayload });
      } else {
        assert27(false);
      }
      return true;
    }
    __name(write, "write");
    function writeH2(client, session, request3) {
      const { body, method, path: path67, host, upgrade, expectContinue, signal, headers: reqHeaders } = request3;
      let headers;
      if (typeof reqHeaders === "string")
        headers = Request3[kHTTP2CopyHeaders](reqHeaders.trim());
      else
        headers = reqHeaders;
      if (upgrade) {
        errorRequest(client, request3, new Error("Upgrade not supported for H2"));
        return false;
      }
      try {
        request3.onConnect((err) => {
          if (request3.aborted || request3.completed) {
            return;
          }
          errorRequest(client, request3, err || new RequestAbortedError());
        });
      } catch (err) {
        errorRequest(client, request3, err);
      }
      if (request3.aborted) {
        return false;
      }
      let stream2;
      const h2State = client[kHTTP2SessionState];
      headers[HTTP2_HEADER_AUTHORITY] = host || client[kHost];
      headers[HTTP2_HEADER_METHOD] = method;
      if (method === "CONNECT") {
        session.ref();
        stream2 = session.request(headers, { endStream: false, signal });
        if (stream2.id && !stream2.pending) {
          request3.onUpgrade(null, null, stream2);
          ++h2State.openStreams;
        } else {
          stream2.once("ready", () => {
            request3.onUpgrade(null, null, stream2);
            ++h2State.openStreams;
          });
        }
        stream2.once("close", () => {
          h2State.openStreams -= 1;
          if (h2State.openStreams === 0)
            session.unref();
        });
        return true;
      }
      headers[HTTP2_HEADER_PATH] = path67;
      headers[HTTP2_HEADER_SCHEME] = "https";
      const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
      if (body && typeof body.read === "function") {
        body.read(0);
      }
      let contentLength = util4.bodyLength(body);
      if (contentLength == null) {
        contentLength = request3.contentLength;
      }
      if (contentLength === 0 || !expectsPayload) {
        contentLength = null;
      }
      if (shouldSendContentLength(method) && contentLength > 0 && request3.contentLength != null && request3.contentLength !== contentLength) {
        if (client[kStrictContentLength]) {
          errorRequest(client, request3, new RequestContentLengthMismatchError());
          return false;
        }
        process.emitWarning(new RequestContentLengthMismatchError());
      }
      if (contentLength != null) {
        assert27(body, "no body must not have content length");
        headers[HTTP2_HEADER_CONTENT_LENGTH] = `${contentLength}`;
      }
      session.ref();
      const shouldEndStream = method === "GET" || method === "HEAD";
      if (expectContinue) {
        headers[HTTP2_HEADER_EXPECT] = "100-continue";
        stream2 = session.request(headers, { endStream: shouldEndStream, signal });
        stream2.once("continue", writeBodyH2);
      } else {
        stream2 = session.request(headers, {
          endStream: shouldEndStream,
          signal
        });
        writeBodyH2();
      }
      ++h2State.openStreams;
      stream2.once("response", (headers2) => {
        const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers2;
        if (request3.onHeaders(Number(statusCode), realHeaders, stream2.resume.bind(stream2), "") === false) {
          stream2.pause();
        }
      });
      stream2.once("end", () => {
        request3.onComplete([]);
      });
      stream2.on("data", (chunk) => {
        if (request3.onData(chunk) === false) {
          stream2.pause();
        }
      });
      stream2.once("close", () => {
        h2State.openStreams -= 1;
        if (h2State.openStreams === 0) {
          session.unref();
        }
      });
      stream2.once("error", function(err) {
        if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) {
          h2State.streams -= 1;
          util4.destroy(stream2, err);
        }
      });
      stream2.once("frameError", (type, code) => {
        const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`);
        errorRequest(client, request3, err);
        if (client[kHTTP2Session] && !client[kHTTP2Session].destroyed && !this.closed && !this.destroyed) {
          h2State.streams -= 1;
          util4.destroy(stream2, err);
        }
      });
      return true;
      function writeBodyH2() {
        if (!body) {
          request3.onRequestSent();
        } else if (util4.isBuffer(body)) {
          assert27(contentLength === body.byteLength, "buffer body must have content length");
          stream2.cork();
          stream2.write(body);
          stream2.uncork();
          stream2.end();
          request3.onBodySent(body);
          request3.onRequestSent();
        } else if (util4.isBlobLike(body)) {
          if (typeof body.stream === "function") {
            writeIterable({
              client,
              request: request3,
              contentLength,
              h2stream: stream2,
              expectsPayload,
              body: body.stream(),
              socket: client[kSocket],
              header: ""
            });
          } else {
            writeBlob({
              body,
              client,
              request: request3,
              contentLength,
              expectsPayload,
              h2stream: stream2,
              header: "",
              socket: client[kSocket]
            });
          }
        } else if (util4.isStream(body)) {
          writeStream({
            body,
            client,
            request: request3,
            contentLength,
            expectsPayload,
            socket: client[kSocket],
            h2stream: stream2,
            header: ""
          });
        } else if (util4.isIterable(body)) {
          writeIterable({
            body,
            client,
            request: request3,
            contentLength,
            expectsPayload,
            header: "",
            h2stream: stream2,
            socket: client[kSocket]
          });
        } else {
          assert27(false);
        }
      }
      __name(writeBodyH2, "writeBodyH2");
    }
    __name(writeH2, "writeH2");
    function writeStream({ h2stream, body, client, request: request3, socket, contentLength, header, expectsPayload }) {
      assert27(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined");
      if (client[kHTTPConnVersion] === "h2") {
        let onPipeData = function(chunk) {
          request3.onBodySent(chunk);
        };
        __name(onPipeData, "onPipeData");
        const pipe = pipeline(
          body,
          h2stream,
          (err) => {
            if (err) {
              util4.destroy(body, err);
              util4.destroy(h2stream, err);
            } else {
              request3.onRequestSent();
            }
          }
        );
        pipe.on("data", onPipeData);
        pipe.once("end", () => {
          pipe.removeListener("data", onPipeData);
          util4.destroy(pipe);
        });
        return;
      }
      let finished = false;
      const writer = new AsyncWriter({ socket, request: request3, contentLength, client, expectsPayload, header });
      const onData = /* @__PURE__ */ __name(function(chunk) {
        if (finished) {
          return;
        }
        try {
          if (!writer.write(chunk) && this.pause) {
            this.pause();
          }
        } catch (err) {
          util4.destroy(this, err);
        }
      }, "onData");
      const onDrain = /* @__PURE__ */ __name(function() {
        if (finished) {
          return;
        }
        if (body.resume) {
          body.resume();
        }
      }, "onDrain");
      const onAbort = /* @__PURE__ */ __name(function() {
        if (finished) {
          return;
        }
        const err = new RequestAbortedError();
        queueMicrotask(() => onFinished(err));
      }, "onAbort");
      const onFinished = /* @__PURE__ */ __name(function(err) {
        if (finished) {
          return;
        }
        finished = true;
        assert27(socket.destroyed || socket[kWriting] && client[kRunning] <= 1);
        socket.off("drain", onDrain).off("error", onFinished);
        body.removeListener("data", onData).removeListener("end", onFinished).removeListener("error", onFinished).removeListener("close", onAbort);
        if (!err) {
          try {
            writer.end();
          } catch (er) {
            err = er;
          }
        }
        writer.destroy(err);
        if (err && (err.code !== "UND_ERR_INFO" || err.message !== "reset")) {
          util4.destroy(body, err);
        } else {
          util4.destroy(body);
        }
      }, "onFinished");
      body.on("data", onData).on("end", onFinished).on("error", onFinished).on("close", onAbort);
      if (body.resume) {
        body.resume();
      }
      socket.on("drain", onDrain).on("error", onFinished);
    }
    __name(writeStream, "writeStream");
    async function writeBlob({ h2stream, body, client, request: request3, socket, contentLength, header, expectsPayload }) {
      assert27(contentLength === body.size, "blob body must have content length");
      const isH2 = client[kHTTPConnVersion] === "h2";
      try {
        if (contentLength != null && contentLength !== body.size) {
          throw new RequestContentLengthMismatchError();
        }
        const buffer = Buffer.from(await body.arrayBuffer());
        if (isH2) {
          h2stream.cork();
          h2stream.write(buffer);
          h2stream.uncork();
        } else {
          socket.cork();
          socket.write(`${header}content-length: ${contentLength}\r
\r
`, "latin1");
          socket.write(buffer);
          socket.uncork();
        }
        request3.onBodySent(buffer);
        request3.onRequestSent();
        if (!expectsPayload) {
          socket[kReset2] = true;
        }
        resume(client);
      } catch (err) {
        util4.destroy(isH2 ? h2stream : socket, err);
      }
    }
    __name(writeBlob, "writeBlob");
    async function writeIterable({ h2stream, body, client, request: request3, socket, contentLength, header, expectsPayload }) {
      assert27(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined");
      let callback = null;
      function onDrain() {
        if (callback) {
          const cb = callback;
          callback = null;
          cb();
        }
      }
      __name(onDrain, "onDrain");
      const waitForDrain = /* @__PURE__ */ __name(() => new Promise((resolve19, reject) => {
        assert27(callback === null);
        if (socket[kError]) {
          reject(socket[kError]);
        } else {
          callback = resolve19;
        }
      }), "waitForDrain");
      if (client[kHTTPConnVersion] === "h2") {
        h2stream.on("close", onDrain).on("drain", onDrain);
        try {
          for await (const chunk of body) {
            if (socket[kError]) {
              throw socket[kError];
            }
            const res = h2stream.write(chunk);
            request3.onBodySent(chunk);
            if (!res) {
              await waitForDrain();
            }
          }
        } catch (err) {
          h2stream.destroy(err);
        } finally {
          request3.onRequestSent();
          h2stream.end();
          h2stream.off("close", onDrain).off("drain", onDrain);
        }
        return;
      }
      socket.on("close", onDrain).on("drain", onDrain);
      const writer = new AsyncWriter({ socket, request: request3, contentLength, client, expectsPayload, header });
      try {
        for await (const chunk of body) {
          if (socket[kError]) {
            throw socket[kError];
          }
          if (!writer.write(chunk)) {
            await waitForDrain();
          }
        }
        writer.end();
      } catch (err) {
        writer.destroy(err);
      } finally {
        socket.off("close", onDrain).off("drain", onDrain);
      }
    }
    __name(writeIterable, "writeIterable");
    var AsyncWriter = class {
      constructor({ socket, request: request3, contentLength, client, expectsPayload, header }) {
        this.socket = socket;
        this.request = request3;
        this.contentLength = contentLength;
        this.client = client;
        this.bytesWritten = 0;
        this.expectsPayload = expectsPayload;
        this.header = header;
        socket[kWriting] = true;
      }
      write(chunk) {
        const { socket, request: request3, contentLength, client, bytesWritten, expectsPayload, header } = this;
        if (socket[kError]) {
          throw socket[kError];
        }
        if (socket.destroyed) {
          return false;
        }
        const len = Buffer.byteLength(chunk);
        if (!len) {
          return true;
        }
        if (contentLength !== null && bytesWritten + len > contentLength) {
          if (client[kStrictContentLength]) {
            throw new RequestContentLengthMismatchError();
          }
          process.emitWarning(new RequestContentLengthMismatchError());
        }
        socket.cork();
        if (bytesWritten === 0) {
          if (!expectsPayload) {
            socket[kReset2] = true;
          }
          if (contentLength === null) {
            socket.write(`${header}transfer-encoding: chunked\r
`, "latin1");
          } else {
            socket.write(`${header}content-length: ${contentLength}\r
\r
`, "latin1");
          }
        }
        if (contentLength === null) {
          socket.write(`\r
${len.toString(16)}\r
`, "latin1");
        }
        this.bytesWritten += len;
        const ret = socket.write(chunk);
        socket.uncork();
        request3.onBodySent(chunk);
        if (!ret) {
          if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
            if (socket[kParser].timeout.refresh) {
              socket[kParser].timeout.refresh();
            }
          }
        }
        return ret;
      }
      end() {
        const { socket, contentLength, client, bytesWritten, expectsPayload, header, request: request3 } = this;
        request3.onRequestSent();
        socket[kWriting] = false;
        if (socket[kError]) {
          throw socket[kError];
        }
        if (socket.destroyed) {
          return;
        }
        if (bytesWritten === 0) {
          if (expectsPayload) {
            socket.write(`${header}content-length: 0\r
\r
`, "latin1");
          } else {
            socket.write(`${header}\r
`, "latin1");
          }
        } else if (contentLength === null) {
          socket.write("\r\n0\r\n\r\n", "latin1");
        }
        if (contentLength !== null && bytesWritten !== contentLength) {
          if (client[kStrictContentLength]) {
            throw new RequestContentLengthMismatchError();
          } else {
            process.emitWarning(new RequestContentLengthMismatchError());
          }
        }
        if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
          if (socket[kParser].timeout.refresh) {
            socket[kParser].timeout.refresh();
          }
        }
        resume(client);
      }
      destroy(err) {
        const { socket, client } = this;
        socket[kWriting] = false;
        if (err) {
          assert27(client[kRunning] <= 1, "pipeline should only contain this request");
          util4.destroy(socket, err);
        }
      }
    };
    __name(AsyncWriter, "AsyncWriter");
    function errorRequest(client, request3, err) {
      try {
        request3.onError(err);
        assert27(request3.aborted);
      } catch (err2) {
        client.emit("error", err2);
      }
    }
    __name(errorRequest, "errorRequest");
    module3.exports = Client;
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/node/fixed-queue.js
var require_fixed_queue2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/node/fixed-queue.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var kSize = 2048;
    var kMask = kSize - 1;
    var FixedCircularBuffer = class {
      constructor() {
        this.bottom = 0;
        this.top = 0;
        this.list = new Array(kSize);
        this.next = null;
      }
      isEmpty() {
        return this.top === this.bottom;
      }
      isFull() {
        return (this.top + 1 & kMask) === this.bottom;
      }
      push(data) {
        this.list[this.top] = data;
        this.top = this.top + 1 & kMask;
      }
      shift() {
        const nextItem = this.list[this.bottom];
        if (nextItem === void 0)
          return null;
        this.list[this.bottom] = void 0;
        this.bottom = this.bottom + 1 & kMask;
        return nextItem;
      }
    };
    __name(FixedCircularBuffer, "FixedCircularBuffer");
    module3.exports = /* @__PURE__ */ __name(class FixedQueue {
      constructor() {
        this.head = this.tail = new FixedCircularBuffer();
      }
      isEmpty() {
        return this.head.isEmpty();
      }
      push(data) {
        if (this.head.isFull()) {
          this.head = this.head.next = new FixedCircularBuffer();
        }
        this.head.push(data);
      }
      shift() {
        const tail = this.tail;
        const next = tail.shift();
        if (tail.isEmpty() && tail.next !== null) {
          this.tail = tail.next;
        }
        return next;
      }
    }, "FixedQueue");
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/pool-stats.js
var require_pool_stats2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/pool-stats.js"(exports2, module3) {
    init_import_meta_url();
    var { kFree, kConnected, kPending, kQueued, kRunning, kSize } = require_symbols6();
    var kPool = Symbol("pool");
    var PoolStats = class {
      constructor(pool2) {
        this[kPool] = pool2;
      }
      get connected() {
        return this[kPool][kConnected];
      }
      get free() {
        return this[kPool][kFree];
      }
      get pending() {
        return this[kPool][kPending];
      }
      get queued() {
        return this[kPool][kQueued];
      }
      get running() {
        return this[kPool][kRunning];
      }
      get size() {
        return this[kPool][kSize];
      }
    };
    __name(PoolStats, "PoolStats");
    module3.exports = PoolStats;
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/pool-base.js
var require_pool_base2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/pool-base.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var DispatcherBase = require_dispatcher_base2();
    var FixedQueue = require_fixed_queue2();
    var { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = require_symbols6();
    var PoolStats = require_pool_stats2();
    var kClients = Symbol("clients");
    var kNeedDrain = Symbol("needDrain");
    var kQueue = Symbol("queue");
    var kClosedResolve = Symbol("closed resolve");
    var kOnDrain = Symbol("onDrain");
    var kOnConnect = Symbol("onConnect");
    var kOnDisconnect = Symbol("onDisconnect");
    var kOnConnectionError = Symbol("onConnectionError");
    var kGetDispatcher = Symbol("get dispatcher");
    var kAddClient = Symbol("add client");
    var kRemoveClient = Symbol("remove client");
    var kStats = Symbol("stats");
    var PoolBase = class extends DispatcherBase {
      constructor() {
        super();
        this[kQueue] = new FixedQueue();
        this[kClients] = [];
        this[kQueued] = 0;
        const pool2 = this;
        this[kOnDrain] = /* @__PURE__ */ __name(function onDrain(origin, targets) {
          const queue = pool2[kQueue];
          let needDrain = false;
          while (!needDrain) {
            const item = queue.shift();
            if (!item) {
              break;
            }
            pool2[kQueued]--;
            needDrain = !this.dispatch(item.opts, item.handler);
          }
          this[kNeedDrain] = needDrain;
          if (!this[kNeedDrain] && pool2[kNeedDrain]) {
            pool2[kNeedDrain] = false;
            pool2.emit("drain", origin, [pool2, ...targets]);
          }
          if (pool2[kClosedResolve] && queue.isEmpty()) {
            Promise.all(pool2[kClients].map((c2) => c2.close())).then(pool2[kClosedResolve]);
          }
        }, "onDrain");
        this[kOnConnect] = (origin, targets) => {
          pool2.emit("connect", origin, [pool2, ...targets]);
        };
        this[kOnDisconnect] = (origin, targets, err) => {
          pool2.emit("disconnect", origin, [pool2, ...targets], err);
        };
        this[kOnConnectionError] = (origin, targets, err) => {
          pool2.emit("connectionError", origin, [pool2, ...targets], err);
        };
        this[kStats] = new PoolStats(this);
      }
      get [kBusy]() {
        return this[kNeedDrain];
      }
      get [kConnected]() {
        return this[kClients].filter((client) => client[kConnected]).length;
      }
      get [kFree]() {
        return this[kClients].filter((client) => client[kConnected] && !client[kNeedDrain]).length;
      }
      get [kPending]() {
        let ret = this[kQueued];
        for (const { [kPending]: pending } of this[kClients]) {
          ret += pending;
        }
        return ret;
      }
      get [kRunning]() {
        let ret = 0;
        for (const { [kRunning]: running } of this[kClients]) {
          ret += running;
        }
        return ret;
      }
      get [kSize]() {
        let ret = this[kQueued];
        for (const { [kSize]: size } of this[kClients]) {
          ret += size;
        }
        return ret;
      }
      get stats() {
        return this[kStats];
      }
      async [kClose]() {
        if (this[kQueue].isEmpty()) {
          return Promise.all(this[kClients].map((c2) => c2.close()));
        } else {
          return new Promise((resolve19) => {
            this[kClosedResolve] = resolve19;
          });
        }
      }
      async [kDestroy](err) {
        while (true) {
          const item = this[kQueue].shift();
          if (!item) {
            break;
          }
          item.handler.onError(err);
        }
        return Promise.all(this[kClients].map((c2) => c2.destroy(err)));
      }
      [kDispatch](opts, handler30) {
        const dispatcher = this[kGetDispatcher]();
        if (!dispatcher) {
          this[kNeedDrain] = true;
          this[kQueue].push({ opts, handler: handler30 });
          this[kQueued]++;
        } else if (!dispatcher.dispatch(opts, handler30)) {
          dispatcher[kNeedDrain] = true;
          this[kNeedDrain] = !this[kGetDispatcher]();
        }
        return !this[kNeedDrain];
      }
      [kAddClient](client) {
        client.on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]);
        this[kClients].push(client);
        if (this[kNeedDrain]) {
          process.nextTick(() => {
            if (this[kNeedDrain]) {
              this[kOnDrain](client[kUrl], [this, client]);
            }
          });
        }
        return this;
      }
      [kRemoveClient](client) {
        client.close(() => {
          const idx = this[kClients].indexOf(client);
          if (idx !== -1) {
            this[kClients].splice(idx, 1);
          }
        });
        this[kNeedDrain] = this[kClients].some((dispatcher) => !dispatcher[kNeedDrain] && dispatcher.closed !== true && dispatcher.destroyed !== true);
      }
    };
    __name(PoolBase, "PoolBase");
    module3.exports = {
      PoolBase,
      kClients,
      kNeedDrain,
      kAddClient,
      kRemoveClient,
      kGetDispatcher
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/pool.js
var require_pool2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/pool.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var {
      PoolBase,
      kClients,
      kNeedDrain,
      kAddClient,
      kGetDispatcher
    } = require_pool_base2();
    var Client = require_client2();
    var {
      InvalidArgumentError
    } = require_errors2();
    var util4 = require_util12();
    var { kUrl, kInterceptors } = require_symbols6();
    var buildConnector = require_connect2();
    var kOptions = Symbol("options");
    var kConnections = Symbol("connections");
    var kFactory = Symbol("factory");
    function defaultFactory(origin, opts) {
      return new Client(origin, opts);
    }
    __name(defaultFactory, "defaultFactory");
    var Pool = class extends PoolBase {
      constructor(origin, {
        connections,
        factory = defaultFactory,
        connect: connect2,
        connectTimeout,
        tls,
        maxCachedSessions,
        socketPath,
        autoSelectFamily,
        autoSelectFamilyAttemptTimeout,
        allowH2,
        ...options29
      } = {}) {
        super();
        if (connections != null && (!Number.isFinite(connections) || connections < 0)) {
          throw new InvalidArgumentError("invalid connections");
        }
        if (typeof factory !== "function") {
          throw new InvalidArgumentError("factory must be a function.");
        }
        if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") {
          throw new InvalidArgumentError("connect must be a function or an object");
        }
        if (typeof connect2 !== "function") {
          connect2 = buildConnector({
            ...tls,
            maxCachedSessions,
            allowH2,
            socketPath,
            timeout: connectTimeout,
            ...util4.nodeHasAutoSelectFamily && autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
            ...connect2
          });
        }
        this[kInterceptors] = options29.interceptors && options29.interceptors.Pool && Array.isArray(options29.interceptors.Pool) ? options29.interceptors.Pool : [];
        this[kConnections] = connections || null;
        this[kUrl] = util4.parseOrigin(origin);
        this[kOptions] = { ...util4.deepClone(options29), connect: connect2, allowH2 };
        this[kOptions].interceptors = options29.interceptors ? { ...options29.interceptors } : void 0;
        this[kFactory] = factory;
      }
      [kGetDispatcher]() {
        let dispatcher = this[kClients].find((dispatcher2) => !dispatcher2[kNeedDrain]);
        if (dispatcher) {
          return dispatcher;
        }
        if (!this[kConnections] || this[kClients].length < this[kConnections]) {
          dispatcher = this[kFactory](this[kUrl], this[kOptions]);
          this[kAddClient](dispatcher);
        }
        return dispatcher;
      }
    };
    __name(Pool, "Pool");
    module3.exports = Pool;
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/balanced-pool.js
var require_balanced_pool2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/balanced-pool.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var {
      BalancedPoolMissingUpstreamError,
      InvalidArgumentError
    } = require_errors2();
    var {
      PoolBase,
      kClients,
      kNeedDrain,
      kAddClient,
      kRemoveClient,
      kGetDispatcher
    } = require_pool_base2();
    var Pool = require_pool2();
    var { kUrl, kInterceptors } = require_symbols6();
    var { parseOrigin } = require_util12();
    var kFactory = Symbol("factory");
    var kOptions = Symbol("options");
    var kGreatestCommonDivisor = Symbol("kGreatestCommonDivisor");
    var kCurrentWeight = Symbol("kCurrentWeight");
    var kIndex = Symbol("kIndex");
    var kWeight = Symbol("kWeight");
    var kMaxWeightPerServer = Symbol("kMaxWeightPerServer");
    var kErrorPenalty = Symbol("kErrorPenalty");
    function getGreatestCommonDivisor(a, b2) {
      if (b2 === 0)
        return a;
      return getGreatestCommonDivisor(b2, a % b2);
    }
    __name(getGreatestCommonDivisor, "getGreatestCommonDivisor");
    function defaultFactory(origin, opts) {
      return new Pool(origin, opts);
    }
    __name(defaultFactory, "defaultFactory");
    var BalancedPool = class extends PoolBase {
      constructor(upstreams = [], { factory = defaultFactory, ...opts } = {}) {
        super();
        this[kOptions] = opts;
        this[kIndex] = -1;
        this[kCurrentWeight] = 0;
        this[kMaxWeightPerServer] = this[kOptions].maxWeightPerServer || 100;
        this[kErrorPenalty] = this[kOptions].errorPenalty || 15;
        if (!Array.isArray(upstreams)) {
          upstreams = [upstreams];
        }
        if (typeof factory !== "function") {
          throw new InvalidArgumentError("factory must be a function.");
        }
        this[kInterceptors] = opts.interceptors && opts.interceptors.BalancedPool && Array.isArray(opts.interceptors.BalancedPool) ? opts.interceptors.BalancedPool : [];
        this[kFactory] = factory;
        for (const upstream of upstreams) {
          this.addUpstream(upstream);
        }
        this._updateBalancedPoolStats();
      }
      addUpstream(upstream) {
        const upstreamOrigin = parseOrigin(upstream).origin;
        if (this[kClients].find((pool3) => pool3[kUrl].origin === upstreamOrigin && pool3.closed !== true && pool3.destroyed !== true)) {
          return this;
        }
        const pool2 = this[kFactory](upstreamOrigin, Object.assign({}, this[kOptions]));
        this[kAddClient](pool2);
        pool2.on("connect", () => {
          pool2[kWeight] = Math.min(this[kMaxWeightPerServer], pool2[kWeight] + this[kErrorPenalty]);
        });
        pool2.on("connectionError", () => {
          pool2[kWeight] = Math.max(1, pool2[kWeight] - this[kErrorPenalty]);
          this._updateBalancedPoolStats();
        });
        pool2.on("disconnect", (...args) => {
          const err = args[2];
          if (err && err.code === "UND_ERR_SOCKET") {
            pool2[kWeight] = Math.max(1, pool2[kWeight] - this[kErrorPenalty]);
            this._updateBalancedPoolStats();
          }
        });
        for (const client of this[kClients]) {
          client[kWeight] = this[kMaxWeightPerServer];
        }
        this._updateBalancedPoolStats();
        return this;
      }
      _updateBalancedPoolStats() {
        this[kGreatestCommonDivisor] = this[kClients].map((p2) => p2[kWeight]).reduce(getGreatestCommonDivisor, 0);
      }
      removeUpstream(upstream) {
        const upstreamOrigin = parseOrigin(upstream).origin;
        const pool2 = this[kClients].find((pool3) => pool3[kUrl].origin === upstreamOrigin && pool3.closed !== true && pool3.destroyed !== true);
        if (pool2) {
          this[kRemoveClient](pool2);
        }
        return this;
      }
      get upstreams() {
        return this[kClients].filter((dispatcher) => dispatcher.closed !== true && dispatcher.destroyed !== true).map((p2) => p2[kUrl].origin);
      }
      [kGetDispatcher]() {
        if (this[kClients].length === 0) {
          throw new BalancedPoolMissingUpstreamError();
        }
        const dispatcher = this[kClients].find((dispatcher2) => !dispatcher2[kNeedDrain] && dispatcher2.closed !== true && dispatcher2.destroyed !== true);
        if (!dispatcher) {
          return;
        }
        const allClientsBusy = this[kClients].map((pool2) => pool2[kNeedDrain]).reduce((a, b2) => a && b2, true);
        if (allClientsBusy) {
          return;
        }
        let counter = 0;
        let maxWeightIndex = this[kClients].findIndex((pool2) => !pool2[kNeedDrain]);
        while (counter++ < this[kClients].length) {
          this[kIndex] = (this[kIndex] + 1) % this[kClients].length;
          const pool2 = this[kClients][this[kIndex]];
          if (pool2[kWeight] > this[kClients][maxWeightIndex][kWeight] && !pool2[kNeedDrain]) {
            maxWeightIndex = this[kIndex];
          }
          if (this[kIndex] === 0) {
            this[kCurrentWeight] = this[kCurrentWeight] - this[kGreatestCommonDivisor];
            if (this[kCurrentWeight] <= 0) {
              this[kCurrentWeight] = this[kMaxWeightPerServer];
            }
          }
          if (pool2[kWeight] >= this[kCurrentWeight] && !pool2[kNeedDrain]) {
            return pool2;
          }
        }
        this[kCurrentWeight] = this[kClients][maxWeightIndex][kWeight];
        this[kIndex] = maxWeightIndex;
        return this[kClients][maxWeightIndex];
      }
    };
    __name(BalancedPool, "BalancedPool");
    module3.exports = BalancedPool;
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/compat/dispatcher-weakref.js
var require_dispatcher_weakref2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/compat/dispatcher-weakref.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { kConnected, kSize } = require_symbols6();
    var CompatWeakRef = class {
      constructor(value) {
        this.value = value;
      }
      deref() {
        return this.value[kConnected] === 0 && this.value[kSize] === 0 ? void 0 : this.value;
      }
    };
    __name(CompatWeakRef, "CompatWeakRef");
    var CompatFinalizer = class {
      constructor(finalizer) {
        this.finalizer = finalizer;
      }
      register(dispatcher, key) {
        if (dispatcher.on) {
          dispatcher.on("disconnect", () => {
            if (dispatcher[kConnected] === 0 && dispatcher[kSize] === 0) {
              this.finalizer(key);
            }
          });
        }
      }
    };
    __name(CompatFinalizer, "CompatFinalizer");
    module3.exports = function() {
      if (process.env.NODE_V8_COVERAGE) {
        return {
          WeakRef: CompatWeakRef,
          FinalizationRegistry: CompatFinalizer
        };
      }
      return {
        WeakRef: global.WeakRef || CompatWeakRef,
        FinalizationRegistry: global.FinalizationRegistry || CompatFinalizer
      };
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/agent.js
var require_agent2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/agent.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { InvalidArgumentError } = require_errors2();
    var { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = require_symbols6();
    var DispatcherBase = require_dispatcher_base2();
    var Pool = require_pool2();
    var Client = require_client2();
    var util4 = require_util12();
    var createRedirectInterceptor = require_redirectInterceptor2();
    var { WeakRef: WeakRef2, FinalizationRegistry: FinalizationRegistry2 } = require_dispatcher_weakref2()();
    var kOnConnect = Symbol("onConnect");
    var kOnDisconnect = Symbol("onDisconnect");
    var kOnConnectionError = Symbol("onConnectionError");
    var kMaxRedirections = Symbol("maxRedirections");
    var kOnDrain = Symbol("onDrain");
    var kFactory = Symbol("factory");
    var kFinalizer = Symbol("finalizer");
    var kOptions = Symbol("options");
    function defaultFactory(origin, opts) {
      return opts && opts.connections === 1 ? new Client(origin, opts) : new Pool(origin, opts);
    }
    __name(defaultFactory, "defaultFactory");
    var Agent = class extends DispatcherBase {
      constructor({ factory = defaultFactory, maxRedirections = 0, connect: connect2, ...options29 } = {}) {
        super();
        if (typeof factory !== "function") {
          throw new InvalidArgumentError("factory must be a function.");
        }
        if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") {
          throw new InvalidArgumentError("connect must be a function or an object");
        }
        if (!Number.isInteger(maxRedirections) || maxRedirections < 0) {
          throw new InvalidArgumentError("maxRedirections must be a positive number");
        }
        if (connect2 && typeof connect2 !== "function") {
          connect2 = { ...connect2 };
        }
        this[kInterceptors] = options29.interceptors && options29.interceptors.Agent && Array.isArray(options29.interceptors.Agent) ? options29.interceptors.Agent : [createRedirectInterceptor({ maxRedirections })];
        this[kOptions] = { ...util4.deepClone(options29), connect: connect2 };
        this[kOptions].interceptors = options29.interceptors ? { ...options29.interceptors } : void 0;
        this[kMaxRedirections] = maxRedirections;
        this[kFactory] = factory;
        this[kClients] = /* @__PURE__ */ new Map();
        this[kFinalizer] = new FinalizationRegistry2(
          /* istanbul ignore next: gc is undeterministic */
          (key) => {
            const ref = this[kClients].get(key);
            if (ref !== void 0 && ref.deref() === void 0) {
              this[kClients].delete(key);
            }
          }
        );
        const agent = this;
        this[kOnDrain] = (origin, targets) => {
          agent.emit("drain", origin, [agent, ...targets]);
        };
        this[kOnConnect] = (origin, targets) => {
          agent.emit("connect", origin, [agent, ...targets]);
        };
        this[kOnDisconnect] = (origin, targets, err) => {
          agent.emit("disconnect", origin, [agent, ...targets], err);
        };
        this[kOnConnectionError] = (origin, targets, err) => {
          agent.emit("connectionError", origin, [agent, ...targets], err);
        };
      }
      get [kRunning]() {
        let ret = 0;
        for (const ref of this[kClients].values()) {
          const client = ref.deref();
          if (client) {
            ret += client[kRunning];
          }
        }
        return ret;
      }
      [kDispatch](opts, handler30) {
        let key;
        if (opts.origin && (typeof opts.origin === "string" || opts.origin instanceof URL)) {
          key = String(opts.origin);
        } else {
          throw new InvalidArgumentError("opts.origin must be a non-empty string or URL.");
        }
        const ref = this[kClients].get(key);
        let dispatcher = ref ? ref.deref() : null;
        if (!dispatcher) {
          dispatcher = this[kFactory](opts.origin, this[kOptions]).on("drain", this[kOnDrain]).on("connect", this[kOnConnect]).on("disconnect", this[kOnDisconnect]).on("connectionError", this[kOnConnectionError]);
          this[kClients].set(key, new WeakRef2(dispatcher));
          this[kFinalizer].register(dispatcher, key);
        }
        return dispatcher.dispatch(opts, handler30);
      }
      async [kClose]() {
        const closePromises = [];
        for (const ref of this[kClients].values()) {
          const client = ref.deref();
          if (client) {
            closePromises.push(client.close());
          }
        }
        await Promise.all(closePromises);
      }
      async [kDestroy](err) {
        const destroyPromises = [];
        for (const ref of this[kClients].values()) {
          const client = ref.deref();
          if (client) {
            destroyPromises.push(client.destroy(err));
          }
        }
        await Promise.all(destroyPromises);
      }
    };
    __name(Agent, "Agent");
    module3.exports = Agent;
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/api/readable.js
var require_readable2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/api/readable.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var assert27 = require("assert");
    var { Readable: Readable2 } = require("stream");
    var { RequestAbortedError, NotSupportedError, InvalidArgumentError } = require_errors2();
    var util4 = require_util12();
    var { ReadableStreamFrom, toUSVString } = require_util12();
    var Blob6;
    var kConsume = Symbol("kConsume");
    var kReading = Symbol("kReading");
    var kBody = Symbol("kBody");
    var kAbort = Symbol("abort");
    var kContentType = Symbol("kContentType");
    var noop = /* @__PURE__ */ __name(() => {
    }, "noop");
    module3.exports = /* @__PURE__ */ __name(class BodyReadable extends Readable2 {
      constructor({
        resume,
        abort,
        contentType = "",
        highWaterMark = 64 * 1024
        // Same as nodejs fs streams.
      }) {
        super({
          autoDestroy: true,
          read: resume,
          highWaterMark
        });
        this._readableState.dataEmitted = false;
        this[kAbort] = abort;
        this[kConsume] = null;
        this[kBody] = null;
        this[kContentType] = contentType;
        this[kReading] = false;
      }
      destroy(err) {
        if (this.destroyed) {
          return this;
        }
        if (!err && !this._readableState.endEmitted) {
          err = new RequestAbortedError();
        }
        if (err) {
          this[kAbort]();
        }
        return super.destroy(err);
      }
      emit(ev, ...args) {
        if (ev === "data") {
          this._readableState.dataEmitted = true;
        } else if (ev === "error") {
          this._readableState.errorEmitted = true;
        }
        return super.emit(ev, ...args);
      }
      on(ev, ...args) {
        if (ev === "data" || ev === "readable") {
          this[kReading] = true;
        }
        return super.on(ev, ...args);
      }
      addListener(ev, ...args) {
        return this.on(ev, ...args);
      }
      off(ev, ...args) {
        const ret = super.off(ev, ...args);
        if (ev === "data" || ev === "readable") {
          this[kReading] = this.listenerCount("data") > 0 || this.listenerCount("readable") > 0;
        }
        return ret;
      }
      removeListener(ev, ...args) {
        return this.off(ev, ...args);
      }
      push(chunk) {
        if (this[kConsume] && chunk !== null && this.readableLength === 0) {
          consumePush(this[kConsume], chunk);
          return this[kReading] ? super.push(chunk) : true;
        }
        return super.push(chunk);
      }
      // https://fetch.spec.whatwg.org/#dom-body-text
      async text() {
        return consume(this, "text");
      }
      // https://fetch.spec.whatwg.org/#dom-body-json
      async json() {
        return consume(this, "json");
      }
      // https://fetch.spec.whatwg.org/#dom-body-blob
      async blob() {
        return consume(this, "blob");
      }
      // https://fetch.spec.whatwg.org/#dom-body-arraybuffer
      async arrayBuffer() {
        return consume(this, "arrayBuffer");
      }
      // https://fetch.spec.whatwg.org/#dom-body-formdata
      async formData() {
        throw new NotSupportedError();
      }
      // https://fetch.spec.whatwg.org/#dom-body-bodyused
      get bodyUsed() {
        return util4.isDisturbed(this);
      }
      // https://fetch.spec.whatwg.org/#dom-body-body
      get body() {
        if (!this[kBody]) {
          this[kBody] = ReadableStreamFrom(this);
          if (this[kConsume]) {
            this[kBody].getReader();
            assert27(this[kBody].locked);
          }
        }
        return this[kBody];
      }
      dump(opts) {
        let limit = opts && Number.isFinite(opts.limit) ? opts.limit : 262144;
        const signal = opts && opts.signal;
        if (signal) {
          try {
            if (typeof signal !== "object" || !("aborted" in signal)) {
              throw new InvalidArgumentError("signal must be an AbortSignal");
            }
            util4.throwIfAborted(signal);
          } catch (err) {
            return Promise.reject(err);
          }
        }
        if (this.closed) {
          return Promise.resolve(null);
        }
        return new Promise((resolve19, reject) => {
          const signalListenerCleanup = signal ? util4.addAbortListener(signal, () => {
            this.destroy();
          }) : noop;
          this.on("close", function() {
            signalListenerCleanup();
            if (signal && signal.aborted) {
              reject(signal.reason || Object.assign(new Error("The operation was aborted"), { name: "AbortError" }));
            } else {
              resolve19(null);
            }
          }).on("error", noop).on("data", function(chunk) {
            limit -= chunk.length;
            if (limit <= 0) {
              this.destroy();
            }
          }).resume();
        });
      }
    }, "BodyReadable");
    function isLocked(self2) {
      return self2[kBody] && self2[kBody].locked === true || self2[kConsume];
    }
    __name(isLocked, "isLocked");
    function isUnusable(self2) {
      return util4.isDisturbed(self2) || isLocked(self2);
    }
    __name(isUnusable, "isUnusable");
    async function consume(stream2, type) {
      if (isUnusable(stream2)) {
        throw new TypeError("unusable");
      }
      assert27(!stream2[kConsume]);
      return new Promise((resolve19, reject) => {
        stream2[kConsume] = {
          type,
          stream: stream2,
          resolve: resolve19,
          reject,
          length: 0,
          body: []
        };
        stream2.on("error", function(err) {
          consumeFinish(this[kConsume], err);
        }).on("close", function() {
          if (this[kConsume].body !== null) {
            consumeFinish(this[kConsume], new RequestAbortedError());
          }
        });
        process.nextTick(consumeStart, stream2[kConsume]);
      });
    }
    __name(consume, "consume");
    function consumeStart(consume2) {
      if (consume2.body === null) {
        return;
      }
      const { _readableState: state } = consume2.stream;
      for (const chunk of state.buffer) {
        consumePush(consume2, chunk);
      }
      if (state.endEmitted) {
        consumeEnd(this[kConsume]);
      } else {
        consume2.stream.on("end", function() {
          consumeEnd(this[kConsume]);
        });
      }
      consume2.stream.resume();
      while (consume2.stream.read() != null) {
      }
    }
    __name(consumeStart, "consumeStart");
    function consumeEnd(consume2) {
      const { type, body, resolve: resolve19, stream: stream2, length } = consume2;
      try {
        if (type === "text") {
          resolve19(toUSVString(Buffer.concat(body)));
        } else if (type === "json") {
          resolve19(JSON.parse(Buffer.concat(body)));
        } else if (type === "arrayBuffer") {
          const dst = new Uint8Array(length);
          let pos = 0;
          for (const buf of body) {
            dst.set(buf, pos);
            pos += buf.byteLength;
          }
          resolve19(dst.buffer);
        } else if (type === "blob") {
          if (!Blob6) {
            Blob6 = require("buffer").Blob;
          }
          resolve19(new Blob6(body, { type: stream2[kContentType] }));
        }
        consumeFinish(consume2);
      } catch (err) {
        stream2.destroy(err);
      }
    }
    __name(consumeEnd, "consumeEnd");
    function consumePush(consume2, chunk) {
      consume2.length += chunk.length;
      consume2.body.push(chunk);
    }
    __name(consumePush, "consumePush");
    function consumeFinish(consume2, err) {
      if (consume2.body === null) {
        return;
      }
      if (err) {
        consume2.reject(err);
      } else {
        consume2.resolve();
      }
      consume2.type = null;
      consume2.stream = null;
      consume2.resolve = null;
      consume2.reject = null;
      consume2.length = 0;
      consume2.body = null;
    }
    __name(consumeFinish, "consumeFinish");
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/api/util.js
var require_util14 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/api/util.js"(exports2, module3) {
    init_import_meta_url();
    var assert27 = require("assert");
    var {
      ResponseStatusCodeError
    } = require_errors2();
    var { toUSVString } = require_util12();
    async function getResolveErrorBodyCallback({ callback, body, contentType, statusCode, statusMessage, headers }) {
      assert27(body);
      let chunks = [];
      let limit = 0;
      for await (const chunk of body) {
        chunks.push(chunk);
        limit += chunk.length;
        if (limit > 128 * 1024) {
          chunks = null;
          break;
        }
      }
      if (statusCode === 204 || !contentType || !chunks) {
        process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers));
        return;
      }
      try {
        if (contentType.startsWith("application/json")) {
          const payload = JSON.parse(toUSVString(Buffer.concat(chunks)));
          process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers, payload));
          return;
        }
        if (contentType.startsWith("text/")) {
          const payload = toUSVString(Buffer.concat(chunks));
          process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers, payload));
          return;
        }
      } catch (err) {
      }
      process.nextTick(callback, new ResponseStatusCodeError(`Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ""}`, statusCode, headers));
    }
    __name(getResolveErrorBodyCallback, "getResolveErrorBodyCallback");
    module3.exports = { getResolveErrorBodyCallback };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/api/abort-signal.js
var require_abort_signal2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/api/abort-signal.js"(exports2, module3) {
    init_import_meta_url();
    var { addAbortListener } = require_util12();
    var { RequestAbortedError } = require_errors2();
    var kListener = Symbol("kListener");
    var kSignal = Symbol("kSignal");
    function abort(self2) {
      if (self2.abort) {
        self2.abort();
      } else {
        self2.onError(new RequestAbortedError());
      }
    }
    __name(abort, "abort");
    function addSignal(self2, signal) {
      self2[kSignal] = null;
      self2[kListener] = null;
      if (!signal) {
        return;
      }
      if (signal.aborted) {
        abort(self2);
        return;
      }
      self2[kSignal] = signal;
      self2[kListener] = () => {
        abort(self2);
      };
      addAbortListener(self2[kSignal], self2[kListener]);
    }
    __name(addSignal, "addSignal");
    function removeSignal(self2) {
      if (!self2[kSignal]) {
        return;
      }
      if ("removeEventListener" in self2[kSignal]) {
        self2[kSignal].removeEventListener("abort", self2[kListener]);
      } else {
        self2[kSignal].removeListener("abort", self2[kListener]);
      }
      self2[kSignal] = null;
      self2[kListener] = null;
    }
    __name(removeSignal, "removeSignal");
    module3.exports = {
      addSignal,
      removeSignal
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/api/api-request.js
var require_api_request2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/api/api-request.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var Readable2 = require_readable2();
    var {
      InvalidArgumentError,
      RequestAbortedError
    } = require_errors2();
    var util4 = require_util12();
    var { getResolveErrorBodyCallback } = require_util14();
    var { AsyncResource } = require("async_hooks");
    var { addSignal, removeSignal } = require_abort_signal2();
    var RequestHandler = class extends AsyncResource {
      constructor(opts, callback) {
        if (!opts || typeof opts !== "object") {
          throw new InvalidArgumentError("invalid opts");
        }
        const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError, highWaterMark } = opts;
        try {
          if (typeof callback !== "function") {
            throw new InvalidArgumentError("invalid callback");
          }
          if (highWaterMark && (typeof highWaterMark !== "number" || highWaterMark < 0)) {
            throw new InvalidArgumentError("invalid highWaterMark");
          }
          if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
            throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
          }
          if (method === "CONNECT") {
            throw new InvalidArgumentError("invalid method");
          }
          if (onInfo && typeof onInfo !== "function") {
            throw new InvalidArgumentError("invalid onInfo callback");
          }
          super("UNDICI_REQUEST");
        } catch (err) {
          if (util4.isStream(body)) {
            util4.destroy(body.on("error", util4.nop), err);
          }
          throw err;
        }
        this.responseHeaders = responseHeaders || null;
        this.opaque = opaque || null;
        this.callback = callback;
        this.res = null;
        this.abort = null;
        this.body = body;
        this.trailers = {};
        this.context = null;
        this.onInfo = onInfo || null;
        this.throwOnError = throwOnError;
        this.highWaterMark = highWaterMark;
        if (util4.isStream(body)) {
          body.on("error", (err) => {
            this.onError(err);
          });
        }
        addSignal(this, signal);
      }
      onConnect(abort, context2) {
        if (!this.callback) {
          throw new RequestAbortedError();
        }
        this.abort = abort;
        this.context = context2;
      }
      onHeaders(statusCode, rawHeaders, resume, statusMessage) {
        const { callback, opaque, abort, context: context2, responseHeaders, highWaterMark } = this;
        const headers = responseHeaders === "raw" ? util4.parseRawHeaders(rawHeaders) : util4.parseHeaders(rawHeaders);
        if (statusCode < 200) {
          if (this.onInfo) {
            this.onInfo({ statusCode, headers });
          }
          return;
        }
        const parsedHeaders = responseHeaders === "raw" ? util4.parseHeaders(rawHeaders) : headers;
        const contentType = parsedHeaders["content-type"];
        const body = new Readable2({ resume, abort, contentType, highWaterMark });
        this.callback = null;
        this.res = body;
        if (callback !== null) {
          if (this.throwOnError && statusCode >= 400) {
            this.runInAsyncScope(
              getResolveErrorBodyCallback,
              null,
              { callback, body, contentType, statusCode, statusMessage, headers }
            );
          } else {
            this.runInAsyncScope(callback, null, null, {
              statusCode,
              headers,
              trailers: this.trailers,
              opaque,
              body,
              context: context2
            });
          }
        }
      }
      onData(chunk) {
        const { res } = this;
        return res.push(chunk);
      }
      onComplete(trailers) {
        const { res } = this;
        removeSignal(this);
        util4.parseHeaders(trailers, this.trailers);
        res.push(null);
      }
      onError(err) {
        const { res, callback, body, opaque } = this;
        removeSignal(this);
        if (callback) {
          this.callback = null;
          queueMicrotask(() => {
            this.runInAsyncScope(callback, null, err, { opaque });
          });
        }
        if (res) {
          this.res = null;
          queueMicrotask(() => {
            util4.destroy(res, err);
          });
        }
        if (body) {
          this.body = null;
          util4.destroy(body, err);
        }
      }
    };
    __name(RequestHandler, "RequestHandler");
    function request3(opts, callback) {
      if (callback === void 0) {
        return new Promise((resolve19, reject) => {
          request3.call(this, opts, (err, data) => {
            return err ? reject(err) : resolve19(data);
          });
        });
      }
      try {
        this.dispatch(opts, new RequestHandler(opts, callback));
      } catch (err) {
        if (typeof callback !== "function") {
          throw err;
        }
        const opaque = opts && opts.opaque;
        queueMicrotask(() => callback(err, { opaque }));
      }
    }
    __name(request3, "request");
    module3.exports = request3;
    module3.exports.RequestHandler = RequestHandler;
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/api/api-stream.js
var require_api_stream2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/api/api-stream.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { finished, PassThrough } = require("stream");
    var {
      InvalidArgumentError,
      InvalidReturnValueError,
      RequestAbortedError
    } = require_errors2();
    var util4 = require_util12();
    var { getResolveErrorBodyCallback } = require_util14();
    var { AsyncResource } = require("async_hooks");
    var { addSignal, removeSignal } = require_abort_signal2();
    var StreamHandler = class extends AsyncResource {
      constructor(opts, factory, callback) {
        if (!opts || typeof opts !== "object") {
          throw new InvalidArgumentError("invalid opts");
        }
        const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError } = opts;
        try {
          if (typeof callback !== "function") {
            throw new InvalidArgumentError("invalid callback");
          }
          if (typeof factory !== "function") {
            throw new InvalidArgumentError("invalid factory");
          }
          if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
            throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
          }
          if (method === "CONNECT") {
            throw new InvalidArgumentError("invalid method");
          }
          if (onInfo && typeof onInfo !== "function") {
            throw new InvalidArgumentError("invalid onInfo callback");
          }
          super("UNDICI_STREAM");
        } catch (err) {
          if (util4.isStream(body)) {
            util4.destroy(body.on("error", util4.nop), err);
          }
          throw err;
        }
        this.responseHeaders = responseHeaders || null;
        this.opaque = opaque || null;
        this.factory = factory;
        this.callback = callback;
        this.res = null;
        this.abort = null;
        this.context = null;
        this.trailers = null;
        this.body = body;
        this.onInfo = onInfo || null;
        this.throwOnError = throwOnError || false;
        if (util4.isStream(body)) {
          body.on("error", (err) => {
            this.onError(err);
          });
        }
        addSignal(this, signal);
      }
      onConnect(abort, context2) {
        if (!this.callback) {
          throw new RequestAbortedError();
        }
        this.abort = abort;
        this.context = context2;
      }
      onHeaders(statusCode, rawHeaders, resume, statusMessage) {
        const { factory, opaque, context: context2, callback, responseHeaders } = this;
        const headers = responseHeaders === "raw" ? util4.parseRawHeaders(rawHeaders) : util4.parseHeaders(rawHeaders);
        if (statusCode < 200) {
          if (this.onInfo) {
            this.onInfo({ statusCode, headers });
          }
          return;
        }
        this.factory = null;
        let res;
        if (this.throwOnError && statusCode >= 400) {
          const parsedHeaders = responseHeaders === "raw" ? util4.parseHeaders(rawHeaders) : headers;
          const contentType = parsedHeaders["content-type"];
          res = new PassThrough();
          this.callback = null;
          this.runInAsyncScope(
            getResolveErrorBodyCallback,
            null,
            { callback, body: res, contentType, statusCode, statusMessage, headers }
          );
        } else {
          if (factory === null) {
            return;
          }
          res = this.runInAsyncScope(factory, null, {
            statusCode,
            headers,
            opaque,
            context: context2
          });
          if (!res || typeof res.write !== "function" || typeof res.end !== "function" || typeof res.on !== "function") {
            throw new InvalidReturnValueError("expected Writable");
          }
          finished(res, { readable: false }, (err) => {
            const { callback: callback2, res: res2, opaque: opaque2, trailers, abort } = this;
            this.res = null;
            if (err || !res2.readable) {
              util4.destroy(res2, err);
            }
            this.callback = null;
            this.runInAsyncScope(callback2, null, err || null, { opaque: opaque2, trailers });
            if (err) {
              abort();
            }
          });
        }
        res.on("drain", resume);
        this.res = res;
        const needDrain = res.writableNeedDrain !== void 0 ? res.writableNeedDrain : res._writableState && res._writableState.needDrain;
        return needDrain !== true;
      }
      onData(chunk) {
        const { res } = this;
        return res ? res.write(chunk) : true;
      }
      onComplete(trailers) {
        const { res } = this;
        removeSignal(this);
        if (!res) {
          return;
        }
        this.trailers = util4.parseHeaders(trailers);
        res.end();
      }
      onError(err) {
        const { res, callback, opaque, body } = this;
        removeSignal(this);
        this.factory = null;
        if (res) {
          this.res = null;
          util4.destroy(res, err);
        } else if (callback) {
          this.callback = null;
          queueMicrotask(() => {
            this.runInAsyncScope(callback, null, err, { opaque });
          });
        }
        if (body) {
          this.body = null;
          util4.destroy(body, err);
        }
      }
    };
    __name(StreamHandler, "StreamHandler");
    function stream2(opts, factory, callback) {
      if (callback === void 0) {
        return new Promise((resolve19, reject) => {
          stream2.call(this, opts, factory, (err, data) => {
            return err ? reject(err) : resolve19(data);
          });
        });
      }
      try {
        this.dispatch(opts, new StreamHandler(opts, factory, callback));
      } catch (err) {
        if (typeof callback !== "function") {
          throw err;
        }
        const opaque = opts && opts.opaque;
        queueMicrotask(() => callback(err, { opaque }));
      }
    }
    __name(stream2, "stream");
    module3.exports = stream2;
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/api/api-pipeline.js
var require_api_pipeline2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/api/api-pipeline.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var {
      Readable: Readable2,
      Duplex,
      PassThrough
    } = require("stream");
    var {
      InvalidArgumentError,
      InvalidReturnValueError,
      RequestAbortedError
    } = require_errors2();
    var util4 = require_util12();
    var { AsyncResource } = require("async_hooks");
    var { addSignal, removeSignal } = require_abort_signal2();
    var assert27 = require("assert");
    var kResume = Symbol("resume");
    var PipelineRequest = class extends Readable2 {
      constructor() {
        super({ autoDestroy: true });
        this[kResume] = null;
      }
      _read() {
        const { [kResume]: resume } = this;
        if (resume) {
          this[kResume] = null;
          resume();
        }
      }
      _destroy(err, callback) {
        this._read();
        callback(err);
      }
    };
    __name(PipelineRequest, "PipelineRequest");
    var PipelineResponse = class extends Readable2 {
      constructor(resume) {
        super({ autoDestroy: true });
        this[kResume] = resume;
      }
      _read() {
        this[kResume]();
      }
      _destroy(err, callback) {
        if (!err && !this._readableState.endEmitted) {
          err = new RequestAbortedError();
        }
        callback(err);
      }
    };
    __name(PipelineResponse, "PipelineResponse");
    var PipelineHandler = class extends AsyncResource {
      constructor(opts, handler30) {
        if (!opts || typeof opts !== "object") {
          throw new InvalidArgumentError("invalid opts");
        }
        if (typeof handler30 !== "function") {
          throw new InvalidArgumentError("invalid handler");
        }
        const { signal, method, opaque, onInfo, responseHeaders } = opts;
        if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
          throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
        }
        if (method === "CONNECT") {
          throw new InvalidArgumentError("invalid method");
        }
        if (onInfo && typeof onInfo !== "function") {
          throw new InvalidArgumentError("invalid onInfo callback");
        }
        super("UNDICI_PIPELINE");
        this.opaque = opaque || null;
        this.responseHeaders = responseHeaders || null;
        this.handler = handler30;
        this.abort = null;
        this.context = null;
        this.onInfo = onInfo || null;
        this.req = new PipelineRequest().on("error", util4.nop);
        this.ret = new Duplex({
          readableObjectMode: opts.objectMode,
          autoDestroy: true,
          read: () => {
            const { body } = this;
            if (body && body.resume) {
              body.resume();
            }
          },
          write: (chunk, encoding, callback) => {
            const { req } = this;
            if (req.push(chunk, encoding) || req._readableState.destroyed) {
              callback();
            } else {
              req[kResume] = callback;
            }
          },
          destroy: (err, callback) => {
            const { body, req, res, ret, abort } = this;
            if (!err && !ret._readableState.endEmitted) {
              err = new RequestAbortedError();
            }
            if (abort && err) {
              abort();
            }
            util4.destroy(body, err);
            util4.destroy(req, err);
            util4.destroy(res, err);
            removeSignal(this);
            callback(err);
          }
        }).on("prefinish", () => {
          const { req } = this;
          req.push(null);
        });
        this.res = null;
        addSignal(this, signal);
      }
      onConnect(abort, context2) {
        const { ret, res } = this;
        assert27(!res, "pipeline cannot be retried");
        if (ret.destroyed) {
          throw new RequestAbortedError();
        }
        this.abort = abort;
        this.context = context2;
      }
      onHeaders(statusCode, rawHeaders, resume) {
        const { opaque, handler: handler30, context: context2 } = this;
        if (statusCode < 200) {
          if (this.onInfo) {
            const headers = this.responseHeaders === "raw" ? util4.parseRawHeaders(rawHeaders) : util4.parseHeaders(rawHeaders);
            this.onInfo({ statusCode, headers });
          }
          return;
        }
        this.res = new PipelineResponse(resume);
        let body;
        try {
          this.handler = null;
          const headers = this.responseHeaders === "raw" ? util4.parseRawHeaders(rawHeaders) : util4.parseHeaders(rawHeaders);
          body = this.runInAsyncScope(handler30, null, {
            statusCode,
            headers,
            opaque,
            body: this.res,
            context: context2
          });
        } catch (err) {
          this.res.on("error", util4.nop);
          throw err;
        }
        if (!body || typeof body.on !== "function") {
          throw new InvalidReturnValueError("expected Readable");
        }
        body.on("data", (chunk) => {
          const { ret, body: body2 } = this;
          if (!ret.push(chunk) && body2.pause) {
            body2.pause();
          }
        }).on("error", (err) => {
          const { ret } = this;
          util4.destroy(ret, err);
        }).on("end", () => {
          const { ret } = this;
          ret.push(null);
        }).on("close", () => {
          const { ret } = this;
          if (!ret._readableState.ended) {
            util4.destroy(ret, new RequestAbortedError());
          }
        });
        this.body = body;
      }
      onData(chunk) {
        const { res } = this;
        return res.push(chunk);
      }
      onComplete(trailers) {
        const { res } = this;
        res.push(null);
      }
      onError(err) {
        const { ret } = this;
        this.handler = null;
        util4.destroy(ret, err);
      }
    };
    __name(PipelineHandler, "PipelineHandler");
    function pipeline(opts, handler30) {
      try {
        const pipelineHandler = new PipelineHandler(opts, handler30);
        this.dispatch({ ...opts, body: pipelineHandler.req }, pipelineHandler);
        return pipelineHandler.ret;
      } catch (err) {
        return new PassThrough().destroy(err);
      }
    }
    __name(pipeline, "pipeline");
    module3.exports = pipeline;
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/api/api-upgrade.js
var require_api_upgrade2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/api/api-upgrade.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { InvalidArgumentError, RequestAbortedError, SocketError } = require_errors2();
    var { AsyncResource } = require("async_hooks");
    var util4 = require_util12();
    var { addSignal, removeSignal } = require_abort_signal2();
    var assert27 = require("assert");
    var UpgradeHandler = class extends AsyncResource {
      constructor(opts, callback) {
        if (!opts || typeof opts !== "object") {
          throw new InvalidArgumentError("invalid opts");
        }
        if (typeof callback !== "function") {
          throw new InvalidArgumentError("invalid callback");
        }
        const { signal, opaque, responseHeaders } = opts;
        if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
          throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
        }
        super("UNDICI_UPGRADE");
        this.responseHeaders = responseHeaders || null;
        this.opaque = opaque || null;
        this.callback = callback;
        this.abort = null;
        this.context = null;
        addSignal(this, signal);
      }
      onConnect(abort, context2) {
        if (!this.callback) {
          throw new RequestAbortedError();
        }
        this.abort = abort;
        this.context = null;
      }
      onHeaders() {
        throw new SocketError("bad upgrade", null);
      }
      onUpgrade(statusCode, rawHeaders, socket) {
        const { callback, opaque, context: context2 } = this;
        assert27.strictEqual(statusCode, 101);
        removeSignal(this);
        this.callback = null;
        const headers = this.responseHeaders === "raw" ? util4.parseRawHeaders(rawHeaders) : util4.parseHeaders(rawHeaders);
        this.runInAsyncScope(callback, null, null, {
          headers,
          socket,
          opaque,
          context: context2
        });
      }
      onError(err) {
        const { callback, opaque } = this;
        removeSignal(this);
        if (callback) {
          this.callback = null;
          queueMicrotask(() => {
            this.runInAsyncScope(callback, null, err, { opaque });
          });
        }
      }
    };
    __name(UpgradeHandler, "UpgradeHandler");
    function upgrade(opts, callback) {
      if (callback === void 0) {
        return new Promise((resolve19, reject) => {
          upgrade.call(this, opts, (err, data) => {
            return err ? reject(err) : resolve19(data);
          });
        });
      }
      try {
        const upgradeHandler = new UpgradeHandler(opts, callback);
        this.dispatch({
          ...opts,
          method: opts.method || "GET",
          upgrade: opts.protocol || "Websocket"
        }, upgradeHandler);
      } catch (err) {
        if (typeof callback !== "function") {
          throw err;
        }
        const opaque = opts && opts.opaque;
        queueMicrotask(() => callback(err, { opaque }));
      }
    }
    __name(upgrade, "upgrade");
    module3.exports = upgrade;
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/api/api-connect.js
var require_api_connect2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/api/api-connect.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { AsyncResource } = require("async_hooks");
    var { InvalidArgumentError, RequestAbortedError, SocketError } = require_errors2();
    var util4 = require_util12();
    var { addSignal, removeSignal } = require_abort_signal2();
    var ConnectHandler = class extends AsyncResource {
      constructor(opts, callback) {
        if (!opts || typeof opts !== "object") {
          throw new InvalidArgumentError("invalid opts");
        }
        if (typeof callback !== "function") {
          throw new InvalidArgumentError("invalid callback");
        }
        const { signal, opaque, responseHeaders } = opts;
        if (signal && typeof signal.on !== "function" && typeof signal.addEventListener !== "function") {
          throw new InvalidArgumentError("signal must be an EventEmitter or EventTarget");
        }
        super("UNDICI_CONNECT");
        this.opaque = opaque || null;
        this.responseHeaders = responseHeaders || null;
        this.callback = callback;
        this.abort = null;
        addSignal(this, signal);
      }
      onConnect(abort, context2) {
        if (!this.callback) {
          throw new RequestAbortedError();
        }
        this.abort = abort;
        this.context = context2;
      }
      onHeaders() {
        throw new SocketError("bad connect", null);
      }
      onUpgrade(statusCode, rawHeaders, socket) {
        const { callback, opaque, context: context2 } = this;
        removeSignal(this);
        this.callback = null;
        let headers = rawHeaders;
        if (headers != null) {
          headers = this.responseHeaders === "raw" ? util4.parseRawHeaders(rawHeaders) : util4.parseHeaders(rawHeaders);
        }
        this.runInAsyncScope(callback, null, null, {
          statusCode,
          headers,
          socket,
          opaque,
          context: context2
        });
      }
      onError(err) {
        const { callback, opaque } = this;
        removeSignal(this);
        if (callback) {
          this.callback = null;
          queueMicrotask(() => {
            this.runInAsyncScope(callback, null, err, { opaque });
          });
        }
      }
    };
    __name(ConnectHandler, "ConnectHandler");
    function connect2(opts, callback) {
      if (callback === void 0) {
        return new Promise((resolve19, reject) => {
          connect2.call(this, opts, (err, data) => {
            return err ? reject(err) : resolve19(data);
          });
        });
      }
      try {
        const connectHandler = new ConnectHandler(opts, callback);
        this.dispatch({ ...opts, method: "CONNECT" }, connectHandler);
      } catch (err) {
        if (typeof callback !== "function") {
          throw err;
        }
        const opaque = opts && opts.opaque;
        queueMicrotask(() => callback(err, { opaque }));
      }
    }
    __name(connect2, "connect");
    module3.exports = connect2;
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/api/index.js
var require_api2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/api/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports.request = require_api_request2();
    module3.exports.stream = require_api_stream2();
    module3.exports.pipeline = require_api_pipeline2();
    module3.exports.upgrade = require_api_upgrade2();
    module3.exports.connect = require_api_connect2();
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/mock/mock-errors.js
var require_mock_errors2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/mock/mock-errors.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { UndiciError } = require_errors2();
    var MockNotMatchedError = class extends UndiciError {
      constructor(message) {
        super(message);
        Error.captureStackTrace(this, MockNotMatchedError);
        this.name = "MockNotMatchedError";
        this.message = message || "The request does not match any registered mock dispatches";
        this.code = "UND_MOCK_ERR_MOCK_NOT_MATCHED";
      }
    };
    __name(MockNotMatchedError, "MockNotMatchedError");
    module3.exports = {
      MockNotMatchedError
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/mock/mock-symbols.js
var require_mock_symbols2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/mock/mock-symbols.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = {
      kAgent: Symbol("agent"),
      kOptions: Symbol("options"),
      kFactory: Symbol("factory"),
      kDispatches: Symbol("dispatches"),
      kDispatchKey: Symbol("dispatch key"),
      kDefaultHeaders: Symbol("default headers"),
      kDefaultTrailers: Symbol("default trailers"),
      kContentLength: Symbol("content length"),
      kMockAgent: Symbol("mock agent"),
      kMockAgentSet: Symbol("mock agent set"),
      kMockAgentGet: Symbol("mock agent get"),
      kMockDispatch: Symbol("mock dispatch"),
      kClose: Symbol("close"),
      kOriginalClose: Symbol("original agent close"),
      kOrigin: Symbol("origin"),
      kIsMockActive: Symbol("is mock active"),
      kNetConnect: Symbol("net connect"),
      kGetNetConnect: Symbol("get net connect"),
      kConnected: Symbol("connected")
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/mock/mock-utils.js
var require_mock_utils2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/mock/mock-utils.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { MockNotMatchedError } = require_mock_errors2();
    var {
      kDispatches,
      kMockAgent,
      kOriginalDispatch,
      kOrigin,
      kGetNetConnect
    } = require_mock_symbols2();
    var { buildURL, nop } = require_util12();
    var { STATUS_CODES } = require("http");
    var {
      types: {
        isPromise: isPromise2
      }
    } = require("util");
    function matchValue(match, value) {
      if (typeof match === "string") {
        return match === value;
      }
      if (match instanceof RegExp) {
        return match.test(value);
      }
      if (typeof match === "function") {
        return match(value) === true;
      }
      return false;
    }
    __name(matchValue, "matchValue");
    function lowerCaseEntries(headers) {
      return Object.fromEntries(
        Object.entries(headers).map(([headerName, headerValue]) => {
          return [headerName.toLocaleLowerCase(), headerValue];
        })
      );
    }
    __name(lowerCaseEntries, "lowerCaseEntries");
    function getHeaderByName(headers, key) {
      if (Array.isArray(headers)) {
        for (let i = 0; i < headers.length; i += 2) {
          if (headers[i].toLocaleLowerCase() === key.toLocaleLowerCase()) {
            return headers[i + 1];
          }
        }
        return void 0;
      } else if (typeof headers.get === "function") {
        return headers.get(key);
      } else {
        return lowerCaseEntries(headers)[key.toLocaleLowerCase()];
      }
    }
    __name(getHeaderByName, "getHeaderByName");
    function buildHeadersFromArray(headers) {
      const clone = headers.slice();
      const entries = [];
      for (let index = 0; index < clone.length; index += 2) {
        entries.push([clone[index], clone[index + 1]]);
      }
      return Object.fromEntries(entries);
    }
    __name(buildHeadersFromArray, "buildHeadersFromArray");
    function matchHeaders(mockDispatch2, headers) {
      if (typeof mockDispatch2.headers === "function") {
        if (Array.isArray(headers)) {
          headers = buildHeadersFromArray(headers);
        }
        return mockDispatch2.headers(headers ? lowerCaseEntries(headers) : {});
      }
      if (typeof mockDispatch2.headers === "undefined") {
        return true;
      }
      if (typeof headers !== "object" || typeof mockDispatch2.headers !== "object") {
        return false;
      }
      for (const [matchHeaderName, matchHeaderValue] of Object.entries(mockDispatch2.headers)) {
        const headerValue = getHeaderByName(headers, matchHeaderName);
        if (!matchValue(matchHeaderValue, headerValue)) {
          return false;
        }
      }
      return true;
    }
    __name(matchHeaders, "matchHeaders");
    function safeUrl(path67) {
      if (typeof path67 !== "string") {
        return path67;
      }
      const pathSegments = path67.split("?");
      if (pathSegments.length !== 2) {
        return path67;
      }
      const qp = new URLSearchParams(pathSegments.pop());
      qp.sort();
      return [...pathSegments, qp.toString()].join("?");
    }
    __name(safeUrl, "safeUrl");
    function matchKey(mockDispatch2, { path: path67, method, body, headers }) {
      const pathMatch = matchValue(mockDispatch2.path, path67);
      const methodMatch = matchValue(mockDispatch2.method, method);
      const bodyMatch = typeof mockDispatch2.body !== "undefined" ? matchValue(mockDispatch2.body, body) : true;
      const headersMatch = matchHeaders(mockDispatch2, headers);
      return pathMatch && methodMatch && bodyMatch && headersMatch;
    }
    __name(matchKey, "matchKey");
    function getResponseData(data) {
      if (Buffer.isBuffer(data)) {
        return data;
      } else if (typeof data === "object") {
        return JSON.stringify(data);
      } else {
        return data.toString();
      }
    }
    __name(getResponseData, "getResponseData");
    function getMockDispatch(mockDispatches, key) {
      const basePath = key.query ? buildURL(key.path, key.query) : key.path;
      const resolvedPath = typeof basePath === "string" ? safeUrl(basePath) : basePath;
      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path67 }) => matchValue(safeUrl(path67), resolvedPath));
      if (matchedMockDispatches.length === 0) {
        throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`);
      }
      matchedMockDispatches = matchedMockDispatches.filter(({ method }) => matchValue(method, key.method));
      if (matchedMockDispatches.length === 0) {
        throw new MockNotMatchedError(`Mock dispatch not matched for method '${key.method}'`);
      }
      matchedMockDispatches = matchedMockDispatches.filter(({ body }) => typeof body !== "undefined" ? matchValue(body, key.body) : true);
      if (matchedMockDispatches.length === 0) {
        throw new MockNotMatchedError(`Mock dispatch not matched for body '${key.body}'`);
      }
      matchedMockDispatches = matchedMockDispatches.filter((mockDispatch2) => matchHeaders(mockDispatch2, key.headers));
      if (matchedMockDispatches.length === 0) {
        throw new MockNotMatchedError(`Mock dispatch not matched for headers '${typeof key.headers === "object" ? JSON.stringify(key.headers) : key.headers}'`);
      }
      return matchedMockDispatches[0];
    }
    __name(getMockDispatch, "getMockDispatch");
    function addMockDispatch(mockDispatches, key, data) {
      const baseData = { timesInvoked: 0, times: 1, persist: false, consumed: false };
      const replyData = typeof data === "function" ? { callback: data } : { ...data };
      const newMockDispatch = { ...baseData, ...key, pending: true, data: { error: null, ...replyData } };
      mockDispatches.push(newMockDispatch);
      return newMockDispatch;
    }
    __name(addMockDispatch, "addMockDispatch");
    function deleteMockDispatch(mockDispatches, key) {
      const index = mockDispatches.findIndex((dispatch) => {
        if (!dispatch.consumed) {
          return false;
        }
        return matchKey(dispatch, key);
      });
      if (index !== -1) {
        mockDispatches.splice(index, 1);
      }
    }
    __name(deleteMockDispatch, "deleteMockDispatch");
    function buildKey(opts) {
      const { path: path67, method, body, headers, query } = opts;
      return {
        path: path67,
        method,
        body,
        headers,
        query
      };
    }
    __name(buildKey, "buildKey");
    function generateKeyValues(data) {
      return Object.entries(data).reduce((keyValuePairs, [key, value]) => [
        ...keyValuePairs,
        Buffer.from(`${key}`),
        Array.isArray(value) ? value.map((x2) => Buffer.from(`${x2}`)) : Buffer.from(`${value}`)
      ], []);
    }
    __name(generateKeyValues, "generateKeyValues");
    function getStatusText(statusCode) {
      return STATUS_CODES[statusCode] || "unknown";
    }
    __name(getStatusText, "getStatusText");
    async function getResponse(body) {
      const buffers = [];
      for await (const data of body) {
        buffers.push(data);
      }
      return Buffer.concat(buffers).toString("utf8");
    }
    __name(getResponse, "getResponse");
    function mockDispatch(opts, handler30) {
      const key = buildKey(opts);
      const mockDispatch2 = getMockDispatch(this[kDispatches], key);
      mockDispatch2.timesInvoked++;
      if (mockDispatch2.data.callback) {
        mockDispatch2.data = { ...mockDispatch2.data, ...mockDispatch2.data.callback(opts) };
      }
      const { data: { statusCode, data, headers, trailers, error: error2 }, delay, persist } = mockDispatch2;
      const { timesInvoked, times } = mockDispatch2;
      mockDispatch2.consumed = !persist && timesInvoked >= times;
      mockDispatch2.pending = timesInvoked < times;
      if (error2 !== null) {
        deleteMockDispatch(this[kDispatches], key);
        handler30.onError(error2);
        return true;
      }
      if (typeof delay === "number" && delay > 0) {
        setTimeout(() => {
          handleReply(this[kDispatches]);
        }, delay);
      } else {
        handleReply(this[kDispatches]);
      }
      function handleReply(mockDispatches, _data = data) {
        const optsHeaders = Array.isArray(opts.headers) ? buildHeadersFromArray(opts.headers) : opts.headers;
        const body = typeof _data === "function" ? _data({ ...opts, headers: optsHeaders }) : _data;
        if (isPromise2(body)) {
          body.then((newData) => handleReply(mockDispatches, newData));
          return;
        }
        const responseData = getResponseData(body);
        const responseHeaders = generateKeyValues(headers);
        const responseTrailers = generateKeyValues(trailers);
        handler30.abort = nop;
        handler30.onHeaders(statusCode, responseHeaders, resume, getStatusText(statusCode));
        handler30.onData(Buffer.from(responseData));
        handler30.onComplete(responseTrailers);
        deleteMockDispatch(mockDispatches, key);
      }
      __name(handleReply, "handleReply");
      function resume() {
      }
      __name(resume, "resume");
      return true;
    }
    __name(mockDispatch, "mockDispatch");
    function buildMockDispatch() {
      const agent = this[kMockAgent];
      const origin = this[kOrigin];
      const originalDispatch = this[kOriginalDispatch];
      return /* @__PURE__ */ __name(function dispatch(opts, handler30) {
        if (agent.isMockActive) {
          try {
            mockDispatch.call(this, opts, handler30);
          } catch (error2) {
            if (error2 instanceof MockNotMatchedError) {
              const netConnect = agent[kGetNetConnect]();
              if (netConnect === false) {
                throw new MockNotMatchedError(`${error2.message}: subsequent request to origin ${origin} was not allowed (net.connect disabled)`);
              }
              if (checkNetConnect(netConnect, origin)) {
                originalDispatch.call(this, opts, handler30);
              } else {
                throw new MockNotMatchedError(`${error2.message}: subsequent request to origin ${origin} was not allowed (net.connect is not enabled for this origin)`);
              }
            } else {
              throw error2;
            }
          }
        } else {
          originalDispatch.call(this, opts, handler30);
        }
      }, "dispatch");
    }
    __name(buildMockDispatch, "buildMockDispatch");
    function checkNetConnect(netConnect, origin) {
      const url4 = new URL(origin);
      if (netConnect === true) {
        return true;
      } else if (Array.isArray(netConnect) && netConnect.some((matcher) => matchValue(matcher, url4.host))) {
        return true;
      }
      return false;
    }
    __name(checkNetConnect, "checkNetConnect");
    function buildMockOptions(opts) {
      if (opts) {
        const { agent, ...mockOptions } = opts;
        return mockOptions;
      }
    }
    __name(buildMockOptions, "buildMockOptions");
    module3.exports = {
      getResponseData,
      getMockDispatch,
      addMockDispatch,
      deleteMockDispatch,
      buildKey,
      generateKeyValues,
      matchValue,
      getResponse,
      getStatusText,
      mockDispatch,
      buildMockDispatch,
      checkNetConnect,
      buildMockOptions,
      getHeaderByName
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/mock/mock-interceptor.js
var require_mock_interceptor2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/mock/mock-interceptor.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { getResponseData, buildKey, addMockDispatch } = require_mock_utils2();
    var {
      kDispatches,
      kDispatchKey,
      kDefaultHeaders,
      kDefaultTrailers,
      kContentLength,
      kMockDispatch
    } = require_mock_symbols2();
    var { InvalidArgumentError } = require_errors2();
    var { buildURL } = require_util12();
    var MockScope = class {
      constructor(mockDispatch) {
        this[kMockDispatch] = mockDispatch;
      }
      /**
       * Delay a reply by a set amount in ms.
       */
      delay(waitInMs) {
        if (typeof waitInMs !== "number" || !Number.isInteger(waitInMs) || waitInMs <= 0) {
          throw new InvalidArgumentError("waitInMs must be a valid integer > 0");
        }
        this[kMockDispatch].delay = waitInMs;
        return this;
      }
      /**
       * For a defined reply, never mark as consumed.
       */
      persist() {
        this[kMockDispatch].persist = true;
        return this;
      }
      /**
       * Allow one to define a reply for a set amount of matching requests.
       */
      times(repeatTimes) {
        if (typeof repeatTimes !== "number" || !Number.isInteger(repeatTimes) || repeatTimes <= 0) {
          throw new InvalidArgumentError("repeatTimes must be a valid integer > 0");
        }
        this[kMockDispatch].times = repeatTimes;
        return this;
      }
    };
    __name(MockScope, "MockScope");
    var MockInterceptor = class {
      constructor(opts, mockDispatches) {
        if (typeof opts !== "object") {
          throw new InvalidArgumentError("opts must be an object");
        }
        if (typeof opts.path === "undefined") {
          throw new InvalidArgumentError("opts.path must be defined");
        }
        if (typeof opts.method === "undefined") {
          opts.method = "GET";
        }
        if (typeof opts.path === "string") {
          if (opts.query) {
            opts.path = buildURL(opts.path, opts.query);
          } else {
            const parsedURL = new URL(opts.path, "data://");
            opts.path = parsedURL.pathname + parsedURL.search;
          }
        }
        if (typeof opts.method === "string") {
          opts.method = opts.method.toUpperCase();
        }
        this[kDispatchKey] = buildKey(opts);
        this[kDispatches] = mockDispatches;
        this[kDefaultHeaders] = {};
        this[kDefaultTrailers] = {};
        this[kContentLength] = false;
      }
      createMockScopeDispatchData(statusCode, data, responseOptions = {}) {
        const responseData = getResponseData(data);
        const contentLength = this[kContentLength] ? { "content-length": responseData.length } : {};
        const headers = { ...this[kDefaultHeaders], ...contentLength, ...responseOptions.headers };
        const trailers = { ...this[kDefaultTrailers], ...responseOptions.trailers };
        return { statusCode, data, headers, trailers };
      }
      validateReplyParameters(statusCode, data, responseOptions) {
        if (typeof statusCode === "undefined") {
          throw new InvalidArgumentError("statusCode must be defined");
        }
        if (typeof data === "undefined") {
          throw new InvalidArgumentError("data must be defined");
        }
        if (typeof responseOptions !== "object") {
          throw new InvalidArgumentError("responseOptions must be an object");
        }
      }
      /**
       * Mock an undici request with a defined reply.
       */
      reply(replyData) {
        if (typeof replyData === "function") {
          const wrappedDefaultsCallback = /* @__PURE__ */ __name((opts) => {
            const resolvedData = replyData(opts);
            if (typeof resolvedData !== "object") {
              throw new InvalidArgumentError("reply options callback must return an object");
            }
            const { statusCode: statusCode2, data: data2 = "", responseOptions: responseOptions2 = {} } = resolvedData;
            this.validateReplyParameters(statusCode2, data2, responseOptions2);
            return {
              ...this.createMockScopeDispatchData(statusCode2, data2, responseOptions2)
            };
          }, "wrappedDefaultsCallback");
          const newMockDispatch2 = addMockDispatch(this[kDispatches], this[kDispatchKey], wrappedDefaultsCallback);
          return new MockScope(newMockDispatch2);
        }
        const [statusCode, data = "", responseOptions = {}] = [...arguments];
        this.validateReplyParameters(statusCode, data, responseOptions);
        const dispatchData = this.createMockScopeDispatchData(statusCode, data, responseOptions);
        const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], dispatchData);
        return new MockScope(newMockDispatch);
      }
      /**
       * Mock an undici request with a defined error.
       */
      replyWithError(error2) {
        if (typeof error2 === "undefined") {
          throw new InvalidArgumentError("error must be defined");
        }
        const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], { error: error2 });
        return new MockScope(newMockDispatch);
      }
      /**
       * Set default reply headers on the interceptor for subsequent replies
       */
      defaultReplyHeaders(headers) {
        if (typeof headers === "undefined") {
          throw new InvalidArgumentError("headers must be defined");
        }
        this[kDefaultHeaders] = headers;
        return this;
      }
      /**
       * Set default reply trailers on the interceptor for subsequent replies
       */
      defaultReplyTrailers(trailers) {
        if (typeof trailers === "undefined") {
          throw new InvalidArgumentError("trailers must be defined");
        }
        this[kDefaultTrailers] = trailers;
        return this;
      }
      /**
       * Set reply content length header for replies on the interceptor
       */
      replyContentLength() {
        this[kContentLength] = true;
        return this;
      }
    };
    __name(MockInterceptor, "MockInterceptor");
    module3.exports.MockInterceptor = MockInterceptor;
    module3.exports.MockScope = MockScope;
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/mock/mock-client.js
var require_mock_client2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/mock/mock-client.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { promisify: promisify2 } = require("util");
    var Client = require_client2();
    var { buildMockDispatch } = require_mock_utils2();
    var {
      kDispatches,
      kMockAgent,
      kClose,
      kOriginalClose,
      kOrigin,
      kOriginalDispatch,
      kConnected
    } = require_mock_symbols2();
    var { MockInterceptor } = require_mock_interceptor2();
    var Symbols = require_symbols6();
    var { InvalidArgumentError } = require_errors2();
    var MockClient = class extends Client {
      constructor(origin, opts) {
        super(origin, opts);
        if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") {
          throw new InvalidArgumentError("Argument opts.agent must implement Agent");
        }
        this[kMockAgent] = opts.agent;
        this[kOrigin] = origin;
        this[kDispatches] = [];
        this[kConnected] = 1;
        this[kOriginalDispatch] = this.dispatch;
        this[kOriginalClose] = this.close.bind(this);
        this.dispatch = buildMockDispatch.call(this);
        this.close = this[kClose];
      }
      get [Symbols.kConnected]() {
        return this[kConnected];
      }
      /**
       * Sets up the base interceptor for mocking replies from undici.
       */
      intercept(opts) {
        return new MockInterceptor(opts, this[kDispatches]);
      }
      async [kClose]() {
        await promisify2(this[kOriginalClose])();
        this[kConnected] = 0;
        this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
      }
    };
    __name(MockClient, "MockClient");
    module3.exports = MockClient;
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/mock/mock-pool.js
var require_mock_pool2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/mock/mock-pool.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { promisify: promisify2 } = require("util");
    var Pool = require_pool2();
    var { buildMockDispatch } = require_mock_utils2();
    var {
      kDispatches,
      kMockAgent,
      kClose,
      kOriginalClose,
      kOrigin,
      kOriginalDispatch,
      kConnected
    } = require_mock_symbols2();
    var { MockInterceptor } = require_mock_interceptor2();
    var Symbols = require_symbols6();
    var { InvalidArgumentError } = require_errors2();
    var MockPool = class extends Pool {
      constructor(origin, opts) {
        super(origin, opts);
        if (!opts || !opts.agent || typeof opts.agent.dispatch !== "function") {
          throw new InvalidArgumentError("Argument opts.agent must implement Agent");
        }
        this[kMockAgent] = opts.agent;
        this[kOrigin] = origin;
        this[kDispatches] = [];
        this[kConnected] = 1;
        this[kOriginalDispatch] = this.dispatch;
        this[kOriginalClose] = this.close.bind(this);
        this.dispatch = buildMockDispatch.call(this);
        this.close = this[kClose];
      }
      get [Symbols.kConnected]() {
        return this[kConnected];
      }
      /**
       * Sets up the base interceptor for mocking replies from undici.
       */
      intercept(opts) {
        return new MockInterceptor(opts, this[kDispatches]);
      }
      async [kClose]() {
        await promisify2(this[kOriginalClose])();
        this[kConnected] = 0;
        this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
      }
    };
    __name(MockPool, "MockPool");
    module3.exports = MockPool;
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/mock/pluralizer.js
var require_pluralizer2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/mock/pluralizer.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var singulars = {
      pronoun: "it",
      is: "is",
      was: "was",
      this: "this"
    };
    var plurals = {
      pronoun: "they",
      is: "are",
      was: "were",
      this: "these"
    };
    module3.exports = /* @__PURE__ */ __name(class Pluralizer {
      constructor(singular, plural2) {
        this.singular = singular;
        this.plural = plural2;
      }
      pluralize(count) {
        const one = count === 1;
        const keys = one ? singulars : plurals;
        const noun = one ? this.singular : this.plural;
        return { ...keys, count, noun };
      }
    }, "Pluralizer");
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/mock/pending-interceptors-formatter.js
var require_pending_interceptors_formatter2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/mock/pending-interceptors-formatter.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { Transform } = require("stream");
    var { Console: Console2 } = require("console");
    module3.exports = /* @__PURE__ */ __name(class PendingInterceptorsFormatter {
      constructor({ disableColors } = {}) {
        this.transform = new Transform({
          transform(chunk, _enc, cb) {
            cb(null, chunk);
          }
        });
        this.logger = new Console2({
          stdout: this.transform,
          inspectOptions: {
            colors: !disableColors && !process.env.CI
          }
        });
      }
      format(pendingInterceptors) {
        const withPrettyHeaders = pendingInterceptors.map(
          ({ method, path: path67, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
            Method: method,
            Origin: origin,
            Path: path67,
            "Status code": statusCode,
            Persistent: persist ? "\u2705" : "\u274C",
            Invocations: timesInvoked,
            Remaining: persist ? Infinity : times - timesInvoked
          })
        );
        this.logger.table(withPrettyHeaders);
        return this.transform.read().toString();
      }
    }, "PendingInterceptorsFormatter");
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/mock/mock-agent.js
var require_mock_agent2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/mock/mock-agent.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { kClients } = require_symbols6();
    var Agent = require_agent2();
    var {
      kAgent,
      kMockAgentSet,
      kMockAgentGet,
      kDispatches,
      kIsMockActive,
      kNetConnect,
      kGetNetConnect,
      kOptions,
      kFactory
    } = require_mock_symbols2();
    var MockClient = require_mock_client2();
    var MockPool = require_mock_pool2();
    var { matchValue, buildMockOptions } = require_mock_utils2();
    var { InvalidArgumentError, UndiciError } = require_errors2();
    var Dispatcher2 = require_dispatcher2();
    var Pluralizer = require_pluralizer2();
    var PendingInterceptorsFormatter = require_pending_interceptors_formatter2();
    var FakeWeakRef = class {
      constructor(value) {
        this.value = value;
      }
      deref() {
        return this.value;
      }
    };
    __name(FakeWeakRef, "FakeWeakRef");
    var MockAgent = class extends Dispatcher2 {
      constructor(opts) {
        super(opts);
        this[kNetConnect] = true;
        this[kIsMockActive] = true;
        if (opts && opts.agent && typeof opts.agent.dispatch !== "function") {
          throw new InvalidArgumentError("Argument opts.agent must implement Agent");
        }
        const agent = opts && opts.agent ? opts.agent : new Agent(opts);
        this[kAgent] = agent;
        this[kClients] = agent[kClients];
        this[kOptions] = buildMockOptions(opts);
      }
      get(origin) {
        let dispatcher = this[kMockAgentGet](origin);
        if (!dispatcher) {
          dispatcher = this[kFactory](origin);
          this[kMockAgentSet](origin, dispatcher);
        }
        return dispatcher;
      }
      dispatch(opts, handler30) {
        this.get(opts.origin);
        return this[kAgent].dispatch(opts, handler30);
      }
      async close() {
        await this[kAgent].close();
        this[kClients].clear();
      }
      deactivate() {
        this[kIsMockActive] = false;
      }
      activate() {
        this[kIsMockActive] = true;
      }
      enableNetConnect(matcher) {
        if (typeof matcher === "string" || typeof matcher === "function" || matcher instanceof RegExp) {
          if (Array.isArray(this[kNetConnect])) {
            this[kNetConnect].push(matcher);
          } else {
            this[kNetConnect] = [matcher];
          }
        } else if (typeof matcher === "undefined") {
          this[kNetConnect] = true;
        } else {
          throw new InvalidArgumentError("Unsupported matcher. Must be one of String|Function|RegExp.");
        }
      }
      disableNetConnect() {
        this[kNetConnect] = false;
      }
      // This is required to bypass issues caused by using global symbols - see:
      // https://github.com/nodejs/undici/issues/1447
      get isMockActive() {
        return this[kIsMockActive];
      }
      [kMockAgentSet](origin, dispatcher) {
        this[kClients].set(origin, new FakeWeakRef(dispatcher));
      }
      [kFactory](origin) {
        const mockOptions = Object.assign({ agent: this }, this[kOptions]);
        return this[kOptions] && this[kOptions].connections === 1 ? new MockClient(origin, mockOptions) : new MockPool(origin, mockOptions);
      }
      [kMockAgentGet](origin) {
        const ref = this[kClients].get(origin);
        if (ref) {
          return ref.deref();
        }
        if (typeof origin !== "string") {
          const dispatcher = this[kFactory]("http://localhost:9999");
          this[kMockAgentSet](origin, dispatcher);
          return dispatcher;
        }
        for (const [keyMatcher, nonExplicitRef] of Array.from(this[kClients])) {
          const nonExplicitDispatcher = nonExplicitRef.deref();
          if (nonExplicitDispatcher && typeof keyMatcher !== "string" && matchValue(keyMatcher, origin)) {
            const dispatcher = this[kFactory](origin);
            this[kMockAgentSet](origin, dispatcher);
            dispatcher[kDispatches] = nonExplicitDispatcher[kDispatches];
            return dispatcher;
          }
        }
      }
      [kGetNetConnect]() {
        return this[kNetConnect];
      }
      pendingInterceptors() {
        const mockAgentClients = this[kClients];
        return Array.from(mockAgentClients.entries()).flatMap(([origin, scope]) => scope.deref()[kDispatches].map((dispatch) => ({ ...dispatch, origin }))).filter(({ pending }) => pending);
      }
      assertNoPendingInterceptors({ pendingInterceptorsFormatter = new PendingInterceptorsFormatter() } = {}) {
        const pending = this.pendingInterceptors();
        if (pending.length === 0) {
          return;
        }
        const pluralizer = new Pluralizer("interceptor", "interceptors").pluralize(pending.length);
        throw new UndiciError(`
${pluralizer.count} ${pluralizer.noun} ${pluralizer.is} pending:

${pendingInterceptorsFormatter.format(pending)}
`.trim());
      }
    };
    __name(MockAgent, "MockAgent");
    module3.exports = MockAgent;
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/proxy-agent.js
var require_proxy_agent2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/proxy-agent.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { kProxy, kClose, kDestroy, kInterceptors } = require_symbols6();
    var { URL: URL7 } = require("url");
    var Agent = require_agent2();
    var Pool = require_pool2();
    var DispatcherBase = require_dispatcher_base2();
    var { InvalidArgumentError, RequestAbortedError } = require_errors2();
    var buildConnector = require_connect2();
    var kAgent = Symbol("proxy agent");
    var kClient = Symbol("proxy client");
    var kProxyHeaders = Symbol("proxy headers");
    var kRequestTls = Symbol("request tls settings");
    var kProxyTls = Symbol("proxy tls settings");
    var kConnectEndpoint = Symbol("connect endpoint function");
    function defaultProtocolPort(protocol) {
      return protocol === "https:" ? 443 : 80;
    }
    __name(defaultProtocolPort, "defaultProtocolPort");
    function buildProxyOptions(opts) {
      if (typeof opts === "string") {
        opts = { uri: opts };
      }
      if (!opts || !opts.uri) {
        throw new InvalidArgumentError("Proxy opts.uri is mandatory");
      }
      return {
        uri: opts.uri,
        protocol: opts.protocol || "https"
      };
    }
    __name(buildProxyOptions, "buildProxyOptions");
    function defaultFactory(origin, opts) {
      return new Pool(origin, opts);
    }
    __name(defaultFactory, "defaultFactory");
    var ProxyAgent2 = class extends DispatcherBase {
      constructor(opts) {
        super(opts);
        this[kProxy] = buildProxyOptions(opts);
        this[kAgent] = new Agent(opts);
        this[kInterceptors] = opts.interceptors && opts.interceptors.ProxyAgent && Array.isArray(opts.interceptors.ProxyAgent) ? opts.interceptors.ProxyAgent : [];
        if (typeof opts === "string") {
          opts = { uri: opts };
        }
        if (!opts || !opts.uri) {
          throw new InvalidArgumentError("Proxy opts.uri is mandatory");
        }
        const { clientFactory = defaultFactory } = opts;
        if (typeof clientFactory !== "function") {
          throw new InvalidArgumentError("Proxy opts.clientFactory must be a function.");
        }
        this[kRequestTls] = opts.requestTls;
        this[kProxyTls] = opts.proxyTls;
        this[kProxyHeaders] = opts.headers || {};
        const resolvedUrl = new URL7(opts.uri);
        const { origin, port: port2, host, username, password } = resolvedUrl;
        if (opts.auth && opts.token) {
          throw new InvalidArgumentError("opts.auth cannot be used in combination with opts.token");
        } else if (opts.auth) {
          this[kProxyHeaders]["proxy-authorization"] = `Basic ${opts.auth}`;
        } else if (opts.token) {
          this[kProxyHeaders]["proxy-authorization"] = opts.token;
        } else if (username && password) {
          this[kProxyHeaders]["proxy-authorization"] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString("base64")}`;
        }
        const connect2 = buildConnector({ ...opts.proxyTls });
        this[kConnectEndpoint] = buildConnector({ ...opts.requestTls });
        this[kClient] = clientFactory(resolvedUrl, { connect: connect2 });
        this[kAgent] = new Agent({
          ...opts,
          connect: async (opts2, callback) => {
            let requestedHost = opts2.host;
            if (!opts2.port) {
              requestedHost += `:${defaultProtocolPort(opts2.protocol)}`;
            }
            try {
              const { socket, statusCode } = await this[kClient].connect({
                origin,
                port: port2,
                path: requestedHost,
                signal: opts2.signal,
                headers: {
                  ...this[kProxyHeaders],
                  host
                }
              });
              if (statusCode !== 200) {
                socket.on("error", () => {
                }).destroy();
                callback(new RequestAbortedError(`Proxy response (${statusCode}) !== 200 when HTTP Tunneling`));
              }
              if (opts2.protocol !== "https:") {
                callback(null, socket);
                return;
              }
              let servername;
              if (this[kRequestTls]) {
                servername = this[kRequestTls].servername;
              } else {
                servername = opts2.servername;
              }
              this[kConnectEndpoint]({ ...opts2, servername, httpSocket: socket }, callback);
            } catch (err) {
              callback(err);
            }
          }
        });
      }
      dispatch(opts, handler30) {
        const { host } = new URL7(opts.origin);
        const headers = buildHeaders(opts.headers);
        throwIfProxyAuthIsSent(headers);
        return this[kAgent].dispatch(
          {
            ...opts,
            headers: {
              ...headers,
              host
            }
          },
          handler30
        );
      }
      async [kClose]() {
        await this[kAgent].close();
        await this[kClient].close();
      }
      async [kDestroy]() {
        await this[kAgent].destroy();
        await this[kClient].destroy();
      }
    };
    __name(ProxyAgent2, "ProxyAgent");
    function buildHeaders(headers) {
      if (Array.isArray(headers)) {
        const headersPair = {};
        for (let i = 0; i < headers.length; i += 2) {
          headersPair[headers[i]] = headers[i + 1];
        }
        return headersPair;
      }
      return headers;
    }
    __name(buildHeaders, "buildHeaders");
    function throwIfProxyAuthIsSent(headers) {
      const existProxyAuth = headers && Object.keys(headers).find((key) => key.toLowerCase() === "proxy-authorization");
      if (existProxyAuth) {
        throw new InvalidArgumentError("Proxy-Authorization should be sent in ProxyAgent constructor");
      }
    }
    __name(throwIfProxyAuthIsSent, "throwIfProxyAuthIsSent");
    module3.exports = ProxyAgent2;
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/handler/RetryHandler.js
var require_RetryHandler2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/handler/RetryHandler.js"(exports2, module3) {
    init_import_meta_url();
    var assert27 = require("assert");
    var { kRetryHandlerDefaultRetry } = require_symbols6();
    var { RequestRetryError } = require_errors2();
    var { isDisturbed, parseHeaders: parseHeaders2, parseRangeHeader } = require_util12();
    function calculateRetryAfterHeader(retryAfter) {
      const current = Date.now();
      const diff = new Date(retryAfter).getTime() - current;
      return diff;
    }
    __name(calculateRetryAfterHeader, "calculateRetryAfterHeader");
    var RetryHandler = class {
      constructor(opts, handlers2) {
        const { retryOptions, ...dispatchOpts } = opts;
        const {
          // Retry scoped
          retry: retryFn,
          maxRetries,
          maxTimeout,
          minTimeout,
          timeoutFactor,
          // Response scoped
          methods,
          errorCodes,
          retryAfter,
          statusCodes
        } = retryOptions ?? {};
        this.dispatch = handlers2.dispatch;
        this.handler = handlers2.handler;
        this.opts = dispatchOpts;
        this.abort = null;
        this.aborted = false;
        this.retryOpts = {
          retry: retryFn ?? RetryHandler[kRetryHandlerDefaultRetry],
          retryAfter: retryAfter ?? true,
          maxTimeout: maxTimeout ?? 30 * 1e3,
          // 30s,
          timeout: minTimeout ?? 500,
          // .5s
          timeoutFactor: timeoutFactor ?? 2,
          maxRetries: maxRetries ?? 5,
          // What errors we should retry
          methods: methods ?? ["GET", "HEAD", "OPTIONS", "PUT", "DELETE", "TRACE"],
          // Indicates which errors to retry
          statusCodes: statusCodes ?? [500, 502, 503, 504, 429],
          // List of errors to retry
          errorCodes: errorCodes ?? [
            "ECONNRESET",
            "ECONNREFUSED",
            "ENOTFOUND",
            "ENETDOWN",
            "ENETUNREACH",
            "EHOSTDOWN",
            "EHOSTUNREACH",
            "EPIPE"
          ]
        };
        this.retryCount = 0;
        this.start = 0;
        this.end = null;
        this.etag = null;
        this.resume = null;
        this.handler.onConnect((reason) => {
          this.aborted = true;
          if (this.abort) {
            this.abort(reason);
          } else {
            this.reason = reason;
          }
        });
      }
      onRequestSent() {
        if (this.handler.onRequestSent) {
          this.handler.onRequestSent();
        }
      }
      onUpgrade(statusCode, headers, socket) {
        if (this.handler.onUpgrade) {
          this.handler.onUpgrade(statusCode, headers, socket);
        }
      }
      onConnect(abort) {
        if (this.aborted) {
          abort(this.reason);
        } else {
          this.abort = abort;
        }
      }
      onBodySent(chunk) {
        if (this.handler.onBodySent)
          return this.handler.onBodySent(chunk);
      }
      static [kRetryHandlerDefaultRetry](err, { state, opts }, cb) {
        const { statusCode, code, headers } = err;
        const { method, retryOptions } = opts;
        const {
          maxRetries,
          timeout,
          maxTimeout,
          timeoutFactor,
          statusCodes,
          errorCodes,
          methods
        } = retryOptions;
        let { counter, currentTimeout } = state;
        currentTimeout = currentTimeout != null && currentTimeout > 0 ? currentTimeout : timeout;
        if (code && code !== "UND_ERR_REQ_RETRY" && code !== "UND_ERR_SOCKET" && !errorCodes.includes(code)) {
          cb(err);
          return;
        }
        if (Array.isArray(methods) && !methods.includes(method)) {
          cb(err);
          return;
        }
        if (statusCode != null && Array.isArray(statusCodes) && !statusCodes.includes(statusCode)) {
          cb(err);
          return;
        }
        if (counter > maxRetries) {
          cb(err);
          return;
        }
        let retryAfterHeader = headers != null && headers["retry-after"];
        if (retryAfterHeader) {
          retryAfterHeader = Number(retryAfterHeader);
          retryAfterHeader = isNaN(retryAfterHeader) ? calculateRetryAfterHeader(retryAfterHeader) : retryAfterHeader * 1e3;
        }
        const retryTimeout = retryAfterHeader > 0 ? Math.min(retryAfterHeader, maxTimeout) : Math.min(currentTimeout * timeoutFactor ** counter, maxTimeout);
        state.currentTimeout = retryTimeout;
        setTimeout(() => cb(null), retryTimeout);
      }
      onHeaders(statusCode, rawHeaders, resume, statusMessage) {
        const headers = parseHeaders2(rawHeaders);
        this.retryCount += 1;
        if (statusCode >= 300) {
          this.abort(
            new RequestRetryError("Request failed", statusCode, {
              headers,
              count: this.retryCount
            })
          );
          return false;
        }
        if (this.resume != null) {
          this.resume = null;
          if (statusCode !== 206) {
            return true;
          }
          const contentRange = parseRangeHeader(headers["content-range"]);
          if (!contentRange) {
            this.abort(
              new RequestRetryError("Content-Range mismatch", statusCode, {
                headers,
                count: this.retryCount
              })
            );
            return false;
          }
          if (this.etag != null && this.etag !== headers.etag) {
            this.abort(
              new RequestRetryError("ETag mismatch", statusCode, {
                headers,
                count: this.retryCount
              })
            );
            return false;
          }
          const { start, size, end = size } = contentRange;
          assert27(this.start === start, "content-range mismatch");
          assert27(this.end == null || this.end === end, "content-range mismatch");
          this.resume = resume;
          return true;
        }
        if (this.end == null) {
          if (statusCode === 206) {
            const range = parseRangeHeader(headers["content-range"]);
            if (range == null) {
              return this.handler.onHeaders(
                statusCode,
                rawHeaders,
                resume,
                statusMessage
              );
            }
            const { start, size, end = size } = range;
            assert27(
              start != null && Number.isFinite(start) && this.start !== start,
              "content-range mismatch"
            );
            assert27(Number.isFinite(start));
            assert27(
              end != null && Number.isFinite(end) && this.end !== end,
              "invalid content-length"
            );
            this.start = start;
            this.end = end;
          }
          if (this.end == null) {
            const contentLength = headers["content-length"];
            this.end = contentLength != null ? Number(contentLength) : null;
          }
          assert27(Number.isFinite(this.start));
          assert27(
            this.end == null || Number.isFinite(this.end),
            "invalid content-length"
          );
          this.resume = resume;
          this.etag = headers.etag != null ? headers.etag : null;
          return this.handler.onHeaders(
            statusCode,
            rawHeaders,
            resume,
            statusMessage
          );
        }
        const err = new RequestRetryError("Request failed", statusCode, {
          headers,
          count: this.retryCount
        });
        this.abort(err);
        return false;
      }
      onData(chunk) {
        this.start += chunk.length;
        return this.handler.onData(chunk);
      }
      onComplete(rawTrailers) {
        this.retryCount = 0;
        return this.handler.onComplete(rawTrailers);
      }
      onError(err) {
        if (this.aborted || isDisturbed(this.opts.body)) {
          return this.handler.onError(err);
        }
        this.retryOpts.retry(
          err,
          {
            state: { counter: this.retryCount++, currentTimeout: this.retryAfter },
            opts: { retryOptions: this.retryOpts, ...this.opts }
          },
          onRetry.bind(this)
        );
        function onRetry(err2) {
          if (err2 != null || this.aborted || isDisturbed(this.opts.body)) {
            return this.handler.onError(err2);
          }
          if (this.start !== 0) {
            this.opts = {
              ...this.opts,
              headers: {
                ...this.opts.headers,
                range: `bytes=${this.start}-${this.end ?? ""}`
              }
            };
          }
          try {
            this.dispatch(this.opts, this);
          } catch (err3) {
            this.handler.onError(err3);
          }
        }
        __name(onRetry, "onRetry");
      }
    };
    __name(RetryHandler, "RetryHandler");
    module3.exports = RetryHandler;
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/global.js
var require_global4 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/global.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var globalDispatcher = Symbol.for("undici.globalDispatcher.1");
    var { InvalidArgumentError } = require_errors2();
    var Agent = require_agent2();
    if (getGlobalDispatcher2() === void 0) {
      setGlobalDispatcher2(new Agent());
    }
    function setGlobalDispatcher2(agent) {
      if (!agent || typeof agent.dispatch !== "function") {
        throw new InvalidArgumentError("Argument agent must implement Agent");
      }
      Object.defineProperty(globalThis, globalDispatcher, {
        value: agent,
        writable: true,
        enumerable: false,
        configurable: false
      });
    }
    __name(setGlobalDispatcher2, "setGlobalDispatcher");
    function getGlobalDispatcher2() {
      return globalThis[globalDispatcher];
    }
    __name(getGlobalDispatcher2, "getGlobalDispatcher");
    module3.exports = {
      setGlobalDispatcher: setGlobalDispatcher2,
      getGlobalDispatcher: getGlobalDispatcher2
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/handler/DecoratorHandler.js
var require_DecoratorHandler2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/handler/DecoratorHandler.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(class DecoratorHandler {
      constructor(handler30) {
        this.handler = handler30;
      }
      onConnect(...args) {
        return this.handler.onConnect(...args);
      }
      onError(...args) {
        return this.handler.onError(...args);
      }
      onUpgrade(...args) {
        return this.handler.onUpgrade(...args);
      }
      onHeaders(...args) {
        return this.handler.onHeaders(...args);
      }
      onData(...args) {
        return this.handler.onData(...args);
      }
      onComplete(...args) {
        return this.handler.onComplete(...args);
      }
      onBodySent(...args) {
        return this.handler.onBodySent(...args);
      }
    }, "DecoratorHandler");
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/headers.js
var require_headers2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/headers.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { kHeadersList, kConstruct } = require_symbols6();
    var { kGuard } = require_symbols7();
    var { kEnumerableProperty } = require_util12();
    var {
      makeIterator,
      isValidHeaderName,
      isValidHeaderValue
    } = require_util13();
    var { webidl } = require_webidl2();
    var assert27 = require("assert");
    var kHeadersMap = Symbol("headers map");
    var kHeadersSortedMap = Symbol("headers map sorted");
    function isHTTPWhiteSpaceCharCode(code) {
      return code === 10 || code === 13 || code === 9 || code === 32;
    }
    __name(isHTTPWhiteSpaceCharCode, "isHTTPWhiteSpaceCharCode");
    function headerValueNormalize(potentialValue) {
      let i = 0;
      let j2 = potentialValue.length;
      while (j2 > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(j2 - 1)))
        --j2;
      while (j2 > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(i)))
        ++i;
      return i === 0 && j2 === potentialValue.length ? potentialValue : potentialValue.substring(i, j2);
    }
    __name(headerValueNormalize, "headerValueNormalize");
    function fill2(headers, object) {
      if (Array.isArray(object)) {
        for (let i = 0; i < object.length; ++i) {
          const header = object[i];
          if (header.length !== 2) {
            throw webidl.errors.exception({
              header: "Headers constructor",
              message: `expected name/value pair to be length 2, found ${header.length}.`
            });
          }
          appendHeader(headers, header[0], header[1]);
        }
      } else if (typeof object === "object" && object !== null) {
        const keys = Object.keys(object);
        for (let i = 0; i < keys.length; ++i) {
          appendHeader(headers, keys[i], object[keys[i]]);
        }
      } else {
        throw webidl.errors.conversionFailed({
          prefix: "Headers constructor",
          argument: "Argument 1",
          types: ["sequence<sequence<ByteString>>", "record<ByteString, ByteString>"]
        });
      }
    }
    __name(fill2, "fill");
    function appendHeader(headers, name, value) {
      value = headerValueNormalize(value);
      if (!isValidHeaderName(name)) {
        throw webidl.errors.invalidArgument({
          prefix: "Headers.append",
          value: name,
          type: "header name"
        });
      } else if (!isValidHeaderValue(value)) {
        throw webidl.errors.invalidArgument({
          prefix: "Headers.append",
          value,
          type: "header value"
        });
      }
      if (headers[kGuard] === "immutable") {
        throw new TypeError("immutable");
      } else if (headers[kGuard] === "request-no-cors") {
      }
      return headers[kHeadersList].append(name, value);
    }
    __name(appendHeader, "appendHeader");
    var HeadersList = class {
      /** @type {[string, string][]|null} */
      cookies = null;
      constructor(init3) {
        if (init3 instanceof HeadersList) {
          this[kHeadersMap] = new Map(init3[kHeadersMap]);
          this[kHeadersSortedMap] = init3[kHeadersSortedMap];
          this.cookies = init3.cookies === null ? null : [...init3.cookies];
        } else {
          this[kHeadersMap] = new Map(init3);
          this[kHeadersSortedMap] = null;
        }
      }
      // https://fetch.spec.whatwg.org/#header-list-contains
      contains(name) {
        name = name.toLowerCase();
        return this[kHeadersMap].has(name);
      }
      clear() {
        this[kHeadersMap].clear();
        this[kHeadersSortedMap] = null;
        this.cookies = null;
      }
      // https://fetch.spec.whatwg.org/#concept-header-list-append
      append(name, value) {
        this[kHeadersSortedMap] = null;
        const lowercaseName = name.toLowerCase();
        const exists = this[kHeadersMap].get(lowercaseName);
        if (exists) {
          const delimiter = lowercaseName === "cookie" ? "; " : ", ";
          this[kHeadersMap].set(lowercaseName, {
            name: exists.name,
            value: `${exists.value}${delimiter}${value}`
          });
        } else {
          this[kHeadersMap].set(lowercaseName, { name, value });
        }
        if (lowercaseName === "set-cookie") {
          this.cookies ??= [];
          this.cookies.push(value);
        }
      }
      // https://fetch.spec.whatwg.org/#concept-header-list-set
      set(name, value) {
        this[kHeadersSortedMap] = null;
        const lowercaseName = name.toLowerCase();
        if (lowercaseName === "set-cookie") {
          this.cookies = [value];
        }
        this[kHeadersMap].set(lowercaseName, { name, value });
      }
      // https://fetch.spec.whatwg.org/#concept-header-list-delete
      delete(name) {
        this[kHeadersSortedMap] = null;
        name = name.toLowerCase();
        if (name === "set-cookie") {
          this.cookies = null;
        }
        this[kHeadersMap].delete(name);
      }
      // https://fetch.spec.whatwg.org/#concept-header-list-get
      get(name) {
        const value = this[kHeadersMap].get(name.toLowerCase());
        return value === void 0 ? null : value.value;
      }
      *[Symbol.iterator]() {
        for (const [name, { value }] of this[kHeadersMap]) {
          yield [name, value];
        }
      }
      get entries() {
        const headers = {};
        if (this[kHeadersMap].size) {
          for (const { name, value } of this[kHeadersMap].values()) {
            headers[name] = value;
          }
        }
        return headers;
      }
    };
    __name(HeadersList, "HeadersList");
    var Headers5 = class {
      constructor(init3 = void 0) {
        if (init3 === kConstruct) {
          return;
        }
        this[kHeadersList] = new HeadersList();
        this[kGuard] = "none";
        if (init3 !== void 0) {
          init3 = webidl.converters.HeadersInit(init3);
          fill2(this, init3);
        }
      }
      // https://fetch.spec.whatwg.org/#dom-headers-append
      append(name, value) {
        webidl.brandCheck(this, Headers5);
        webidl.argumentLengthCheck(arguments, 2, { header: "Headers.append" });
        name = webidl.converters.ByteString(name);
        value = webidl.converters.ByteString(value);
        return appendHeader(this, name, value);
      }
      // https://fetch.spec.whatwg.org/#dom-headers-delete
      delete(name) {
        webidl.brandCheck(this, Headers5);
        webidl.argumentLengthCheck(arguments, 1, { header: "Headers.delete" });
        name = webidl.converters.ByteString(name);
        if (!isValidHeaderName(name)) {
          throw webidl.errors.invalidArgument({
            prefix: "Headers.delete",
            value: name,
            type: "header name"
          });
        }
        if (this[kGuard] === "immutable") {
          throw new TypeError("immutable");
        } else if (this[kGuard] === "request-no-cors") {
        }
        if (!this[kHeadersList].contains(name)) {
          return;
        }
        this[kHeadersList].delete(name);
      }
      // https://fetch.spec.whatwg.org/#dom-headers-get
      get(name) {
        webidl.brandCheck(this, Headers5);
        webidl.argumentLengthCheck(arguments, 1, { header: "Headers.get" });
        name = webidl.converters.ByteString(name);
        if (!isValidHeaderName(name)) {
          throw webidl.errors.invalidArgument({
            prefix: "Headers.get",
            value: name,
            type: "header name"
          });
        }
        return this[kHeadersList].get(name);
      }
      // https://fetch.spec.whatwg.org/#dom-headers-has
      has(name) {
        webidl.brandCheck(this, Headers5);
        webidl.argumentLengthCheck(arguments, 1, { header: "Headers.has" });
        name = webidl.converters.ByteString(name);
        if (!isValidHeaderName(name)) {
          throw webidl.errors.invalidArgument({
            prefix: "Headers.has",
            value: name,
            type: "header name"
          });
        }
        return this[kHeadersList].contains(name);
      }
      // https://fetch.spec.whatwg.org/#dom-headers-set
      set(name, value) {
        webidl.brandCheck(this, Headers5);
        webidl.argumentLengthCheck(arguments, 2, { header: "Headers.set" });
        name = webidl.converters.ByteString(name);
        value = webidl.converters.ByteString(value);
        value = headerValueNormalize(value);
        if (!isValidHeaderName(name)) {
          throw webidl.errors.invalidArgument({
            prefix: "Headers.set",
            value: name,
            type: "header name"
          });
        } else if (!isValidHeaderValue(value)) {
          throw webidl.errors.invalidArgument({
            prefix: "Headers.set",
            value,
            type: "header value"
          });
        }
        if (this[kGuard] === "immutable") {
          throw new TypeError("immutable");
        } else if (this[kGuard] === "request-no-cors") {
        }
        this[kHeadersList].set(name, value);
      }
      // https://fetch.spec.whatwg.org/#dom-headers-getsetcookie
      getSetCookie() {
        webidl.brandCheck(this, Headers5);
        const list = this[kHeadersList].cookies;
        if (list) {
          return [...list];
        }
        return [];
      }
      // https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine
      get [kHeadersSortedMap]() {
        if (this[kHeadersList][kHeadersSortedMap]) {
          return this[kHeadersList][kHeadersSortedMap];
        }
        const headers = [];
        const names = [...this[kHeadersList]].sort((a, b2) => a[0] < b2[0] ? -1 : 1);
        const cookies = this[kHeadersList].cookies;
        for (let i = 0; i < names.length; ++i) {
          const [name, value] = names[i];
          if (name === "set-cookie") {
            for (let j2 = 0; j2 < cookies.length; ++j2) {
              headers.push([name, cookies[j2]]);
            }
          } else {
            assert27(value !== null);
            headers.push([name, value]);
          }
        }
        this[kHeadersList][kHeadersSortedMap] = headers;
        return headers;
      }
      keys() {
        webidl.brandCheck(this, Headers5);
        if (this[kGuard] === "immutable") {
          const value = this[kHeadersSortedMap];
          return makeIterator(
            () => value,
            "Headers",
            "key"
          );
        }
        return makeIterator(
          () => [...this[kHeadersSortedMap].values()],
          "Headers",
          "key"
        );
      }
      values() {
        webidl.brandCheck(this, Headers5);
        if (this[kGuard] === "immutable") {
          const value = this[kHeadersSortedMap];
          return makeIterator(
            () => value,
            "Headers",
            "value"
          );
        }
        return makeIterator(
          () => [...this[kHeadersSortedMap].values()],
          "Headers",
          "value"
        );
      }
      entries() {
        webidl.brandCheck(this, Headers5);
        if (this[kGuard] === "immutable") {
          const value = this[kHeadersSortedMap];
          return makeIterator(
            () => value,
            "Headers",
            "key+value"
          );
        }
        return makeIterator(
          () => [...this[kHeadersSortedMap].values()],
          "Headers",
          "key+value"
        );
      }
      /**
       * @param {(value: string, key: string, self: Headers) => void} callbackFn
       * @param {unknown} thisArg
       */
      forEach(callbackFn, thisArg = globalThis) {
        webidl.brandCheck(this, Headers5);
        webidl.argumentLengthCheck(arguments, 1, { header: "Headers.forEach" });
        if (typeof callbackFn !== "function") {
          throw new TypeError(
            "Failed to execute 'forEach' on 'Headers': parameter 1 is not of type 'Function'."
          );
        }
        for (const [key, value] of this) {
          callbackFn.apply(thisArg, [value, key, this]);
        }
      }
      [Symbol.for("nodejs.util.inspect.custom")]() {
        webidl.brandCheck(this, Headers5);
        return this[kHeadersList];
      }
    };
    __name(Headers5, "Headers");
    Headers5.prototype[Symbol.iterator] = Headers5.prototype.entries;
    Object.defineProperties(Headers5.prototype, {
      append: kEnumerableProperty,
      delete: kEnumerableProperty,
      get: kEnumerableProperty,
      has: kEnumerableProperty,
      set: kEnumerableProperty,
      getSetCookie: kEnumerableProperty,
      keys: kEnumerableProperty,
      values: kEnumerableProperty,
      entries: kEnumerableProperty,
      forEach: kEnumerableProperty,
      [Symbol.iterator]: { enumerable: false },
      [Symbol.toStringTag]: {
        value: "Headers",
        configurable: true
      }
    });
    webidl.converters.HeadersInit = function(V2) {
      if (webidl.util.Type(V2) === "Object") {
        if (V2[Symbol.iterator]) {
          return webidl.converters["sequence<sequence<ByteString>>"](V2);
        }
        return webidl.converters["record<ByteString, ByteString>"](V2);
      }
      throw webidl.errors.conversionFailed({
        prefix: "Headers constructor",
        argument: "Argument 1",
        types: ["sequence<sequence<ByteString>>", "record<ByteString, ByteString>"]
      });
    };
    module3.exports = {
      fill: fill2,
      Headers: Headers5,
      HeadersList
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/response.js
var require_response3 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/response.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { Headers: Headers5, HeadersList, fill: fill2 } = require_headers2();
    var { extractBody, cloneBody, mixinBody } = require_body2();
    var util4 = require_util12();
    var { kEnumerableProperty } = util4;
    var {
      isValidReasonPhrase,
      isCancelled,
      isAborted,
      isBlobLike,
      serializeJavascriptValueToJSONString,
      isErrorLike,
      isomorphicEncode
    } = require_util13();
    var {
      redirectStatusSet,
      nullBodyStatus,
      DOMException: DOMException2
    } = require_constants9();
    var { kState, kHeaders, kGuard, kRealm } = require_symbols7();
    var { webidl } = require_webidl2();
    var { FormData: FormData10 } = require_formdata2();
    var { getGlobalOrigin } = require_global3();
    var { URLSerializer } = require_dataURL2();
    var { kHeadersList, kConstruct } = require_symbols6();
    var assert27 = require("assert");
    var { types } = require("util");
    var ReadableStream2 = globalThis.ReadableStream || require("stream/web").ReadableStream;
    var textEncoder = new TextEncoder("utf-8");
    var Response9 = class {
      // Creates network error Response.
      static error() {
        const relevantRealm = { settingsObject: {} };
        const responseObject = new Response9();
        responseObject[kState] = makeNetworkError();
        responseObject[kRealm] = relevantRealm;
        responseObject[kHeaders][kHeadersList] = responseObject[kState].headersList;
        responseObject[kHeaders][kGuard] = "immutable";
        responseObject[kHeaders][kRealm] = relevantRealm;
        return responseObject;
      }
      // https://fetch.spec.whatwg.org/#dom-response-json
      static json(data, init3 = {}) {
        webidl.argumentLengthCheck(arguments, 1, { header: "Response.json" });
        if (init3 !== null) {
          init3 = webidl.converters.ResponseInit(init3);
        }
        const bytes = textEncoder.encode(
          serializeJavascriptValueToJSONString(data)
        );
        const body = extractBody(bytes);
        const relevantRealm = { settingsObject: {} };
        const responseObject = new Response9();
        responseObject[kRealm] = relevantRealm;
        responseObject[kHeaders][kGuard] = "response";
        responseObject[kHeaders][kRealm] = relevantRealm;
        initializeResponse(responseObject, init3, { body: body[0], type: "application/json" });
        return responseObject;
      }
      // Creates a redirect Response that redirects to url with status status.
      static redirect(url4, status2 = 302) {
        const relevantRealm = { settingsObject: {} };
        webidl.argumentLengthCheck(arguments, 1, { header: "Response.redirect" });
        url4 = webidl.converters.USVString(url4);
        status2 = webidl.converters["unsigned short"](status2);
        let parsedURL;
        try {
          parsedURL = new URL(url4, getGlobalOrigin());
        } catch (err) {
          throw Object.assign(new TypeError("Failed to parse URL from " + url4), {
            cause: err
          });
        }
        if (!redirectStatusSet.has(status2)) {
          throw new RangeError("Invalid status code " + status2);
        }
        const responseObject = new Response9();
        responseObject[kRealm] = relevantRealm;
        responseObject[kHeaders][kGuard] = "immutable";
        responseObject[kHeaders][kRealm] = relevantRealm;
        responseObject[kState].status = status2;
        const value = isomorphicEncode(URLSerializer(parsedURL));
        responseObject[kState].headersList.append("location", value);
        return responseObject;
      }
      // https://fetch.spec.whatwg.org/#dom-response
      constructor(body = null, init3 = {}) {
        if (body !== null) {
          body = webidl.converters.BodyInit(body);
        }
        init3 = webidl.converters.ResponseInit(init3);
        this[kRealm] = { settingsObject: {} };
        this[kState] = makeResponse({});
        this[kHeaders] = new Headers5(kConstruct);
        this[kHeaders][kGuard] = "response";
        this[kHeaders][kHeadersList] = this[kState].headersList;
        this[kHeaders][kRealm] = this[kRealm];
        let bodyWithType = null;
        if (body != null) {
          const [extractedBody, type] = extractBody(body);
          bodyWithType = { body: extractedBody, type };
        }
        initializeResponse(this, init3, bodyWithType);
      }
      // Returns response’s type, e.g., "cors".
      get type() {
        webidl.brandCheck(this, Response9);
        return this[kState].type;
      }
      // Returns response’s URL, if it has one; otherwise the empty string.
      get url() {
        webidl.brandCheck(this, Response9);
        const urlList = this[kState].urlList;
        const url4 = urlList[urlList.length - 1] ?? null;
        if (url4 === null) {
          return "";
        }
        return URLSerializer(url4, true);
      }
      // Returns whether response was obtained through a redirect.
      get redirected() {
        webidl.brandCheck(this, Response9);
        return this[kState].urlList.length > 1;
      }
      // Returns response’s status.
      get status() {
        webidl.brandCheck(this, Response9);
        return this[kState].status;
      }
      // Returns whether response’s status is an ok status.
      get ok() {
        webidl.brandCheck(this, Response9);
        return this[kState].status >= 200 && this[kState].status <= 299;
      }
      // Returns response’s status message.
      get statusText() {
        webidl.brandCheck(this, Response9);
        return this[kState].statusText;
      }
      // Returns response’s headers as Headers.
      get headers() {
        webidl.brandCheck(this, Response9);
        return this[kHeaders];
      }
      get body() {
        webidl.brandCheck(this, Response9);
        return this[kState].body ? this[kState].body.stream : null;
      }
      get bodyUsed() {
        webidl.brandCheck(this, Response9);
        return !!this[kState].body && util4.isDisturbed(this[kState].body.stream);
      }
      // Returns a clone of response.
      clone() {
        webidl.brandCheck(this, Response9);
        if (this.bodyUsed || this.body && this.body.locked) {
          throw webidl.errors.exception({
            header: "Response.clone",
            message: "Body has already been consumed."
          });
        }
        const clonedResponse = cloneResponse(this[kState]);
        const clonedResponseObject = new Response9();
        clonedResponseObject[kState] = clonedResponse;
        clonedResponseObject[kRealm] = this[kRealm];
        clonedResponseObject[kHeaders][kHeadersList] = clonedResponse.headersList;
        clonedResponseObject[kHeaders][kGuard] = this[kHeaders][kGuard];
        clonedResponseObject[kHeaders][kRealm] = this[kHeaders][kRealm];
        return clonedResponseObject;
      }
    };
    __name(Response9, "Response");
    mixinBody(Response9);
    Object.defineProperties(Response9.prototype, {
      type: kEnumerableProperty,
      url: kEnumerableProperty,
      status: kEnumerableProperty,
      ok: kEnumerableProperty,
      redirected: kEnumerableProperty,
      statusText: kEnumerableProperty,
      headers: kEnumerableProperty,
      clone: kEnumerableProperty,
      body: kEnumerableProperty,
      bodyUsed: kEnumerableProperty,
      [Symbol.toStringTag]: {
        value: "Response",
        configurable: true
      }
    });
    Object.defineProperties(Response9, {
      json: kEnumerableProperty,
      redirect: kEnumerableProperty,
      error: kEnumerableProperty
    });
    function cloneResponse(response) {
      if (response.internalResponse) {
        return filterResponse(
          cloneResponse(response.internalResponse),
          response.type
        );
      }
      const newResponse = makeResponse({ ...response, body: null });
      if (response.body != null) {
        newResponse.body = cloneBody(response.body);
      }
      return newResponse;
    }
    __name(cloneResponse, "cloneResponse");
    function makeResponse(init3) {
      return {
        aborted: false,
        rangeRequested: false,
        timingAllowPassed: false,
        requestIncludesCredentials: false,
        type: "default",
        status: 200,
        timingInfo: null,
        cacheState: "",
        statusText: "",
        ...init3,
        headersList: init3.headersList ? new HeadersList(init3.headersList) : new HeadersList(),
        urlList: init3.urlList ? [...init3.urlList] : []
      };
    }
    __name(makeResponse, "makeResponse");
    function makeNetworkError(reason) {
      const isError2 = isErrorLike(reason);
      return makeResponse({
        type: "error",
        status: 0,
        error: isError2 ? reason : new Error(reason ? String(reason) : reason),
        aborted: reason && reason.name === "AbortError"
      });
    }
    __name(makeNetworkError, "makeNetworkError");
    function makeFilteredResponse(response, state) {
      state = {
        internalResponse: response,
        ...state
      };
      return new Proxy(response, {
        get(target, p2) {
          return p2 in state ? state[p2] : target[p2];
        },
        set(target, p2, value) {
          assert27(!(p2 in state));
          target[p2] = value;
          return true;
        }
      });
    }
    __name(makeFilteredResponse, "makeFilteredResponse");
    function filterResponse(response, type) {
      if (type === "basic") {
        return makeFilteredResponse(response, {
          type: "basic",
          headersList: response.headersList
        });
      } else if (type === "cors") {
        return makeFilteredResponse(response, {
          type: "cors",
          headersList: response.headersList
        });
      } else if (type === "opaque") {
        return makeFilteredResponse(response, {
          type: "opaque",
          urlList: Object.freeze([]),
          status: 0,
          statusText: "",
          body: null
        });
      } else if (type === "opaqueredirect") {
        return makeFilteredResponse(response, {
          type: "opaqueredirect",
          status: 0,
          statusText: "",
          headersList: [],
          body: null
        });
      } else {
        assert27(false);
      }
    }
    __name(filterResponse, "filterResponse");
    function makeAppropriateNetworkError(fetchParams, err = null) {
      assert27(isCancelled(fetchParams));
      return isAborted(fetchParams) ? makeNetworkError(Object.assign(new DOMException2("The operation was aborted.", "AbortError"), { cause: err })) : makeNetworkError(Object.assign(new DOMException2("Request was cancelled."), { cause: err }));
    }
    __name(makeAppropriateNetworkError, "makeAppropriateNetworkError");
    function initializeResponse(response, init3, body) {
      if (init3.status !== null && (init3.status < 200 || init3.status > 599)) {
        throw new RangeError('init["status"] must be in the range of 200 to 599, inclusive.');
      }
      if ("statusText" in init3 && init3.statusText != null) {
        if (!isValidReasonPhrase(String(init3.statusText))) {
          throw new TypeError("Invalid statusText");
        }
      }
      if ("status" in init3 && init3.status != null) {
        response[kState].status = init3.status;
      }
      if ("statusText" in init3 && init3.statusText != null) {
        response[kState].statusText = init3.statusText;
      }
      if ("headers" in init3 && init3.headers != null) {
        fill2(response[kHeaders], init3.headers);
      }
      if (body) {
        if (nullBodyStatus.includes(response.status)) {
          throw webidl.errors.exception({
            header: "Response constructor",
            message: "Invalid response status code " + response.status
          });
        }
        response[kState].body = body.body;
        if (body.type != null && !response[kState].headersList.contains("Content-Type")) {
          response[kState].headersList.append("content-type", body.type);
        }
      }
    }
    __name(initializeResponse, "initializeResponse");
    webidl.converters.ReadableStream = webidl.interfaceConverter(
      ReadableStream2
    );
    webidl.converters.FormData = webidl.interfaceConverter(
      FormData10
    );
    webidl.converters.URLSearchParams = webidl.interfaceConverter(
      URLSearchParams
    );
    webidl.converters.XMLHttpRequestBodyInit = function(V2) {
      if (typeof V2 === "string") {
        return webidl.converters.USVString(V2);
      }
      if (isBlobLike(V2)) {
        return webidl.converters.Blob(V2, { strict: false });
      }
      if (types.isArrayBuffer(V2) || types.isTypedArray(V2) || types.isDataView(V2)) {
        return webidl.converters.BufferSource(V2);
      }
      if (util4.isFormDataLike(V2)) {
        return webidl.converters.FormData(V2, { strict: false });
      }
      if (V2 instanceof URLSearchParams) {
        return webidl.converters.URLSearchParams(V2);
      }
      return webidl.converters.DOMString(V2);
    };
    webidl.converters.BodyInit = function(V2) {
      if (V2 instanceof ReadableStream2) {
        return webidl.converters.ReadableStream(V2);
      }
      if (V2?.[Symbol.asyncIterator]) {
        return V2;
      }
      return webidl.converters.XMLHttpRequestBodyInit(V2);
    };
    webidl.converters.ResponseInit = webidl.dictionaryConverter([
      {
        key: "status",
        converter: webidl.converters["unsigned short"],
        defaultValue: 200
      },
      {
        key: "statusText",
        converter: webidl.converters.ByteString,
        defaultValue: ""
      },
      {
        key: "headers",
        converter: webidl.converters.HeadersInit
      }
    ]);
    module3.exports = {
      makeNetworkError,
      makeResponse,
      makeAppropriateNetworkError,
      filterResponse,
      Response: Response9,
      cloneResponse
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/request.js
var require_request5 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/request.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { extractBody, mixinBody, cloneBody } = require_body2();
    var { Headers: Headers5, fill: fillHeaders, HeadersList } = require_headers2();
    var { FinalizationRegistry: FinalizationRegistry2 } = require_dispatcher_weakref2()();
    var util4 = require_util12();
    var {
      isValidHTTPToken,
      sameOrigin,
      normalizeMethod,
      makePolicyContainer,
      normalizeMethodRecord
    } = require_util13();
    var {
      forbiddenMethodsSet,
      corsSafeListedMethodsSet,
      referrerPolicy,
      requestRedirect,
      requestMode,
      requestCredentials,
      requestCache,
      requestDuplex
    } = require_constants9();
    var { kEnumerableProperty } = util4;
    var { kHeaders, kSignal, kState, kGuard, kRealm } = require_symbols7();
    var { webidl } = require_webidl2();
    var { getGlobalOrigin } = require_global3();
    var { URLSerializer } = require_dataURL2();
    var { kHeadersList, kConstruct } = require_symbols6();
    var assert27 = require("assert");
    var { getMaxListeners, setMaxListeners, getEventListeners, defaultMaxListeners } = require("events");
    var TransformStream = globalThis.TransformStream;
    var kAbortController = Symbol("abortController");
    var requestFinalizer = new FinalizationRegistry2(({ signal, abort }) => {
      signal.removeEventListener("abort", abort);
    });
    var Request3 = class {
      // https://fetch.spec.whatwg.org/#dom-request
      constructor(input, init3 = {}) {
        if (input === kConstruct) {
          return;
        }
        webidl.argumentLengthCheck(arguments, 1, { header: "Request constructor" });
        input = webidl.converters.RequestInfo(input);
        init3 = webidl.converters.RequestInit(init3);
        this[kRealm] = {
          settingsObject: {
            baseUrl: getGlobalOrigin(),
            get origin() {
              return this.baseUrl?.origin;
            },
            policyContainer: makePolicyContainer()
          }
        };
        let request3 = null;
        let fallbackMode = null;
        const baseUrl = this[kRealm].settingsObject.baseUrl;
        let signal = null;
        if (typeof input === "string") {
          let parsedURL;
          try {
            parsedURL = new URL(input, baseUrl);
          } catch (err) {
            throw new TypeError("Failed to parse URL from " + input, { cause: err });
          }
          if (parsedURL.username || parsedURL.password) {
            throw new TypeError(
              "Request cannot be constructed from a URL that includes credentials: " + input
            );
          }
          request3 = makeRequest({ urlList: [parsedURL] });
          fallbackMode = "cors";
        } else {
          assert27(input instanceof Request3);
          request3 = input[kState];
          signal = input[kSignal];
        }
        const origin = this[kRealm].settingsObject.origin;
        let window2 = "client";
        if (request3.window?.constructor?.name === "EnvironmentSettingsObject" && sameOrigin(request3.window, origin)) {
          window2 = request3.window;
        }
        if (init3.window != null) {
          throw new TypeError(`'window' option '${window2}' must be null`);
        }
        if ("window" in init3) {
          window2 = "no-window";
        }
        request3 = makeRequest({
          // URL request’s URL.
          // undici implementation note: this is set as the first item in request's urlList in makeRequest
          // method request’s method.
          method: request3.method,
          // header list A copy of request’s header list.
          // undici implementation note: headersList is cloned in makeRequest
          headersList: request3.headersList,
          // unsafe-request flag Set.
          unsafeRequest: request3.unsafeRequest,
          // client This’s relevant settings object.
          client: this[kRealm].settingsObject,
          // window window.
          window: window2,
          // priority request’s priority.
          priority: request3.priority,
          // origin request’s origin. The propagation of the origin is only significant for navigation requests
          // being handled by a service worker. In this scenario a request can have an origin that is different
          // from the current client.
          origin: request3.origin,
          // referrer request’s referrer.
          referrer: request3.referrer,
          // referrer policy request’s referrer policy.
          referrerPolicy: request3.referrerPolicy,
          // mode request’s mode.
          mode: request3.mode,
          // credentials mode request’s credentials mode.
          credentials: request3.credentials,
          // cache mode request’s cache mode.
          cache: request3.cache,
          // redirect mode request’s redirect mode.
          redirect: request3.redirect,
          // integrity metadata request’s integrity metadata.
          integrity: request3.integrity,
          // keepalive request’s keepalive.
          keepalive: request3.keepalive,
          // reload-navigation flag request’s reload-navigation flag.
          reloadNavigation: request3.reloadNavigation,
          // history-navigation flag request’s history-navigation flag.
          historyNavigation: request3.historyNavigation,
          // URL list A clone of request’s URL list.
          urlList: [...request3.urlList]
        });
        const initHasKey = Object.keys(init3).length !== 0;
        if (initHasKey) {
          if (request3.mode === "navigate") {
            request3.mode = "same-origin";
          }
          request3.reloadNavigation = false;
          request3.historyNavigation = false;
          request3.origin = "client";
          request3.referrer = "client";
          request3.referrerPolicy = "";
          request3.url = request3.urlList[request3.urlList.length - 1];
          request3.urlList = [request3.url];
        }
        if (init3.referrer !== void 0) {
          const referrer = init3.referrer;
          if (referrer === "") {
            request3.referrer = "no-referrer";
          } else {
            let parsedReferrer;
            try {
              parsedReferrer = new URL(referrer, baseUrl);
            } catch (err) {
              throw new TypeError(`Referrer "${referrer}" is not a valid URL.`, { cause: err });
            }
            if (parsedReferrer.protocol === "about:" && parsedReferrer.hostname === "client" || origin && !sameOrigin(parsedReferrer, this[kRealm].settingsObject.baseUrl)) {
              request3.referrer = "client";
            } else {
              request3.referrer = parsedReferrer;
            }
          }
        }
        if (init3.referrerPolicy !== void 0) {
          request3.referrerPolicy = init3.referrerPolicy;
        }
        let mode;
        if (init3.mode !== void 0) {
          mode = init3.mode;
        } else {
          mode = fallbackMode;
        }
        if (mode === "navigate") {
          throw webidl.errors.exception({
            header: "Request constructor",
            message: "invalid request mode navigate."
          });
        }
        if (mode != null) {
          request3.mode = mode;
        }
        if (init3.credentials !== void 0) {
          request3.credentials = init3.credentials;
        }
        if (init3.cache !== void 0) {
          request3.cache = init3.cache;
        }
        if (request3.cache === "only-if-cached" && request3.mode !== "same-origin") {
          throw new TypeError(
            "'only-if-cached' can be set only with 'same-origin' mode"
          );
        }
        if (init3.redirect !== void 0) {
          request3.redirect = init3.redirect;
        }
        if (init3.integrity != null) {
          request3.integrity = String(init3.integrity);
        }
        if (init3.keepalive !== void 0) {
          request3.keepalive = Boolean(init3.keepalive);
        }
        if (init3.method !== void 0) {
          let method = init3.method;
          if (!isValidHTTPToken(method)) {
            throw new TypeError(`'${method}' is not a valid HTTP method.`);
          }
          if (forbiddenMethodsSet.has(method.toUpperCase())) {
            throw new TypeError(`'${method}' HTTP method is unsupported.`);
          }
          method = normalizeMethodRecord[method] ?? normalizeMethod(method);
          request3.method = method;
        }
        if (init3.signal !== void 0) {
          signal = init3.signal;
        }
        this[kState] = request3;
        const ac = new AbortController();
        this[kSignal] = ac.signal;
        this[kSignal][kRealm] = this[kRealm];
        if (signal != null) {
          if (!signal || typeof signal.aborted !== "boolean" || typeof signal.addEventListener !== "function") {
            throw new TypeError(
              "Failed to construct 'Request': member signal is not of type AbortSignal."
            );
          }
          if (signal.aborted) {
            ac.abort(signal.reason);
          } else {
            this[kAbortController] = ac;
            const acRef = new WeakRef(ac);
            const abort = /* @__PURE__ */ __name(function() {
              const ac2 = acRef.deref();
              if (ac2 !== void 0) {
                ac2.abort(this.reason);
              }
            }, "abort");
            try {
              if (typeof getMaxListeners === "function" && getMaxListeners(signal) === defaultMaxListeners) {
                setMaxListeners(100, signal);
              } else if (getEventListeners(signal, "abort").length >= defaultMaxListeners) {
                setMaxListeners(100, signal);
              }
            } catch {
            }
            util4.addAbortListener(signal, abort);
            requestFinalizer.register(ac, { signal, abort });
          }
        }
        this[kHeaders] = new Headers5(kConstruct);
        this[kHeaders][kHeadersList] = request3.headersList;
        this[kHeaders][kGuard] = "request";
        this[kHeaders][kRealm] = this[kRealm];
        if (mode === "no-cors") {
          if (!corsSafeListedMethodsSet.has(request3.method)) {
            throw new TypeError(
              `'${request3.method} is unsupported in no-cors mode.`
            );
          }
          this[kHeaders][kGuard] = "request-no-cors";
        }
        if (initHasKey) {
          const headersList = this[kHeaders][kHeadersList];
          const headers = init3.headers !== void 0 ? init3.headers : new HeadersList(headersList);
          headersList.clear();
          if (headers instanceof HeadersList) {
            for (const [key, val] of headers) {
              headersList.append(key, val);
            }
            headersList.cookies = headers.cookies;
          } else {
            fillHeaders(this[kHeaders], headers);
          }
        }
        const inputBody = input instanceof Request3 ? input[kState].body : null;
        if ((init3.body != null || inputBody != null) && (request3.method === "GET" || request3.method === "HEAD")) {
          throw new TypeError("Request with GET/HEAD method cannot have body.");
        }
        let initBody = null;
        if (init3.body != null) {
          const [extractedBody, contentType] = extractBody(
            init3.body,
            request3.keepalive
          );
          initBody = extractedBody;
          if (contentType && !this[kHeaders][kHeadersList].contains("content-type")) {
            this[kHeaders].append("content-type", contentType);
          }
        }
        const inputOrInitBody = initBody ?? inputBody;
        if (inputOrInitBody != null && inputOrInitBody.source == null) {
          if (initBody != null && init3.duplex == null) {
            throw new TypeError("RequestInit: duplex option is required when sending a body.");
          }
          if (request3.mode !== "same-origin" && request3.mode !== "cors") {
            throw new TypeError(
              'If request is made from ReadableStream, mode should be "same-origin" or "cors"'
            );
          }
          request3.useCORSPreflightFlag = true;
        }
        let finalBody = inputOrInitBody;
        if (initBody == null && inputBody != null) {
          if (util4.isDisturbed(inputBody.stream) || inputBody.stream.locked) {
            throw new TypeError(
              "Cannot construct a Request with a Request object that has already been used."
            );
          }
          if (!TransformStream) {
            TransformStream = require("stream/web").TransformStream;
          }
          const identityTransform = new TransformStream();
          inputBody.stream.pipeThrough(identityTransform);
          finalBody = {
            source: inputBody.source,
            length: inputBody.length,
            stream: identityTransform.readable
          };
        }
        this[kState].body = finalBody;
      }
      // Returns request’s HTTP method, which is "GET" by default.
      get method() {
        webidl.brandCheck(this, Request3);
        return this[kState].method;
      }
      // Returns the URL of request as a string.
      get url() {
        webidl.brandCheck(this, Request3);
        return URLSerializer(this[kState].url);
      }
      // Returns a Headers object consisting of the headers associated with request.
      // Note that headers added in the network layer by the user agent will not
      // be accounted for in this object, e.g., the "Host" header.
      get headers() {
        webidl.brandCheck(this, Request3);
        return this[kHeaders];
      }
      // Returns the kind of resource requested by request, e.g., "document"
      // or "script".
      get destination() {
        webidl.brandCheck(this, Request3);
        return this[kState].destination;
      }
      // Returns the referrer of request. Its value can be a same-origin URL if
      // explicitly set in init, the empty string to indicate no referrer, and
      // "about:client" when defaulting to the global’s default. This is used
      // during fetching to determine the value of the `Referer` header of the
      // request being made.
      get referrer() {
        webidl.brandCheck(this, Request3);
        if (this[kState].referrer === "no-referrer") {
          return "";
        }
        if (this[kState].referrer === "client") {
          return "about:client";
        }
        return this[kState].referrer.toString();
      }
      // Returns the referrer policy associated with request.
      // This is used during fetching to compute the value of the request’s
      // referrer.
      get referrerPolicy() {
        webidl.brandCheck(this, Request3);
        return this[kState].referrerPolicy;
      }
      // Returns the mode associated with request, which is a string indicating
      // whether the request will use CORS, or will be restricted to same-origin
      // URLs.
      get mode() {
        webidl.brandCheck(this, Request3);
        return this[kState].mode;
      }
      // Returns the credentials mode associated with request,
      // which is a string indicating whether credentials will be sent with the
      // request always, never, or only when sent to a same-origin URL.
      get credentials() {
        return this[kState].credentials;
      }
      // Returns the cache mode associated with request,
      // which is a string indicating how the request will
      // interact with the browser’s cache when fetching.
      get cache() {
        webidl.brandCheck(this, Request3);
        return this[kState].cache;
      }
      // Returns the redirect mode associated with request,
      // which is a string indicating how redirects for the
      // request will be handled during fetching. A request
      // will follow redirects by default.
      get redirect() {
        webidl.brandCheck(this, Request3);
        return this[kState].redirect;
      }
      // Returns request’s subresource integrity metadata, which is a
      // cryptographic hash of the resource being fetched. Its value
      // consists of multiple hashes separated by whitespace. [SRI]
      get integrity() {
        webidl.brandCheck(this, Request3);
        return this[kState].integrity;
      }
      // Returns a boolean indicating whether or not request can outlive the
      // global in which it was created.
      get keepalive() {
        webidl.brandCheck(this, Request3);
        return this[kState].keepalive;
      }
      // Returns a boolean indicating whether or not request is for a reload
      // navigation.
      get isReloadNavigation() {
        webidl.brandCheck(this, Request3);
        return this[kState].reloadNavigation;
      }
      // Returns a boolean indicating whether or not request is for a history
      // navigation (a.k.a. back-foward navigation).
      get isHistoryNavigation() {
        webidl.brandCheck(this, Request3);
        return this[kState].historyNavigation;
      }
      // Returns the signal associated with request, which is an AbortSignal
      // object indicating whether or not request has been aborted, and its
      // abort event handler.
      get signal() {
        webidl.brandCheck(this, Request3);
        return this[kSignal];
      }
      get body() {
        webidl.brandCheck(this, Request3);
        return this[kState].body ? this[kState].body.stream : null;
      }
      get bodyUsed() {
        webidl.brandCheck(this, Request3);
        return !!this[kState].body && util4.isDisturbed(this[kState].body.stream);
      }
      get duplex() {
        webidl.brandCheck(this, Request3);
        return "half";
      }
      // Returns a clone of request.
      clone() {
        webidl.brandCheck(this, Request3);
        if (this.bodyUsed || this.body?.locked) {
          throw new TypeError("unusable");
        }
        const clonedRequest = cloneRequest(this[kState]);
        const clonedRequestObject = new Request3(kConstruct);
        clonedRequestObject[kState] = clonedRequest;
        clonedRequestObject[kRealm] = this[kRealm];
        clonedRequestObject[kHeaders] = new Headers5(kConstruct);
        clonedRequestObject[kHeaders][kHeadersList] = clonedRequest.headersList;
        clonedRequestObject[kHeaders][kGuard] = this[kHeaders][kGuard];
        clonedRequestObject[kHeaders][kRealm] = this[kHeaders][kRealm];
        const ac = new AbortController();
        if (this.signal.aborted) {
          ac.abort(this.signal.reason);
        } else {
          util4.addAbortListener(
            this.signal,
            () => {
              ac.abort(this.signal.reason);
            }
          );
        }
        clonedRequestObject[kSignal] = ac.signal;
        return clonedRequestObject;
      }
    };
    __name(Request3, "Request");
    mixinBody(Request3);
    function makeRequest(init3) {
      const request3 = {
        method: "GET",
        localURLsOnly: false,
        unsafeRequest: false,
        body: null,
        client: null,
        reservedClient: null,
        replacesClientId: "",
        window: "client",
        keepalive: false,
        serviceWorkers: "all",
        initiator: "",
        destination: "",
        priority: null,
        origin: "client",
        policyContainer: "client",
        referrer: "client",
        referrerPolicy: "",
        mode: "no-cors",
        useCORSPreflightFlag: false,
        credentials: "same-origin",
        useCredentials: false,
        cache: "default",
        redirect: "follow",
        integrity: "",
        cryptoGraphicsNonceMetadata: "",
        parserMetadata: "",
        reloadNavigation: false,
        historyNavigation: false,
        userActivation: false,
        taintedOrigin: false,
        redirectCount: 0,
        responseTainting: "basic",
        preventNoCacheCacheControlHeaderModification: false,
        done: false,
        timingAllowFailed: false,
        ...init3,
        headersList: init3.headersList ? new HeadersList(init3.headersList) : new HeadersList()
      };
      request3.url = request3.urlList[0];
      return request3;
    }
    __name(makeRequest, "makeRequest");
    function cloneRequest(request3) {
      const newRequest = makeRequest({ ...request3, body: null });
      if (request3.body != null) {
        newRequest.body = cloneBody(request3.body);
      }
      return newRequest;
    }
    __name(cloneRequest, "cloneRequest");
    Object.defineProperties(Request3.prototype, {
      method: kEnumerableProperty,
      url: kEnumerableProperty,
      headers: kEnumerableProperty,
      redirect: kEnumerableProperty,
      clone: kEnumerableProperty,
      signal: kEnumerableProperty,
      duplex: kEnumerableProperty,
      destination: kEnumerableProperty,
      body: kEnumerableProperty,
      bodyUsed: kEnumerableProperty,
      isHistoryNavigation: kEnumerableProperty,
      isReloadNavigation: kEnumerableProperty,
      keepalive: kEnumerableProperty,
      integrity: kEnumerableProperty,
      cache: kEnumerableProperty,
      credentials: kEnumerableProperty,
      attribute: kEnumerableProperty,
      referrerPolicy: kEnumerableProperty,
      referrer: kEnumerableProperty,
      mode: kEnumerableProperty,
      [Symbol.toStringTag]: {
        value: "Request",
        configurable: true
      }
    });
    webidl.converters.Request = webidl.interfaceConverter(
      Request3
    );
    webidl.converters.RequestInfo = function(V2) {
      if (typeof V2 === "string") {
        return webidl.converters.USVString(V2);
      }
      if (V2 instanceof Request3) {
        return webidl.converters.Request(V2);
      }
      return webidl.converters.USVString(V2);
    };
    webidl.converters.AbortSignal = webidl.interfaceConverter(
      AbortSignal
    );
    webidl.converters.RequestInit = webidl.dictionaryConverter([
      {
        key: "method",
        converter: webidl.converters.ByteString
      },
      {
        key: "headers",
        converter: webidl.converters.HeadersInit
      },
      {
        key: "body",
        converter: webidl.nullableConverter(
          webidl.converters.BodyInit
        )
      },
      {
        key: "referrer",
        converter: webidl.converters.USVString
      },
      {
        key: "referrerPolicy",
        converter: webidl.converters.DOMString,
        // https://w3c.github.io/webappsec-referrer-policy/#referrer-policy
        allowedValues: referrerPolicy
      },
      {
        key: "mode",
        converter: webidl.converters.DOMString,
        // https://fetch.spec.whatwg.org/#concept-request-mode
        allowedValues: requestMode
      },
      {
        key: "credentials",
        converter: webidl.converters.DOMString,
        // https://fetch.spec.whatwg.org/#requestcredentials
        allowedValues: requestCredentials
      },
      {
        key: "cache",
        converter: webidl.converters.DOMString,
        // https://fetch.spec.whatwg.org/#requestcache
        allowedValues: requestCache
      },
      {
        key: "redirect",
        converter: webidl.converters.DOMString,
        // https://fetch.spec.whatwg.org/#requestredirect
        allowedValues: requestRedirect
      },
      {
        key: "integrity",
        converter: webidl.converters.DOMString
      },
      {
        key: "keepalive",
        converter: webidl.converters.boolean
      },
      {
        key: "signal",
        converter: webidl.nullableConverter(
          (signal) => webidl.converters.AbortSignal(
            signal,
            { strict: false }
          )
        )
      },
      {
        key: "window",
        converter: webidl.converters.any
      },
      {
        key: "duplex",
        converter: webidl.converters.DOMString,
        allowedValues: requestDuplex
      }
    ]);
    module3.exports = { Request: Request3, makeRequest };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/index.js
var require_fetch2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fetch/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var {
      Response: Response9,
      makeNetworkError,
      makeAppropriateNetworkError,
      filterResponse,
      makeResponse
    } = require_response3();
    var { Headers: Headers5 } = require_headers2();
    var { Request: Request3, makeRequest } = require_request5();
    var zlib = require("zlib");
    var {
      bytesMatch,
      makePolicyContainer,
      clonePolicyContainer,
      requestBadPort,
      TAOCheck,
      appendRequestOriginHeader,
      responseLocationURL,
      requestCurrentURL,
      setRequestReferrerPolicyOnRedirect,
      tryUpgradeRequestToAPotentiallyTrustworthyURL,
      createOpaqueTimingInfo,
      appendFetchMetadata,
      corsCheck,
      crossOriginResourcePolicyCheck,
      determineRequestsReferrer,
      coarsenedSharedCurrentTime,
      createDeferredPromise,
      isBlobLike,
      sameOrigin,
      isCancelled,
      isAborted,
      isErrorLike,
      fullyReadBody,
      readableStreamClose,
      isomorphicEncode,
      urlIsLocal,
      urlIsHttpHttpsScheme,
      urlHasHttpsScheme
    } = require_util13();
    var { kState, kHeaders, kGuard, kRealm } = require_symbols7();
    var assert27 = require("assert");
    var { safelyExtractBody } = require_body2();
    var {
      redirectStatusSet,
      nullBodyStatus,
      safeMethodsSet,
      requestBodyHeader,
      subresourceSet,
      DOMException: DOMException2
    } = require_constants9();
    var { kHeadersList } = require_symbols6();
    var EE = require("events");
    var { Readable: Readable2, pipeline } = require("stream");
    var { addAbortListener, isErrored, isReadable, nodeMajor, nodeMinor } = require_util12();
    var { dataURLProcessor, serializeAMimeType } = require_dataURL2();
    var { TransformStream } = require("stream/web");
    var { getGlobalDispatcher: getGlobalDispatcher2 } = require_global4();
    var { webidl } = require_webidl2();
    var { STATUS_CODES } = require("http");
    var GET_OR_HEAD = ["GET", "HEAD"];
    var resolveObjectURL;
    var ReadableStream2 = globalThis.ReadableStream;
    var Fetch = class extends EE {
      constructor(dispatcher) {
        super();
        this.dispatcher = dispatcher;
        this.connection = null;
        this.dump = false;
        this.state = "ongoing";
        this.setMaxListeners(21);
      }
      terminate(reason) {
        if (this.state !== "ongoing") {
          return;
        }
        this.state = "terminated";
        this.connection?.destroy(reason);
        this.emit("terminated", reason);
      }
      // https://fetch.spec.whatwg.org/#fetch-controller-abort
      abort(error2) {
        if (this.state !== "ongoing") {
          return;
        }
        this.state = "aborted";
        if (!error2) {
          error2 = new DOMException2("The operation was aborted.", "AbortError");
        }
        this.serializedAbortReason = error2;
        this.connection?.destroy(error2);
        this.emit("terminated", error2);
      }
    };
    __name(Fetch, "Fetch");
    function fetch15(input, init3 = {}) {
      webidl.argumentLengthCheck(arguments, 1, { header: "globalThis.fetch" });
      const p2 = createDeferredPromise();
      let requestObject;
      try {
        requestObject = new Request3(input, init3);
      } catch (e3) {
        p2.reject(e3);
        return p2.promise;
      }
      const request3 = requestObject[kState];
      if (requestObject.signal.aborted) {
        abortFetch(p2, request3, null, requestObject.signal.reason);
        return p2.promise;
      }
      const globalObject = request3.client.globalObject;
      if (globalObject?.constructor?.name === "ServiceWorkerGlobalScope") {
        request3.serviceWorkers = "none";
      }
      let responseObject = null;
      const relevantRealm = null;
      let locallyAborted = false;
      let controller = null;
      addAbortListener(
        requestObject.signal,
        () => {
          locallyAborted = true;
          assert27(controller != null);
          controller.abort(requestObject.signal.reason);
          abortFetch(p2, request3, responseObject, requestObject.signal.reason);
        }
      );
      const handleFetchDone = /* @__PURE__ */ __name((response) => finalizeAndReportTiming(response, "fetch"), "handleFetchDone");
      const processResponse = /* @__PURE__ */ __name((response) => {
        if (locallyAborted) {
          return Promise.resolve();
        }
        if (response.aborted) {
          abortFetch(p2, request3, responseObject, controller.serializedAbortReason);
          return Promise.resolve();
        }
        if (response.type === "error") {
          p2.reject(
            Object.assign(new TypeError("fetch failed"), { cause: response.error })
          );
          return Promise.resolve();
        }
        responseObject = new Response9();
        responseObject[kState] = response;
        responseObject[kRealm] = relevantRealm;
        responseObject[kHeaders][kHeadersList] = response.headersList;
        responseObject[kHeaders][kGuard] = "immutable";
        responseObject[kHeaders][kRealm] = relevantRealm;
        p2.resolve(responseObject);
      }, "processResponse");
      controller = fetching({
        request: request3,
        processResponseEndOfBody: handleFetchDone,
        processResponse,
        dispatcher: init3.dispatcher ?? getGlobalDispatcher2()
        // undici
      });
      return p2.promise;
    }
    __name(fetch15, "fetch");
    function finalizeAndReportTiming(response, initiatorType = "other") {
      if (response.type === "error" && response.aborted) {
        return;
      }
      if (!response.urlList?.length) {
        return;
      }
      const originalURL = response.urlList[0];
      let timingInfo = response.timingInfo;
      let cacheState = response.cacheState;
      if (!urlIsHttpHttpsScheme(originalURL)) {
        return;
      }
      if (timingInfo === null) {
        return;
      }
      if (!response.timingAllowPassed) {
        timingInfo = createOpaqueTimingInfo({
          startTime: timingInfo.startTime
        });
        cacheState = "";
      }
      timingInfo.endTime = coarsenedSharedCurrentTime();
      response.timingInfo = timingInfo;
      markResourceTiming(
        timingInfo,
        originalURL,
        initiatorType,
        globalThis,
        cacheState
      );
    }
    __name(finalizeAndReportTiming, "finalizeAndReportTiming");
    function markResourceTiming(timingInfo, originalURL, initiatorType, globalThis2, cacheState) {
      if (nodeMajor > 18 || nodeMajor === 18 && nodeMinor >= 2) {
        performance.markResourceTiming(timingInfo, originalURL.href, initiatorType, globalThis2, cacheState);
      }
    }
    __name(markResourceTiming, "markResourceTiming");
    function abortFetch(p2, request3, responseObject, error2) {
      if (!error2) {
        error2 = new DOMException2("The operation was aborted.", "AbortError");
      }
      p2.reject(error2);
      if (request3.body != null && isReadable(request3.body?.stream)) {
        request3.body.stream.cancel(error2).catch((err) => {
          if (err.code === "ERR_INVALID_STATE") {
            return;
          }
          throw err;
        });
      }
      if (responseObject == null) {
        return;
      }
      const response = responseObject[kState];
      if (response.body != null && isReadable(response.body?.stream)) {
        response.body.stream.cancel(error2).catch((err) => {
          if (err.code === "ERR_INVALID_STATE") {
            return;
          }
          throw err;
        });
      }
    }
    __name(abortFetch, "abortFetch");
    function fetching({
      request: request3,
      processRequestBodyChunkLength,
      processRequestEndOfBody,
      processResponse,
      processResponseEndOfBody,
      processResponseConsumeBody,
      useParallelQueue = false,
      dispatcher
      // undici
    }) {
      let taskDestination = null;
      let crossOriginIsolatedCapability = false;
      if (request3.client != null) {
        taskDestination = request3.client.globalObject;
        crossOriginIsolatedCapability = request3.client.crossOriginIsolatedCapability;
      }
      const currenTime = coarsenedSharedCurrentTime(crossOriginIsolatedCapability);
      const timingInfo = createOpaqueTimingInfo({
        startTime: currenTime
      });
      const fetchParams = {
        controller: new Fetch(dispatcher),
        request: request3,
        timingInfo,
        processRequestBodyChunkLength,
        processRequestEndOfBody,
        processResponse,
        processResponseConsumeBody,
        processResponseEndOfBody,
        taskDestination,
        crossOriginIsolatedCapability
      };
      assert27(!request3.body || request3.body.stream);
      if (request3.window === "client") {
        request3.window = request3.client?.globalObject?.constructor?.name === "Window" ? request3.client : "no-window";
      }
      if (request3.origin === "client") {
        request3.origin = request3.client?.origin;
      }
      if (request3.policyContainer === "client") {
        if (request3.client != null) {
          request3.policyContainer = clonePolicyContainer(
            request3.client.policyContainer
          );
        } else {
          request3.policyContainer = makePolicyContainer();
        }
      }
      if (!request3.headersList.contains("accept")) {
        const value = "*/*";
        request3.headersList.append("accept", value);
      }
      if (!request3.headersList.contains("accept-language")) {
        request3.headersList.append("accept-language", "*");
      }
      if (request3.priority === null) {
      }
      if (subresourceSet.has(request3.destination)) {
      }
      mainFetch(fetchParams).catch((err) => {
        fetchParams.controller.terminate(err);
      });
      return fetchParams.controller;
    }
    __name(fetching, "fetching");
    async function mainFetch(fetchParams, recursive = false) {
      const request3 = fetchParams.request;
      let response = null;
      if (request3.localURLsOnly && !urlIsLocal(requestCurrentURL(request3))) {
        response = makeNetworkError("local URLs only");
      }
      tryUpgradeRequestToAPotentiallyTrustworthyURL(request3);
      if (requestBadPort(request3) === "blocked") {
        response = makeNetworkError("bad port");
      }
      if (request3.referrerPolicy === "") {
        request3.referrerPolicy = request3.policyContainer.referrerPolicy;
      }
      if (request3.referrer !== "no-referrer") {
        request3.referrer = determineRequestsReferrer(request3);
      }
      if (response === null) {
        response = await (async () => {
          const currentURL = requestCurrentURL(request3);
          if (
            // - request’s current URL’s origin is same origin with request’s origin,
            //   and request’s response tainting is "basic"
            sameOrigin(currentURL, request3.url) && request3.responseTainting === "basic" || // request’s current URL’s scheme is "data"
            currentURL.protocol === "data:" || // - request’s mode is "navigate" or "websocket"
            (request3.mode === "navigate" || request3.mode === "websocket")
          ) {
            request3.responseTainting = "basic";
            return await schemeFetch(fetchParams);
          }
          if (request3.mode === "same-origin") {
            return makeNetworkError('request mode cannot be "same-origin"');
          }
          if (request3.mode === "no-cors") {
            if (request3.redirect !== "follow") {
              return makeNetworkError(
                'redirect mode cannot be "follow" for "no-cors" request'
              );
            }
            request3.responseTainting = "opaque";
            return await schemeFetch(fetchParams);
          }
          if (!urlIsHttpHttpsScheme(requestCurrentURL(request3))) {
            return makeNetworkError("URL scheme must be a HTTP(S) scheme");
          }
          request3.responseTainting = "cors";
          return await httpFetch(fetchParams);
        })();
      }
      if (recursive) {
        return response;
      }
      if (response.status !== 0 && !response.internalResponse) {
        if (request3.responseTainting === "cors") {
        }
        if (request3.responseTainting === "basic") {
          response = filterResponse(response, "basic");
        } else if (request3.responseTainting === "cors") {
          response = filterResponse(response, "cors");
        } else if (request3.responseTainting === "opaque") {
          response = filterResponse(response, "opaque");
        } else {
          assert27(false);
        }
      }
      let internalResponse = response.status === 0 ? response : response.internalResponse;
      if (internalResponse.urlList.length === 0) {
        internalResponse.urlList.push(...request3.urlList);
      }
      if (!request3.timingAllowFailed) {
        response.timingAllowPassed = true;
      }
      if (response.type === "opaque" && internalResponse.status === 206 && internalResponse.rangeRequested && !request3.headers.contains("range")) {
        response = internalResponse = makeNetworkError();
      }
      if (response.status !== 0 && (request3.method === "HEAD" || request3.method === "CONNECT" || nullBodyStatus.includes(internalResponse.status))) {
        internalResponse.body = null;
        fetchParams.controller.dump = true;
      }
      if (request3.integrity) {
        const processBodyError = /* @__PURE__ */ __name((reason) => fetchFinale(fetchParams, makeNetworkError(reason)), "processBodyError");
        if (request3.responseTainting === "opaque" || response.body == null) {
          processBodyError(response.error);
          return;
        }
        const processBody = /* @__PURE__ */ __name((bytes) => {
          if (!bytesMatch(bytes, request3.integrity)) {
            processBodyError("integrity mismatch");
            return;
          }
          response.body = safelyExtractBody(bytes)[0];
          fetchFinale(fetchParams, response);
        }, "processBody");
        await fullyReadBody(response.body, processBody, processBodyError);
      } else {
        fetchFinale(fetchParams, response);
      }
    }
    __name(mainFetch, "mainFetch");
    function schemeFetch(fetchParams) {
      if (isCancelled(fetchParams) && fetchParams.request.redirectCount === 0) {
        return Promise.resolve(makeAppropriateNetworkError(fetchParams));
      }
      const { request: request3 } = fetchParams;
      const { protocol: scheme } = requestCurrentURL(request3);
      switch (scheme) {
        case "about:": {
          return Promise.resolve(makeNetworkError("about scheme is not supported"));
        }
        case "blob:": {
          if (!resolveObjectURL) {
            resolveObjectURL = require("buffer").resolveObjectURL;
          }
          const blobURLEntry = requestCurrentURL(request3);
          if (blobURLEntry.search.length !== 0) {
            return Promise.resolve(makeNetworkError("NetworkError when attempting to fetch resource."));
          }
          const blobURLEntryObject = resolveObjectURL(blobURLEntry.toString());
          if (request3.method !== "GET" || !isBlobLike(blobURLEntryObject)) {
            return Promise.resolve(makeNetworkError("invalid method"));
          }
          const bodyWithType = safelyExtractBody(blobURLEntryObject);
          const body = bodyWithType[0];
          const length = isomorphicEncode(`${body.length}`);
          const type = bodyWithType[1] ?? "";
          const response = makeResponse({
            statusText: "OK",
            headersList: [
              ["content-length", { name: "Content-Length", value: length }],
              ["content-type", { name: "Content-Type", value: type }]
            ]
          });
          response.body = body;
          return Promise.resolve(response);
        }
        case "data:": {
          const currentURL = requestCurrentURL(request3);
          const dataURLStruct = dataURLProcessor(currentURL);
          if (dataURLStruct === "failure") {
            return Promise.resolve(makeNetworkError("failed to fetch the data URL"));
          }
          const mimeType = serializeAMimeType(dataURLStruct.mimeType);
          return Promise.resolve(makeResponse({
            statusText: "OK",
            headersList: [
              ["content-type", { name: "Content-Type", value: mimeType }]
            ],
            body: safelyExtractBody(dataURLStruct.body)[0]
          }));
        }
        case "file:": {
          return Promise.resolve(makeNetworkError("not implemented... yet..."));
        }
        case "http:":
        case "https:": {
          return httpFetch(fetchParams).catch((err) => makeNetworkError(err));
        }
        default: {
          return Promise.resolve(makeNetworkError("unknown scheme"));
        }
      }
    }
    __name(schemeFetch, "schemeFetch");
    function finalizeResponse(fetchParams, response) {
      fetchParams.request.done = true;
      if (fetchParams.processResponseDone != null) {
        queueMicrotask(() => fetchParams.processResponseDone(response));
      }
    }
    __name(finalizeResponse, "finalizeResponse");
    function fetchFinale(fetchParams, response) {
      if (response.type === "error") {
        response.urlList = [fetchParams.request.urlList[0]];
        response.timingInfo = createOpaqueTimingInfo({
          startTime: fetchParams.timingInfo.startTime
        });
      }
      const processResponseEndOfBody = /* @__PURE__ */ __name(() => {
        fetchParams.request.done = true;
        if (fetchParams.processResponseEndOfBody != null) {
          queueMicrotask(() => fetchParams.processResponseEndOfBody(response));
        }
      }, "processResponseEndOfBody");
      if (fetchParams.processResponse != null) {
        queueMicrotask(() => fetchParams.processResponse(response));
      }
      if (response.body == null) {
        processResponseEndOfBody();
      } else {
        const identityTransformAlgorithm = /* @__PURE__ */ __name((chunk, controller) => {
          controller.enqueue(chunk);
        }, "identityTransformAlgorithm");
        const transformStream = new TransformStream({
          start() {
          },
          transform: identityTransformAlgorithm,
          flush: processResponseEndOfBody
        }, {
          size() {
            return 1;
          }
        }, {
          size() {
            return 1;
          }
        });
        response.body = { stream: response.body.stream.pipeThrough(transformStream) };
      }
      if (fetchParams.processResponseConsumeBody != null) {
        const processBody = /* @__PURE__ */ __name((nullOrBytes) => fetchParams.processResponseConsumeBody(response, nullOrBytes), "processBody");
        const processBodyError = /* @__PURE__ */ __name((failure) => fetchParams.processResponseConsumeBody(response, failure), "processBodyError");
        if (response.body == null) {
          queueMicrotask(() => processBody(null));
        } else {
          return fullyReadBody(response.body, processBody, processBodyError);
        }
        return Promise.resolve();
      }
    }
    __name(fetchFinale, "fetchFinale");
    async function httpFetch(fetchParams) {
      const request3 = fetchParams.request;
      let response = null;
      let actualResponse = null;
      const timingInfo = fetchParams.timingInfo;
      if (request3.serviceWorkers === "all") {
      }
      if (response === null) {
        if (request3.redirect === "follow") {
          request3.serviceWorkers = "none";
        }
        actualResponse = response = await httpNetworkOrCacheFetch(fetchParams);
        if (request3.responseTainting === "cors" && corsCheck(request3, response) === "failure") {
          return makeNetworkError("cors failure");
        }
        if (TAOCheck(request3, response) === "failure") {
          request3.timingAllowFailed = true;
        }
      }
      if ((request3.responseTainting === "opaque" || response.type === "opaque") && crossOriginResourcePolicyCheck(
        request3.origin,
        request3.client,
        request3.destination,
        actualResponse
      ) === "blocked") {
        return makeNetworkError("blocked");
      }
      if (redirectStatusSet.has(actualResponse.status)) {
        if (request3.redirect !== "manual") {
          fetchParams.controller.connection.destroy();
        }
        if (request3.redirect === "error") {
          response = makeNetworkError("unexpected redirect");
        } else if (request3.redirect === "manual") {
          response = actualResponse;
        } else if (request3.redirect === "follow") {
          response = await httpRedirectFetch(fetchParams, response);
        } else {
          assert27(false);
        }
      }
      response.timingInfo = timingInfo;
      return response;
    }
    __name(httpFetch, "httpFetch");
    function httpRedirectFetch(fetchParams, response) {
      const request3 = fetchParams.request;
      const actualResponse = response.internalResponse ? response.internalResponse : response;
      let locationURL;
      try {
        locationURL = responseLocationURL(
          actualResponse,
          requestCurrentURL(request3).hash
        );
        if (locationURL == null) {
          return response;
        }
      } catch (err) {
        return Promise.resolve(makeNetworkError(err));
      }
      if (!urlIsHttpHttpsScheme(locationURL)) {
        return Promise.resolve(makeNetworkError("URL scheme must be a HTTP(S) scheme"));
      }
      if (request3.redirectCount === 20) {
        return Promise.resolve(makeNetworkError("redirect count exceeded"));
      }
      request3.redirectCount += 1;
      if (request3.mode === "cors" && (locationURL.username || locationURL.password) && !sameOrigin(request3, locationURL)) {
        return Promise.resolve(makeNetworkError('cross origin not allowed for request mode "cors"'));
      }
      if (request3.responseTainting === "cors" && (locationURL.username || locationURL.password)) {
        return Promise.resolve(makeNetworkError(
          'URL cannot contain credentials for request mode "cors"'
        ));
      }
      if (actualResponse.status !== 303 && request3.body != null && request3.body.source == null) {
        return Promise.resolve(makeNetworkError());
      }
      if ([301, 302].includes(actualResponse.status) && request3.method === "POST" || actualResponse.status === 303 && !GET_OR_HEAD.includes(request3.method)) {
        request3.method = "GET";
        request3.body = null;
        for (const headerName of requestBodyHeader) {
          request3.headersList.delete(headerName);
        }
      }
      if (!sameOrigin(requestCurrentURL(request3), locationURL)) {
        request3.headersList.delete("authorization");
        request3.headersList.delete("cookie");
        request3.headersList.delete("host");
      }
      if (request3.body != null) {
        assert27(request3.body.source != null);
        request3.body = safelyExtractBody(request3.body.source)[0];
      }
      const timingInfo = fetchParams.timingInfo;
      timingInfo.redirectEndTime = timingInfo.postRedirectStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability);
      if (timingInfo.redirectStartTime === 0) {
        timingInfo.redirectStartTime = timingInfo.startTime;
      }
      request3.urlList.push(locationURL);
      setRequestReferrerPolicyOnRedirect(request3, actualResponse);
      return mainFetch(fetchParams, true);
    }
    __name(httpRedirectFetch, "httpRedirectFetch");
    async function httpNetworkOrCacheFetch(fetchParams, isAuthenticationFetch = false, isNewConnectionFetch = false) {
      const request3 = fetchParams.request;
      let httpFetchParams = null;
      let httpRequest = null;
      let response = null;
      const httpCache = null;
      const revalidatingFlag = false;
      if (request3.window === "no-window" && request3.redirect === "error") {
        httpFetchParams = fetchParams;
        httpRequest = request3;
      } else {
        httpRequest = makeRequest(request3);
        httpFetchParams = { ...fetchParams };
        httpFetchParams.request = httpRequest;
      }
      const includeCredentials = request3.credentials === "include" || request3.credentials === "same-origin" && request3.responseTainting === "basic";
      const contentLength = httpRequest.body ? httpRequest.body.length : null;
      let contentLengthHeaderValue = null;
      if (httpRequest.body == null && ["POST", "PUT"].includes(httpRequest.method)) {
        contentLengthHeaderValue = "0";
      }
      if (contentLength != null) {
        contentLengthHeaderValue = isomorphicEncode(`${contentLength}`);
      }
      if (contentLengthHeaderValue != null) {
        httpRequest.headersList.append("content-length", contentLengthHeaderValue);
      }
      if (contentLength != null && httpRequest.keepalive) {
      }
      if (httpRequest.referrer instanceof URL) {
        httpRequest.headersList.append("referer", isomorphicEncode(httpRequest.referrer.href));
      }
      appendRequestOriginHeader(httpRequest);
      appendFetchMetadata(httpRequest);
      if (!httpRequest.headersList.contains("user-agent")) {
        httpRequest.headersList.append("user-agent", typeof esbuildDetection === "undefined" ? "undici" : "node");
      }
      if (httpRequest.cache === "default" && (httpRequest.headersList.contains("if-modified-since") || httpRequest.headersList.contains("if-none-match") || httpRequest.headersList.contains("if-unmodified-since") || httpRequest.headersList.contains("if-match") || httpRequest.headersList.contains("if-range"))) {
        httpRequest.cache = "no-store";
      }
      if (httpRequest.cache === "no-cache" && !httpRequest.preventNoCacheCacheControlHeaderModification && !httpRequest.headersList.contains("cache-control")) {
        httpRequest.headersList.append("cache-control", "max-age=0");
      }
      if (httpRequest.cache === "no-store" || httpRequest.cache === "reload") {
        if (!httpRequest.headersList.contains("pragma")) {
          httpRequest.headersList.append("pragma", "no-cache");
        }
        if (!httpRequest.headersList.contains("cache-control")) {
          httpRequest.headersList.append("cache-control", "no-cache");
        }
      }
      if (httpRequest.headersList.contains("range")) {
        httpRequest.headersList.append("accept-encoding", "identity");
      }
      if (!httpRequest.headersList.contains("accept-encoding")) {
        if (urlHasHttpsScheme(requestCurrentURL(httpRequest))) {
          httpRequest.headersList.append("accept-encoding", "br, gzip, deflate");
        } else {
          httpRequest.headersList.append("accept-encoding", "gzip, deflate");
        }
      }
      httpRequest.headersList.delete("host");
      if (includeCredentials) {
      }
      if (httpCache == null) {
        httpRequest.cache = "no-store";
      }
      if (httpRequest.mode !== "no-store" && httpRequest.mode !== "reload") {
      }
      if (response == null) {
        if (httpRequest.mode === "only-if-cached") {
          return makeNetworkError("only if cached");
        }
        const forwardResponse = await httpNetworkFetch(
          httpFetchParams,
          includeCredentials,
          isNewConnectionFetch
        );
        if (!safeMethodsSet.has(httpRequest.method) && forwardResponse.status >= 200 && forwardResponse.status <= 399) {
        }
        if (revalidatingFlag && forwardResponse.status === 304) {
        }
        if (response == null) {
          response = forwardResponse;
        }
      }
      response.urlList = [...httpRequest.urlList];
      if (httpRequest.headersList.contains("range")) {
        response.rangeRequested = true;
      }
      response.requestIncludesCredentials = includeCredentials;
      if (response.status === 407) {
        if (request3.window === "no-window") {
          return makeNetworkError();
        }
        if (isCancelled(fetchParams)) {
          return makeAppropriateNetworkError(fetchParams);
        }
        return makeNetworkError("proxy authentication required");
      }
      if (
        // response’s status is 421
        response.status === 421 && // isNewConnectionFetch is false
        !isNewConnectionFetch && // request’s body is null, or request’s body is non-null and request’s body’s source is non-null
        (request3.body == null || request3.body.source != null)
      ) {
        if (isCancelled(fetchParams)) {
          return makeAppropriateNetworkError(fetchParams);
        }
        fetchParams.controller.connection.destroy();
        response = await httpNetworkOrCacheFetch(
          fetchParams,
          isAuthenticationFetch,
          true
        );
      }
      if (isAuthenticationFetch) {
      }
      return response;
    }
    __name(httpNetworkOrCacheFetch, "httpNetworkOrCacheFetch");
    async function httpNetworkFetch(fetchParams, includeCredentials = false, forceNewConnection = false) {
      assert27(!fetchParams.controller.connection || fetchParams.controller.connection.destroyed);
      fetchParams.controller.connection = {
        abort: null,
        destroyed: false,
        destroy(err) {
          if (!this.destroyed) {
            this.destroyed = true;
            this.abort?.(err ?? new DOMException2("The operation was aborted.", "AbortError"));
          }
        }
      };
      const request3 = fetchParams.request;
      let response = null;
      const timingInfo = fetchParams.timingInfo;
      const httpCache = null;
      if (httpCache == null) {
        request3.cache = "no-store";
      }
      const newConnection = forceNewConnection ? "yes" : "no";
      if (request3.mode === "websocket") {
      } else {
      }
      let requestBody = null;
      if (request3.body == null && fetchParams.processRequestEndOfBody) {
        queueMicrotask(() => fetchParams.processRequestEndOfBody());
      } else if (request3.body != null) {
        const processBodyChunk = /* @__PURE__ */ __name(async function* (bytes) {
          if (isCancelled(fetchParams)) {
            return;
          }
          yield bytes;
          fetchParams.processRequestBodyChunkLength?.(bytes.byteLength);
        }, "processBodyChunk");
        const processEndOfBody = /* @__PURE__ */ __name(() => {
          if (isCancelled(fetchParams)) {
            return;
          }
          if (fetchParams.processRequestEndOfBody) {
            fetchParams.processRequestEndOfBody();
          }
        }, "processEndOfBody");
        const processBodyError = /* @__PURE__ */ __name((e3) => {
          if (isCancelled(fetchParams)) {
            return;
          }
          if (e3.name === "AbortError") {
            fetchParams.controller.abort();
          } else {
            fetchParams.controller.terminate(e3);
          }
        }, "processBodyError");
        requestBody = async function* () {
          try {
            for await (const bytes of request3.body.stream) {
              yield* processBodyChunk(bytes);
            }
            processEndOfBody();
          } catch (err) {
            processBodyError(err);
          }
        }();
      }
      try {
        const { body, status: status2, statusText, headersList, socket } = await dispatch({ body: requestBody });
        if (socket) {
          response = makeResponse({ status: status2, statusText, headersList, socket });
        } else {
          const iterator = body[Symbol.asyncIterator]();
          fetchParams.controller.next = () => iterator.next();
          response = makeResponse({ status: status2, statusText, headersList });
        }
      } catch (err) {
        if (err.name === "AbortError") {
          fetchParams.controller.connection.destroy();
          return makeAppropriateNetworkError(fetchParams, err);
        }
        return makeNetworkError(err);
      }
      const pullAlgorithm = /* @__PURE__ */ __name(() => {
        fetchParams.controller.resume();
      }, "pullAlgorithm");
      const cancelAlgorithm = /* @__PURE__ */ __name((reason) => {
        fetchParams.controller.abort(reason);
      }, "cancelAlgorithm");
      if (!ReadableStream2) {
        ReadableStream2 = require("stream/web").ReadableStream;
      }
      const stream2 = new ReadableStream2(
        {
          async start(controller) {
            fetchParams.controller.controller = controller;
          },
          async pull(controller) {
            await pullAlgorithm(controller);
          },
          async cancel(reason) {
            await cancelAlgorithm(reason);
          }
        },
        {
          highWaterMark: 0,
          size() {
            return 1;
          }
        }
      );
      response.body = { stream: stream2 };
      fetchParams.controller.on("terminated", onAborted);
      fetchParams.controller.resume = async () => {
        while (true) {
          let bytes;
          let isFailure;
          try {
            const { done, value } = await fetchParams.controller.next();
            if (isAborted(fetchParams)) {
              break;
            }
            bytes = done ? void 0 : value;
          } catch (err) {
            if (fetchParams.controller.ended && !timingInfo.encodedBodySize) {
              bytes = void 0;
            } else {
              bytes = err;
              isFailure = true;
            }
          }
          if (bytes === void 0) {
            readableStreamClose(fetchParams.controller.controller);
            finalizeResponse(fetchParams, response);
            return;
          }
          timingInfo.decodedBodySize += bytes?.byteLength ?? 0;
          if (isFailure) {
            fetchParams.controller.terminate(bytes);
            return;
          }
          fetchParams.controller.controller.enqueue(new Uint8Array(bytes));
          if (isErrored(stream2)) {
            fetchParams.controller.terminate();
            return;
          }
          if (!fetchParams.controller.controller.desiredSize) {
            return;
          }
        }
      };
      function onAborted(reason) {
        if (isAborted(fetchParams)) {
          response.aborted = true;
          if (isReadable(stream2)) {
            fetchParams.controller.controller.error(
              fetchParams.controller.serializedAbortReason
            );
          }
        } else {
          if (isReadable(stream2)) {
            fetchParams.controller.controller.error(new TypeError("terminated", {
              cause: isErrorLike(reason) ? reason : void 0
            }));
          }
        }
        fetchParams.controller.connection.destroy();
      }
      __name(onAborted, "onAborted");
      return response;
      async function dispatch({ body }) {
        const url4 = requestCurrentURL(request3);
        const agent = fetchParams.controller.dispatcher;
        return new Promise((resolve19, reject) => agent.dispatch(
          {
            path: url4.pathname + url4.search,
            origin: url4.origin,
            method: request3.method,
            body: fetchParams.controller.dispatcher.isMockActive ? request3.body && (request3.body.source || request3.body.stream) : body,
            headers: request3.headersList.entries,
            maxRedirections: 0,
            upgrade: request3.mode === "websocket" ? "websocket" : void 0
          },
          {
            body: null,
            abort: null,
            onConnect(abort) {
              const { connection } = fetchParams.controller;
              if (connection.destroyed) {
                abort(new DOMException2("The operation was aborted.", "AbortError"));
              } else {
                fetchParams.controller.on("terminated", abort);
                this.abort = connection.abort = abort;
              }
            },
            onHeaders(status2, headersList, resume, statusText) {
              if (status2 < 200) {
                return;
              }
              let codings = [];
              let location = "";
              const headers = new Headers5();
              if (Array.isArray(headersList)) {
                for (let n2 = 0; n2 < headersList.length; n2 += 2) {
                  const key = headersList[n2 + 0].toString("latin1");
                  const val = headersList[n2 + 1].toString("latin1");
                  if (key.toLowerCase() === "content-encoding") {
                    codings = val.toLowerCase().split(",").map((x2) => x2.trim());
                  } else if (key.toLowerCase() === "location") {
                    location = val;
                  }
                  headers[kHeadersList].append(key, val);
                }
              } else {
                const keys = Object.keys(headersList);
                for (const key of keys) {
                  const val = headersList[key];
                  if (key.toLowerCase() === "content-encoding") {
                    codings = val.toLowerCase().split(",").map((x2) => x2.trim()).reverse();
                  } else if (key.toLowerCase() === "location") {
                    location = val;
                  }
                  headers[kHeadersList].append(key, val);
                }
              }
              this.body = new Readable2({ read: resume });
              const decoders = [];
              const willFollow = request3.redirect === "follow" && location && redirectStatusSet.has(status2);
              if (request3.method !== "HEAD" && request3.method !== "CONNECT" && !nullBodyStatus.includes(status2) && !willFollow) {
                for (const coding of codings) {
                  if (coding === "x-gzip" || coding === "gzip") {
                    decoders.push(zlib.createGunzip({
                      // Be less strict when decoding compressed responses, since sometimes
                      // servers send slightly invalid responses that are still accepted
                      // by common browsers.
                      // Always using Z_SYNC_FLUSH is what cURL does.
                      flush: zlib.constants.Z_SYNC_FLUSH,
                      finishFlush: zlib.constants.Z_SYNC_FLUSH
                    }));
                  } else if (coding === "deflate") {
                    decoders.push(zlib.createInflate());
                  } else if (coding === "br") {
                    decoders.push(zlib.createBrotliDecompress());
                  } else {
                    decoders.length = 0;
                    break;
                  }
                }
              }
              resolve19({
                status: status2,
                statusText,
                headersList: headers[kHeadersList],
                body: decoders.length ? pipeline(this.body, ...decoders, () => {
                }) : this.body.on("error", () => {
                })
              });
              return true;
            },
            onData(chunk) {
              if (fetchParams.controller.dump) {
                return;
              }
              const bytes = chunk;
              timingInfo.encodedBodySize += bytes.byteLength;
              return this.body.push(bytes);
            },
            onComplete() {
              if (this.abort) {
                fetchParams.controller.off("terminated", this.abort);
              }
              fetchParams.controller.ended = true;
              this.body.push(null);
            },
            onError(error2) {
              if (this.abort) {
                fetchParams.controller.off("terminated", this.abort);
              }
              this.body?.destroy(error2);
              fetchParams.controller.terminate(error2);
              reject(error2);
            },
            onUpgrade(status2, headersList, socket) {
              if (status2 !== 101) {
                return;
              }
              const headers = new Headers5();
              for (let n2 = 0; n2 < headersList.length; n2 += 2) {
                const key = headersList[n2 + 0].toString("latin1");
                const val = headersList[n2 + 1].toString("latin1");
                headers[kHeadersList].append(key, val);
              }
              resolve19({
                status: status2,
                statusText: STATUS_CODES[status2],
                headersList: headers[kHeadersList],
                socket
              });
              return true;
            }
          }
        ));
      }
      __name(dispatch, "dispatch");
    }
    __name(httpNetworkFetch, "httpNetworkFetch");
    module3.exports = {
      fetch: fetch15,
      Fetch,
      fetching,
      finalizeAndReportTiming
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fileapi/symbols.js
var require_symbols8 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fileapi/symbols.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = {
      kState: Symbol("FileReader state"),
      kResult: Symbol("FileReader result"),
      kError: Symbol("FileReader error"),
      kLastProgressEventFired: Symbol("FileReader last progress event fired timestamp"),
      kEvents: Symbol("FileReader events"),
      kAborted: Symbol("FileReader aborted")
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fileapi/progressevent.js
var require_progressevent2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fileapi/progressevent.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { webidl } = require_webidl2();
    var kState = Symbol("ProgressEvent state");
    var ProgressEvent = class extends Event {
      constructor(type, eventInitDict = {}) {
        type = webidl.converters.DOMString(type);
        eventInitDict = webidl.converters.ProgressEventInit(eventInitDict ?? {});
        super(type, eventInitDict);
        this[kState] = {
          lengthComputable: eventInitDict.lengthComputable,
          loaded: eventInitDict.loaded,
          total: eventInitDict.total
        };
      }
      get lengthComputable() {
        webidl.brandCheck(this, ProgressEvent);
        return this[kState].lengthComputable;
      }
      get loaded() {
        webidl.brandCheck(this, ProgressEvent);
        return this[kState].loaded;
      }
      get total() {
        webidl.brandCheck(this, ProgressEvent);
        return this[kState].total;
      }
    };
    __name(ProgressEvent, "ProgressEvent");
    webidl.converters.ProgressEventInit = webidl.dictionaryConverter([
      {
        key: "lengthComputable",
        converter: webidl.converters.boolean,
        defaultValue: false
      },
      {
        key: "loaded",
        converter: webidl.converters["unsigned long long"],
        defaultValue: 0
      },
      {
        key: "total",
        converter: webidl.converters["unsigned long long"],
        defaultValue: 0
      },
      {
        key: "bubbles",
        converter: webidl.converters.boolean,
        defaultValue: false
      },
      {
        key: "cancelable",
        converter: webidl.converters.boolean,
        defaultValue: false
      },
      {
        key: "composed",
        converter: webidl.converters.boolean,
        defaultValue: false
      }
    ]);
    module3.exports = {
      ProgressEvent
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fileapi/encoding.js
var require_encoding3 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fileapi/encoding.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    function getEncoding(label) {
      if (!label) {
        return "failure";
      }
      switch (label.trim().toLowerCase()) {
        case "unicode-1-1-utf-8":
        case "unicode11utf8":
        case "unicode20utf8":
        case "utf-8":
        case "utf8":
        case "x-unicode20utf8":
          return "UTF-8";
        case "866":
        case "cp866":
        case "csibm866":
        case "ibm866":
          return "IBM866";
        case "csisolatin2":
        case "iso-8859-2":
        case "iso-ir-101":
        case "iso8859-2":
        case "iso88592":
        case "iso_8859-2":
        case "iso_8859-2:1987":
        case "l2":
        case "latin2":
          return "ISO-8859-2";
        case "csisolatin3":
        case "iso-8859-3":
        case "iso-ir-109":
        case "iso8859-3":
        case "iso88593":
        case "iso_8859-3":
        case "iso_8859-3:1988":
        case "l3":
        case "latin3":
          return "ISO-8859-3";
        case "csisolatin4":
        case "iso-8859-4":
        case "iso-ir-110":
        case "iso8859-4":
        case "iso88594":
        case "iso_8859-4":
        case "iso_8859-4:1988":
        case "l4":
        case "latin4":
          return "ISO-8859-4";
        case "csisolatincyrillic":
        case "cyrillic":
        case "iso-8859-5":
        case "iso-ir-144":
        case "iso8859-5":
        case "iso88595":
        case "iso_8859-5":
        case "iso_8859-5:1988":
          return "ISO-8859-5";
        case "arabic":
        case "asmo-708":
        case "csiso88596e":
        case "csiso88596i":
        case "csisolatinarabic":
        case "ecma-114":
        case "iso-8859-6":
        case "iso-8859-6-e":
        case "iso-8859-6-i":
        case "iso-ir-127":
        case "iso8859-6":
        case "iso88596":
        case "iso_8859-6":
        case "iso_8859-6:1987":
          return "ISO-8859-6";
        case "csisolatingreek":
        case "ecma-118":
        case "elot_928":
        case "greek":
        case "greek8":
        case "iso-8859-7":
        case "iso-ir-126":
        case "iso8859-7":
        case "iso88597":
        case "iso_8859-7":
        case "iso_8859-7:1987":
        case "sun_eu_greek":
          return "ISO-8859-7";
        case "csiso88598e":
        case "csisolatinhebrew":
        case "hebrew":
        case "iso-8859-8":
        case "iso-8859-8-e":
        case "iso-ir-138":
        case "iso8859-8":
        case "iso88598":
        case "iso_8859-8":
        case "iso_8859-8:1988":
        case "visual":
          return "ISO-8859-8";
        case "csiso88598i":
        case "iso-8859-8-i":
        case "logical":
          return "ISO-8859-8-I";
        case "csisolatin6":
        case "iso-8859-10":
        case "iso-ir-157":
        case "iso8859-10":
        case "iso885910":
        case "l6":
        case "latin6":
          return "ISO-8859-10";
        case "iso-8859-13":
        case "iso8859-13":
        case "iso885913":
          return "ISO-8859-13";
        case "iso-8859-14":
        case "iso8859-14":
        case "iso885914":
          return "ISO-8859-14";
        case "csisolatin9":
        case "iso-8859-15":
        case "iso8859-15":
        case "iso885915":
        case "iso_8859-15":
        case "l9":
          return "ISO-8859-15";
        case "iso-8859-16":
          return "ISO-8859-16";
        case "cskoi8r":
        case "koi":
        case "koi8":
        case "koi8-r":
        case "koi8_r":
          return "KOI8-R";
        case "koi8-ru":
        case "koi8-u":
          return "KOI8-U";
        case "csmacintosh":
        case "mac":
        case "macintosh":
        case "x-mac-roman":
          return "macintosh";
        case "iso-8859-11":
        case "iso8859-11":
        case "iso885911":
        case "tis-620":
        case "windows-874":
          return "windows-874";
        case "cp1250":
        case "windows-1250":
        case "x-cp1250":
          return "windows-1250";
        case "cp1251":
        case "windows-1251":
        case "x-cp1251":
          return "windows-1251";
        case "ansi_x3.4-1968":
        case "ascii":
        case "cp1252":
        case "cp819":
        case "csisolatin1":
        case "ibm819":
        case "iso-8859-1":
        case "iso-ir-100":
        case "iso8859-1":
        case "iso88591":
        case "iso_8859-1":
        case "iso_8859-1:1987":
        case "l1":
        case "latin1":
        case "us-ascii":
        case "windows-1252":
        case "x-cp1252":
          return "windows-1252";
        case "cp1253":
        case "windows-1253":
        case "x-cp1253":
          return "windows-1253";
        case "cp1254":
        case "csisolatin5":
        case "iso-8859-9":
        case "iso-ir-148":
        case "iso8859-9":
        case "iso88599":
        case "iso_8859-9":
        case "iso_8859-9:1989":
        case "l5":
        case "latin5":
        case "windows-1254":
        case "x-cp1254":
          return "windows-1254";
        case "cp1255":
        case "windows-1255":
        case "x-cp1255":
          return "windows-1255";
        case "cp1256":
        case "windows-1256":
        case "x-cp1256":
          return "windows-1256";
        case "cp1257":
        case "windows-1257":
        case "x-cp1257":
          return "windows-1257";
        case "cp1258":
        case "windows-1258":
        case "x-cp1258":
          return "windows-1258";
        case "x-mac-cyrillic":
        case "x-mac-ukrainian":
          return "x-mac-cyrillic";
        case "chinese":
        case "csgb2312":
        case "csiso58gb231280":
        case "gb2312":
        case "gb_2312":
        case "gb_2312-80":
        case "gbk":
        case "iso-ir-58":
        case "x-gbk":
          return "GBK";
        case "gb18030":
          return "gb18030";
        case "big5":
        case "big5-hkscs":
        case "cn-big5":
        case "csbig5":
        case "x-x-big5":
          return "Big5";
        case "cseucpkdfmtjapanese":
        case "euc-jp":
        case "x-euc-jp":
          return "EUC-JP";
        case "csiso2022jp":
        case "iso-2022-jp":
          return "ISO-2022-JP";
        case "csshiftjis":
        case "ms932":
        case "ms_kanji":
        case "shift-jis":
        case "shift_jis":
        case "sjis":
        case "windows-31j":
        case "x-sjis":
          return "Shift_JIS";
        case "cseuckr":
        case "csksc56011987":
        case "euc-kr":
        case "iso-ir-149":
        case "korean":
        case "ks_c_5601-1987":
        case "ks_c_5601-1989":
        case "ksc5601":
        case "ksc_5601":
        case "windows-949":
          return "EUC-KR";
        case "csiso2022kr":
        case "hz-gb-2312":
        case "iso-2022-cn":
        case "iso-2022-cn-ext":
        case "iso-2022-kr":
        case "replacement":
          return "replacement";
        case "unicodefffe":
        case "utf-16be":
          return "UTF-16BE";
        case "csunicode":
        case "iso-10646-ucs-2":
        case "ucs-2":
        case "unicode":
        case "unicodefeff":
        case "utf-16":
        case "utf-16le":
          return "UTF-16LE";
        case "x-user-defined":
          return "x-user-defined";
        default:
          return "failure";
      }
    }
    __name(getEncoding, "getEncoding");
    module3.exports = {
      getEncoding
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fileapi/util.js
var require_util15 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fileapi/util.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var {
      kState,
      kError,
      kResult,
      kAborted,
      kLastProgressEventFired
    } = require_symbols8();
    var { ProgressEvent } = require_progressevent2();
    var { getEncoding } = require_encoding3();
    var { DOMException: DOMException2 } = require_constants9();
    var { serializeAMimeType, parseMIMEType } = require_dataURL2();
    var { types } = require("util");
    var { StringDecoder: StringDecoder2 } = require("string_decoder");
    var { btoa: btoa2 } = require("buffer");
    var staticPropertyDescriptors = {
      enumerable: true,
      writable: false,
      configurable: false
    };
    function readOperation(fr2, blob, type, encodingName) {
      if (fr2[kState] === "loading") {
        throw new DOMException2("Invalid state", "InvalidStateError");
      }
      fr2[kState] = "loading";
      fr2[kResult] = null;
      fr2[kError] = null;
      const stream2 = blob.stream();
      const reader = stream2.getReader();
      const bytes = [];
      let chunkPromise = reader.read();
      let isFirstChunk = true;
      (async () => {
        while (!fr2[kAborted]) {
          try {
            const { done, value } = await chunkPromise;
            if (isFirstChunk && !fr2[kAborted]) {
              queueMicrotask(() => {
                fireAProgressEvent("loadstart", fr2);
              });
            }
            isFirstChunk = false;
            if (!done && types.isUint8Array(value)) {
              bytes.push(value);
              if ((fr2[kLastProgressEventFired] === void 0 || Date.now() - fr2[kLastProgressEventFired] >= 50) && !fr2[kAborted]) {
                fr2[kLastProgressEventFired] = Date.now();
                queueMicrotask(() => {
                  fireAProgressEvent("progress", fr2);
                });
              }
              chunkPromise = reader.read();
            } else if (done) {
              queueMicrotask(() => {
                fr2[kState] = "done";
                try {
                  const result = packageData(bytes, type, blob.type, encodingName);
                  if (fr2[kAborted]) {
                    return;
                  }
                  fr2[kResult] = result;
                  fireAProgressEvent("load", fr2);
                } catch (error2) {
                  fr2[kError] = error2;
                  fireAProgressEvent("error", fr2);
                }
                if (fr2[kState] !== "loading") {
                  fireAProgressEvent("loadend", fr2);
                }
              });
              break;
            }
          } catch (error2) {
            if (fr2[kAborted]) {
              return;
            }
            queueMicrotask(() => {
              fr2[kState] = "done";
              fr2[kError] = error2;
              fireAProgressEvent("error", fr2);
              if (fr2[kState] !== "loading") {
                fireAProgressEvent("loadend", fr2);
              }
            });
            break;
          }
        }
      })();
    }
    __name(readOperation, "readOperation");
    function fireAProgressEvent(e3, reader) {
      const event = new ProgressEvent(e3, {
        bubbles: false,
        cancelable: false
      });
      reader.dispatchEvent(event);
    }
    __name(fireAProgressEvent, "fireAProgressEvent");
    function packageData(bytes, type, mimeType, encodingName) {
      switch (type) {
        case "DataURL": {
          let dataURL = "data:";
          const parsed = parseMIMEType(mimeType || "application/octet-stream");
          if (parsed !== "failure") {
            dataURL += serializeAMimeType(parsed);
          }
          dataURL += ";base64,";
          const decoder = new StringDecoder2("latin1");
          for (const chunk of bytes) {
            dataURL += btoa2(decoder.write(chunk));
          }
          dataURL += btoa2(decoder.end());
          return dataURL;
        }
        case "Text": {
          let encoding = "failure";
          if (encodingName) {
            encoding = getEncoding(encodingName);
          }
          if (encoding === "failure" && mimeType) {
            const type2 = parseMIMEType(mimeType);
            if (type2 !== "failure") {
              encoding = getEncoding(type2.parameters.get("charset"));
            }
          }
          if (encoding === "failure") {
            encoding = "UTF-8";
          }
          return decode(bytes, encoding);
        }
        case "ArrayBuffer": {
          const sequence = combineByteSequences(bytes);
          return sequence.buffer;
        }
        case "BinaryString": {
          let binaryString = "";
          const decoder = new StringDecoder2("latin1");
          for (const chunk of bytes) {
            binaryString += decoder.write(chunk);
          }
          binaryString += decoder.end();
          return binaryString;
        }
      }
    }
    __name(packageData, "packageData");
    function decode(ioQueue, encoding) {
      const bytes = combineByteSequences(ioQueue);
      const BOMEncoding = BOMSniffing(bytes);
      let slice = 0;
      if (BOMEncoding !== null) {
        encoding = BOMEncoding;
        slice = BOMEncoding === "UTF-8" ? 3 : 2;
      }
      const sliced = bytes.slice(slice);
      return new TextDecoder(encoding).decode(sliced);
    }
    __name(decode, "decode");
    function BOMSniffing(ioQueue) {
      const [a, b2, c2] = ioQueue;
      if (a === 239 && b2 === 187 && c2 === 191) {
        return "UTF-8";
      } else if (a === 254 && b2 === 255) {
        return "UTF-16BE";
      } else if (a === 255 && b2 === 254) {
        return "UTF-16LE";
      }
      return null;
    }
    __name(BOMSniffing, "BOMSniffing");
    function combineByteSequences(sequences) {
      const size = sequences.reduce((a, b2) => {
        return a + b2.byteLength;
      }, 0);
      let offset = 0;
      return sequences.reduce((a, b2) => {
        a.set(b2, offset);
        offset += b2.byteLength;
        return a;
      }, new Uint8Array(size));
    }
    __name(combineByteSequences, "combineByteSequences");
    module3.exports = {
      staticPropertyDescriptors,
      readOperation,
      fireAProgressEvent
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fileapi/filereader.js
var require_filereader2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/fileapi/filereader.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var {
      staticPropertyDescriptors,
      readOperation,
      fireAProgressEvent
    } = require_util15();
    var {
      kState,
      kError,
      kResult,
      kEvents,
      kAborted
    } = require_symbols8();
    var { webidl } = require_webidl2();
    var { kEnumerableProperty } = require_util12();
    var FileReader = class extends EventTarget {
      constructor() {
        super();
        this[kState] = "empty";
        this[kResult] = null;
        this[kError] = null;
        this[kEvents] = {
          loadend: null,
          error: null,
          abort: null,
          load: null,
          progress: null,
          loadstart: null
        };
      }
      /**
       * @see https://w3c.github.io/FileAPI/#dfn-readAsArrayBuffer
       * @param {import('buffer').Blob} blob
       */
      readAsArrayBuffer(blob) {
        webidl.brandCheck(this, FileReader);
        webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsArrayBuffer" });
        blob = webidl.converters.Blob(blob, { strict: false });
        readOperation(this, blob, "ArrayBuffer");
      }
      /**
       * @see https://w3c.github.io/FileAPI/#readAsBinaryString
       * @param {import('buffer').Blob} blob
       */
      readAsBinaryString(blob) {
        webidl.brandCheck(this, FileReader);
        webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsBinaryString" });
        blob = webidl.converters.Blob(blob, { strict: false });
        readOperation(this, blob, "BinaryString");
      }
      /**
       * @see https://w3c.github.io/FileAPI/#readAsDataText
       * @param {import('buffer').Blob} blob
       * @param {string?} encoding
       */
      readAsText(blob, encoding = void 0) {
        webidl.brandCheck(this, FileReader);
        webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsText" });
        blob = webidl.converters.Blob(blob, { strict: false });
        if (encoding !== void 0) {
          encoding = webidl.converters.DOMString(encoding);
        }
        readOperation(this, blob, "Text", encoding);
      }
      /**
       * @see https://w3c.github.io/FileAPI/#dfn-readAsDataURL
       * @param {import('buffer').Blob} blob
       */
      readAsDataURL(blob) {
        webidl.brandCheck(this, FileReader);
        webidl.argumentLengthCheck(arguments, 1, { header: "FileReader.readAsDataURL" });
        blob = webidl.converters.Blob(blob, { strict: false });
        readOperation(this, blob, "DataURL");
      }
      /**
       * @see https://w3c.github.io/FileAPI/#dfn-abort
       */
      abort() {
        if (this[kState] === "empty" || this[kState] === "done") {
          this[kResult] = null;
          return;
        }
        if (this[kState] === "loading") {
          this[kState] = "done";
          this[kResult] = null;
        }
        this[kAborted] = true;
        fireAProgressEvent("abort", this);
        if (this[kState] !== "loading") {
          fireAProgressEvent("loadend", this);
        }
      }
      /**
       * @see https://w3c.github.io/FileAPI/#dom-filereader-readystate
       */
      get readyState() {
        webidl.brandCheck(this, FileReader);
        switch (this[kState]) {
          case "empty":
            return this.EMPTY;
          case "loading":
            return this.LOADING;
          case "done":
            return this.DONE;
        }
      }
      /**
       * @see https://w3c.github.io/FileAPI/#dom-filereader-result
       */
      get result() {
        webidl.brandCheck(this, FileReader);
        return this[kResult];
      }
      /**
       * @see https://w3c.github.io/FileAPI/#dom-filereader-error
       */
      get error() {
        webidl.brandCheck(this, FileReader);
        return this[kError];
      }
      get onloadend() {
        webidl.brandCheck(this, FileReader);
        return this[kEvents].loadend;
      }
      set onloadend(fn2) {
        webidl.brandCheck(this, FileReader);
        if (this[kEvents].loadend) {
          this.removeEventListener("loadend", this[kEvents].loadend);
        }
        if (typeof fn2 === "function") {
          this[kEvents].loadend = fn2;
          this.addEventListener("loadend", fn2);
        } else {
          this[kEvents].loadend = null;
        }
      }
      get onerror() {
        webidl.brandCheck(this, FileReader);
        return this[kEvents].error;
      }
      set onerror(fn2) {
        webidl.brandCheck(this, FileReader);
        if (this[kEvents].error) {
          this.removeEventListener("error", this[kEvents].error);
        }
        if (typeof fn2 === "function") {
          this[kEvents].error = fn2;
          this.addEventListener("error", fn2);
        } else {
          this[kEvents].error = null;
        }
      }
      get onloadstart() {
        webidl.brandCheck(this, FileReader);
        return this[kEvents].loadstart;
      }
      set onloadstart(fn2) {
        webidl.brandCheck(this, FileReader);
        if (this[kEvents].loadstart) {
          this.removeEventListener("loadstart", this[kEvents].loadstart);
        }
        if (typeof fn2 === "function") {
          this[kEvents].loadstart = fn2;
          this.addEventListener("loadstart", fn2);
        } else {
          this[kEvents].loadstart = null;
        }
      }
      get onprogress() {
        webidl.brandCheck(this, FileReader);
        return this[kEvents].progress;
      }
      set onprogress(fn2) {
        webidl.brandCheck(this, FileReader);
        if (this[kEvents].progress) {
          this.removeEventListener("progress", this[kEvents].progress);
        }
        if (typeof fn2 === "function") {
          this[kEvents].progress = fn2;
          this.addEventListener("progress", fn2);
        } else {
          this[kEvents].progress = null;
        }
      }
      get onload() {
        webidl.brandCheck(this, FileReader);
        return this[kEvents].load;
      }
      set onload(fn2) {
        webidl.brandCheck(this, FileReader);
        if (this[kEvents].load) {
          this.removeEventListener("load", this[kEvents].load);
        }
        if (typeof fn2 === "function") {
          this[kEvents].load = fn2;
          this.addEventListener("load", fn2);
        } else {
          this[kEvents].load = null;
        }
      }
      get onabort() {
        webidl.brandCheck(this, FileReader);
        return this[kEvents].abort;
      }
      set onabort(fn2) {
        webidl.brandCheck(this, FileReader);
        if (this[kEvents].abort) {
          this.removeEventListener("abort", this[kEvents].abort);
        }
        if (typeof fn2 === "function") {
          this[kEvents].abort = fn2;
          this.addEventListener("abort", fn2);
        } else {
          this[kEvents].abort = null;
        }
      }
    };
    __name(FileReader, "FileReader");
    FileReader.EMPTY = FileReader.prototype.EMPTY = 0;
    FileReader.LOADING = FileReader.prototype.LOADING = 1;
    FileReader.DONE = FileReader.prototype.DONE = 2;
    Object.defineProperties(FileReader.prototype, {
      EMPTY: staticPropertyDescriptors,
      LOADING: staticPropertyDescriptors,
      DONE: staticPropertyDescriptors,
      readAsArrayBuffer: kEnumerableProperty,
      readAsBinaryString: kEnumerableProperty,
      readAsText: kEnumerableProperty,
      readAsDataURL: kEnumerableProperty,
      abort: kEnumerableProperty,
      readyState: kEnumerableProperty,
      result: kEnumerableProperty,
      error: kEnumerableProperty,
      onloadstart: kEnumerableProperty,
      onprogress: kEnumerableProperty,
      onload: kEnumerableProperty,
      onabort: kEnumerableProperty,
      onerror: kEnumerableProperty,
      onloadend: kEnumerableProperty,
      [Symbol.toStringTag]: {
        value: "FileReader",
        writable: false,
        enumerable: false,
        configurable: true
      }
    });
    Object.defineProperties(FileReader, {
      EMPTY: staticPropertyDescriptors,
      LOADING: staticPropertyDescriptors,
      DONE: staticPropertyDescriptors
    });
    module3.exports = {
      FileReader
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/cache/symbols.js
var require_symbols9 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/cache/symbols.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = {
      kConstruct: require_symbols6().kConstruct
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/cache/util.js
var require_util16 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/cache/util.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var assert27 = require("assert");
    var { URLSerializer } = require_dataURL2();
    var { isValidHeaderName } = require_util13();
    function urlEquals(A2, B2, excludeFragment = false) {
      const serializedA = URLSerializer(A2, excludeFragment);
      const serializedB = URLSerializer(B2, excludeFragment);
      return serializedA === serializedB;
    }
    __name(urlEquals, "urlEquals");
    function fieldValues(header) {
      assert27(header !== null);
      const values = [];
      for (let value of header.split(",")) {
        value = value.trim();
        if (!value.length) {
          continue;
        } else if (!isValidHeaderName(value)) {
          continue;
        }
        values.push(value);
      }
      return values;
    }
    __name(fieldValues, "fieldValues");
    module3.exports = {
      urlEquals,
      fieldValues
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/cache/cache.js
var require_cache3 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/cache/cache.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { kConstruct } = require_symbols9();
    var { urlEquals, fieldValues: getFieldValues } = require_util16();
    var { kEnumerableProperty, isDisturbed } = require_util12();
    var { kHeadersList } = require_symbols6();
    var { webidl } = require_webidl2();
    var { Response: Response9, cloneResponse } = require_response3();
    var { Request: Request3 } = require_request5();
    var { kState, kHeaders, kGuard, kRealm } = require_symbols7();
    var { fetching } = require_fetch2();
    var { urlIsHttpHttpsScheme, createDeferredPromise, readAllBytes } = require_util13();
    var assert27 = require("assert");
    var { getGlobalDispatcher: getGlobalDispatcher2 } = require_global4();
    var Cache3 = class {
      /**
       * @see https://w3c.github.io/ServiceWorker/#dfn-relevant-request-response-list
       * @type {requestResponseList}
       */
      #relevantRequestResponseList;
      constructor() {
        if (arguments[0] !== kConstruct) {
          webidl.illegalConstructor();
        }
        this.#relevantRequestResponseList = arguments[1];
      }
      async match(request3, options29 = {}) {
        webidl.brandCheck(this, Cache3);
        webidl.argumentLengthCheck(arguments, 1, { header: "Cache.match" });
        request3 = webidl.converters.RequestInfo(request3);
        options29 = webidl.converters.CacheQueryOptions(options29);
        const p2 = await this.matchAll(request3, options29);
        if (p2.length === 0) {
          return;
        }
        return p2[0];
      }
      async matchAll(request3 = void 0, options29 = {}) {
        webidl.brandCheck(this, Cache3);
        if (request3 !== void 0)
          request3 = webidl.converters.RequestInfo(request3);
        options29 = webidl.converters.CacheQueryOptions(options29);
        let r3 = null;
        if (request3 !== void 0) {
          if (request3 instanceof Request3) {
            r3 = request3[kState];
            if (r3.method !== "GET" && !options29.ignoreMethod) {
              return [];
            }
          } else if (typeof request3 === "string") {
            r3 = new Request3(request3)[kState];
          }
        }
        const responses = [];
        if (request3 === void 0) {
          for (const requestResponse of this.#relevantRequestResponseList) {
            responses.push(requestResponse[1]);
          }
        } else {
          const requestResponses = this.#queryCache(r3, options29);
          for (const requestResponse of requestResponses) {
            responses.push(requestResponse[1]);
          }
        }
        const responseList = [];
        for (const response of responses) {
          const responseObject = new Response9(response.body?.source ?? null);
          const body = responseObject[kState].body;
          responseObject[kState] = response;
          responseObject[kState].body = body;
          responseObject[kHeaders][kHeadersList] = response.headersList;
          responseObject[kHeaders][kGuard] = "immutable";
          responseList.push(responseObject);
        }
        return Object.freeze(responseList);
      }
      async add(request3) {
        webidl.brandCheck(this, Cache3);
        webidl.argumentLengthCheck(arguments, 1, { header: "Cache.add" });
        request3 = webidl.converters.RequestInfo(request3);
        const requests = [request3];
        const responseArrayPromise = this.addAll(requests);
        return await responseArrayPromise;
      }
      async addAll(requests) {
        webidl.brandCheck(this, Cache3);
        webidl.argumentLengthCheck(arguments, 1, { header: "Cache.addAll" });
        requests = webidl.converters["sequence<RequestInfo>"](requests);
        const responsePromises = [];
        const requestList = [];
        for (const request3 of requests) {
          if (typeof request3 === "string") {
            continue;
          }
          const r3 = request3[kState];
          if (!urlIsHttpHttpsScheme(r3.url) || r3.method !== "GET") {
            throw webidl.errors.exception({
              header: "Cache.addAll",
              message: "Expected http/s scheme when method is not GET."
            });
          }
        }
        const fetchControllers = [];
        for (const request3 of requests) {
          const r3 = new Request3(request3)[kState];
          if (!urlIsHttpHttpsScheme(r3.url)) {
            throw webidl.errors.exception({
              header: "Cache.addAll",
              message: "Expected http/s scheme."
            });
          }
          r3.initiator = "fetch";
          r3.destination = "subresource";
          requestList.push(r3);
          const responsePromise = createDeferredPromise();
          fetchControllers.push(fetching({
            request: r3,
            dispatcher: getGlobalDispatcher2(),
            processResponse(response) {
              if (response.type === "error" || response.status === 206 || response.status < 200 || response.status > 299) {
                responsePromise.reject(webidl.errors.exception({
                  header: "Cache.addAll",
                  message: "Received an invalid status code or the request failed."
                }));
              } else if (response.headersList.contains("vary")) {
                const fieldValues = getFieldValues(response.headersList.get("vary"));
                for (const fieldValue of fieldValues) {
                  if (fieldValue === "*") {
                    responsePromise.reject(webidl.errors.exception({
                      header: "Cache.addAll",
                      message: "invalid vary field value"
                    }));
                    for (const controller of fetchControllers) {
                      controller.abort();
                    }
                    return;
                  }
                }
              }
            },
            processResponseEndOfBody(response) {
              if (response.aborted) {
                responsePromise.reject(new DOMException("aborted", "AbortError"));
                return;
              }
              responsePromise.resolve(response);
            }
          }));
          responsePromises.push(responsePromise.promise);
        }
        const p2 = Promise.all(responsePromises);
        const responses = await p2;
        const operations = [];
        let index = 0;
        for (const response of responses) {
          const operation = {
            type: "put",
            // 7.3.2
            request: requestList[index],
            // 7.3.3
            response
            // 7.3.4
          };
          operations.push(operation);
          index++;
        }
        const cacheJobPromise = createDeferredPromise();
        let errorData = null;
        try {
          this.#batchCacheOperations(operations);
        } catch (e3) {
          errorData = e3;
        }
        queueMicrotask(() => {
          if (errorData === null) {
            cacheJobPromise.resolve(void 0);
          } else {
            cacheJobPromise.reject(errorData);
          }
        });
        return cacheJobPromise.promise;
      }
      async put(request3, response) {
        webidl.brandCheck(this, Cache3);
        webidl.argumentLengthCheck(arguments, 2, { header: "Cache.put" });
        request3 = webidl.converters.RequestInfo(request3);
        response = webidl.converters.Response(response);
        let innerRequest = null;
        if (request3 instanceof Request3) {
          innerRequest = request3[kState];
        } else {
          innerRequest = new Request3(request3)[kState];
        }
        if (!urlIsHttpHttpsScheme(innerRequest.url) || innerRequest.method !== "GET") {
          throw webidl.errors.exception({
            header: "Cache.put",
            message: "Expected an http/s scheme when method is not GET"
          });
        }
        const innerResponse = response[kState];
        if (innerResponse.status === 206) {
          throw webidl.errors.exception({
            header: "Cache.put",
            message: "Got 206 status"
          });
        }
        if (innerResponse.headersList.contains("vary")) {
          const fieldValues = getFieldValues(innerResponse.headersList.get("vary"));
          for (const fieldValue of fieldValues) {
            if (fieldValue === "*") {
              throw webidl.errors.exception({
                header: "Cache.put",
                message: "Got * vary field value"
              });
            }
          }
        }
        if (innerResponse.body && (isDisturbed(innerResponse.body.stream) || innerResponse.body.stream.locked)) {
          throw webidl.errors.exception({
            header: "Cache.put",
            message: "Response body is locked or disturbed"
          });
        }
        const clonedResponse = cloneResponse(innerResponse);
        const bodyReadPromise = createDeferredPromise();
        if (innerResponse.body != null) {
          const stream2 = innerResponse.body.stream;
          const reader = stream2.getReader();
          readAllBytes(reader).then(bodyReadPromise.resolve, bodyReadPromise.reject);
        } else {
          bodyReadPromise.resolve(void 0);
        }
        const operations = [];
        const operation = {
          type: "put",
          // 14.
          request: innerRequest,
          // 15.
          response: clonedResponse
          // 16.
        };
        operations.push(operation);
        const bytes = await bodyReadPromise.promise;
        if (clonedResponse.body != null) {
          clonedResponse.body.source = bytes;
        }
        const cacheJobPromise = createDeferredPromise();
        let errorData = null;
        try {
          this.#batchCacheOperations(operations);
        } catch (e3) {
          errorData = e3;
        }
        queueMicrotask(() => {
          if (errorData === null) {
            cacheJobPromise.resolve();
          } else {
            cacheJobPromise.reject(errorData);
          }
        });
        return cacheJobPromise.promise;
      }
      async delete(request3, options29 = {}) {
        webidl.brandCheck(this, Cache3);
        webidl.argumentLengthCheck(arguments, 1, { header: "Cache.delete" });
        request3 = webidl.converters.RequestInfo(request3);
        options29 = webidl.converters.CacheQueryOptions(options29);
        let r3 = null;
        if (request3 instanceof Request3) {
          r3 = request3[kState];
          if (r3.method !== "GET" && !options29.ignoreMethod) {
            return false;
          }
        } else {
          assert27(typeof request3 === "string");
          r3 = new Request3(request3)[kState];
        }
        const operations = [];
        const operation = {
          type: "delete",
          request: r3,
          options: options29
        };
        operations.push(operation);
        const cacheJobPromise = createDeferredPromise();
        let errorData = null;
        let requestResponses;
        try {
          requestResponses = this.#batchCacheOperations(operations);
        } catch (e3) {
          errorData = e3;
        }
        queueMicrotask(() => {
          if (errorData === null) {
            cacheJobPromise.resolve(!!requestResponses?.length);
          } else {
            cacheJobPromise.reject(errorData);
          }
        });
        return cacheJobPromise.promise;
      }
      /**
       * @see https://w3c.github.io/ServiceWorker/#dom-cache-keys
       * @param {any} request
       * @param {import('../../types/cache').CacheQueryOptions} options
       * @returns {readonly Request[]}
       */
      async keys(request3 = void 0, options29 = {}) {
        webidl.brandCheck(this, Cache3);
        if (request3 !== void 0)
          request3 = webidl.converters.RequestInfo(request3);
        options29 = webidl.converters.CacheQueryOptions(options29);
        let r3 = null;
        if (request3 !== void 0) {
          if (request3 instanceof Request3) {
            r3 = request3[kState];
            if (r3.method !== "GET" && !options29.ignoreMethod) {
              return [];
            }
          } else if (typeof request3 === "string") {
            r3 = new Request3(request3)[kState];
          }
        }
        const promise = createDeferredPromise();
        const requests = [];
        if (request3 === void 0) {
          for (const requestResponse of this.#relevantRequestResponseList) {
            requests.push(requestResponse[0]);
          }
        } else {
          const requestResponses = this.#queryCache(r3, options29);
          for (const requestResponse of requestResponses) {
            requests.push(requestResponse[0]);
          }
        }
        queueMicrotask(() => {
          const requestList = [];
          for (const request4 of requests) {
            const requestObject = new Request3("https://a");
            requestObject[kState] = request4;
            requestObject[kHeaders][kHeadersList] = request4.headersList;
            requestObject[kHeaders][kGuard] = "immutable";
            requestObject[kRealm] = request4.client;
            requestList.push(requestObject);
          }
          promise.resolve(Object.freeze(requestList));
        });
        return promise.promise;
      }
      /**
       * @see https://w3c.github.io/ServiceWorker/#batch-cache-operations-algorithm
       * @param {CacheBatchOperation[]} operations
       * @returns {requestResponseList}
       */
      #batchCacheOperations(operations) {
        const cache2 = this.#relevantRequestResponseList;
        const backupCache = [...cache2];
        const addedItems = [];
        const resultList = [];
        try {
          for (const operation of operations) {
            if (operation.type !== "delete" && operation.type !== "put") {
              throw webidl.errors.exception({
                header: "Cache.#batchCacheOperations",
                message: 'operation type does not match "delete" or "put"'
              });
            }
            if (operation.type === "delete" && operation.response != null) {
              throw webidl.errors.exception({
                header: "Cache.#batchCacheOperations",
                message: "delete operation should not have an associated response"
              });
            }
            if (this.#queryCache(operation.request, operation.options, addedItems).length) {
              throw new DOMException("???", "InvalidStateError");
            }
            let requestResponses;
            if (operation.type === "delete") {
              requestResponses = this.#queryCache(operation.request, operation.options);
              if (requestResponses.length === 0) {
                return [];
              }
              for (const requestResponse of requestResponses) {
                const idx = cache2.indexOf(requestResponse);
                assert27(idx !== -1);
                cache2.splice(idx, 1);
              }
            } else if (operation.type === "put") {
              if (operation.response == null) {
                throw webidl.errors.exception({
                  header: "Cache.#batchCacheOperations",
                  message: "put operation should have an associated response"
                });
              }
              const r3 = operation.request;
              if (!urlIsHttpHttpsScheme(r3.url)) {
                throw webidl.errors.exception({
                  header: "Cache.#batchCacheOperations",
                  message: "expected http or https scheme"
                });
              }
              if (r3.method !== "GET") {
                throw webidl.errors.exception({
                  header: "Cache.#batchCacheOperations",
                  message: "not get method"
                });
              }
              if (operation.options != null) {
                throw webidl.errors.exception({
                  header: "Cache.#batchCacheOperations",
                  message: "options must not be defined"
                });
              }
              requestResponses = this.#queryCache(operation.request);
              for (const requestResponse of requestResponses) {
                const idx = cache2.indexOf(requestResponse);
                assert27(idx !== -1);
                cache2.splice(idx, 1);
              }
              cache2.push([operation.request, operation.response]);
              addedItems.push([operation.request, operation.response]);
            }
            resultList.push([operation.request, operation.response]);
          }
          return resultList;
        } catch (e3) {
          this.#relevantRequestResponseList.length = 0;
          this.#relevantRequestResponseList = backupCache;
          throw e3;
        }
      }
      /**
       * @see https://w3c.github.io/ServiceWorker/#query-cache
       * @param {any} requestQuery
       * @param {import('../../types/cache').CacheQueryOptions} options
       * @param {requestResponseList} targetStorage
       * @returns {requestResponseList}
       */
      #queryCache(requestQuery, options29, targetStorage) {
        const resultList = [];
        const storage = targetStorage ?? this.#relevantRequestResponseList;
        for (const requestResponse of storage) {
          const [cachedRequest, cachedResponse] = requestResponse;
          if (this.#requestMatchesCachedItem(requestQuery, cachedRequest, cachedResponse, options29)) {
            resultList.push(requestResponse);
          }
        }
        return resultList;
      }
      /**
       * @see https://w3c.github.io/ServiceWorker/#request-matches-cached-item-algorithm
       * @param {any} requestQuery
       * @param {any} request
       * @param {any | null} response
       * @param {import('../../types/cache').CacheQueryOptions | undefined} options
       * @returns {boolean}
       */
      #requestMatchesCachedItem(requestQuery, request3, response = null, options29) {
        const queryURL = new URL(requestQuery.url);
        const cachedURL = new URL(request3.url);
        if (options29?.ignoreSearch) {
          cachedURL.search = "";
          queryURL.search = "";
        }
        if (!urlEquals(queryURL, cachedURL, true)) {
          return false;
        }
        if (response == null || options29?.ignoreVary || !response.headersList.contains("vary")) {
          return true;
        }
        const fieldValues = getFieldValues(response.headersList.get("vary"));
        for (const fieldValue of fieldValues) {
          if (fieldValue === "*") {
            return false;
          }
          const requestValue = request3.headersList.get(fieldValue);
          const queryValue = requestQuery.headersList.get(fieldValue);
          if (requestValue !== queryValue) {
            return false;
          }
        }
        return true;
      }
    };
    __name(Cache3, "Cache");
    Object.defineProperties(Cache3.prototype, {
      [Symbol.toStringTag]: {
        value: "Cache",
        configurable: true
      },
      match: kEnumerableProperty,
      matchAll: kEnumerableProperty,
      add: kEnumerableProperty,
      addAll: kEnumerableProperty,
      put: kEnumerableProperty,
      delete: kEnumerableProperty,
      keys: kEnumerableProperty
    });
    var cacheQueryOptionConverters = [
      {
        key: "ignoreSearch",
        converter: webidl.converters.boolean,
        defaultValue: false
      },
      {
        key: "ignoreMethod",
        converter: webidl.converters.boolean,
        defaultValue: false
      },
      {
        key: "ignoreVary",
        converter: webidl.converters.boolean,
        defaultValue: false
      }
    ];
    webidl.converters.CacheQueryOptions = webidl.dictionaryConverter(cacheQueryOptionConverters);
    webidl.converters.MultiCacheQueryOptions = webidl.dictionaryConverter([
      ...cacheQueryOptionConverters,
      {
        key: "cacheName",
        converter: webidl.converters.DOMString
      }
    ]);
    webidl.converters.Response = webidl.interfaceConverter(Response9);
    webidl.converters["sequence<RequestInfo>"] = webidl.sequenceConverter(
      webidl.converters.RequestInfo
    );
    module3.exports = {
      Cache: Cache3
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/cache/cachestorage.js
var require_cachestorage2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/cache/cachestorage.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { kConstruct } = require_symbols9();
    var { Cache: Cache3 } = require_cache3();
    var { webidl } = require_webidl2();
    var { kEnumerableProperty } = require_util12();
    var CacheStorage2 = class {
      /**
       * @see https://w3c.github.io/ServiceWorker/#dfn-relevant-name-to-cache-map
       * @type {Map<string, import('./cache').requestResponseList}
       */
      #caches = /* @__PURE__ */ new Map();
      constructor() {
        if (arguments[0] !== kConstruct) {
          webidl.illegalConstructor();
        }
      }
      async match(request3, options29 = {}) {
        webidl.brandCheck(this, CacheStorage2);
        webidl.argumentLengthCheck(arguments, 1, { header: "CacheStorage.match" });
        request3 = webidl.converters.RequestInfo(request3);
        options29 = webidl.converters.MultiCacheQueryOptions(options29);
        if (options29.cacheName != null) {
          if (this.#caches.has(options29.cacheName)) {
            const cacheList = this.#caches.get(options29.cacheName);
            const cache2 = new Cache3(kConstruct, cacheList);
            return await cache2.match(request3, options29);
          }
        } else {
          for (const cacheList of this.#caches.values()) {
            const cache2 = new Cache3(kConstruct, cacheList);
            const response = await cache2.match(request3, options29);
            if (response !== void 0) {
              return response;
            }
          }
        }
      }
      /**
       * @see https://w3c.github.io/ServiceWorker/#cache-storage-has
       * @param {string} cacheName
       * @returns {Promise<boolean>}
       */
      async has(cacheName) {
        webidl.brandCheck(this, CacheStorage2);
        webidl.argumentLengthCheck(arguments, 1, { header: "CacheStorage.has" });
        cacheName = webidl.converters.DOMString(cacheName);
        return this.#caches.has(cacheName);
      }
      /**
       * @see https://w3c.github.io/ServiceWorker/#dom-cachestorage-open
       * @param {string} cacheName
       * @returns {Promise<Cache>}
       */
      async open(cacheName) {
        webidl.brandCheck(this, CacheStorage2);
        webidl.argumentLengthCheck(arguments, 1, { header: "CacheStorage.open" });
        cacheName = webidl.converters.DOMString(cacheName);
        if (this.#caches.has(cacheName)) {
          const cache3 = this.#caches.get(cacheName);
          return new Cache3(kConstruct, cache3);
        }
        const cache2 = [];
        this.#caches.set(cacheName, cache2);
        return new Cache3(kConstruct, cache2);
      }
      /**
       * @see https://w3c.github.io/ServiceWorker/#cache-storage-delete
       * @param {string} cacheName
       * @returns {Promise<boolean>}
       */
      async delete(cacheName) {
        webidl.brandCheck(this, CacheStorage2);
        webidl.argumentLengthCheck(arguments, 1, { header: "CacheStorage.delete" });
        cacheName = webidl.converters.DOMString(cacheName);
        return this.#caches.delete(cacheName);
      }
      /**
       * @see https://w3c.github.io/ServiceWorker/#cache-storage-keys
       * @returns {string[]}
       */
      async keys() {
        webidl.brandCheck(this, CacheStorage2);
        const keys = this.#caches.keys();
        return [...keys];
      }
    };
    __name(CacheStorage2, "CacheStorage");
    Object.defineProperties(CacheStorage2.prototype, {
      [Symbol.toStringTag]: {
        value: "CacheStorage",
        configurable: true
      },
      match: kEnumerableProperty,
      has: kEnumerableProperty,
      open: kEnumerableProperty,
      delete: kEnumerableProperty,
      keys: kEnumerableProperty
    });
    module3.exports = {
      CacheStorage: CacheStorage2
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/cookies/constants.js
var require_constants11 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/cookies/constants.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var maxAttributeValueSize = 1024;
    var maxNameValuePairSize = 4096;
    module3.exports = {
      maxAttributeValueSize,
      maxNameValuePairSize
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/cookies/util.js
var require_util17 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/cookies/util.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var assert27 = require("assert");
    var { kHeadersList } = require_symbols6();
    function isCTLExcludingHtab(value) {
      if (value.length === 0) {
        return false;
      }
      for (const char of value) {
        const code = char.charCodeAt(0);
        if (code >= 0 || code <= 8 || (code >= 10 || code <= 31) || code === 127) {
          return false;
        }
      }
    }
    __name(isCTLExcludingHtab, "isCTLExcludingHtab");
    function validateCookieName(name) {
      for (const char of name) {
        const code = char.charCodeAt(0);
        if (code <= 32 || code > 127 || char === "(" || char === ")" || char === ">" || char === "<" || char === "@" || char === "," || char === ";" || char === ":" || char === "\\" || char === '"' || char === "/" || char === "[" || char === "]" || char === "?" || char === "=" || char === "{" || char === "}") {
          throw new Error("Invalid cookie name");
        }
      }
    }
    __name(validateCookieName, "validateCookieName");
    function validateCookieValue(value) {
      for (const char of value) {
        const code = char.charCodeAt(0);
        if (code < 33 || // exclude CTLs (0-31)
        code === 34 || code === 44 || code === 59 || code === 92 || code > 126) {
          throw new Error("Invalid header value");
        }
      }
    }
    __name(validateCookieValue, "validateCookieValue");
    function validateCookiePath(path67) {
      for (const char of path67) {
        const code = char.charCodeAt(0);
        if (code < 33 || char === ";") {
          throw new Error("Invalid cookie path");
        }
      }
    }
    __name(validateCookiePath, "validateCookiePath");
    function validateCookieDomain(domain2) {
      if (domain2.startsWith("-") || domain2.endsWith(".") || domain2.endsWith("-")) {
        throw new Error("Invalid cookie domain");
      }
    }
    __name(validateCookieDomain, "validateCookieDomain");
    function toIMFDate(date) {
      if (typeof date === "number") {
        date = new Date(date);
      }
      const days = [
        "Sun",
        "Mon",
        "Tue",
        "Wed",
        "Thu",
        "Fri",
        "Sat"
      ];
      const months = [
        "Jan",
        "Feb",
        "Mar",
        "Apr",
        "May",
        "Jun",
        "Jul",
        "Aug",
        "Sep",
        "Oct",
        "Nov",
        "Dec"
      ];
      const dayName = days[date.getUTCDay()];
      const day2 = date.getUTCDate().toString().padStart(2, "0");
      const month2 = months[date.getUTCMonth()];
      const year2 = date.getUTCFullYear();
      const hour2 = date.getUTCHours().toString().padStart(2, "0");
      const minute2 = date.getUTCMinutes().toString().padStart(2, "0");
      const second = date.getUTCSeconds().toString().padStart(2, "0");
      return `${dayName}, ${day2} ${month2} ${year2} ${hour2}:${minute2}:${second} GMT`;
    }
    __name(toIMFDate, "toIMFDate");
    function validateCookieMaxAge(maxAge) {
      if (maxAge < 0) {
        throw new Error("Invalid cookie max-age");
      }
    }
    __name(validateCookieMaxAge, "validateCookieMaxAge");
    function stringify(cookie) {
      if (cookie.name.length === 0) {
        return null;
      }
      validateCookieName(cookie.name);
      validateCookieValue(cookie.value);
      const out = [`${cookie.name}=${cookie.value}`];
      if (cookie.name.startsWith("__Secure-")) {
        cookie.secure = true;
      }
      if (cookie.name.startsWith("__Host-")) {
        cookie.secure = true;
        cookie.domain = null;
        cookie.path = "/";
      }
      if (cookie.secure) {
        out.push("Secure");
      }
      if (cookie.httpOnly) {
        out.push("HttpOnly");
      }
      if (typeof cookie.maxAge === "number") {
        validateCookieMaxAge(cookie.maxAge);
        out.push(`Max-Age=${cookie.maxAge}`);
      }
      if (cookie.domain) {
        validateCookieDomain(cookie.domain);
        out.push(`Domain=${cookie.domain}`);
      }
      if (cookie.path) {
        validateCookiePath(cookie.path);
        out.push(`Path=${cookie.path}`);
      }
      if (cookie.expires && cookie.expires.toString() !== "Invalid Date") {
        out.push(`Expires=${toIMFDate(cookie.expires)}`);
      }
      if (cookie.sameSite) {
        out.push(`SameSite=${cookie.sameSite}`);
      }
      for (const part of cookie.unparsed) {
        if (!part.includes("=")) {
          throw new Error("Invalid unparsed");
        }
        const [key, ...value] = part.split("=");
        out.push(`${key.trim()}=${value.join("=")}`);
      }
      return out.join("; ");
    }
    __name(stringify, "stringify");
    var kHeadersListNode;
    function getHeadersList(headers) {
      if (headers[kHeadersList]) {
        return headers[kHeadersList];
      }
      if (!kHeadersListNode) {
        kHeadersListNode = Object.getOwnPropertySymbols(headers).find(
          (symbol) => symbol.description === "headers list"
        );
        assert27(kHeadersListNode, "Headers cannot be parsed");
      }
      const headersList = headers[kHeadersListNode];
      assert27(headersList);
      return headersList;
    }
    __name(getHeadersList, "getHeadersList");
    module3.exports = {
      isCTLExcludingHtab,
      stringify,
      getHeadersList
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/cookies/parse.js
var require_parse7 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/cookies/parse.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { maxNameValuePairSize, maxAttributeValueSize } = require_constants11();
    var { isCTLExcludingHtab } = require_util17();
    var { collectASequenceOfCodePointsFast } = require_dataURL2();
    var assert27 = require("assert");
    function parseSetCookie(header) {
      if (isCTLExcludingHtab(header)) {
        return null;
      }
      let nameValuePair = "";
      let unparsedAttributes = "";
      let name = "";
      let value = "";
      if (header.includes(";")) {
        const position = { position: 0 };
        nameValuePair = collectASequenceOfCodePointsFast(";", header, position);
        unparsedAttributes = header.slice(position.position);
      } else {
        nameValuePair = header;
      }
      if (!nameValuePair.includes("=")) {
        value = nameValuePair;
      } else {
        const position = { position: 0 };
        name = collectASequenceOfCodePointsFast(
          "=",
          nameValuePair,
          position
        );
        value = nameValuePair.slice(position.position + 1);
      }
      name = name.trim();
      value = value.trim();
      if (name.length + value.length > maxNameValuePairSize) {
        return null;
      }
      return {
        name,
        value,
        ...parseUnparsedAttributes(unparsedAttributes)
      };
    }
    __name(parseSetCookie, "parseSetCookie");
    function parseUnparsedAttributes(unparsedAttributes, cookieAttributeList = {}) {
      if (unparsedAttributes.length === 0) {
        return cookieAttributeList;
      }
      assert27(unparsedAttributes[0] === ";");
      unparsedAttributes = unparsedAttributes.slice(1);
      let cookieAv = "";
      if (unparsedAttributes.includes(";")) {
        cookieAv = collectASequenceOfCodePointsFast(
          ";",
          unparsedAttributes,
          { position: 0 }
        );
        unparsedAttributes = unparsedAttributes.slice(cookieAv.length);
      } else {
        cookieAv = unparsedAttributes;
        unparsedAttributes = "";
      }
      let attributeName = "";
      let attributeValue = "";
      if (cookieAv.includes("=")) {
        const position = { position: 0 };
        attributeName = collectASequenceOfCodePointsFast(
          "=",
          cookieAv,
          position
        );
        attributeValue = cookieAv.slice(position.position + 1);
      } else {
        attributeName = cookieAv;
      }
      attributeName = attributeName.trim();
      attributeValue = attributeValue.trim();
      if (attributeValue.length > maxAttributeValueSize) {
        return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
      }
      const attributeNameLowercase = attributeName.toLowerCase();
      if (attributeNameLowercase === "expires") {
        const expiryTime = new Date(attributeValue);
        cookieAttributeList.expires = expiryTime;
      } else if (attributeNameLowercase === "max-age") {
        const charCode = attributeValue.charCodeAt(0);
        if ((charCode < 48 || charCode > 57) && attributeValue[0] !== "-") {
          return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
        }
        if (!/^\d+$/.test(attributeValue)) {
          return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
        }
        const deltaSeconds = Number(attributeValue);
        cookieAttributeList.maxAge = deltaSeconds;
      } else if (attributeNameLowercase === "domain") {
        let cookieDomain = attributeValue;
        if (cookieDomain[0] === ".") {
          cookieDomain = cookieDomain.slice(1);
        }
        cookieDomain = cookieDomain.toLowerCase();
        cookieAttributeList.domain = cookieDomain;
      } else if (attributeNameLowercase === "path") {
        let cookiePath = "";
        if (attributeValue.length === 0 || attributeValue[0] !== "/") {
          cookiePath = "/";
        } else {
          cookiePath = attributeValue;
        }
        cookieAttributeList.path = cookiePath;
      } else if (attributeNameLowercase === "secure") {
        cookieAttributeList.secure = true;
      } else if (attributeNameLowercase === "httponly") {
        cookieAttributeList.httpOnly = true;
      } else if (attributeNameLowercase === "samesite") {
        let enforcement = "Default";
        const attributeValueLowercase = attributeValue.toLowerCase();
        if (attributeValueLowercase.includes("none")) {
          enforcement = "None";
        }
        if (attributeValueLowercase.includes("strict")) {
          enforcement = "Strict";
        }
        if (attributeValueLowercase.includes("lax")) {
          enforcement = "Lax";
        }
        cookieAttributeList.sameSite = enforcement;
      } else {
        cookieAttributeList.unparsed ??= [];
        cookieAttributeList.unparsed.push(`${attributeName}=${attributeValue}`);
      }
      return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
    }
    __name(parseUnparsedAttributes, "parseUnparsedAttributes");
    module3.exports = {
      parseSetCookie,
      parseUnparsedAttributes
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/cookies/index.js
var require_cookies2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/cookies/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { parseSetCookie } = require_parse7();
    var { stringify, getHeadersList } = require_util17();
    var { webidl } = require_webidl2();
    var { Headers: Headers5 } = require_headers2();
    function getCookies(headers) {
      webidl.argumentLengthCheck(arguments, 1, { header: "getCookies" });
      webidl.brandCheck(headers, Headers5, { strict: false });
      const cookie = headers.get("cookie");
      const out = {};
      if (!cookie) {
        return out;
      }
      for (const piece of cookie.split(";")) {
        const [name, ...value] = piece.split("=");
        out[name.trim()] = value.join("=");
      }
      return out;
    }
    __name(getCookies, "getCookies");
    function deleteCookie(headers, name, attributes) {
      webidl.argumentLengthCheck(arguments, 2, { header: "deleteCookie" });
      webidl.brandCheck(headers, Headers5, { strict: false });
      name = webidl.converters.DOMString(name);
      attributes = webidl.converters.DeleteCookieAttributes(attributes);
      setCookie(headers, {
        name,
        value: "",
        expires: /* @__PURE__ */ new Date(0),
        ...attributes
      });
    }
    __name(deleteCookie, "deleteCookie");
    function getSetCookies(headers) {
      webidl.argumentLengthCheck(arguments, 1, { header: "getSetCookies" });
      webidl.brandCheck(headers, Headers5, { strict: false });
      const cookies = getHeadersList(headers).cookies;
      if (!cookies) {
        return [];
      }
      return cookies.map((pair) => parseSetCookie(Array.isArray(pair) ? pair[1] : pair));
    }
    __name(getSetCookies, "getSetCookies");
    function setCookie(headers, cookie) {
      webidl.argumentLengthCheck(arguments, 2, { header: "setCookie" });
      webidl.brandCheck(headers, Headers5, { strict: false });
      cookie = webidl.converters.Cookie(cookie);
      const str = stringify(cookie);
      if (str) {
        headers.append("Set-Cookie", stringify(cookie));
      }
    }
    __name(setCookie, "setCookie");
    webidl.converters.DeleteCookieAttributes = webidl.dictionaryConverter([
      {
        converter: webidl.nullableConverter(webidl.converters.DOMString),
        key: "path",
        defaultValue: null
      },
      {
        converter: webidl.nullableConverter(webidl.converters.DOMString),
        key: "domain",
        defaultValue: null
      }
    ]);
    webidl.converters.Cookie = webidl.dictionaryConverter([
      {
        converter: webidl.converters.DOMString,
        key: "name"
      },
      {
        converter: webidl.converters.DOMString,
        key: "value"
      },
      {
        converter: webidl.nullableConverter((value) => {
          if (typeof value === "number") {
            return webidl.converters["unsigned long long"](value);
          }
          return new Date(value);
        }),
        key: "expires",
        defaultValue: null
      },
      {
        converter: webidl.nullableConverter(webidl.converters["long long"]),
        key: "maxAge",
        defaultValue: null
      },
      {
        converter: webidl.nullableConverter(webidl.converters.DOMString),
        key: "domain",
        defaultValue: null
      },
      {
        converter: webidl.nullableConverter(webidl.converters.DOMString),
        key: "path",
        defaultValue: null
      },
      {
        converter: webidl.nullableConverter(webidl.converters.boolean),
        key: "secure",
        defaultValue: null
      },
      {
        converter: webidl.nullableConverter(webidl.converters.boolean),
        key: "httpOnly",
        defaultValue: null
      },
      {
        converter: webidl.converters.USVString,
        key: "sameSite",
        allowedValues: ["Strict", "Lax", "None"]
      },
      {
        converter: webidl.sequenceConverter(webidl.converters.DOMString),
        key: "unparsed",
        defaultValue: []
      }
    ]);
    module3.exports = {
      getCookies,
      deleteCookie,
      getSetCookies,
      setCookie
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/websocket/constants.js
var require_constants12 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/websocket/constants.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var uid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
    var staticPropertyDescriptors = {
      enumerable: true,
      writable: false,
      configurable: false
    };
    var states = {
      CONNECTING: 0,
      OPEN: 1,
      CLOSING: 2,
      CLOSED: 3
    };
    var opcodes = {
      CONTINUATION: 0,
      TEXT: 1,
      BINARY: 2,
      CLOSE: 8,
      PING: 9,
      PONG: 10
    };
    var maxUnsigned16Bit = 2 ** 16 - 1;
    var parserStates = {
      INFO: 0,
      PAYLOADLENGTH_16: 2,
      PAYLOADLENGTH_64: 3,
      READ_DATA: 4
    };
    var emptyBuffer = Buffer.allocUnsafe(0);
    module3.exports = {
      uid,
      staticPropertyDescriptors,
      states,
      opcodes,
      maxUnsigned16Bit,
      parserStates,
      emptyBuffer
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/websocket/symbols.js
var require_symbols10 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/websocket/symbols.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = {
      kWebSocketURL: Symbol("url"),
      kReadyState: Symbol("ready state"),
      kController: Symbol("controller"),
      kResponse: Symbol("response"),
      kBinaryType: Symbol("binary type"),
      kSentClose: Symbol("sent close"),
      kReceivedClose: Symbol("received close"),
      kByteParser: Symbol("byte parser")
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/websocket/events.js
var require_events2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/websocket/events.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { webidl } = require_webidl2();
    var { kEnumerableProperty } = require_util12();
    var { MessagePort } = require("worker_threads");
    var MessageEvent = class extends Event {
      #eventInit;
      constructor(type, eventInitDict = {}) {
        webidl.argumentLengthCheck(arguments, 1, { header: "MessageEvent constructor" });
        type = webidl.converters.DOMString(type);
        eventInitDict = webidl.converters.MessageEventInit(eventInitDict);
        super(type, eventInitDict);
        this.#eventInit = eventInitDict;
      }
      get data() {
        webidl.brandCheck(this, MessageEvent);
        return this.#eventInit.data;
      }
      get origin() {
        webidl.brandCheck(this, MessageEvent);
        return this.#eventInit.origin;
      }
      get lastEventId() {
        webidl.brandCheck(this, MessageEvent);
        return this.#eventInit.lastEventId;
      }
      get source() {
        webidl.brandCheck(this, MessageEvent);
        return this.#eventInit.source;
      }
      get ports() {
        webidl.brandCheck(this, MessageEvent);
        if (!Object.isFrozen(this.#eventInit.ports)) {
          Object.freeze(this.#eventInit.ports);
        }
        return this.#eventInit.ports;
      }
      initMessageEvent(type, bubbles = false, cancelable = false, data = null, origin = "", lastEventId2 = "", source = null, ports = []) {
        webidl.brandCheck(this, MessageEvent);
        webidl.argumentLengthCheck(arguments, 1, { header: "MessageEvent.initMessageEvent" });
        return new MessageEvent(type, {
          bubbles,
          cancelable,
          data,
          origin,
          lastEventId: lastEventId2,
          source,
          ports
        });
      }
    };
    __name(MessageEvent, "MessageEvent");
    var CloseEvent = class extends Event {
      #eventInit;
      constructor(type, eventInitDict = {}) {
        webidl.argumentLengthCheck(arguments, 1, { header: "CloseEvent constructor" });
        type = webidl.converters.DOMString(type);
        eventInitDict = webidl.converters.CloseEventInit(eventInitDict);
        super(type, eventInitDict);
        this.#eventInit = eventInitDict;
      }
      get wasClean() {
        webidl.brandCheck(this, CloseEvent);
        return this.#eventInit.wasClean;
      }
      get code() {
        webidl.brandCheck(this, CloseEvent);
        return this.#eventInit.code;
      }
      get reason() {
        webidl.brandCheck(this, CloseEvent);
        return this.#eventInit.reason;
      }
    };
    __name(CloseEvent, "CloseEvent");
    var ErrorEvent2 = class extends Event {
      #eventInit;
      constructor(type, eventInitDict) {
        webidl.argumentLengthCheck(arguments, 1, { header: "ErrorEvent constructor" });
        super(type, eventInitDict);
        type = webidl.converters.DOMString(type);
        eventInitDict = webidl.converters.ErrorEventInit(eventInitDict ?? {});
        this.#eventInit = eventInitDict;
      }
      get message() {
        webidl.brandCheck(this, ErrorEvent2);
        return this.#eventInit.message;
      }
      get filename() {
        webidl.brandCheck(this, ErrorEvent2);
        return this.#eventInit.filename;
      }
      get lineno() {
        webidl.brandCheck(this, ErrorEvent2);
        return this.#eventInit.lineno;
      }
      get colno() {
        webidl.brandCheck(this, ErrorEvent2);
        return this.#eventInit.colno;
      }
      get error() {
        webidl.brandCheck(this, ErrorEvent2);
        return this.#eventInit.error;
      }
    };
    __name(ErrorEvent2, "ErrorEvent");
    Object.defineProperties(MessageEvent.prototype, {
      [Symbol.toStringTag]: {
        value: "MessageEvent",
        configurable: true
      },
      data: kEnumerableProperty,
      origin: kEnumerableProperty,
      lastEventId: kEnumerableProperty,
      source: kEnumerableProperty,
      ports: kEnumerableProperty,
      initMessageEvent: kEnumerableProperty
    });
    Object.defineProperties(CloseEvent.prototype, {
      [Symbol.toStringTag]: {
        value: "CloseEvent",
        configurable: true
      },
      reason: kEnumerableProperty,
      code: kEnumerableProperty,
      wasClean: kEnumerableProperty
    });
    Object.defineProperties(ErrorEvent2.prototype, {
      [Symbol.toStringTag]: {
        value: "ErrorEvent",
        configurable: true
      },
      message: kEnumerableProperty,
      filename: kEnumerableProperty,
      lineno: kEnumerableProperty,
      colno: kEnumerableProperty,
      error: kEnumerableProperty
    });
    webidl.converters.MessagePort = webidl.interfaceConverter(MessagePort);
    webidl.converters["sequence<MessagePort>"] = webidl.sequenceConverter(
      webidl.converters.MessagePort
    );
    var eventInit = [
      {
        key: "bubbles",
        converter: webidl.converters.boolean,
        defaultValue: false
      },
      {
        key: "cancelable",
        converter: webidl.converters.boolean,
        defaultValue: false
      },
      {
        key: "composed",
        converter: webidl.converters.boolean,
        defaultValue: false
      }
    ];
    webidl.converters.MessageEventInit = webidl.dictionaryConverter([
      ...eventInit,
      {
        key: "data",
        converter: webidl.converters.any,
        defaultValue: null
      },
      {
        key: "origin",
        converter: webidl.converters.USVString,
        defaultValue: ""
      },
      {
        key: "lastEventId",
        converter: webidl.converters.DOMString,
        defaultValue: ""
      },
      {
        key: "source",
        // Node doesn't implement WindowProxy or ServiceWorker, so the only
        // valid value for source is a MessagePort.
        converter: webidl.nullableConverter(webidl.converters.MessagePort),
        defaultValue: null
      },
      {
        key: "ports",
        converter: webidl.converters["sequence<MessagePort>"],
        get defaultValue() {
          return [];
        }
      }
    ]);
    webidl.converters.CloseEventInit = webidl.dictionaryConverter([
      ...eventInit,
      {
        key: "wasClean",
        converter: webidl.converters.boolean,
        defaultValue: false
      },
      {
        key: "code",
        converter: webidl.converters["unsigned short"],
        defaultValue: 0
      },
      {
        key: "reason",
        converter: webidl.converters.USVString,
        defaultValue: ""
      }
    ]);
    webidl.converters.ErrorEventInit = webidl.dictionaryConverter([
      ...eventInit,
      {
        key: "message",
        converter: webidl.converters.DOMString,
        defaultValue: ""
      },
      {
        key: "filename",
        converter: webidl.converters.USVString,
        defaultValue: ""
      },
      {
        key: "lineno",
        converter: webidl.converters["unsigned long"],
        defaultValue: 0
      },
      {
        key: "colno",
        converter: webidl.converters["unsigned long"],
        defaultValue: 0
      },
      {
        key: "error",
        converter: webidl.converters.any
      }
    ]);
    module3.exports = {
      MessageEvent,
      CloseEvent,
      ErrorEvent: ErrorEvent2
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/websocket/util.js
var require_util18 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/websocket/util.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = require_symbols10();
    var { states, opcodes } = require_constants12();
    var { MessageEvent, ErrorEvent: ErrorEvent2 } = require_events2();
    function isEstablished(ws) {
      return ws[kReadyState] === states.OPEN;
    }
    __name(isEstablished, "isEstablished");
    function isClosing(ws) {
      return ws[kReadyState] === states.CLOSING;
    }
    __name(isClosing, "isClosing");
    function isClosed(ws) {
      return ws[kReadyState] === states.CLOSED;
    }
    __name(isClosed, "isClosed");
    function fireEvent(e3, target, eventConstructor = Event, eventInitDict) {
      const event = new eventConstructor(e3, eventInitDict);
      target.dispatchEvent(event);
    }
    __name(fireEvent, "fireEvent");
    function websocketMessageReceived(ws, type, data) {
      if (ws[kReadyState] !== states.OPEN) {
        return;
      }
      let dataForEvent;
      if (type === opcodes.TEXT) {
        try {
          dataForEvent = new TextDecoder("utf-8", { fatal: true }).decode(data);
        } catch {
          failWebsocketConnection(ws, "Received invalid UTF-8 in text frame.");
          return;
        }
      } else if (type === opcodes.BINARY) {
        if (ws[kBinaryType] === "blob") {
          dataForEvent = new Blob([data]);
        } else {
          dataForEvent = new Uint8Array(data).buffer;
        }
      }
      fireEvent("message", ws, MessageEvent, {
        origin: ws[kWebSocketURL].origin,
        data: dataForEvent
      });
    }
    __name(websocketMessageReceived, "websocketMessageReceived");
    function isValidSubprotocol(protocol) {
      if (protocol.length === 0) {
        return false;
      }
      for (const char of protocol) {
        const code = char.charCodeAt(0);
        if (code < 33 || code > 126 || char === "(" || char === ")" || char === "<" || char === ">" || char === "@" || char === "," || char === ";" || char === ":" || char === "\\" || char === '"' || char === "/" || char === "[" || char === "]" || char === "?" || char === "=" || char === "{" || char === "}" || code === 32 || // SP
        code === 9) {
          return false;
        }
      }
      return true;
    }
    __name(isValidSubprotocol, "isValidSubprotocol");
    function isValidStatusCode(code) {
      if (code >= 1e3 && code < 1015) {
        return code !== 1004 && // reserved
        code !== 1005 && // "MUST NOT be set as a status code"
        code !== 1006;
      }
      return code >= 3e3 && code <= 4999;
    }
    __name(isValidStatusCode, "isValidStatusCode");
    function failWebsocketConnection(ws, reason) {
      const { [kController]: controller, [kResponse]: response } = ws;
      controller.abort();
      if (response?.socket && !response.socket.destroyed) {
        response.socket.destroy();
      }
      if (reason) {
        fireEvent("error", ws, ErrorEvent2, {
          error: new Error(reason)
        });
      }
    }
    __name(failWebsocketConnection, "failWebsocketConnection");
    module3.exports = {
      isEstablished,
      isClosing,
      isClosed,
      fireEvent,
      isValidSubprotocol,
      isValidStatusCode,
      failWebsocketConnection,
      websocketMessageReceived
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/websocket/connection.js
var require_connection2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/websocket/connection.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var diagnosticsChannel = require("diagnostics_channel");
    var { uid, states } = require_constants12();
    var {
      kReadyState,
      kSentClose,
      kByteParser,
      kReceivedClose
    } = require_symbols10();
    var { fireEvent, failWebsocketConnection } = require_util18();
    var { CloseEvent } = require_events2();
    var { makeRequest } = require_request5();
    var { fetching } = require_fetch2();
    var { Headers: Headers5 } = require_headers2();
    var { getGlobalDispatcher: getGlobalDispatcher2 } = require_global4();
    var { kHeadersList } = require_symbols6();
    var channels = {};
    channels.open = diagnosticsChannel.channel("undici:websocket:open");
    channels.close = diagnosticsChannel.channel("undici:websocket:close");
    channels.socketError = diagnosticsChannel.channel("undici:websocket:socket_error");
    var crypto5;
    try {
      crypto5 = require("crypto");
    } catch {
    }
    function establishWebSocketConnection(url4, protocols, ws, onEstablish, options29) {
      const requestURL = url4;
      requestURL.protocol = url4.protocol === "ws:" ? "http:" : "https:";
      const request3 = makeRequest({
        urlList: [requestURL],
        serviceWorkers: "none",
        referrer: "no-referrer",
        mode: "websocket",
        credentials: "include",
        cache: "no-store",
        redirect: "error"
      });
      if (options29.headers) {
        const headersList = new Headers5(options29.headers)[kHeadersList];
        request3.headersList = headersList;
      }
      const keyValue = crypto5.randomBytes(16).toString("base64");
      request3.headersList.append("sec-websocket-key", keyValue);
      request3.headersList.append("sec-websocket-version", "13");
      for (const protocol of protocols) {
        request3.headersList.append("sec-websocket-protocol", protocol);
      }
      const permessageDeflate = "";
      const controller = fetching({
        request: request3,
        useParallelQueue: true,
        dispatcher: options29.dispatcher ?? getGlobalDispatcher2(),
        processResponse(response) {
          if (response.type === "error" || response.status !== 101) {
            failWebsocketConnection(ws, "Received network error or non-101 status code.");
            return;
          }
          if (protocols.length !== 0 && !response.headersList.get("Sec-WebSocket-Protocol")) {
            failWebsocketConnection(ws, "Server did not respond with sent protocols.");
            return;
          }
          if (response.headersList.get("Upgrade")?.toLowerCase() !== "websocket") {
            failWebsocketConnection(ws, 'Server did not set Upgrade header to "websocket".');
            return;
          }
          if (response.headersList.get("Connection")?.toLowerCase() !== "upgrade") {
            failWebsocketConnection(ws, 'Server did not set Connection header to "upgrade".');
            return;
          }
          const secWSAccept = response.headersList.get("Sec-WebSocket-Accept");
          const digest = crypto5.createHash("sha1").update(keyValue + uid).digest("base64");
          if (secWSAccept !== digest) {
            failWebsocketConnection(ws, "Incorrect hash received in Sec-WebSocket-Accept header.");
            return;
          }
          const secExtension = response.headersList.get("Sec-WebSocket-Extensions");
          if (secExtension !== null && secExtension !== permessageDeflate) {
            failWebsocketConnection(ws, "Received different permessage-deflate than the one set.");
            return;
          }
          const secProtocol = response.headersList.get("Sec-WebSocket-Protocol");
          if (secProtocol !== null && secProtocol !== request3.headersList.get("Sec-WebSocket-Protocol")) {
            failWebsocketConnection(ws, "Protocol was not set in the opening handshake.");
            return;
          }
          response.socket.on("data", onSocketData);
          response.socket.on("close", onSocketClose);
          response.socket.on("error", onSocketError);
          if (channels.open.hasSubscribers) {
            channels.open.publish({
              address: response.socket.address(),
              protocol: secProtocol,
              extensions: secExtension
            });
          }
          onEstablish(response);
        }
      });
      return controller;
    }
    __name(establishWebSocketConnection, "establishWebSocketConnection");
    function onSocketData(chunk) {
      if (!this.ws[kByteParser].write(chunk)) {
        this.pause();
      }
    }
    __name(onSocketData, "onSocketData");
    function onSocketClose() {
      const { ws } = this;
      const wasClean = ws[kSentClose] && ws[kReceivedClose];
      let code = 1005;
      let reason = "";
      const result = ws[kByteParser].closingInfo;
      if (result) {
        code = result.code ?? 1005;
        reason = result.reason;
      } else if (!ws[kSentClose]) {
        code = 1006;
      }
      ws[kReadyState] = states.CLOSED;
      fireEvent("close", ws, CloseEvent, {
        wasClean,
        code,
        reason
      });
      if (channels.close.hasSubscribers) {
        channels.close.publish({
          websocket: ws,
          code,
          reason
        });
      }
    }
    __name(onSocketClose, "onSocketClose");
    function onSocketError(error2) {
      const { ws } = this;
      ws[kReadyState] = states.CLOSING;
      if (channels.socketError.hasSubscribers) {
        channels.socketError.publish(error2);
      }
      this.destroy();
    }
    __name(onSocketError, "onSocketError");
    module3.exports = {
      establishWebSocketConnection
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/websocket/frame.js
var require_frame2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/websocket/frame.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { maxUnsigned16Bit } = require_constants12();
    var crypto5;
    try {
      crypto5 = require("crypto");
    } catch {
    }
    var WebsocketFrameSend = class {
      /**
       * @param {Buffer|undefined} data
       */
      constructor(data) {
        this.frameData = data;
        this.maskKey = crypto5.randomBytes(4);
      }
      createFrame(opcode) {
        const bodyLength = this.frameData?.byteLength ?? 0;
        let payloadLength = bodyLength;
        let offset = 6;
        if (bodyLength > maxUnsigned16Bit) {
          offset += 8;
          payloadLength = 127;
        } else if (bodyLength > 125) {
          offset += 2;
          payloadLength = 126;
        }
        const buffer = Buffer.allocUnsafe(bodyLength + offset);
        buffer[0] = buffer[1] = 0;
        buffer[0] |= 128;
        buffer[0] = (buffer[0] & 240) + opcode;
        buffer[offset - 4] = this.maskKey[0];
        buffer[offset - 3] = this.maskKey[1];
        buffer[offset - 2] = this.maskKey[2];
        buffer[offset - 1] = this.maskKey[3];
        buffer[1] = payloadLength;
        if (payloadLength === 126) {
          buffer.writeUInt16BE(bodyLength, 2);
        } else if (payloadLength === 127) {
          buffer[2] = buffer[3] = 0;
          buffer.writeUIntBE(bodyLength, 4, 6);
        }
        buffer[1] |= 128;
        for (let i = 0; i < bodyLength; i++) {
          buffer[offset + i] = this.frameData[i] ^ this.maskKey[i % 4];
        }
        return buffer;
      }
    };
    __name(WebsocketFrameSend, "WebsocketFrameSend");
    module3.exports = {
      WebsocketFrameSend
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/websocket/receiver.js
var require_receiver3 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/websocket/receiver.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { Writable } = require("stream");
    var diagnosticsChannel = require("diagnostics_channel");
    var { parserStates, opcodes, states, emptyBuffer } = require_constants12();
    var { kReadyState, kSentClose, kResponse, kReceivedClose } = require_symbols10();
    var { isValidStatusCode, failWebsocketConnection, websocketMessageReceived } = require_util18();
    var { WebsocketFrameSend } = require_frame2();
    var channels = {};
    channels.ping = diagnosticsChannel.channel("undici:websocket:ping");
    channels.pong = diagnosticsChannel.channel("undici:websocket:pong");
    var ByteParser = class extends Writable {
      #buffers = [];
      #byteOffset = 0;
      #state = parserStates.INFO;
      #info = {};
      #fragments = [];
      constructor(ws) {
        super();
        this.ws = ws;
      }
      /**
       * @param {Buffer} chunk
       * @param {() => void} callback
       */
      _write(chunk, _3, callback) {
        this.#buffers.push(chunk);
        this.#byteOffset += chunk.length;
        this.run(callback);
      }
      /**
       * Runs whenever a new chunk is received.
       * Callback is called whenever there are no more chunks buffering,
       * or not enough bytes are buffered to parse.
       */
      run(callback) {
        while (true) {
          if (this.#state === parserStates.INFO) {
            if (this.#byteOffset < 2) {
              return callback();
            }
            const buffer = this.consume(2);
            this.#info.fin = (buffer[0] & 128) !== 0;
            this.#info.opcode = buffer[0] & 15;
            this.#info.originalOpcode ??= this.#info.opcode;
            this.#info.fragmented = !this.#info.fin && this.#info.opcode !== opcodes.CONTINUATION;
            if (this.#info.fragmented && this.#info.opcode !== opcodes.BINARY && this.#info.opcode !== opcodes.TEXT) {
              failWebsocketConnection(this.ws, "Invalid frame type was fragmented.");
              return;
            }
            const payloadLength = buffer[1] & 127;
            if (payloadLength <= 125) {
              this.#info.payloadLength = payloadLength;
              this.#state = parserStates.READ_DATA;
            } else if (payloadLength === 126) {
              this.#state = parserStates.PAYLOADLENGTH_16;
            } else if (payloadLength === 127) {
              this.#state = parserStates.PAYLOADLENGTH_64;
            }
            if (this.#info.fragmented && payloadLength > 125) {
              failWebsocketConnection(this.ws, "Fragmented frame exceeded 125 bytes.");
              return;
            } else if ((this.#info.opcode === opcodes.PING || this.#info.opcode === opcodes.PONG || this.#info.opcode === opcodes.CLOSE) && payloadLength > 125) {
              failWebsocketConnection(this.ws, "Payload length for control frame exceeded 125 bytes.");
              return;
            } else if (this.#info.opcode === opcodes.CLOSE) {
              if (payloadLength === 1) {
                failWebsocketConnection(this.ws, "Received close frame with a 1-byte body.");
                return;
              }
              const body = this.consume(payloadLength);
              this.#info.closeInfo = this.parseCloseBody(false, body);
              if (!this.ws[kSentClose]) {
                const body2 = Buffer.allocUnsafe(2);
                body2.writeUInt16BE(this.#info.closeInfo.code, 0);
                const closeFrame = new WebsocketFrameSend(body2);
                this.ws[kResponse].socket.write(
                  closeFrame.createFrame(opcodes.CLOSE),
                  (err) => {
                    if (!err) {
                      this.ws[kSentClose] = true;
                    }
                  }
                );
              }
              this.ws[kReadyState] = states.CLOSING;
              this.ws[kReceivedClose] = true;
              this.end();
              return;
            } else if (this.#info.opcode === opcodes.PING) {
              const body = this.consume(payloadLength);
              if (!this.ws[kReceivedClose]) {
                const frame = new WebsocketFrameSend(body);
                this.ws[kResponse].socket.write(frame.createFrame(opcodes.PONG));
                if (channels.ping.hasSubscribers) {
                  channels.ping.publish({
                    payload: body
                  });
                }
              }
              this.#state = parserStates.INFO;
              if (this.#byteOffset > 0) {
                continue;
              } else {
                callback();
                return;
              }
            } else if (this.#info.opcode === opcodes.PONG) {
              const body = this.consume(payloadLength);
              if (channels.pong.hasSubscribers) {
                channels.pong.publish({
                  payload: body
                });
              }
              if (this.#byteOffset > 0) {
                continue;
              } else {
                callback();
                return;
              }
            }
          } else if (this.#state === parserStates.PAYLOADLENGTH_16) {
            if (this.#byteOffset < 2) {
              return callback();
            }
            const buffer = this.consume(2);
            this.#info.payloadLength = buffer.readUInt16BE(0);
            this.#state = parserStates.READ_DATA;
          } else if (this.#state === parserStates.PAYLOADLENGTH_64) {
            if (this.#byteOffset < 8) {
              return callback();
            }
            const buffer = this.consume(8);
            const upper = buffer.readUInt32BE(0);
            if (upper > 2 ** 31 - 1) {
              failWebsocketConnection(this.ws, "Received payload length > 2^31 bytes.");
              return;
            }
            const lower = buffer.readUInt32BE(4);
            this.#info.payloadLength = (upper << 8) + lower;
            this.#state = parserStates.READ_DATA;
          } else if (this.#state === parserStates.READ_DATA) {
            if (this.#byteOffset < this.#info.payloadLength) {
              return callback();
            } else if (this.#byteOffset >= this.#info.payloadLength) {
              const body = this.consume(this.#info.payloadLength);
              this.#fragments.push(body);
              if (!this.#info.fragmented || this.#info.fin && this.#info.opcode === opcodes.CONTINUATION) {
                const fullMessage = Buffer.concat(this.#fragments);
                websocketMessageReceived(this.ws, this.#info.originalOpcode, fullMessage);
                this.#info = {};
                this.#fragments.length = 0;
              }
              this.#state = parserStates.INFO;
            }
          }
          if (this.#byteOffset > 0) {
            continue;
          } else {
            callback();
            break;
          }
        }
      }
      /**
       * Take n bytes from the buffered Buffers
       * @param {number} n
       * @returns {Buffer|null}
       */
      consume(n2) {
        if (n2 > this.#byteOffset) {
          return null;
        } else if (n2 === 0) {
          return emptyBuffer;
        }
        if (this.#buffers[0].length === n2) {
          this.#byteOffset -= this.#buffers[0].length;
          return this.#buffers.shift();
        }
        const buffer = Buffer.allocUnsafe(n2);
        let offset = 0;
        while (offset !== n2) {
          const next = this.#buffers[0];
          const { length } = next;
          if (length + offset === n2) {
            buffer.set(this.#buffers.shift(), offset);
            break;
          } else if (length + offset > n2) {
            buffer.set(next.subarray(0, n2 - offset), offset);
            this.#buffers[0] = next.subarray(n2 - offset);
            break;
          } else {
            buffer.set(this.#buffers.shift(), offset);
            offset += next.length;
          }
        }
        this.#byteOffset -= n2;
        return buffer;
      }
      parseCloseBody(onlyCode, data) {
        let code;
        if (data.length >= 2) {
          code = data.readUInt16BE(0);
        }
        if (onlyCode) {
          if (!isValidStatusCode(code)) {
            return null;
          }
          return { code };
        }
        let reason = data.subarray(2);
        if (reason[0] === 239 && reason[1] === 187 && reason[2] === 191) {
          reason = reason.subarray(3);
        }
        if (code !== void 0 && !isValidStatusCode(code)) {
          return null;
        }
        try {
          reason = new TextDecoder("utf-8", { fatal: true }).decode(reason);
        } catch {
          return null;
        }
        return { code, reason };
      }
      get closingInfo() {
        return this.#info.closeInfo;
      }
    };
    __name(ByteParser, "ByteParser");
    module3.exports = {
      ByteParser
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/websocket/websocket.js
var require_websocket3 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/lib/websocket/websocket.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { webidl } = require_webidl2();
    var { DOMException: DOMException2 } = require_constants9();
    var { URLSerializer } = require_dataURL2();
    var { getGlobalOrigin } = require_global3();
    var { staticPropertyDescriptors, states, opcodes, emptyBuffer } = require_constants12();
    var {
      kWebSocketURL,
      kReadyState,
      kController,
      kBinaryType,
      kResponse,
      kSentClose,
      kByteParser
    } = require_symbols10();
    var { isEstablished, isClosing, isValidSubprotocol, failWebsocketConnection, fireEvent } = require_util18();
    var { establishWebSocketConnection } = require_connection2();
    var { WebsocketFrameSend } = require_frame2();
    var { ByteParser } = require_receiver3();
    var { kEnumerableProperty, isBlobLike } = require_util12();
    var { getGlobalDispatcher: getGlobalDispatcher2 } = require_global4();
    var { types } = require("util");
    var experimentalWarned = false;
    var WebSocket3 = class extends EventTarget {
      #events = {
        open: null,
        error: null,
        close: null,
        message: null
      };
      #bufferedAmount = 0;
      #protocol = "";
      #extensions = "";
      /**
       * @param {string} url
       * @param {string|string[]} protocols
       */
      constructor(url4, protocols = []) {
        super();
        webidl.argumentLengthCheck(arguments, 1, { header: "WebSocket constructor" });
        if (!experimentalWarned) {
          experimentalWarned = true;
          process.emitWarning("WebSockets are experimental, expect them to change at any time.", {
            code: "UNDICI-WS"
          });
        }
        const options29 = webidl.converters["DOMString or sequence<DOMString> or WebSocketInit"](protocols);
        url4 = webidl.converters.USVString(url4);
        protocols = options29.protocols;
        const baseURL = getGlobalOrigin();
        let urlRecord;
        try {
          urlRecord = new URL(url4, baseURL);
        } catch (e3) {
          throw new DOMException2(e3, "SyntaxError");
        }
        if (urlRecord.protocol === "http:") {
          urlRecord.protocol = "ws:";
        } else if (urlRecord.protocol === "https:") {
          urlRecord.protocol = "wss:";
        }
        if (urlRecord.protocol !== "ws:" && urlRecord.protocol !== "wss:") {
          throw new DOMException2(
            `Expected a ws: or wss: protocol, got ${urlRecord.protocol}`,
            "SyntaxError"
          );
        }
        if (urlRecord.hash || urlRecord.href.endsWith("#")) {
          throw new DOMException2("Got fragment", "SyntaxError");
        }
        if (typeof protocols === "string") {
          protocols = [protocols];
        }
        if (protocols.length !== new Set(protocols.map((p2) => p2.toLowerCase())).size) {
          throw new DOMException2("Invalid Sec-WebSocket-Protocol value", "SyntaxError");
        }
        if (protocols.length > 0 && !protocols.every((p2) => isValidSubprotocol(p2))) {
          throw new DOMException2("Invalid Sec-WebSocket-Protocol value", "SyntaxError");
        }
        this[kWebSocketURL] = new URL(urlRecord.href);
        this[kController] = establishWebSocketConnection(
          urlRecord,
          protocols,
          this,
          (response) => this.#onConnectionEstablished(response),
          options29
        );
        this[kReadyState] = WebSocket3.CONNECTING;
        this[kBinaryType] = "blob";
      }
      /**
       * @see https://websockets.spec.whatwg.org/#dom-websocket-close
       * @param {number|undefined} code
       * @param {string|undefined} reason
       */
      close(code = void 0, reason = void 0) {
        webidl.brandCheck(this, WebSocket3);
        if (code !== void 0) {
          code = webidl.converters["unsigned short"](code, { clamp: true });
        }
        if (reason !== void 0) {
          reason = webidl.converters.USVString(reason);
        }
        if (code !== void 0) {
          if (code !== 1e3 && (code < 3e3 || code > 4999)) {
            throw new DOMException2("invalid code", "InvalidAccessError");
          }
        }
        let reasonByteLength = 0;
        if (reason !== void 0) {
          reasonByteLength = Buffer.byteLength(reason);
          if (reasonByteLength > 123) {
            throw new DOMException2(
              `Reason must be less than 123 bytes; received ${reasonByteLength}`,
              "SyntaxError"
            );
          }
        }
        if (this[kReadyState] === WebSocket3.CLOSING || this[kReadyState] === WebSocket3.CLOSED) {
        } else if (!isEstablished(this)) {
          failWebsocketConnection(this, "Connection was closed before it was established.");
          this[kReadyState] = WebSocket3.CLOSING;
        } else if (!isClosing(this)) {
          const frame = new WebsocketFrameSend();
          if (code !== void 0 && reason === void 0) {
            frame.frameData = Buffer.allocUnsafe(2);
            frame.frameData.writeUInt16BE(code, 0);
          } else if (code !== void 0 && reason !== void 0) {
            frame.frameData = Buffer.allocUnsafe(2 + reasonByteLength);
            frame.frameData.writeUInt16BE(code, 0);
            frame.frameData.write(reason, 2, "utf-8");
          } else {
            frame.frameData = emptyBuffer;
          }
          const socket = this[kResponse].socket;
          socket.write(frame.createFrame(opcodes.CLOSE), (err) => {
            if (!err) {
              this[kSentClose] = true;
            }
          });
          this[kReadyState] = states.CLOSING;
        } else {
          this[kReadyState] = WebSocket3.CLOSING;
        }
      }
      /**
       * @see https://websockets.spec.whatwg.org/#dom-websocket-send
       * @param {NodeJS.TypedArray|ArrayBuffer|Blob|string} data
       */
      send(data) {
        webidl.brandCheck(this, WebSocket3);
        webidl.argumentLengthCheck(arguments, 1, { header: "WebSocket.send" });
        data = webidl.converters.WebSocketSendData(data);
        if (this[kReadyState] === WebSocket3.CONNECTING) {
          throw new DOMException2("Sent before connected.", "InvalidStateError");
        }
        if (!isEstablished(this) || isClosing(this)) {
          return;
        }
        const socket = this[kResponse].socket;
        if (typeof data === "string") {
          const value = Buffer.from(data);
          const frame = new WebsocketFrameSend(value);
          const buffer = frame.createFrame(opcodes.TEXT);
          this.#bufferedAmount += value.byteLength;
          socket.write(buffer, () => {
            this.#bufferedAmount -= value.byteLength;
          });
        } else if (types.isArrayBuffer(data)) {
          const value = Buffer.from(data);
          const frame = new WebsocketFrameSend(value);
          const buffer = frame.createFrame(opcodes.BINARY);
          this.#bufferedAmount += value.byteLength;
          socket.write(buffer, () => {
            this.#bufferedAmount -= value.byteLength;
          });
        } else if (ArrayBuffer.isView(data)) {
          const ab = Buffer.from(data, data.byteOffset, data.byteLength);
          const frame = new WebsocketFrameSend(ab);
          const buffer = frame.createFrame(opcodes.BINARY);
          this.#bufferedAmount += ab.byteLength;
          socket.write(buffer, () => {
            this.#bufferedAmount -= ab.byteLength;
          });
        } else if (isBlobLike(data)) {
          const frame = new WebsocketFrameSend();
          data.arrayBuffer().then((ab) => {
            const value = Buffer.from(ab);
            frame.frameData = value;
            const buffer = frame.createFrame(opcodes.BINARY);
            this.#bufferedAmount += value.byteLength;
            socket.write(buffer, () => {
              this.#bufferedAmount -= value.byteLength;
            });
          });
        }
      }
      get readyState() {
        webidl.brandCheck(this, WebSocket3);
        return this[kReadyState];
      }
      get bufferedAmount() {
        webidl.brandCheck(this, WebSocket3);
        return this.#bufferedAmount;
      }
      get url() {
        webidl.brandCheck(this, WebSocket3);
        return URLSerializer(this[kWebSocketURL]);
      }
      get extensions() {
        webidl.brandCheck(this, WebSocket3);
        return this.#extensions;
      }
      get protocol() {
        webidl.brandCheck(this, WebSocket3);
        return this.#protocol;
      }
      get onopen() {
        webidl.brandCheck(this, WebSocket3);
        return this.#events.open;
      }
      set onopen(fn2) {
        webidl.brandCheck(this, WebSocket3);
        if (this.#events.open) {
          this.removeEventListener("open", this.#events.open);
        }
        if (typeof fn2 === "function") {
          this.#events.open = fn2;
          this.addEventListener("open", fn2);
        } else {
          this.#events.open = null;
        }
      }
      get onerror() {
        webidl.brandCheck(this, WebSocket3);
        return this.#events.error;
      }
      set onerror(fn2) {
        webidl.brandCheck(this, WebSocket3);
        if (this.#events.error) {
          this.removeEventListener("error", this.#events.error);
        }
        if (typeof fn2 === "function") {
          this.#events.error = fn2;
          this.addEventListener("error", fn2);
        } else {
          this.#events.error = null;
        }
      }
      get onclose() {
        webidl.brandCheck(this, WebSocket3);
        return this.#events.close;
      }
      set onclose(fn2) {
        webidl.brandCheck(this, WebSocket3);
        if (this.#events.close) {
          this.removeEventListener("close", this.#events.close);
        }
        if (typeof fn2 === "function") {
          this.#events.close = fn2;
          this.addEventListener("close", fn2);
        } else {
          this.#events.close = null;
        }
      }
      get onmessage() {
        webidl.brandCheck(this, WebSocket3);
        return this.#events.message;
      }
      set onmessage(fn2) {
        webidl.brandCheck(this, WebSocket3);
        if (this.#events.message) {
          this.removeEventListener("message", this.#events.message);
        }
        if (typeof fn2 === "function") {
          this.#events.message = fn2;
          this.addEventListener("message", fn2);
        } else {
          this.#events.message = null;
        }
      }
      get binaryType() {
        webidl.brandCheck(this, WebSocket3);
        return this[kBinaryType];
      }
      set binaryType(type) {
        webidl.brandCheck(this, WebSocket3);
        if (type !== "blob" && type !== "arraybuffer") {
          this[kBinaryType] = "blob";
        } else {
          this[kBinaryType] = type;
        }
      }
      /**
       * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
       */
      #onConnectionEstablished(response) {
        this[kResponse] = response;
        const parser2 = new ByteParser(this);
        parser2.on("drain", /* @__PURE__ */ __name(function onParserDrain() {
          this.ws[kResponse].socket.resume();
        }, "onParserDrain"));
        response.socket.ws = this;
        this[kByteParser] = parser2;
        this[kReadyState] = states.OPEN;
        const extensions = response.headersList.get("sec-websocket-extensions");
        if (extensions !== null) {
          this.#extensions = extensions;
        }
        const protocol = response.headersList.get("sec-websocket-protocol");
        if (protocol !== null) {
          this.#protocol = protocol;
        }
        fireEvent("open", this);
      }
    };
    __name(WebSocket3, "WebSocket");
    WebSocket3.CONNECTING = WebSocket3.prototype.CONNECTING = states.CONNECTING;
    WebSocket3.OPEN = WebSocket3.prototype.OPEN = states.OPEN;
    WebSocket3.CLOSING = WebSocket3.prototype.CLOSING = states.CLOSING;
    WebSocket3.CLOSED = WebSocket3.prototype.CLOSED = states.CLOSED;
    Object.defineProperties(WebSocket3.prototype, {
      CONNECTING: staticPropertyDescriptors,
      OPEN: staticPropertyDescriptors,
      CLOSING: staticPropertyDescriptors,
      CLOSED: staticPropertyDescriptors,
      url: kEnumerableProperty,
      readyState: kEnumerableProperty,
      bufferedAmount: kEnumerableProperty,
      onopen: kEnumerableProperty,
      onerror: kEnumerableProperty,
      onclose: kEnumerableProperty,
      close: kEnumerableProperty,
      onmessage: kEnumerableProperty,
      binaryType: kEnumerableProperty,
      send: kEnumerableProperty,
      extensions: kEnumerableProperty,
      protocol: kEnumerableProperty,
      [Symbol.toStringTag]: {
        value: "WebSocket",
        writable: false,
        enumerable: false,
        configurable: true
      }
    });
    Object.defineProperties(WebSocket3, {
      CONNECTING: staticPropertyDescriptors,
      OPEN: staticPropertyDescriptors,
      CLOSING: staticPropertyDescriptors,
      CLOSED: staticPropertyDescriptors
    });
    webidl.converters["sequence<DOMString>"] = webidl.sequenceConverter(
      webidl.converters.DOMString
    );
    webidl.converters["DOMString or sequence<DOMString>"] = function(V2) {
      if (webidl.util.Type(V2) === "Object" && Symbol.iterator in V2) {
        return webidl.converters["sequence<DOMString>"](V2);
      }
      return webidl.converters.DOMString(V2);
    };
    webidl.converters.WebSocketInit = webidl.dictionaryConverter([
      {
        key: "protocols",
        converter: webidl.converters["DOMString or sequence<DOMString>"],
        get defaultValue() {
          return [];
        }
      },
      {
        key: "dispatcher",
        converter: (V2) => V2,
        get defaultValue() {
          return getGlobalDispatcher2();
        }
      },
      {
        key: "headers",
        converter: webidl.nullableConverter(webidl.converters.HeadersInit)
      }
    ]);
    webidl.converters["DOMString or sequence<DOMString> or WebSocketInit"] = function(V2) {
      if (webidl.util.Type(V2) === "Object" && !(Symbol.iterator in V2)) {
        return webidl.converters.WebSocketInit(V2);
      }
      return { protocols: webidl.converters["DOMString or sequence<DOMString>"](V2) };
    };
    webidl.converters.WebSocketSendData = function(V2) {
      if (webidl.util.Type(V2) === "Object") {
        if (isBlobLike(V2)) {
          return webidl.converters.Blob(V2, { strict: false });
        }
        if (ArrayBuffer.isView(V2) || types.isAnyArrayBuffer(V2)) {
          return webidl.converters.BufferSource(V2);
        }
      }
      return webidl.converters.USVString(V2);
    };
    module3.exports = {
      WebSocket: WebSocket3
    };
  }
});

// ../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/index.js
var require_undici2 = __commonJS({
  "../../node_modules/.pnpm/undici@5.28.2/node_modules/undici/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var Client = require_client2();
    var Dispatcher2 = require_dispatcher2();
    var errors = require_errors2();
    var Pool = require_pool2();
    var BalancedPool = require_balanced_pool2();
    var Agent = require_agent2();
    var util4 = require_util12();
    var { InvalidArgumentError } = errors;
    var api = require_api2();
    var buildConnector = require_connect2();
    var MockClient = require_mock_client2();
    var MockAgent = require_mock_agent2();
    var MockPool = require_mock_pool2();
    var mockErrors = require_mock_errors2();
    var ProxyAgent2 = require_proxy_agent2();
    var RetryHandler = require_RetryHandler2();
    var { getGlobalDispatcher: getGlobalDispatcher2, setGlobalDispatcher: setGlobalDispatcher2 } = require_global4();
    var DecoratorHandler = require_DecoratorHandler2();
    var RedirectHandler = require_RedirectHandler2();
    var createRedirectInterceptor = require_redirectInterceptor2();
    var hasCrypto;
    try {
      require("crypto");
      hasCrypto = true;
    } catch {
      hasCrypto = false;
    }
    Object.assign(Dispatcher2.prototype, api);
    module3.exports.Dispatcher = Dispatcher2;
    module3.exports.Client = Client;
    module3.exports.Pool = Pool;
    module3.exports.BalancedPool = BalancedPool;
    module3.exports.Agent = Agent;
    module3.exports.ProxyAgent = ProxyAgent2;
    module3.exports.RetryHandler = RetryHandler;
    module3.exports.DecoratorHandler = DecoratorHandler;
    module3.exports.RedirectHandler = RedirectHandler;
    module3.exports.createRedirectInterceptor = createRedirectInterceptor;
    module3.exports.buildConnector = buildConnector;
    module3.exports.errors = errors;
    function makeDispatcher(fn2) {
      return (url4, opts, handler30) => {
        if (typeof opts === "function") {
          handler30 = opts;
          opts = null;
        }
        if (!url4 || typeof url4 !== "string" && typeof url4 !== "object" && !(url4 instanceof URL)) {
          throw new InvalidArgumentError("invalid url");
        }
        if (opts != null && typeof opts !== "object") {
          throw new InvalidArgumentError("invalid opts");
        }
        if (opts && opts.path != null) {
          if (typeof opts.path !== "string") {
            throw new InvalidArgumentError("invalid opts.path");
          }
          let path67 = opts.path;
          if (!opts.path.startsWith("/")) {
            path67 = `/${path67}`;
          }
          url4 = new URL(util4.parseOrigin(url4).origin + path67);
        } else {
          if (!opts) {
            opts = typeof url4 === "object" ? url4 : {};
          }
          url4 = util4.parseURL(url4);
        }
        const { agent, dispatcher = getGlobalDispatcher2() } = opts;
        if (agent) {
          throw new InvalidArgumentError("unsupported opts.agent. Did you mean opts.client?");
        }
        return fn2.call(dispatcher, {
          ...opts,
          origin: url4.origin,
          path: url4.search ? `${url4.pathname}${url4.search}` : url4.pathname,
          method: opts.method || (opts.body ? "PUT" : "GET")
        }, handler30);
      };
    }
    __name(makeDispatcher, "makeDispatcher");
    module3.exports.setGlobalDispatcher = setGlobalDispatcher2;
    module3.exports.getGlobalDispatcher = getGlobalDispatcher2;
    if (util4.nodeMajor > 16 || util4.nodeMajor === 16 && util4.nodeMinor >= 8) {
      let fetchImpl = null;
      module3.exports.fetch = /* @__PURE__ */ __name(async function fetch15(resource) {
        if (!fetchImpl) {
          fetchImpl = require_fetch2().fetch;
        }
        try {
          return await fetchImpl(...arguments);
        } catch (err) {
          if (typeof err === "object") {
            Error.captureStackTrace(err, this);
          }
          throw err;
        }
      }, "fetch");
      module3.exports.Headers = require_headers2().Headers;
      module3.exports.Response = require_response3().Response;
      module3.exports.Request = require_request5().Request;
      module3.exports.FormData = require_formdata2().FormData;
      module3.exports.File = require_file2().File;
      module3.exports.FileReader = require_filereader2().FileReader;
      const { setGlobalOrigin, getGlobalOrigin } = require_global3();
      module3.exports.setGlobalOrigin = setGlobalOrigin;
      module3.exports.getGlobalOrigin = getGlobalOrigin;
      const { CacheStorage: CacheStorage2 } = require_cachestorage2();
      const { kConstruct } = require_symbols9();
      module3.exports.caches = new CacheStorage2(kConstruct);
    }
    if (util4.nodeMajor >= 16) {
      const { deleteCookie, getCookies, getSetCookies, setCookie } = require_cookies2();
      module3.exports.deleteCookie = deleteCookie;
      module3.exports.getCookies = getCookies;
      module3.exports.getSetCookies = getSetCookies;
      module3.exports.setCookie = setCookie;
      const { parseMIMEType, serializeAMimeType } = require_dataURL2();
      module3.exports.parseMIMEType = parseMIMEType;
      module3.exports.serializeAMimeType = serializeAMimeType;
    }
    if (util4.nodeMajor >= 18 && hasCrypto) {
      const { WebSocket: WebSocket3 } = require_websocket3();
      module3.exports.WebSocket = WebSocket3;
    }
    module3.exports.request = makeDispatcher(api.request);
    module3.exports.stream = makeDispatcher(api.stream);
    module3.exports.pipeline = makeDispatcher(api.pipeline);
    module3.exports.connect = makeDispatcher(api.connect);
    module3.exports.upgrade = makeDispatcher(api.upgrade);
    module3.exports.MockClient = MockClient;
    module3.exports.MockPool = MockPool;
    module3.exports.MockAgent = MockAgent;
    module3.exports.mockErrors = mockErrors;
  }
});

// ../../node_modules/.pnpm/set-cookie-parser@2.6.0/node_modules/set-cookie-parser/lib/set-cookie.js
var require_set_cookie = __commonJS({
  "../../node_modules/.pnpm/set-cookie-parser@2.6.0/node_modules/set-cookie-parser/lib/set-cookie.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var defaultParseOptions = {
      decodeValues: true,
      map: false,
      silent: false
    };
    function isNonEmptyString(str) {
      return typeof str === "string" && !!str.trim();
    }
    __name(isNonEmptyString, "isNonEmptyString");
    function parseString(setCookieValue, options29) {
      var parts = setCookieValue.split(";").filter(isNonEmptyString);
      var nameValuePairStr = parts.shift();
      var parsed = parseNameValuePair(nameValuePairStr);
      var name = parsed.name;
      var value = parsed.value;
      options29 = options29 ? Object.assign({}, defaultParseOptions, options29) : defaultParseOptions;
      try {
        value = options29.decodeValues ? decodeURIComponent(value) : value;
      } catch (e3) {
        console.error(
          "set-cookie-parser encountered an error while decoding a cookie with value '" + value + "'. Set options.decodeValues to false to disable this feature.",
          e3
        );
      }
      var cookie = {
        name,
        value
      };
      parts.forEach(function(part) {
        var sides = part.split("=");
        var key = sides.shift().trimLeft().toLowerCase();
        var value2 = sides.join("=");
        if (key === "expires") {
          cookie.expires = new Date(value2);
        } else if (key === "max-age") {
          cookie.maxAge = parseInt(value2, 10);
        } else if (key === "secure") {
          cookie.secure = true;
        } else if (key === "httponly") {
          cookie.httpOnly = true;
        } else if (key === "samesite") {
          cookie.sameSite = value2;
        } else {
          cookie[key] = value2;
        }
      });
      return cookie;
    }
    __name(parseString, "parseString");
    function parseNameValuePair(nameValuePairStr) {
      var name = "";
      var value = "";
      var nameValueArr = nameValuePairStr.split("=");
      if (nameValueArr.length > 1) {
        name = nameValueArr.shift();
        value = nameValueArr.join("=");
      } else {
        value = nameValuePairStr;
      }
      return { name, value };
    }
    __name(parseNameValuePair, "parseNameValuePair");
    function parse7(input, options29) {
      options29 = options29 ? Object.assign({}, defaultParseOptions, options29) : defaultParseOptions;
      if (!input) {
        if (!options29.map) {
          return [];
        } else {
          return {};
        }
      }
      if (input.headers) {
        if (typeof input.headers.getSetCookie === "function") {
          input = input.headers.getSetCookie();
        } else if (input.headers["set-cookie"]) {
          input = input.headers["set-cookie"];
        } else {
          var sch = input.headers[Object.keys(input.headers).find(function(key) {
            return key.toLowerCase() === "set-cookie";
          })];
          if (!sch && input.headers.cookie && !options29.silent) {
            console.warn(
              "Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning."
            );
          }
          input = sch;
        }
      }
      if (!Array.isArray(input)) {
        input = [input];
      }
      options29 = options29 ? Object.assign({}, defaultParseOptions, options29) : defaultParseOptions;
      if (!options29.map) {
        return input.filter(isNonEmptyString).map(function(str) {
          return parseString(str, options29);
        });
      } else {
        var cookies = {};
        return input.filter(isNonEmptyString).reduce(function(cookies2, str) {
          var cookie = parseString(str, options29);
          cookies2[cookie.name] = cookie;
          return cookies2;
        }, cookies);
      }
    }
    __name(parse7, "parse");
    function splitCookiesString(cookiesString) {
      if (Array.isArray(cookiesString)) {
        return cookiesString;
      }
      if (typeof cookiesString !== "string") {
        return [];
      }
      var cookiesStrings = [];
      var pos = 0;
      var start;
      var ch;
      var lastComma;
      var nextStart;
      var cookiesSeparatorFound;
      function skipWhitespace() {
        while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
          pos += 1;
        }
        return pos < cookiesString.length;
      }
      __name(skipWhitespace, "skipWhitespace");
      function notSpecialChar() {
        ch = cookiesString.charAt(pos);
        return ch !== "=" && ch !== ";" && ch !== ",";
      }
      __name(notSpecialChar, "notSpecialChar");
      while (pos < cookiesString.length) {
        start = pos;
        cookiesSeparatorFound = false;
        while (skipWhitespace()) {
          ch = cookiesString.charAt(pos);
          if (ch === ",") {
            lastComma = pos;
            pos += 1;
            skipWhitespace();
            nextStart = pos;
            while (pos < cookiesString.length && notSpecialChar()) {
              pos += 1;
            }
            if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
              cookiesSeparatorFound = true;
              pos = nextStart;
              cookiesStrings.push(cookiesString.substring(start, lastComma));
              start = pos;
            } else {
              pos = lastComma + 1;
            }
          } else {
            pos += 1;
          }
        }
        if (!cookiesSeparatorFound || pos >= cookiesString.length) {
          cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
        }
      }
      return cookiesStrings;
    }
    __name(splitCookiesString, "splitCookiesString");
    module3.exports = parse7;
    module3.exports.parse = parse7;
    module3.exports.parseString = parseString;
    module3.exports.splitCookiesString = splitCookiesString;
  }
});

// ../../node_modules/.pnpm/busboy@1.6.0/node_modules/busboy/lib/utils.js
var require_utils8 = __commonJS({
  "../../node_modules/.pnpm/busboy@1.6.0/node_modules/busboy/lib/utils.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    function parseContentType(str) {
      if (str.length === 0)
        return;
      const params = /* @__PURE__ */ Object.create(null);
      let i = 0;
      for (; i < str.length; ++i) {
        const code = str.charCodeAt(i);
        if (TOKEN[code] !== 1) {
          if (code !== 47 || i === 0)
            return;
          break;
        }
      }
      if (i === str.length)
        return;
      const type = str.slice(0, i).toLowerCase();
      const subtypeStart = ++i;
      for (; i < str.length; ++i) {
        const code = str.charCodeAt(i);
        if (TOKEN[code] !== 1) {
          if (i === subtypeStart)
            return;
          if (parseContentTypeParams(str, i, params) === void 0)
            return;
          break;
        }
      }
      if (i === subtypeStart)
        return;
      const subtype = str.slice(subtypeStart, i).toLowerCase();
      return { type, subtype, params };
    }
    __name(parseContentType, "parseContentType");
    function parseContentTypeParams(str, i, params) {
      while (i < str.length) {
        for (; i < str.length; ++i) {
          const code = str.charCodeAt(i);
          if (code !== 32 && code !== 9)
            break;
        }
        if (i === str.length)
          break;
        if (str.charCodeAt(i++) !== 59)
          return;
        for (; i < str.length; ++i) {
          const code = str.charCodeAt(i);
          if (code !== 32 && code !== 9)
            break;
        }
        if (i === str.length)
          return;
        let name;
        const nameStart = i;
        for (; i < str.length; ++i) {
          const code = str.charCodeAt(i);
          if (TOKEN[code] !== 1) {
            if (code !== 61)
              return;
            break;
          }
        }
        if (i === str.length)
          return;
        name = str.slice(nameStart, i);
        ++i;
        if (i === str.length)
          return;
        let value = "";
        let valueStart;
        if (str.charCodeAt(i) === 34) {
          valueStart = ++i;
          let escaping = false;
          for (; i < str.length; ++i) {
            const code = str.charCodeAt(i);
            if (code === 92) {
              if (escaping) {
                valueStart = i;
                escaping = false;
              } else {
                value += str.slice(valueStart, i);
                escaping = true;
              }
              continue;
            }
            if (code === 34) {
              if (escaping) {
                valueStart = i;
                escaping = false;
                continue;
              }
              value += str.slice(valueStart, i);
              break;
            }
            if (escaping) {
              valueStart = i - 1;
              escaping = false;
            }
            if (QDTEXT[code] !== 1)
              return;
          }
          if (i === str.length)
            return;
          ++i;
        } else {
          valueStart = i;
          for (; i < str.length; ++i) {
            const code = str.charCodeAt(i);
            if (TOKEN[code] !== 1) {
              if (i === valueStart)
                return;
              break;
            }
          }
          value = str.slice(valueStart, i);
        }
        name = name.toLowerCase();
        if (params[name] === void 0)
          params[name] = value;
      }
      return params;
    }
    __name(parseContentTypeParams, "parseContentTypeParams");
    function parseDisposition(str, defDecoder) {
      if (str.length === 0)
        return;
      const params = /* @__PURE__ */ Object.create(null);
      let i = 0;
      for (; i < str.length; ++i) {
        const code = str.charCodeAt(i);
        if (TOKEN[code] !== 1) {
          if (parseDispositionParams(str, i, params, defDecoder) === void 0)
            return;
          break;
        }
      }
      const type = str.slice(0, i).toLowerCase();
      return { type, params };
    }
    __name(parseDisposition, "parseDisposition");
    function parseDispositionParams(str, i, params, defDecoder) {
      while (i < str.length) {
        for (; i < str.length; ++i) {
          const code = str.charCodeAt(i);
          if (code !== 32 && code !== 9)
            break;
        }
        if (i === str.length)
          break;
        if (str.charCodeAt(i++) !== 59)
          return;
        for (; i < str.length; ++i) {
          const code = str.charCodeAt(i);
          if (code !== 32 && code !== 9)
            break;
        }
        if (i === str.length)
          return;
        let name;
        const nameStart = i;
        for (; i < str.length; ++i) {
          const code = str.charCodeAt(i);
          if (TOKEN[code] !== 1) {
            if (code === 61)
              break;
            return;
          }
        }
        if (i === str.length)
          return;
        let value = "";
        let valueStart;
        let charset;
        name = str.slice(nameStart, i);
        if (name.charCodeAt(name.length - 1) === 42) {
          const charsetStart = ++i;
          for (; i < str.length; ++i) {
            const code = str.charCodeAt(i);
            if (CHARSET[code] !== 1) {
              if (code !== 39)
                return;
              break;
            }
          }
          if (i === str.length)
            return;
          charset = str.slice(charsetStart, i);
          ++i;
          for (; i < str.length; ++i) {
            const code = str.charCodeAt(i);
            if (code === 39)
              break;
          }
          if (i === str.length)
            return;
          ++i;
          if (i === str.length)
            return;
          valueStart = i;
          let encode = 0;
          for (; i < str.length; ++i) {
            const code = str.charCodeAt(i);
            if (EXTENDED_VALUE[code] !== 1) {
              if (code === 37) {
                let hexUpper;
                let hexLower;
                if (i + 2 < str.length && (hexUpper = HEX_VALUES[str.charCodeAt(i + 1)]) !== -1 && (hexLower = HEX_VALUES[str.charCodeAt(i + 2)]) !== -1) {
                  const byteVal = (hexUpper << 4) + hexLower;
                  value += str.slice(valueStart, i);
                  value += String.fromCharCode(byteVal);
                  i += 2;
                  valueStart = i + 1;
                  if (byteVal >= 128)
                    encode = 2;
                  else if (encode === 0)
                    encode = 1;
                  continue;
                }
                return;
              }
              break;
            }
          }
          value += str.slice(valueStart, i);
          value = convertToUTF8(value, charset, encode);
          if (value === void 0)
            return;
        } else {
          ++i;
          if (i === str.length)
            return;
          if (str.charCodeAt(i) === 34) {
            valueStart = ++i;
            let escaping = false;
            for (; i < str.length; ++i) {
              const code = str.charCodeAt(i);
              if (code === 92) {
                if (escaping) {
                  valueStart = i;
                  escaping = false;
                } else {
                  value += str.slice(valueStart, i);
                  escaping = true;
                }
                continue;
              }
              if (code === 34) {
                if (escaping) {
                  valueStart = i;
                  escaping = false;
                  continue;
                }
                value += str.slice(valueStart, i);
                break;
              }
              if (escaping) {
                valueStart = i - 1;
                escaping = false;
              }
              if (QDTEXT[code] !== 1)
                return;
            }
            if (i === str.length)
              return;
            ++i;
          } else {
            valueStart = i;
            for (; i < str.length; ++i) {
              const code = str.charCodeAt(i);
              if (TOKEN[code] !== 1) {
                if (i === valueStart)
                  return;
                break;
              }
            }
            value = str.slice(valueStart, i);
          }
          value = defDecoder(value, 2);
          if (value === void 0)
            return;
        }
        name = name.toLowerCase();
        if (params[name] === void 0)
          params[name] = value;
      }
      return params;
    }
    __name(parseDispositionParams, "parseDispositionParams");
    function getDecoder(charset) {
      let lc;
      while (true) {
        switch (charset) {
          case "utf-8":
          case "utf8":
            return decoders.utf8;
          case "latin1":
          case "ascii":
          case "us-ascii":
          case "iso-8859-1":
          case "iso8859-1":
          case "iso88591":
          case "iso_8859-1":
          case "windows-1252":
          case "iso_8859-1:1987":
          case "cp1252":
          case "x-cp1252":
            return decoders.latin1;
          case "utf16le":
          case "utf-16le":
          case "ucs2":
          case "ucs-2":
            return decoders.utf16le;
          case "base64":
            return decoders.base64;
          default:
            if (lc === void 0) {
              lc = true;
              charset = charset.toLowerCase();
              continue;
            }
            return decoders.other.bind(charset);
        }
      }
    }
    __name(getDecoder, "getDecoder");
    var decoders = {
      utf8: (data, hint) => {
        if (data.length === 0)
          return "";
        if (typeof data === "string") {
          if (hint < 2)
            return data;
          data = Buffer.from(data, "latin1");
        }
        return data.utf8Slice(0, data.length);
      },
      latin1: (data, hint) => {
        if (data.length === 0)
          return "";
        if (typeof data === "string")
          return data;
        return data.latin1Slice(0, data.length);
      },
      utf16le: (data, hint) => {
        if (data.length === 0)
          return "";
        if (typeof data === "string")
          data = Buffer.from(data, "latin1");
        return data.ucs2Slice(0, data.length);
      },
      base64: (data, hint) => {
        if (data.length === 0)
          return "";
        if (typeof data === "string")
          data = Buffer.from(data, "latin1");
        return data.base64Slice(0, data.length);
      },
      other: (data, hint) => {
        if (data.length === 0)
          return "";
        if (typeof data === "string")
          data = Buffer.from(data, "latin1");
        try {
          const decoder = new TextDecoder(exports2);
          return decoder.decode(data);
        } catch {
        }
      }
    };
    function convertToUTF8(data, charset, hint) {
      const decode = getDecoder(charset);
      if (decode)
        return decode(data, hint);
    }
    __name(convertToUTF8, "convertToUTF8");
    function basename4(path67) {
      if (typeof path67 !== "string")
        return "";
      for (let i = path67.length - 1; i >= 0; --i) {
        switch (path67.charCodeAt(i)) {
          case 47:
          case 92:
            path67 = path67.slice(i + 1);
            return path67 === ".." || path67 === "." ? "" : path67;
        }
      }
      return path67 === ".." || path67 === "." ? "" : path67;
    }
    __name(basename4, "basename");
    var TOKEN = [
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      1,
      0,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      1,
      1,
      0,
      1,
      1,
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      1,
      0,
      1,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0
    ];
    var QDTEXT = [
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      1,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      1,
      1,
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1
    ];
    var CHARSET = [
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      1,
      0,
      1,
      1,
      1,
      1,
      0,
      0,
      0,
      0,
      1,
      0,
      1,
      0,
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      1,
      1,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0
    ];
    var EXTENDED_VALUE = [
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      1,
      0,
      1,
      1,
      0,
      1,
      0,
      0,
      0,
      0,
      1,
      0,
      1,
      1,
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      1,
      0,
      1,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0
    ];
    var HEX_VALUES = [
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      0,
      1,
      2,
      3,
      4,
      5,
      6,
      7,
      8,
      9,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      10,
      11,
      12,
      13,
      14,
      15,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      10,
      11,
      12,
      13,
      14,
      15,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1
    ];
    module3.exports = {
      basename: basename4,
      convertToUTF8,
      getDecoder,
      parseContentType,
      parseDisposition
    };
  }
});

// ../../node_modules/.pnpm/streamsearch@1.1.0/node_modules/streamsearch/lib/sbmh.js
var require_sbmh2 = __commonJS({
  "../../node_modules/.pnpm/streamsearch@1.1.0/node_modules/streamsearch/lib/sbmh.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    function memcmp(buf1, pos1, buf2, pos2, num) {
      for (let i = 0; i < num; ++i) {
        if (buf1[pos1 + i] !== buf2[pos2 + i])
          return false;
      }
      return true;
    }
    __name(memcmp, "memcmp");
    var SBMH = class {
      constructor(needle, cb) {
        if (typeof cb !== "function")
          throw new Error("Missing match callback");
        if (typeof needle === "string")
          needle = Buffer.from(needle);
        else if (!Buffer.isBuffer(needle))
          throw new Error(`Expected Buffer for needle, got ${typeof needle}`);
        const needleLen = needle.length;
        this.maxMatches = Infinity;
        this.matches = 0;
        this._cb = cb;
        this._lookbehindSize = 0;
        this._needle = needle;
        this._bufPos = 0;
        this._lookbehind = Buffer.allocUnsafe(needleLen);
        this._occ = [
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen,
          needleLen
        ];
        if (needleLen > 1) {
          for (let i = 0; i < needleLen - 1; ++i)
            this._occ[needle[i]] = needleLen - 1 - i;
        }
      }
      reset() {
        this.matches = 0;
        this._lookbehindSize = 0;
        this._bufPos = 0;
      }
      push(chunk, pos) {
        let result;
        if (!Buffer.isBuffer(chunk))
          chunk = Buffer.from(chunk, "latin1");
        const chunkLen = chunk.length;
        this._bufPos = pos || 0;
        while (result !== chunkLen && this.matches < this.maxMatches)
          result = feed(this, chunk);
        return result;
      }
      destroy() {
        const lbSize = this._lookbehindSize;
        if (lbSize)
          this._cb(false, this._lookbehind, 0, lbSize, false);
        this.reset();
      }
    };
    __name(SBMH, "SBMH");
    function feed(self2, data) {
      const len = data.length;
      const needle = self2._needle;
      const needleLen = needle.length;
      let pos = -self2._lookbehindSize;
      const lastNeedleCharPos = needleLen - 1;
      const lastNeedleChar = needle[lastNeedleCharPos];
      const end = len - needleLen;
      const occ = self2._occ;
      const lookbehind = self2._lookbehind;
      if (pos < 0) {
        while (pos < 0 && pos <= end) {
          const nextPos = pos + lastNeedleCharPos;
          const ch = nextPos < 0 ? lookbehind[self2._lookbehindSize + nextPos] : data[nextPos];
          if (ch === lastNeedleChar && matchNeedle(self2, data, pos, lastNeedleCharPos)) {
            self2._lookbehindSize = 0;
            ++self2.matches;
            if (pos > -self2._lookbehindSize)
              self2._cb(true, lookbehind, 0, self2._lookbehindSize + pos, false);
            else
              self2._cb(true, void 0, 0, 0, true);
            return self2._bufPos = pos + needleLen;
          }
          pos += occ[ch];
        }
        while (pos < 0 && !matchNeedle(self2, data, pos, len - pos))
          ++pos;
        if (pos < 0) {
          const bytesToCutOff = self2._lookbehindSize + pos;
          if (bytesToCutOff > 0) {
            self2._cb(false, lookbehind, 0, bytesToCutOff, false);
          }
          self2._lookbehindSize -= bytesToCutOff;
          lookbehind.copy(lookbehind, 0, bytesToCutOff, self2._lookbehindSize);
          lookbehind.set(data, self2._lookbehindSize);
          self2._lookbehindSize += len;
          self2._bufPos = len;
          return len;
        }
        self2._cb(false, lookbehind, 0, self2._lookbehindSize, false);
        self2._lookbehindSize = 0;
      }
      pos += self2._bufPos;
      const firstNeedleChar = needle[0];
      while (pos <= end) {
        const ch = data[pos + lastNeedleCharPos];
        if (ch === lastNeedleChar && data[pos] === firstNeedleChar && memcmp(needle, 0, data, pos, lastNeedleCharPos)) {
          ++self2.matches;
          if (pos > 0)
            self2._cb(true, data, self2._bufPos, pos, true);
          else
            self2._cb(true, void 0, 0, 0, true);
          return self2._bufPos = pos + needleLen;
        }
        pos += occ[ch];
      }
      while (pos < len) {
        if (data[pos] !== firstNeedleChar || !memcmp(data, pos, needle, 0, len - pos)) {
          ++pos;
          continue;
        }
        data.copy(lookbehind, 0, pos, len);
        self2._lookbehindSize = len - pos;
        break;
      }
      if (pos > 0)
        self2._cb(false, data, self2._bufPos, pos < len ? pos : len, true);
      self2._bufPos = len;
      return len;
    }
    __name(feed, "feed");
    function matchNeedle(self2, data, pos, len) {
      const lb = self2._lookbehind;
      const lbSize = self2._lookbehindSize;
      const needle = self2._needle;
      for (let i = 0; i < len; ++i, ++pos) {
        const ch = pos < 0 ? lb[lbSize + pos] : data[pos];
        if (ch !== needle[i])
          return false;
      }
      return true;
    }
    __name(matchNeedle, "matchNeedle");
    module3.exports = SBMH;
  }
});

// ../../node_modules/.pnpm/busboy@1.6.0/node_modules/busboy/lib/types/multipart.js
var require_multipart2 = __commonJS({
  "../../node_modules/.pnpm/busboy@1.6.0/node_modules/busboy/lib/types/multipart.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { Readable: Readable2, Writable } = require("stream");
    var StreamSearch = require_sbmh2();
    var {
      basename: basename4,
      convertToUTF8,
      getDecoder,
      parseContentType,
      parseDisposition
    } = require_utils8();
    var BUF_CRLF = Buffer.from("\r\n");
    var BUF_CR = Buffer.from("\r");
    var BUF_DASH = Buffer.from("-");
    function noop() {
    }
    __name(noop, "noop");
    var MAX_HEADER_PAIRS = 2e3;
    var MAX_HEADER_SIZE = 16 * 1024;
    var HPARSER_NAME = 0;
    var HPARSER_PRE_OWS = 1;
    var HPARSER_VALUE = 2;
    var HeaderParser = class {
      constructor(cb) {
        this.header = /* @__PURE__ */ Object.create(null);
        this.pairCount = 0;
        this.byteCount = 0;
        this.state = HPARSER_NAME;
        this.name = "";
        this.value = "";
        this.crlf = 0;
        this.cb = cb;
      }
      reset() {
        this.header = /* @__PURE__ */ Object.create(null);
        this.pairCount = 0;
        this.byteCount = 0;
        this.state = HPARSER_NAME;
        this.name = "";
        this.value = "";
        this.crlf = 0;
      }
      push(chunk, pos, end) {
        let start = pos;
        while (pos < end) {
          switch (this.state) {
            case HPARSER_NAME: {
              let done = false;
              for (; pos < end; ++pos) {
                if (this.byteCount === MAX_HEADER_SIZE)
                  return -1;
                ++this.byteCount;
                const code = chunk[pos];
                if (TOKEN[code] !== 1) {
                  if (code !== 58)
                    return -1;
                  this.name += chunk.latin1Slice(start, pos);
                  if (this.name.length === 0)
                    return -1;
                  ++pos;
                  done = true;
                  this.state = HPARSER_PRE_OWS;
                  break;
                }
              }
              if (!done) {
                this.name += chunk.latin1Slice(start, pos);
                break;
              }
            }
            case HPARSER_PRE_OWS: {
              let done = false;
              for (; pos < end; ++pos) {
                if (this.byteCount === MAX_HEADER_SIZE)
                  return -1;
                ++this.byteCount;
                const code = chunk[pos];
                if (code !== 32 && code !== 9) {
                  start = pos;
                  done = true;
                  this.state = HPARSER_VALUE;
                  break;
                }
              }
              if (!done)
                break;
            }
            case HPARSER_VALUE:
              switch (this.crlf) {
                case 0:
                  for (; pos < end; ++pos) {
                    if (this.byteCount === MAX_HEADER_SIZE)
                      return -1;
                    ++this.byteCount;
                    const code = chunk[pos];
                    if (FIELD_VCHAR[code] !== 1) {
                      if (code !== 13)
                        return -1;
                      ++this.crlf;
                      break;
                    }
                  }
                  this.value += chunk.latin1Slice(start, pos++);
                  break;
                case 1:
                  if (this.byteCount === MAX_HEADER_SIZE)
                    return -1;
                  ++this.byteCount;
                  if (chunk[pos++] !== 10)
                    return -1;
                  ++this.crlf;
                  break;
                case 2: {
                  if (this.byteCount === MAX_HEADER_SIZE)
                    return -1;
                  ++this.byteCount;
                  const code = chunk[pos];
                  if (code === 32 || code === 9) {
                    start = pos;
                    this.crlf = 0;
                  } else {
                    if (++this.pairCount < MAX_HEADER_PAIRS) {
                      this.name = this.name.toLowerCase();
                      if (this.header[this.name] === void 0)
                        this.header[this.name] = [this.value];
                      else
                        this.header[this.name].push(this.value);
                    }
                    if (code === 13) {
                      ++this.crlf;
                      ++pos;
                    } else {
                      start = pos;
                      this.crlf = 0;
                      this.state = HPARSER_NAME;
                      this.name = "";
                      this.value = "";
                    }
                  }
                  break;
                }
                case 3: {
                  if (this.byteCount === MAX_HEADER_SIZE)
                    return -1;
                  ++this.byteCount;
                  if (chunk[pos++] !== 10)
                    return -1;
                  const header = this.header;
                  this.reset();
                  this.cb(header);
                  return pos;
                }
              }
              break;
          }
        }
        return pos;
      }
    };
    __name(HeaderParser, "HeaderParser");
    var FileStream = class extends Readable2 {
      constructor(opts, owner) {
        super(opts);
        this.truncated = false;
        this._readcb = null;
        this.once("end", () => {
          this._read();
          if (--owner._fileEndsLeft === 0 && owner._finalcb) {
            const cb = owner._finalcb;
            owner._finalcb = null;
            process.nextTick(cb);
          }
        });
      }
      _read(n2) {
        const cb = this._readcb;
        if (cb) {
          this._readcb = null;
          cb();
        }
      }
    };
    __name(FileStream, "FileStream");
    var ignoreData = {
      push: (chunk, pos) => {
      },
      destroy: () => {
      }
    };
    function callAndUnsetCb(self2, err) {
      const cb = self2._writecb;
      self2._writecb = null;
      if (err)
        self2.destroy(err);
      else if (cb)
        cb();
    }
    __name(callAndUnsetCb, "callAndUnsetCb");
    function nullDecoder(val, hint) {
      return val;
    }
    __name(nullDecoder, "nullDecoder");
    var Multipart = class extends Writable {
      constructor(cfg) {
        const streamOpts = {
          autoDestroy: true,
          emitClose: true,
          highWaterMark: typeof cfg.highWaterMark === "number" ? cfg.highWaterMark : void 0
        };
        super(streamOpts);
        if (!cfg.conType.params || typeof cfg.conType.params.boundary !== "string")
          throw new Error("Multipart: Boundary not found");
        const boundary = cfg.conType.params.boundary;
        const paramDecoder = typeof cfg.defParamCharset === "string" && cfg.defParamCharset ? getDecoder(cfg.defParamCharset) : nullDecoder;
        const defCharset = cfg.defCharset || "utf8";
        const preservePath = cfg.preservePath;
        const fileOpts = {
          autoDestroy: true,
          emitClose: true,
          highWaterMark: typeof cfg.fileHwm === "number" ? cfg.fileHwm : void 0
        };
        const limits = cfg.limits;
        const fieldSizeLimit = limits && typeof limits.fieldSize === "number" ? limits.fieldSize : 1 * 1024 * 1024;
        const fileSizeLimit = limits && typeof limits.fileSize === "number" ? limits.fileSize : Infinity;
        const filesLimit = limits && typeof limits.files === "number" ? limits.files : Infinity;
        const fieldsLimit = limits && typeof limits.fields === "number" ? limits.fields : Infinity;
        const partsLimit = limits && typeof limits.parts === "number" ? limits.parts : Infinity;
        let parts = -1;
        let fields = 0;
        let files = 0;
        let skipPart = false;
        this._fileEndsLeft = 0;
        this._fileStream = void 0;
        this._complete = false;
        let fileSize = 0;
        let field;
        let fieldSize = 0;
        let partCharset;
        let partEncoding;
        let partType;
        let partName;
        let partTruncated = false;
        let hitFilesLimit = false;
        let hitFieldsLimit = false;
        this._hparser = null;
        const hparser = new HeaderParser((header) => {
          this._hparser = null;
          skipPart = false;
          partType = "text/plain";
          partCharset = defCharset;
          partEncoding = "7bit";
          partName = void 0;
          partTruncated = false;
          let filename;
          if (!header["content-disposition"]) {
            skipPart = true;
            return;
          }
          const disp = parseDisposition(
            header["content-disposition"][0],
            paramDecoder
          );
          if (!disp || disp.type !== "form-data") {
            skipPart = true;
            return;
          }
          if (disp.params) {
            if (disp.params.name)
              partName = disp.params.name;
            if (disp.params["filename*"])
              filename = disp.params["filename*"];
            else if (disp.params.filename)
              filename = disp.params.filename;
            if (filename !== void 0 && !preservePath)
              filename = basename4(filename);
          }
          if (header["content-type"]) {
            const conType = parseContentType(header["content-type"][0]);
            if (conType) {
              partType = `${conType.type}/${conType.subtype}`;
              if (conType.params && typeof conType.params.charset === "string")
                partCharset = conType.params.charset.toLowerCase();
            }
          }
          if (header["content-transfer-encoding"])
            partEncoding = header["content-transfer-encoding"][0].toLowerCase();
          if (partType === "application/octet-stream" || filename !== void 0) {
            if (files === filesLimit) {
              if (!hitFilesLimit) {
                hitFilesLimit = true;
                this.emit("filesLimit");
              }
              skipPart = true;
              return;
            }
            ++files;
            if (this.listenerCount("file") === 0) {
              skipPart = true;
              return;
            }
            fileSize = 0;
            this._fileStream = new FileStream(fileOpts, this);
            ++this._fileEndsLeft;
            this.emit(
              "file",
              partName,
              this._fileStream,
              {
                filename,
                encoding: partEncoding,
                mimeType: partType
              }
            );
          } else {
            if (fields === fieldsLimit) {
              if (!hitFieldsLimit) {
                hitFieldsLimit = true;
                this.emit("fieldsLimit");
              }
              skipPart = true;
              return;
            }
            ++fields;
            if (this.listenerCount("field") === 0) {
              skipPart = true;
              return;
            }
            field = [];
            fieldSize = 0;
          }
        });
        let matchPostBoundary = 0;
        const ssCb = /* @__PURE__ */ __name((isMatch, data, start, end, isDataSafe) => {
          retrydata:
            while (data) {
              if (this._hparser !== null) {
                const ret = this._hparser.push(data, start, end);
                if (ret === -1) {
                  this._hparser = null;
                  hparser.reset();
                  this.emit("error", new Error("Malformed part header"));
                  break;
                }
                start = ret;
              }
              if (start === end)
                break;
              if (matchPostBoundary !== 0) {
                if (matchPostBoundary === 1) {
                  switch (data[start]) {
                    case 45:
                      matchPostBoundary = 2;
                      ++start;
                      break;
                    case 13:
                      matchPostBoundary = 3;
                      ++start;
                      break;
                    default:
                      matchPostBoundary = 0;
                  }
                  if (start === end)
                    return;
                }
                if (matchPostBoundary === 2) {
                  matchPostBoundary = 0;
                  if (data[start] === 45) {
                    this._complete = true;
                    this._bparser = ignoreData;
                    return;
                  }
                  const writecb = this._writecb;
                  this._writecb = noop;
                  ssCb(false, BUF_DASH, 0, 1, false);
                  this._writecb = writecb;
                } else if (matchPostBoundary === 3) {
                  matchPostBoundary = 0;
                  if (data[start] === 10) {
                    ++start;
                    if (parts >= partsLimit)
                      break;
                    this._hparser = hparser;
                    if (start === end)
                      break;
                    continue retrydata;
                  } else {
                    const writecb = this._writecb;
                    this._writecb = noop;
                    ssCb(false, BUF_CR, 0, 1, false);
                    this._writecb = writecb;
                  }
                }
              }
              if (!skipPart) {
                if (this._fileStream) {
                  let chunk;
                  const actualLen = Math.min(end - start, fileSizeLimit - fileSize);
                  if (!isDataSafe) {
                    chunk = Buffer.allocUnsafe(actualLen);
                    data.copy(chunk, 0, start, start + actualLen);
                  } else {
                    chunk = data.slice(start, start + actualLen);
                  }
                  fileSize += chunk.length;
                  if (fileSize === fileSizeLimit) {
                    if (chunk.length > 0)
                      this._fileStream.push(chunk);
                    this._fileStream.emit("limit");
                    this._fileStream.truncated = true;
                    skipPart = true;
                  } else if (!this._fileStream.push(chunk)) {
                    if (this._writecb)
                      this._fileStream._readcb = this._writecb;
                    this._writecb = null;
                  }
                } else if (field !== void 0) {
                  let chunk;
                  const actualLen = Math.min(
                    end - start,
                    fieldSizeLimit - fieldSize
                  );
                  if (!isDataSafe) {
                    chunk = Buffer.allocUnsafe(actualLen);
                    data.copy(chunk, 0, start, start + actualLen);
                  } else {
                    chunk = data.slice(start, start + actualLen);
                  }
                  fieldSize += actualLen;
                  field.push(chunk);
                  if (fieldSize === fieldSizeLimit) {
                    skipPart = true;
                    partTruncated = true;
                  }
                }
              }
              break;
            }
          if (isMatch) {
            matchPostBoundary = 1;
            if (this._fileStream) {
              this._fileStream.push(null);
              this._fileStream = null;
            } else if (field !== void 0) {
              let data2;
              switch (field.length) {
                case 0:
                  data2 = "";
                  break;
                case 1:
                  data2 = convertToUTF8(field[0], partCharset, 0);
                  break;
                default:
                  data2 = convertToUTF8(
                    Buffer.concat(field, fieldSize),
                    partCharset,
                    0
                  );
              }
              field = void 0;
              fieldSize = 0;
              this.emit(
                "field",
                partName,
                data2,
                {
                  nameTruncated: false,
                  valueTruncated: partTruncated,
                  encoding: partEncoding,
                  mimeType: partType
                }
              );
            }
            if (++parts === partsLimit)
              this.emit("partsLimit");
          }
        }, "ssCb");
        this._bparser = new StreamSearch(`\r
--${boundary}`, ssCb);
        this._writecb = null;
        this._finalcb = null;
        this.write(BUF_CRLF);
      }
      static detect(conType) {
        return conType.type === "multipart" && conType.subtype === "form-data";
      }
      _write(chunk, enc, cb) {
        this._writecb = cb;
        this._bparser.push(chunk, 0);
        if (this._writecb)
          callAndUnsetCb(this);
      }
      _destroy(err, cb) {
        this._hparser = null;
        this._bparser = ignoreData;
        if (!err)
          err = checkEndState(this);
        const fileStream = this._fileStream;
        if (fileStream) {
          this._fileStream = null;
          fileStream.destroy(err);
        }
        cb(err);
      }
      _final(cb) {
        this._bparser.destroy();
        if (!this._complete)
          return cb(new Error("Unexpected end of form"));
        if (this._fileEndsLeft)
          this._finalcb = finalcb.bind(null, this, cb);
        else
          finalcb(this, cb);
      }
    };
    __name(Multipart, "Multipart");
    function finalcb(self2, cb, err) {
      if (err)
        return cb(err);
      err = checkEndState(self2);
      cb(err);
    }
    __name(finalcb, "finalcb");
    function checkEndState(self2) {
      if (self2._hparser)
        return new Error("Malformed part header");
      const fileStream = self2._fileStream;
      if (fileStream) {
        self2._fileStream = null;
        fileStream.destroy(new Error("Unexpected end of file"));
      }
      if (!self2._complete)
        return new Error("Unexpected end of form");
    }
    __name(checkEndState, "checkEndState");
    var TOKEN = [
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      1,
      0,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      1,
      1,
      0,
      1,
      1,
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      1,
      0,
      1,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0
    ];
    var FIELD_VCHAR = [
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      1,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1
    ];
    module3.exports = Multipart;
  }
});

// ../../node_modules/.pnpm/busboy@1.6.0/node_modules/busboy/lib/types/urlencoded.js
var require_urlencoded3 = __commonJS({
  "../../node_modules/.pnpm/busboy@1.6.0/node_modules/busboy/lib/types/urlencoded.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { Writable } = require("stream");
    var { getDecoder } = require_utils8();
    var URLEncoded = class extends Writable {
      constructor(cfg) {
        const streamOpts = {
          autoDestroy: true,
          emitClose: true,
          highWaterMark: typeof cfg.highWaterMark === "number" ? cfg.highWaterMark : void 0
        };
        super(streamOpts);
        let charset = cfg.defCharset || "utf8";
        if (cfg.conType.params && typeof cfg.conType.params.charset === "string")
          charset = cfg.conType.params.charset;
        this.charset = charset;
        const limits = cfg.limits;
        this.fieldSizeLimit = limits && typeof limits.fieldSize === "number" ? limits.fieldSize : 1 * 1024 * 1024;
        this.fieldsLimit = limits && typeof limits.fields === "number" ? limits.fields : Infinity;
        this.fieldNameSizeLimit = limits && typeof limits.fieldNameSize === "number" ? limits.fieldNameSize : 100;
        this._inKey = true;
        this._keyTrunc = false;
        this._valTrunc = false;
        this._bytesKey = 0;
        this._bytesVal = 0;
        this._fields = 0;
        this._key = "";
        this._val = "";
        this._byte = -2;
        this._lastPos = 0;
        this._encode = 0;
        this._decoder = getDecoder(charset);
      }
      static detect(conType) {
        return conType.type === "application" && conType.subtype === "x-www-form-urlencoded";
      }
      _write(chunk, enc, cb) {
        if (this._fields >= this.fieldsLimit)
          return cb();
        let i = 0;
        const len = chunk.length;
        this._lastPos = 0;
        if (this._byte !== -2) {
          i = readPctEnc(this, chunk, i, len);
          if (i === -1)
            return cb(new Error("Malformed urlencoded form"));
          if (i >= len)
            return cb();
          if (this._inKey)
            ++this._bytesKey;
          else
            ++this._bytesVal;
        }
        main:
          while (i < len) {
            if (this._inKey) {
              i = skipKeyBytes(this, chunk, i, len);
              while (i < len) {
                switch (chunk[i]) {
                  case 61:
                    if (this._lastPos < i)
                      this._key += chunk.latin1Slice(this._lastPos, i);
                    this._lastPos = ++i;
                    this._key = this._decoder(this._key, this._encode);
                    this._encode = 0;
                    this._inKey = false;
                    continue main;
                  case 38:
                    if (this._lastPos < i)
                      this._key += chunk.latin1Slice(this._lastPos, i);
                    this._lastPos = ++i;
                    this._key = this._decoder(this._key, this._encode);
                    this._encode = 0;
                    if (this._bytesKey > 0) {
                      this.emit(
                        "field",
                        this._key,
                        "",
                        {
                          nameTruncated: this._keyTrunc,
                          valueTruncated: false,
                          encoding: this.charset,
                          mimeType: "text/plain"
                        }
                      );
                    }
                    this._key = "";
                    this._val = "";
                    this._keyTrunc = false;
                    this._valTrunc = false;
                    this._bytesKey = 0;
                    this._bytesVal = 0;
                    if (++this._fields >= this.fieldsLimit) {
                      this.emit("fieldsLimit");
                      return cb();
                    }
                    continue;
                  case 43:
                    if (this._lastPos < i)
                      this._key += chunk.latin1Slice(this._lastPos, i);
                    this._key += " ";
                    this._lastPos = i + 1;
                    break;
                  case 37:
                    if (this._encode === 0)
                      this._encode = 1;
                    if (this._lastPos < i)
                      this._key += chunk.latin1Slice(this._lastPos, i);
                    this._lastPos = i + 1;
                    this._byte = -1;
                    i = readPctEnc(this, chunk, i + 1, len);
                    if (i === -1)
                      return cb(new Error("Malformed urlencoded form"));
                    if (i >= len)
                      return cb();
                    ++this._bytesKey;
                    i = skipKeyBytes(this, chunk, i, len);
                    continue;
                }
                ++i;
                ++this._bytesKey;
                i = skipKeyBytes(this, chunk, i, len);
              }
              if (this._lastPos < i)
                this._key += chunk.latin1Slice(this._lastPos, i);
            } else {
              i = skipValBytes(this, chunk, i, len);
              while (i < len) {
                switch (chunk[i]) {
                  case 38:
                    if (this._lastPos < i)
                      this._val += chunk.latin1Slice(this._lastPos, i);
                    this._lastPos = ++i;
                    this._inKey = true;
                    this._val = this._decoder(this._val, this._encode);
                    this._encode = 0;
                    if (this._bytesKey > 0 || this._bytesVal > 0) {
                      this.emit(
                        "field",
                        this._key,
                        this._val,
                        {
                          nameTruncated: this._keyTrunc,
                          valueTruncated: this._valTrunc,
                          encoding: this.charset,
                          mimeType: "text/plain"
                        }
                      );
                    }
                    this._key = "";
                    this._val = "";
                    this._keyTrunc = false;
                    this._valTrunc = false;
                    this._bytesKey = 0;
                    this._bytesVal = 0;
                    if (++this._fields >= this.fieldsLimit) {
                      this.emit("fieldsLimit");
                      return cb();
                    }
                    continue main;
                  case 43:
                    if (this._lastPos < i)
                      this._val += chunk.latin1Slice(this._lastPos, i);
                    this._val += " ";
                    this._lastPos = i + 1;
                    break;
                  case 37:
                    if (this._encode === 0)
                      this._encode = 1;
                    if (this._lastPos < i)
                      this._val += chunk.latin1Slice(this._lastPos, i);
                    this._lastPos = i + 1;
                    this._byte = -1;
                    i = readPctEnc(this, chunk, i + 1, len);
                    if (i === -1)
                      return cb(new Error("Malformed urlencoded form"));
                    if (i >= len)
                      return cb();
                    ++this._bytesVal;
                    i = skipValBytes(this, chunk, i, len);
                    continue;
                }
                ++i;
                ++this._bytesVal;
                i = skipValBytes(this, chunk, i, len);
              }
              if (this._lastPos < i)
                this._val += chunk.latin1Slice(this._lastPos, i);
            }
          }
        cb();
      }
      _final(cb) {
        if (this._byte !== -2)
          return cb(new Error("Malformed urlencoded form"));
        if (!this._inKey || this._bytesKey > 0 || this._bytesVal > 0) {
          if (this._inKey)
            this._key = this._decoder(this._key, this._encode);
          else
            this._val = this._decoder(this._val, this._encode);
          this.emit(
            "field",
            this._key,
            this._val,
            {
              nameTruncated: this._keyTrunc,
              valueTruncated: this._valTrunc,
              encoding: this.charset,
              mimeType: "text/plain"
            }
          );
        }
        cb();
      }
    };
    __name(URLEncoded, "URLEncoded");
    function readPctEnc(self2, chunk, pos, len) {
      if (pos >= len)
        return len;
      if (self2._byte === -1) {
        const hexUpper = HEX_VALUES[chunk[pos++]];
        if (hexUpper === -1)
          return -1;
        if (hexUpper >= 8)
          self2._encode = 2;
        if (pos < len) {
          const hexLower = HEX_VALUES[chunk[pos++]];
          if (hexLower === -1)
            return -1;
          if (self2._inKey)
            self2._key += String.fromCharCode((hexUpper << 4) + hexLower);
          else
            self2._val += String.fromCharCode((hexUpper << 4) + hexLower);
          self2._byte = -2;
          self2._lastPos = pos;
        } else {
          self2._byte = hexUpper;
        }
      } else {
        const hexLower = HEX_VALUES[chunk[pos++]];
        if (hexLower === -1)
          return -1;
        if (self2._inKey)
          self2._key += String.fromCharCode((self2._byte << 4) + hexLower);
        else
          self2._val += String.fromCharCode((self2._byte << 4) + hexLower);
        self2._byte = -2;
        self2._lastPos = pos;
      }
      return pos;
    }
    __name(readPctEnc, "readPctEnc");
    function skipKeyBytes(self2, chunk, pos, len) {
      if (self2._bytesKey > self2.fieldNameSizeLimit) {
        if (!self2._keyTrunc) {
          if (self2._lastPos < pos)
            self2._key += chunk.latin1Slice(self2._lastPos, pos - 1);
        }
        self2._keyTrunc = true;
        for (; pos < len; ++pos) {
          const code = chunk[pos];
          if (code === 61 || code === 38)
            break;
          ++self2._bytesKey;
        }
        self2._lastPos = pos;
      }
      return pos;
    }
    __name(skipKeyBytes, "skipKeyBytes");
    function skipValBytes(self2, chunk, pos, len) {
      if (self2._bytesVal > self2.fieldSizeLimit) {
        if (!self2._valTrunc) {
          if (self2._lastPos < pos)
            self2._val += chunk.latin1Slice(self2._lastPos, pos - 1);
        }
        self2._valTrunc = true;
        for (; pos < len; ++pos) {
          if (chunk[pos] === 38)
            break;
          ++self2._bytesVal;
        }
        self2._lastPos = pos;
      }
      return pos;
    }
    __name(skipValBytes, "skipValBytes");
    var HEX_VALUES = [
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      0,
      1,
      2,
      3,
      4,
      5,
      6,
      7,
      8,
      9,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      10,
      11,
      12,
      13,
      14,
      15,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      10,
      11,
      12,
      13,
      14,
      15,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1
    ];
    module3.exports = URLEncoded;
  }
});

// ../../node_modules/.pnpm/busboy@1.6.0/node_modules/busboy/lib/index.js
var require_lib6 = __commonJS({
  "../../node_modules/.pnpm/busboy@1.6.0/node_modules/busboy/lib/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { parseContentType } = require_utils8();
    function getInstance(cfg) {
      const headers = cfg.headers;
      const conType = parseContentType(headers["content-type"]);
      if (!conType)
        throw new Error("Malformed content type");
      for (const type of TYPES) {
        const matched = type.detect(conType);
        if (!matched)
          continue;
        const instanceCfg = {
          limits: cfg.limits,
          headers,
          conType,
          highWaterMark: void 0,
          fileHwm: void 0,
          defCharset: void 0,
          defParamCharset: void 0,
          preservePath: false
        };
        if (cfg.highWaterMark)
          instanceCfg.highWaterMark = cfg.highWaterMark;
        if (cfg.fileHwm)
          instanceCfg.fileHwm = cfg.fileHwm;
        instanceCfg.defCharset = cfg.defCharset;
        instanceCfg.defParamCharset = cfg.defParamCharset;
        instanceCfg.preservePath = cfg.preservePath;
        return new type(instanceCfg);
      }
      throw new Error(`Unsupported content type: ${headers["content-type"]}`);
    }
    __name(getInstance, "getInstance");
    var TYPES = [
      require_multipart2(),
      require_urlencoded3()
    ].filter(function(typemod) {
      return typeof typemod.detect === "function";
    });
    module3.exports = (cfg) => {
      if (typeof cfg !== "object" || cfg === null)
        cfg = {};
      if (typeof cfg.headers !== "object" || cfg.headers === null || typeof cfg.headers["content-type"] !== "string") {
        throw new Error("Missing Content-Type");
      }
      return getInstance(cfg);
    };
  }
});

// ../../node_modules/.pnpm/urlpattern-polyfill@4.0.3/node_modules/urlpattern-polyfill/dist/index.cjs
var require_dist3 = __commonJS({
  "../../node_modules/.pnpm/urlpattern-polyfill@4.0.3/node_modules/urlpattern-polyfill/dist/index.cjs"(exports2, module3) {
    init_import_meta_url();
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __esm2 = /* @__PURE__ */ __name((fn2, res) => /* @__PURE__ */ __name(function __init() {
      return fn2 && (res = (0, fn2[__getOwnPropNames2(fn2)[0]])(fn2 = 0)), res;
    }, "__init"), "__esm");
    var __export2 = /* @__PURE__ */ __name((target, all2) => {
      for (var name in all2)
        __defProp2(target, name, { get: all2[name], enumerable: true });
    }, "__export");
    var __copyProps2 = /* @__PURE__ */ __name((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)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    }, "__copyProps");
    var __toCommonJS2 = /* @__PURE__ */ __name((mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod), "__toCommonJS");
    function isASCII(str, extended) {
      return (extended ? /^[\x00-\xFF]*$/ : /^[\x00-\x7F]*$/).test(str);
    }
    __name(isASCII, "isASCII");
    function lexer(str, lenient = false) {
      const tokens = [];
      let i = 0;
      while (i < str.length) {
        const char = str[i];
        const ErrorOrInvalid = /* @__PURE__ */ __name(function(msg) {
          if (!lenient)
            throw new TypeError(msg);
          tokens.push({ type: "INVALID_CHAR", index: i, value: str[i++] });
        }, "ErrorOrInvalid");
        if (char === "*") {
          tokens.push({ type: "ASTERISK", index: i, value: str[i++] });
          continue;
        }
        if (char === "+" || char === "?") {
          tokens.push({ type: "MODIFIER", index: i, value: str[i++] });
          continue;
        }
        if (char === "\\") {
          tokens.push({ type: "ESCAPED_CHAR", index: i++, value: str[i++] });
          continue;
        }
        if (char === "{") {
          tokens.push({ type: "OPEN", index: i, value: str[i++] });
          continue;
        }
        if (char === "}") {
          tokens.push({ type: "CLOSE", index: i, value: str[i++] });
          continue;
        }
        if (char === ":") {
          let name = "";
          let j2 = i + 1;
          while (j2 < str.length) {
            const code = str.substr(j2, 1);
            if (j2 === i + 1 && regexIdentifierStart.test(code) || j2 !== i + 1 && regexIdentifierPart.test(code)) {
              name += str[j2++];
              continue;
            }
            break;
          }
          if (!name) {
            ErrorOrInvalid(`Missing parameter name at ${i}`);
            continue;
          }
          tokens.push({ type: "NAME", index: i, value: name });
          i = j2;
          continue;
        }
        if (char === "(") {
          let count = 1;
          let pattern = "";
          let j2 = i + 1;
          let error2 = false;
          if (str[j2] === "?") {
            ErrorOrInvalid(`Pattern cannot start with "?" at ${j2}`);
            continue;
          }
          while (j2 < str.length) {
            if (!isASCII(str[j2], false)) {
              ErrorOrInvalid(`Invalid character '${str[j2]}' at ${j2}.`);
              error2 = true;
              break;
            }
            if (str[j2] === "\\") {
              pattern += str[j2++] + str[j2++];
              continue;
            }
            if (str[j2] === ")") {
              count--;
              if (count === 0) {
                j2++;
                break;
              }
            } else if (str[j2] === "(") {
              count++;
              if (str[j2 + 1] !== "?") {
                ErrorOrInvalid(`Capturing groups are not allowed at ${j2}`);
                error2 = true;
                break;
              }
            }
            pattern += str[j2++];
          }
          if (error2) {
            continue;
          }
          if (count) {
            ErrorOrInvalid(`Unbalanced pattern at ${i}`);
            continue;
          }
          if (!pattern) {
            ErrorOrInvalid(`Missing pattern at ${i}`);
            continue;
          }
          tokens.push({ type: "PATTERN", index: i, value: pattern });
          i = j2;
          continue;
        }
        tokens.push({ type: "CHAR", index: i, value: str[i++] });
      }
      tokens.push({ type: "END", index: i, value: "" });
      return tokens;
    }
    __name(lexer, "lexer");
    function parse7(str, options29 = {}) {
      const tokens = lexer(str);
      const { prefixes = "./" } = options29;
      const defaultPattern = `[^${escapeString(options29.delimiter || "/#?")}]+?`;
      const result = [];
      let key = 0;
      let i = 0;
      let path67 = "";
      let nameSet = /* @__PURE__ */ new Set();
      const tryConsume = /* @__PURE__ */ __name((type) => {
        if (i < tokens.length && tokens[i].type === type)
          return tokens[i++].value;
      }, "tryConsume");
      const tryConsumeModifier = /* @__PURE__ */ __name(() => {
        const r3 = tryConsume("MODIFIER");
        if (r3) {
          return r3;
        }
        return tryConsume("ASTERISK");
      }, "tryConsumeModifier");
      const mustConsume = /* @__PURE__ */ __name((type) => {
        const value = tryConsume(type);
        if (value !== void 0)
          return value;
        const { type: nextType, index } = tokens[i];
        throw new TypeError(`Unexpected ${nextType} at ${index}, expected ${type}`);
      }, "mustConsume");
      const consumeText = /* @__PURE__ */ __name(() => {
        let result2 = "";
        let value;
        while (value = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR")) {
          result2 += value;
        }
        return result2;
      }, "consumeText");
      const DefaultEncodePart = /* @__PURE__ */ __name((value) => {
        return value;
      }, "DefaultEncodePart");
      const encodePart = options29.encodePart || DefaultEncodePart;
      while (i < tokens.length) {
        const char = tryConsume("CHAR");
        const name = tryConsume("NAME");
        let pattern = tryConsume("PATTERN");
        if (!name && !pattern && tryConsume("ASTERISK")) {
          pattern = ".*";
        }
        if (name || pattern) {
          let prefix = char || "";
          if (prefixes.indexOf(prefix) === -1) {
            path67 += prefix;
            prefix = "";
          }
          if (path67) {
            result.push(encodePart(path67));
            path67 = "";
          }
          const finalName = name || key++;
          if (nameSet.has(finalName)) {
            throw new TypeError(`Duplicate name '${finalName}'.`);
          }
          nameSet.add(finalName);
          result.push({
            name: finalName,
            prefix: encodePart(prefix),
            suffix: "",
            pattern: pattern || defaultPattern,
            modifier: tryConsumeModifier() || ""
          });
          continue;
        }
        const value = char || tryConsume("ESCAPED_CHAR");
        if (value) {
          path67 += value;
          continue;
        }
        const open3 = tryConsume("OPEN");
        if (open3) {
          const prefix = consumeText();
          const name2 = tryConsume("NAME") || "";
          let pattern2 = tryConsume("PATTERN") || "";
          if (!name2 && !pattern2 && tryConsume("ASTERISK")) {
            pattern2 = ".*";
          }
          const suffix = consumeText();
          mustConsume("CLOSE");
          const modifier = tryConsumeModifier() || "";
          if (!name2 && !pattern2 && !modifier) {
            path67 += prefix;
            continue;
          }
          if (!name2 && !pattern2 && !prefix) {
            continue;
          }
          if (path67) {
            result.push(encodePart(path67));
            path67 = "";
          }
          result.push({
            name: name2 || (pattern2 ? key++ : ""),
            pattern: name2 && !pattern2 ? defaultPattern : pattern2,
            prefix: encodePart(prefix),
            suffix: encodePart(suffix),
            modifier
          });
          continue;
        }
        if (path67) {
          result.push(encodePart(path67));
          path67 = "";
        }
        mustConsume("END");
      }
      return result;
    }
    __name(parse7, "parse");
    function escapeString(str) {
      return str.replace(/([.+*?^${}()[\]|/\\])/g, "\\$1");
    }
    __name(escapeString, "escapeString");
    function flags(options29) {
      return options29 && options29.sensitive ? "u" : "ui";
    }
    __name(flags, "flags");
    function regexpToRegexp(path67, keys) {
      if (!keys)
        return path67;
      const groupsRegex = /\((?:\?<(.*?)>)?(?!\?)/g;
      let index = 0;
      let execResult = groupsRegex.exec(path67.source);
      while (execResult) {
        keys.push({
          name: execResult[1] || index++,
          prefix: "",
          suffix: "",
          modifier: "",
          pattern: ""
        });
        execResult = groupsRegex.exec(path67.source);
      }
      return path67;
    }
    __name(regexpToRegexp, "regexpToRegexp");
    function arrayToRegexp(paths, keys, options29) {
      const parts = paths.map((path67) => pathToRegexp(path67, keys, options29).source);
      return new RegExp(`(?:${parts.join("|")})`, flags(options29));
    }
    __name(arrayToRegexp, "arrayToRegexp");
    function stringToRegexp(path67, keys, options29) {
      return tokensToRegexp(parse7(path67, options29), keys, options29);
    }
    __name(stringToRegexp, "stringToRegexp");
    function tokensToRegexp(tokens, keys, options29 = {}) {
      const {
        strict = false,
        start = true,
        end = true,
        encode = /* @__PURE__ */ __name((x2) => x2, "encode")
      } = options29;
      const endsWith = `[${escapeString(options29.endsWith || "")}]|$`;
      const delimiter = `[${escapeString(options29.delimiter || "/#?")}]`;
      let route2 = start ? "^" : "";
      for (const token of tokens) {
        if (typeof token === "string") {
          route2 += escapeString(encode(token));
        } else {
          const prefix = escapeString(encode(token.prefix));
          const suffix = escapeString(encode(token.suffix));
          if (token.pattern) {
            if (keys)
              keys.push(token);
            if (prefix || suffix) {
              if (token.modifier === "+" || token.modifier === "*") {
                const mod = token.modifier === "*" ? "?" : "";
                route2 += `(?:${prefix}((?:${token.pattern})(?:${suffix}${prefix}(?:${token.pattern}))*)${suffix})${mod}`;
              } else {
                route2 += `(?:${prefix}(${token.pattern})${suffix})${token.modifier}`;
              }
            } else {
              if (token.modifier === "+" || token.modifier === "*") {
                route2 += `((?:${token.pattern})${token.modifier})`;
              } else {
                route2 += `(${token.pattern})${token.modifier}`;
              }
            }
          } else {
            route2 += `(?:${prefix}${suffix})${token.modifier}`;
          }
        }
      }
      if (end) {
        if (!strict)
          route2 += `${delimiter}?`;
        route2 += !options29.endsWith ? "$" : `(?=${endsWith})`;
      } else {
        const endToken = tokens[tokens.length - 1];
        const isEndDelimited = typeof endToken === "string" ? delimiter.indexOf(endToken[endToken.length - 1]) > -1 : endToken === void 0;
        if (!strict) {
          route2 += `(?:${delimiter}(?=${endsWith}))?`;
        }
        if (!isEndDelimited) {
          route2 += `(?=${delimiter}|${endsWith})`;
        }
      }
      return new RegExp(route2, flags(options29));
    }
    __name(tokensToRegexp, "tokensToRegexp");
    function pathToRegexp(path67, keys, options29) {
      if (path67 instanceof RegExp)
        return regexpToRegexp(path67, keys);
      if (Array.isArray(path67))
        return arrayToRegexp(path67, keys, options29);
      return stringToRegexp(path67, keys, options29);
    }
    __name(pathToRegexp, "pathToRegexp");
    var regexIdentifierStart;
    var regexIdentifierPart;
    var init_path_to_regex_modified = __esm2({
      "src/path-to-regex-modified.ts"() {
        regexIdentifierStart = /[$_\p{ID_Start}]/u;
        regexIdentifierPart = /[$_\u200C\u200D\p{ID_Continue}]/u;
      }
    });
    function isAbsolutePathname(pathname, isPattern) {
      if (!pathname.length) {
        return false;
      }
      if (pathname[0] === "/") {
        return true;
      }
      if (!isPattern) {
        return false;
      }
      if (pathname.length < 2) {
        return false;
      }
      if ((pathname[0] == "\\" || pathname[0] == "{") && pathname[1] == "/") {
        return true;
      }
      return false;
    }
    __name(isAbsolutePathname, "isAbsolutePathname");
    function maybeStripPrefix(value, prefix) {
      if (value.startsWith(prefix)) {
        return value.substring(prefix.length, value.length);
      }
      return value;
    }
    __name(maybeStripPrefix, "maybeStripPrefix");
    function maybeStripSuffix(value, suffix) {
      if (value.endsWith(suffix)) {
        return value.substr(0, value.length - suffix.length);
      }
      return value;
    }
    __name(maybeStripSuffix, "maybeStripSuffix");
    function treatAsIPv6Hostname(value) {
      if (!value || value.length < 2) {
        return false;
      }
      if (value[0] === "[") {
        return true;
      }
      if ((value[0] === "\\" || value[0] === "{") && value[1] === "[") {
        return true;
      }
      return false;
    }
    __name(treatAsIPv6Hostname, "treatAsIPv6Hostname");
    function isSpecialScheme(protocol_regexp) {
      if (!protocol_regexp) {
        return true;
      }
      for (const scheme of SPECIAL_SCHEMES) {
        if (protocol_regexp.test(scheme)) {
          return true;
        }
      }
      return false;
    }
    __name(isSpecialScheme, "isSpecialScheme");
    function canonicalizeHash(hash, isPattern) {
      hash = maybeStripPrefix(hash, "#");
      if (isPattern || hash === "") {
        return hash;
      }
      const url4 = new URL("https://example.com");
      url4.hash = hash;
      return url4.hash ? url4.hash.substring(1, url4.hash.length) : "";
    }
    __name(canonicalizeHash, "canonicalizeHash");
    function canonicalizeSearch(search, isPattern) {
      search = maybeStripPrefix(search, "?");
      if (isPattern || search === "") {
        return search;
      }
      const url4 = new URL("https://example.com");
      url4.search = search;
      return url4.search ? url4.search.substring(1, url4.search.length) : "";
    }
    __name(canonicalizeSearch, "canonicalizeSearch");
    function canonicalizeHostname(hostname2, isPattern) {
      if (isPattern || hostname2 === "") {
        return hostname2;
      }
      if (treatAsIPv6Hostname(hostname2)) {
        return ipv6HostnameEncodeCallback(hostname2);
      } else {
        return hostnameEncodeCallback(hostname2);
      }
    }
    __name(canonicalizeHostname, "canonicalizeHostname");
    function canonicalizePassword(password, isPattern) {
      if (isPattern || password === "") {
        return password;
      }
      const url4 = new URL("https://example.com");
      url4.password = password;
      return url4.password;
    }
    __name(canonicalizePassword, "canonicalizePassword");
    function canonicalizeUsername(username, isPattern) {
      if (isPattern || username === "") {
        return username;
      }
      const url4 = new URL("https://example.com");
      url4.username = username;
      return url4.username;
    }
    __name(canonicalizeUsername, "canonicalizeUsername");
    function canonicalizePathname(pathname, protocol, isPattern) {
      if (isPattern || pathname === "") {
        return pathname;
      }
      if (protocol && !SPECIAL_SCHEMES.includes(protocol)) {
        const url4 = new URL(`${protocol}:${pathname}`);
        return url4.pathname;
      }
      const leadingSlash = pathname[0] == "/";
      pathname = new URL(!leadingSlash ? "/-" + pathname : pathname, "https://example.com").pathname;
      if (!leadingSlash) {
        pathname = pathname.substring(2, pathname.length);
      }
      return pathname;
    }
    __name(canonicalizePathname, "canonicalizePathname");
    function canonicalizePort(port2, protocol, isPattern) {
      if (defaultPortForProtocol(protocol) === port2) {
        port2 = "";
      }
      if (isPattern || port2 === "") {
        return port2;
      }
      return portEncodeCallback(port2);
    }
    __name(canonicalizePort, "canonicalizePort");
    function canonicalizeProtocol(protocol, isPattern) {
      protocol = maybeStripSuffix(protocol, ":");
      if (isPattern || protocol === "") {
        return protocol;
      }
      return protocolEncodeCallback(protocol);
    }
    __name(canonicalizeProtocol, "canonicalizeProtocol");
    function defaultPortForProtocol(protocol) {
      switch (protocol) {
        case "ws":
        case "http":
          return "80";
        case "wws":
        case "https":
          return "443";
        case "ftp":
          return "21";
        default:
          return "";
      }
    }
    __name(defaultPortForProtocol, "defaultPortForProtocol");
    function protocolEncodeCallback(input) {
      if (input === "") {
        return input;
      }
      if (/^[-+.A-Za-z0-9]*$/.test(input))
        return input.toLowerCase();
      throw new TypeError(`Invalid protocol '${input}'.`);
    }
    __name(protocolEncodeCallback, "protocolEncodeCallback");
    function usernameEncodeCallback(input) {
      if (input === "") {
        return input;
      }
      const url4 = new URL("https://example.com");
      url4.username = input;
      return url4.username;
    }
    __name(usernameEncodeCallback, "usernameEncodeCallback");
    function passwordEncodeCallback(input) {
      if (input === "") {
        return input;
      }
      const url4 = new URL("https://example.com");
      url4.password = input;
      return url4.password;
    }
    __name(passwordEncodeCallback, "passwordEncodeCallback");
    function hostnameEncodeCallback(input) {
      if (input === "") {
        return input;
      }
      if (/[\t\n\r #%/:<>?@[\]^\\|]/g.test(input)) {
        throw new TypeError(`Invalid hostname '${input}'`);
      }
      const url4 = new URL("https://example.com");
      url4.hostname = input;
      return url4.hostname;
    }
    __name(hostnameEncodeCallback, "hostnameEncodeCallback");
    function ipv6HostnameEncodeCallback(input) {
      if (input === "") {
        return input;
      }
      if (/[^0-9a-fA-F[\]:]/g.test(input)) {
        throw new TypeError(`Invalid IPv6 hostname '${input}'`);
      }
      return input.toLowerCase();
    }
    __name(ipv6HostnameEncodeCallback, "ipv6HostnameEncodeCallback");
    function portEncodeCallback(input) {
      if (input === "") {
        return input;
      }
      if (/^[0-9]*$/.test(input) && parseInt(input) <= 65535) {
        return input;
      }
      throw new TypeError(`Invalid port '${input}'.`);
    }
    __name(portEncodeCallback, "portEncodeCallback");
    function standardURLPathnameEncodeCallback(input) {
      if (input === "") {
        return input;
      }
      const url4 = new URL("https://example.com");
      url4.pathname = input[0] !== "/" ? "/-" + input : input;
      if (input[0] !== "/") {
        return url4.pathname.substring(2, url4.pathname.length);
      }
      return url4.pathname;
    }
    __name(standardURLPathnameEncodeCallback, "standardURLPathnameEncodeCallback");
    function pathURLPathnameEncodeCallback(input) {
      if (input === "") {
        return input;
      }
      const url4 = new URL(`data:${input}`);
      return url4.pathname;
    }
    __name(pathURLPathnameEncodeCallback, "pathURLPathnameEncodeCallback");
    function searchEncodeCallback(input) {
      if (input === "") {
        return input;
      }
      const url4 = new URL("https://example.com");
      url4.search = input;
      return url4.search.substring(1, url4.search.length);
    }
    __name(searchEncodeCallback, "searchEncodeCallback");
    function hashEncodeCallback(input) {
      if (input === "") {
        return input;
      }
      const url4 = new URL("https://example.com");
      url4.hash = input;
      return url4.hash.substring(1, url4.hash.length);
    }
    __name(hashEncodeCallback, "hashEncodeCallback");
    var DEFAULT_OPTIONS2;
    var HOSTNAME_OPTIONS;
    var PATHNAME_OPTIONS;
    var SPECIAL_SCHEMES;
    var init_url_utils = __esm2({
      "src/url-utils.ts"() {
        DEFAULT_OPTIONS2 = {
          delimiter: "",
          prefixes: "",
          sensitive: true,
          strict: true
        };
        HOSTNAME_OPTIONS = {
          delimiter: ".",
          prefixes: "",
          sensitive: true,
          strict: true
        };
        PATHNAME_OPTIONS = {
          delimiter: "/",
          prefixes: "/",
          sensitive: true,
          strict: true
        };
        SPECIAL_SCHEMES = [
          "ftp",
          "file",
          "http",
          "https",
          "ws",
          "wss"
        ];
      }
    });
    var Parser2;
    var init_url_pattern_parser = __esm2({
      "src/url-pattern-parser.ts"() {
        init_path_to_regex_modified();
        init_url_utils();
        Parser2 = /* @__PURE__ */ __name(class {
          constructor(input) {
            this.tokenList = [];
            this.internalResult = {};
            this.tokenIndex = 0;
            this.tokenIncrement = 1;
            this.componentStart = 0;
            this.state = 0;
            this.groupDepth = 0;
            this.hostnameIPv6BracketDepth = 0;
            this.shouldTreatAsStandardURL = false;
            this.input = input;
          }
          get result() {
            return this.internalResult;
          }
          parse() {
            this.tokenList = lexer(this.input, true);
            for (; this.tokenIndex < this.tokenList.length; this.tokenIndex += this.tokenIncrement) {
              this.tokenIncrement = 1;
              if (this.tokenList[this.tokenIndex].type === "END") {
                if (this.state === 0) {
                  this.rewind();
                  if (this.isHashPrefix()) {
                    this.changeState(9, 1);
                  } else if (this.isSearchPrefix()) {
                    this.changeState(8, 1);
                    this.internalResult.hash = "";
                  } else {
                    this.changeState(7, 0);
                    this.internalResult.search = "";
                    this.internalResult.hash = "";
                  }
                  continue;
                } else if (this.state === 2) {
                  this.rewindAndSetState(
                    5
                    /* HOSTNAME */
                  );
                  continue;
                }
                this.changeState(10, 0);
                break;
              }
              if (this.groupDepth > 0) {
                if (this.isGroupClose()) {
                  this.groupDepth -= 1;
                } else {
                  continue;
                }
              }
              if (this.isGroupOpen()) {
                this.groupDepth += 1;
                continue;
              }
              switch (this.state) {
                case 0:
                  if (this.isProtocolSuffix()) {
                    this.internalResult.username = "";
                    this.internalResult.password = "";
                    this.internalResult.hostname = "";
                    this.internalResult.port = "";
                    this.internalResult.pathname = "";
                    this.internalResult.search = "";
                    this.internalResult.hash = "";
                    this.rewindAndSetState(
                      1
                      /* PROTOCOL */
                    );
                  }
                  break;
                case 1:
                  if (this.isProtocolSuffix()) {
                    this.computeShouldTreatAsStandardURL();
                    let nextState = 7;
                    let skip = 1;
                    if (this.shouldTreatAsStandardURL) {
                      this.internalResult.pathname = "/";
                    }
                    if (this.nextIsAuthoritySlashes()) {
                      nextState = 2;
                      skip = 3;
                    } else if (this.shouldTreatAsStandardURL) {
                      nextState = 2;
                    }
                    this.changeState(nextState, skip);
                  }
                  break;
                case 2:
                  if (this.isIdentityTerminator()) {
                    this.rewindAndSetState(
                      3
                      /* USERNAME */
                    );
                  } else if (this.isPathnameStart() || this.isSearchPrefix() || this.isHashPrefix()) {
                    this.rewindAndSetState(
                      5
                      /* HOSTNAME */
                    );
                  }
                  break;
                case 3:
                  if (this.isPasswordPrefix()) {
                    this.changeState(4, 1);
                  } else if (this.isIdentityTerminator()) {
                    this.changeState(5, 1);
                  }
                  break;
                case 4:
                  if (this.isIdentityTerminator()) {
                    this.changeState(5, 1);
                  }
                  break;
                case 5:
                  if (this.isIPv6Open()) {
                    this.hostnameIPv6BracketDepth += 1;
                  } else if (this.isIPv6Close()) {
                    this.hostnameIPv6BracketDepth -= 1;
                  }
                  if (this.isPortPrefix() && !this.hostnameIPv6BracketDepth) {
                    this.changeState(6, 1);
                  } else if (this.isPathnameStart()) {
                    this.changeState(7, 0);
                  } else if (this.isSearchPrefix()) {
                    this.changeState(8, 1);
                  } else if (this.isHashPrefix()) {
                    this.changeState(9, 1);
                  }
                  break;
                case 6:
                  if (this.isPathnameStart()) {
                    this.changeState(7, 0);
                  } else if (this.isSearchPrefix()) {
                    this.changeState(8, 1);
                  } else if (this.isHashPrefix()) {
                    this.changeState(9, 1);
                  }
                  break;
                case 7:
                  if (this.isSearchPrefix()) {
                    this.changeState(8, 1);
                  } else if (this.isHashPrefix()) {
                    this.changeState(9, 1);
                  }
                  break;
                case 8:
                  if (this.isHashPrefix()) {
                    this.changeState(9, 1);
                  }
                  break;
                case 9:
                  break;
                case 10:
                  break;
              }
            }
          }
          changeState(newState, skip) {
            switch (this.state) {
              case 0:
                break;
              case 1:
                this.internalResult.protocol = this.makeComponentString();
                break;
              case 2:
                break;
              case 3:
                this.internalResult.username = this.makeComponentString();
                break;
              case 4:
                this.internalResult.password = this.makeComponentString();
                break;
              case 5:
                this.internalResult.hostname = this.makeComponentString();
                break;
              case 6:
                this.internalResult.port = this.makeComponentString();
                break;
              case 7:
                this.internalResult.pathname = this.makeComponentString();
                break;
              case 8:
                this.internalResult.search = this.makeComponentString();
                break;
              case 9:
                this.internalResult.hash = this.makeComponentString();
                break;
              case 10:
                break;
            }
            this.changeStateWithoutSettingComponent(newState, skip);
          }
          changeStateWithoutSettingComponent(newState, skip) {
            this.state = newState;
            this.componentStart = this.tokenIndex + skip;
            this.tokenIndex += skip;
            this.tokenIncrement = 0;
          }
          rewind() {
            this.tokenIndex = this.componentStart;
            this.tokenIncrement = 0;
          }
          rewindAndSetState(newState) {
            this.rewind();
            this.state = newState;
          }
          safeToken(index) {
            if (index < 0) {
              index = this.tokenList.length - index;
            }
            if (index < this.tokenList.length) {
              return this.tokenList[index];
            }
            return this.tokenList[this.tokenList.length - 1];
          }
          isNonSpecialPatternChar(index, value) {
            const token = this.safeToken(index);
            return token.value === value && (token.type === "CHAR" || token.type === "ESCAPED_CHAR" || token.type === "INVALID_CHAR");
          }
          isProtocolSuffix() {
            return this.isNonSpecialPatternChar(this.tokenIndex, ":");
          }
          nextIsAuthoritySlashes() {
            return this.isNonSpecialPatternChar(this.tokenIndex + 1, "/") && this.isNonSpecialPatternChar(this.tokenIndex + 2, "/");
          }
          isIdentityTerminator() {
            return this.isNonSpecialPatternChar(this.tokenIndex, "@");
          }
          isPasswordPrefix() {
            return this.isNonSpecialPatternChar(this.tokenIndex, ":");
          }
          isPortPrefix() {
            return this.isNonSpecialPatternChar(this.tokenIndex, ":");
          }
          isPathnameStart() {
            return this.isNonSpecialPatternChar(this.tokenIndex, "/");
          }
          isSearchPrefix() {
            if (this.isNonSpecialPatternChar(this.tokenIndex, "?")) {
              return true;
            }
            if (this.tokenList[this.tokenIndex].value !== "?") {
              return false;
            }
            const previousToken = this.safeToken(this.tokenIndex - 1);
            return previousToken.type !== "NAME" && previousToken.type !== "PATTERN" && previousToken.type !== "CLOSE" && previousToken.type !== "ASTERISK";
          }
          isHashPrefix() {
            return this.isNonSpecialPatternChar(this.tokenIndex, "#");
          }
          isGroupOpen() {
            return this.tokenList[this.tokenIndex].type == "OPEN";
          }
          isGroupClose() {
            return this.tokenList[this.tokenIndex].type == "CLOSE";
          }
          isIPv6Open() {
            return this.isNonSpecialPatternChar(this.tokenIndex, "[");
          }
          isIPv6Close() {
            return this.isNonSpecialPatternChar(this.tokenIndex, "]");
          }
          makeComponentString() {
            const token = this.tokenList[this.tokenIndex];
            const componentCharStart = this.safeToken(this.componentStart).index;
            return this.input.substring(componentCharStart, token.index);
          }
          computeShouldTreatAsStandardURL() {
            const options29 = {};
            Object.assign(options29, DEFAULT_OPTIONS2);
            options29.encodePart = protocolEncodeCallback;
            const regexp = pathToRegexp(this.makeComponentString(), void 0, options29);
            this.shouldTreatAsStandardURL = isSpecialScheme(regexp);
          }
        }, "Parser");
      }
    });
    var url_pattern_exports = {};
    __export2(url_pattern_exports, {
      URLPattern: () => URLPattern
    });
    function extractValues(url4, baseURL) {
      if (typeof url4 !== "string") {
        throw new TypeError(`parameter 1 is not of type 'string'.`);
      }
      const o2 = new URL(url4, baseURL);
      return {
        protocol: o2.protocol.substring(0, o2.protocol.length - 1),
        username: o2.username,
        password: o2.password,
        hostname: o2.hostname,
        port: o2.port,
        pathname: o2.pathname,
        search: o2.search != "" ? o2.search.substring(1, o2.search.length) : void 0,
        hash: o2.hash != "" ? o2.hash.substring(1, o2.hash.length) : void 0
      };
    }
    __name(extractValues, "extractValues");
    function applyInit(o2, init3, isPattern) {
      let baseURL;
      if (typeof init3.baseURL === "string") {
        try {
          baseURL = new URL(init3.baseURL);
          o2.protocol = baseURL.protocol ? baseURL.protocol.substring(0, baseURL.protocol.length - 1) : "";
          o2.username = baseURL.username;
          o2.password = baseURL.password;
          o2.hostname = baseURL.hostname;
          o2.port = baseURL.port;
          o2.pathname = baseURL.pathname;
          o2.search = baseURL.search ? baseURL.search.substring(1, baseURL.search.length) : "";
          o2.hash = baseURL.hash ? baseURL.hash.substring(1, baseURL.hash.length) : "";
        } catch {
          throw new TypeError(`invalid baseURL '${init3.baseURL}'.`);
        }
      }
      if (typeof init3.protocol === "string") {
        o2.protocol = canonicalizeProtocol(init3.protocol, isPattern);
      }
      if (typeof init3.username === "string") {
        o2.username = canonicalizeUsername(init3.username, isPattern);
      }
      if (typeof init3.password === "string") {
        o2.password = canonicalizePassword(init3.password, isPattern);
      }
      if (typeof init3.hostname === "string") {
        o2.hostname = canonicalizeHostname(init3.hostname, isPattern);
      }
      if (typeof init3.port === "string") {
        o2.port = canonicalizePort(init3.port, o2.protocol, isPattern);
      }
      if (typeof init3.pathname === "string") {
        o2.pathname = init3.pathname;
        if (baseURL && !isAbsolutePathname(o2.pathname, isPattern)) {
          const slashIndex = baseURL.pathname.lastIndexOf("/");
          if (slashIndex >= 0) {
            o2.pathname = baseURL.pathname.substring(0, slashIndex + 1) + o2.pathname;
          }
        }
        o2.pathname = canonicalizePathname(o2.pathname, o2.protocol, isPattern);
      }
      if (typeof init3.search === "string") {
        o2.search = canonicalizeSearch(init3.search, isPattern);
      }
      if (typeof init3.hash === "string") {
        o2.hash = canonicalizeHash(init3.hash, isPattern);
      }
      return o2;
    }
    __name(applyInit, "applyInit");
    function escapePatternString(value) {
      return value.replace(/([+*?:{}()\\])/g, "\\$1");
    }
    __name(escapePatternString, "escapePatternString");
    function escapeRegexpString(value) {
      return value.replace(/([.+*?^${}()[\]|/\\])/g, "\\$1");
    }
    __name(escapeRegexpString, "escapeRegexpString");
    function tokensToPattern(tokens, options29) {
      const wildcardPattern = ".*";
      const segmentWildcardPattern = `[^${escapeRegexpString(options29.delimiter || "/#?")}]+?`;
      const regexIdentifierPart2 = /[$_\u200C\u200D\p{ID_Continue}]/u;
      let result = "";
      for (let i = 0; i < tokens.length; ++i) {
        const token = tokens[i];
        const lastToken = i > 0 ? tokens[i - 1] : null;
        const nextToken = i < tokens.length - 1 ? tokens[i + 1] : null;
        if (typeof token === "string") {
          result += escapePatternString(token);
          continue;
        }
        if (token.pattern === "") {
          if (token.modifier === "") {
            result += escapePatternString(token.prefix);
            continue;
          }
          result += `{${escapePatternString(token.prefix)}}${token.modifier}`;
          continue;
        }
        const customName = typeof token.name !== "number";
        const optionsPrefixes = options29.prefixes !== void 0 ? options29.prefixes : "./";
        let needsGrouping = token.suffix !== "" || token.prefix !== "" && (token.prefix.length !== 1 || !optionsPrefixes.includes(token.prefix));
        if (!needsGrouping && customName && token.pattern === segmentWildcardPattern && token.modifier === "" && nextToken && !nextToken.prefix && !nextToken.suffix) {
          if (typeof nextToken === "string") {
            const code = nextToken.length > 0 ? nextToken[0] : "";
            needsGrouping = regexIdentifierPart2.test(code);
          } else {
            needsGrouping = typeof nextToken.name === "number";
          }
        }
        if (!needsGrouping && token.prefix === "" && lastToken && typeof lastToken === "string" && lastToken.length > 0) {
          const code = lastToken[lastToken.length - 1];
          needsGrouping = optionsPrefixes.includes(code);
        }
        if (needsGrouping) {
          result += "{";
        }
        result += escapePatternString(token.prefix);
        if (customName) {
          result += `:${token.name}`;
        }
        if (token.pattern === wildcardPattern) {
          if (!customName && (!lastToken || typeof lastToken === "string" || lastToken.modifier || needsGrouping || token.prefix !== "")) {
            result += "*";
          } else {
            result += `(${wildcardPattern})`;
          }
        } else if (token.pattern === segmentWildcardPattern) {
          if (!customName) {
            result += `(${segmentWildcardPattern})`;
          }
        } else {
          result += `(${token.pattern})`;
        }
        if (token.pattern === segmentWildcardPattern && customName && token.suffix !== "") {
          if (regexIdentifierPart2.test(token.suffix[0])) {
            result += "\\";
          }
        }
        result += escapePatternString(token.suffix);
        if (needsGrouping) {
          result += "}";
        }
        result += token.modifier;
      }
      return result;
    }
    __name(tokensToPattern, "tokensToPattern");
    var COMPONENTS;
    var DEFAULT_PATTERN;
    var URLPattern;
    var init_url_pattern = __esm2({
      "src/url-pattern.ts"() {
        init_path_to_regex_modified();
        init_url_utils();
        init_url_pattern_parser();
        COMPONENTS = [
          "protocol",
          "username",
          "password",
          "hostname",
          "port",
          "pathname",
          "search",
          "hash"
        ];
        DEFAULT_PATTERN = "*";
        URLPattern = /* @__PURE__ */ __name(class {
          constructor(init3 = {}, baseURL) {
            this.regexp = {};
            this.keys = {};
            this.component_pattern = {};
            try {
              if (typeof init3 === "string") {
                const parser2 = new Parser2(init3);
                parser2.parse();
                init3 = parser2.result;
                if (baseURL) {
                  if (typeof baseURL === "string") {
                    init3.baseURL = baseURL;
                  } else {
                    throw new TypeError(`'baseURL' parameter is not of type 'string'.`);
                  }
                } else if (typeof init3.protocol !== "string") {
                  throw new TypeError(`A base URL must be provided for a relative constructor string.`);
                }
              } else if (baseURL) {
                throw new TypeError(`parameter 1 is not of type 'string'.`);
              }
              if (!init3 || typeof init3 !== "object") {
                throw new TypeError(`parameter 1 is not of type 'string' and cannot convert to dictionary.`);
              }
              const defaults = {
                pathname: DEFAULT_PATTERN,
                protocol: DEFAULT_PATTERN,
                username: DEFAULT_PATTERN,
                password: DEFAULT_PATTERN,
                hostname: DEFAULT_PATTERN,
                port: DEFAULT_PATTERN,
                search: DEFAULT_PATTERN,
                hash: DEFAULT_PATTERN
              };
              this.pattern = applyInit(defaults, init3, true);
              if (defaultPortForProtocol(this.pattern.protocol) === this.pattern.port) {
                this.pattern.port = "";
              }
              let component;
              for (component of COMPONENTS) {
                if (!(component in this.pattern))
                  continue;
                const options29 = {};
                const pattern = this.pattern[component];
                this.keys[component] = [];
                switch (component) {
                  case "protocol":
                    Object.assign(options29, DEFAULT_OPTIONS2);
                    options29.encodePart = protocolEncodeCallback;
                    break;
                  case "username":
                    Object.assign(options29, DEFAULT_OPTIONS2);
                    options29.encodePart = usernameEncodeCallback;
                    break;
                  case "password":
                    Object.assign(options29, DEFAULT_OPTIONS2);
                    options29.encodePart = passwordEncodeCallback;
                    break;
                  case "hostname":
                    Object.assign(options29, HOSTNAME_OPTIONS);
                    if (treatAsIPv6Hostname(pattern)) {
                      options29.encodePart = ipv6HostnameEncodeCallback;
                    } else {
                      options29.encodePart = hostnameEncodeCallback;
                    }
                    break;
                  case "port":
                    Object.assign(options29, DEFAULT_OPTIONS2);
                    options29.encodePart = portEncodeCallback;
                    break;
                  case "pathname":
                    if (isSpecialScheme(this.regexp.protocol)) {
                      Object.assign(options29, PATHNAME_OPTIONS);
                      options29.encodePart = standardURLPathnameEncodeCallback;
                    } else {
                      Object.assign(options29, DEFAULT_OPTIONS2);
                      options29.encodePart = pathURLPathnameEncodeCallback;
                    }
                    break;
                  case "search":
                    Object.assign(options29, DEFAULT_OPTIONS2);
                    options29.encodePart = searchEncodeCallback;
                    break;
                  case "hash":
                    Object.assign(options29, DEFAULT_OPTIONS2);
                    options29.encodePart = hashEncodeCallback;
                    break;
                }
                try {
                  const tokens = parse7(pattern, options29);
                  this.regexp[component] = tokensToRegexp(tokens, this.keys[component], options29);
                  this.component_pattern[component] = tokensToPattern(tokens, options29);
                } catch {
                  throw new TypeError(`invalid ${component} pattern '${this.pattern[component]}'.`);
                }
              }
            } catch (err) {
              throw new TypeError(`Failed to construct 'URLPattern': ${err.message}`);
            }
          }
          test(input = {}, baseURL) {
            let values = {
              pathname: "",
              protocol: "",
              username: "",
              password: "",
              hostname: "",
              port: "",
              search: "",
              hash: ""
            };
            if (typeof input !== "string" && baseURL) {
              throw new TypeError(`parameter 1 is not of type 'string'.`);
            }
            if (typeof input === "undefined") {
              return false;
            }
            try {
              if (typeof input === "object") {
                values = applyInit(values, input, false);
              } else {
                values = applyInit(values, extractValues(input, baseURL), false);
              }
            } catch (err) {
              return false;
            }
            let component;
            for (component in this.pattern) {
              if (!this.regexp[component].exec(values[component])) {
                return false;
              }
            }
            return true;
          }
          exec(input = {}, baseURL) {
            let values = {
              pathname: "",
              protocol: "",
              username: "",
              password: "",
              hostname: "",
              port: "",
              search: "",
              hash: ""
            };
            if (typeof input !== "string" && baseURL) {
              throw new TypeError(`parameter 1 is not of type 'string'.`);
            }
            if (typeof input === "undefined") {
              return;
            }
            try {
              if (typeof input === "object") {
                values = applyInit(values, input, false);
              } else {
                values = applyInit(values, extractValues(input, baseURL), false);
              }
            } catch (err) {
              return null;
            }
            let result = {};
            if (baseURL) {
              result.inputs = [input, baseURL];
            } else {
              result.inputs = [input];
            }
            let component;
            for (component in this.pattern) {
              let match = this.regexp[component].exec(values[component]);
              if (!match) {
                return null;
              }
              let groups = {};
              for (let [i, key] of this.keys[component].entries()) {
                if (typeof key.name === "string" || typeof key.name === "number") {
                  let value = match[i + 1];
                  groups[key.name] = value;
                }
              }
              result[component] = {
                input: values[component] || "",
                groups
              };
            }
            return result;
          }
          get protocol() {
            return this.component_pattern.protocol;
          }
          get username() {
            return this.component_pattern.username;
          }
          get password() {
            return this.component_pattern.password;
          }
          get hostname() {
            return this.component_pattern.hostname;
          }
          get port() {
            return this.component_pattern.port;
          }
          get pathname() {
            return this.component_pattern.pathname;
          }
          get search() {
            return this.component_pattern.search;
          }
          get hash() {
            return this.component_pattern.hash;
          }
        }, "URLPattern");
      }
    });
    var patch_global_exports = {};
    __export2(patch_global_exports, {
      URLPattern: () => URLPattern2
    });
    module3.exports = __toCommonJS2(patch_global_exports);
    var { URLPattern: URLPattern2 } = (init_url_pattern(), __toCommonJS2(url_pattern_exports));
    if (!globalThis.URLPattern) {
      globalThis.URLPattern = URLPattern2;
    }
  }
});

// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/parser.js
var require_parser2 = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/parser.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var ParserEND = 1114112;
    var ParserError = class extends Error {
      /* istanbul ignore next */
      constructor(msg, filename, linenumber) {
        super("[ParserError] " + msg, filename, linenumber);
        this.name = "ParserError";
        this.code = "ParserError";
        if (Error.captureStackTrace)
          Error.captureStackTrace(this, ParserError);
      }
    };
    __name(ParserError, "ParserError");
    var State2 = class {
      constructor(parser2) {
        this.parser = parser2;
        this.buf = "";
        this.returned = null;
        this.result = null;
        this.resultTable = null;
        this.resultArr = null;
      }
    };
    __name(State2, "State");
    var Parser2 = class {
      constructor() {
        this.pos = 0;
        this.col = 0;
        this.line = 0;
        this.obj = {};
        this.ctx = this.obj;
        this.stack = [];
        this._buf = "";
        this.char = null;
        this.ii = 0;
        this.state = new State2(this.parseStart);
      }
      parse(str) {
        if (str.length === 0 || str.length == null)
          return;
        this._buf = String(str);
        this.ii = -1;
        this.char = -1;
        let getNext;
        while (getNext === false || this.nextChar()) {
          getNext = this.runOne();
        }
        this._buf = null;
      }
      nextChar() {
        if (this.char === 10) {
          ++this.line;
          this.col = -1;
        }
        ++this.ii;
        this.char = this._buf.codePointAt(this.ii);
        ++this.pos;
        ++this.col;
        return this.haveBuffer();
      }
      haveBuffer() {
        return this.ii < this._buf.length;
      }
      runOne() {
        return this.state.parser.call(this, this.state.returned);
      }
      finish() {
        this.char = ParserEND;
        let last;
        do {
          last = this.state.parser;
          this.runOne();
        } while (this.state.parser !== last);
        this.ctx = null;
        this.state = null;
        this._buf = null;
        return this.obj;
      }
      next(fn2) {
        if (typeof fn2 !== "function")
          throw new ParserError("Tried to set state to non-existent state: " + JSON.stringify(fn2));
        this.state.parser = fn2;
      }
      goto(fn2) {
        this.next(fn2);
        return this.runOne();
      }
      call(fn2, returnWith) {
        if (returnWith)
          this.next(returnWith);
        this.stack.push(this.state);
        this.state = new State2(fn2);
      }
      callNow(fn2, returnWith) {
        this.call(fn2, returnWith);
        return this.runOne();
      }
      return(value) {
        if (this.stack.length === 0)
          throw this.error(new ParserError("Stack underflow"));
        if (value === void 0)
          value = this.state.buf;
        this.state = this.stack.pop();
        this.state.returned = value;
      }
      returnNow(value) {
        this.return(value);
        return this.runOne();
      }
      consume() {
        if (this.char === ParserEND)
          throw this.error(new ParserError("Unexpected end-of-buffer"));
        this.state.buf += this._buf[this.ii];
      }
      error(err) {
        err.line = this.line;
        err.col = this.col;
        err.pos = this.pos;
        return err;
      }
      /* istanbul ignore next */
      parseStart() {
        throw new ParserError("Must declare a parseStart method");
      }
    };
    __name(Parser2, "Parser");
    Parser2.END = ParserEND;
    Parser2.Error = ParserError;
    module3.exports = Parser2;
  }
});

// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-datetime.js
var require_create_datetime2 = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-datetime.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = (value) => {
      const date = new Date(value);
      if (isNaN(date)) {
        throw new TypeError("Invalid Datetime");
      } else {
        return date;
      }
    };
  }
});

// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/format-num.js
var require_format_num2 = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/format-num.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = (d2, num) => {
      num = String(num);
      while (num.length < d2)
        num = "0" + num;
      return num;
    };
  }
});

// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-datetime-float.js
var require_create_datetime_float2 = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-datetime-float.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var f = require_format_num2();
    var FloatingDateTime = class extends Date {
      constructor(value) {
        super(value + "Z");
        this.isFloating = true;
      }
      toISOString() {
        const date = `${this.getUTCFullYear()}-${f(2, this.getUTCMonth() + 1)}-${f(2, this.getUTCDate())}`;
        const time = `${f(2, this.getUTCHours())}:${f(2, this.getUTCMinutes())}:${f(2, this.getUTCSeconds())}.${f(3, this.getUTCMilliseconds())}`;
        return `${date}T${time}`;
      }
    };
    __name(FloatingDateTime, "FloatingDateTime");
    module3.exports = (value) => {
      const date = new FloatingDateTime(value);
      if (isNaN(date)) {
        throw new TypeError("Invalid Datetime");
      } else {
        return date;
      }
    };
  }
});

// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-date.js
var require_create_date2 = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-date.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var f = require_format_num2();
    var DateTime = global.Date;
    var Date2 = class extends DateTime {
      constructor(value) {
        super(value);
        this.isDate = true;
      }
      toISOString() {
        return `${this.getUTCFullYear()}-${f(2, this.getUTCMonth() + 1)}-${f(2, this.getUTCDate())}`;
      }
    };
    __name(Date2, "Date");
    module3.exports = (value) => {
      const date = new Date2(value);
      if (isNaN(date)) {
        throw new TypeError("Invalid Datetime");
      } else {
        return date;
      }
    };
  }
});

// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-time.js
var require_create_time2 = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-time.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var f = require_format_num2();
    var Time = class extends Date {
      constructor(value) {
        super(`0000-01-01T${value}Z`);
        this.isTime = true;
      }
      toISOString() {
        return `${f(2, this.getUTCHours())}:${f(2, this.getUTCMinutes())}:${f(2, this.getUTCSeconds())}.${f(3, this.getUTCMilliseconds())}`;
      }
    };
    __name(Time, "Time");
    module3.exports = (value) => {
      const date = new Time(value);
      if (isNaN(date)) {
        throw new TypeError("Invalid Datetime");
      } else {
        return date;
      }
    };
  }
});

// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/toml-parser.js
var require_toml_parser2 = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/toml-parser.js"(exports, module) {
    "use strict";
    init_import_meta_url();
    module.exports = makeParserClass(require_parser2());
    module.exports.makeParserClass = makeParserClass;
    var TomlError = class extends Error {
      constructor(msg) {
        super(msg);
        this.name = "TomlError";
        if (Error.captureStackTrace)
          Error.captureStackTrace(this, TomlError);
        this.fromTOML = true;
        this.wrapped = null;
      }
    };
    __name(TomlError, "TomlError");
    TomlError.wrap = (err) => {
      const terr = new TomlError(err.message);
      terr.code = err.code;
      terr.wrapped = err;
      return terr;
    };
    module.exports.TomlError = TomlError;
    var createDateTime = require_create_datetime2();
    var createDateTimeFloat = require_create_datetime_float2();
    var createDate = require_create_date2();
    var createTime = require_create_time2();
    var CTRL_I = 9;
    var CTRL_J = 10;
    var CTRL_M = 13;
    var CTRL_CHAR_BOUNDARY = 31;
    var CHAR_SP = 32;
    var CHAR_QUOT = 34;
    var CHAR_NUM = 35;
    var CHAR_APOS = 39;
    var CHAR_PLUS = 43;
    var CHAR_COMMA = 44;
    var CHAR_HYPHEN = 45;
    var CHAR_PERIOD = 46;
    var CHAR_0 = 48;
    var CHAR_1 = 49;
    var CHAR_7 = 55;
    var CHAR_9 = 57;
    var CHAR_COLON = 58;
    var CHAR_EQUALS = 61;
    var CHAR_A = 65;
    var CHAR_E = 69;
    var CHAR_F = 70;
    var CHAR_T = 84;
    var CHAR_U = 85;
    var CHAR_Z = 90;
    var CHAR_LOWBAR = 95;
    var CHAR_a = 97;
    var CHAR_b = 98;
    var CHAR_e = 101;
    var CHAR_f = 102;
    var CHAR_i = 105;
    var CHAR_l = 108;
    var CHAR_n = 110;
    var CHAR_o = 111;
    var CHAR_r = 114;
    var CHAR_s = 115;
    var CHAR_t = 116;
    var CHAR_u = 117;
    var CHAR_x = 120;
    var CHAR_z = 122;
    var CHAR_LCUB = 123;
    var CHAR_RCUB = 125;
    var CHAR_LSQB = 91;
    var CHAR_BSOL = 92;
    var CHAR_RSQB = 93;
    var CHAR_DEL = 127;
    var SURROGATE_FIRST = 55296;
    var SURROGATE_LAST = 57343;
    var escapes = {
      [CHAR_b]: "\b",
      [CHAR_t]: "	",
      [CHAR_n]: "\n",
      [CHAR_f]: "\f",
      [CHAR_r]: "\r",
      [CHAR_QUOT]: '"',
      [CHAR_BSOL]: "\\"
    };
    function isDigit(cp2) {
      return cp2 >= CHAR_0 && cp2 <= CHAR_9;
    }
    __name(isDigit, "isDigit");
    function isHexit(cp2) {
      return cp2 >= CHAR_A && cp2 <= CHAR_F || cp2 >= CHAR_a && cp2 <= CHAR_f || cp2 >= CHAR_0 && cp2 <= CHAR_9;
    }
    __name(isHexit, "isHexit");
    function isBit(cp2) {
      return cp2 === CHAR_1 || cp2 === CHAR_0;
    }
    __name(isBit, "isBit");
    function isOctit(cp2) {
      return cp2 >= CHAR_0 && cp2 <= CHAR_7;
    }
    __name(isOctit, "isOctit");
    function isAlphaNumQuoteHyphen(cp2) {
      return cp2 >= CHAR_A && cp2 <= CHAR_Z || cp2 >= CHAR_a && cp2 <= CHAR_z || cp2 >= CHAR_0 && cp2 <= CHAR_9 || cp2 === CHAR_APOS || cp2 === CHAR_QUOT || cp2 === CHAR_LOWBAR || cp2 === CHAR_HYPHEN;
    }
    __name(isAlphaNumQuoteHyphen, "isAlphaNumQuoteHyphen");
    function isAlphaNumHyphen(cp2) {
      return cp2 >= CHAR_A && cp2 <= CHAR_Z || cp2 >= CHAR_a && cp2 <= CHAR_z || cp2 >= CHAR_0 && cp2 <= CHAR_9 || cp2 === CHAR_LOWBAR || cp2 === CHAR_HYPHEN;
    }
    __name(isAlphaNumHyphen, "isAlphaNumHyphen");
    var _type = Symbol("type");
    var _declared = Symbol("declared");
    var hasOwnProperty = Object.prototype.hasOwnProperty;
    var defineProperty = Object.defineProperty;
    var descriptor = { configurable: true, enumerable: true, writable: true, value: void 0 };
    function hasKey(obj, key) {
      if (hasOwnProperty.call(obj, key))
        return true;
      if (key === "__proto__")
        defineProperty(obj, "__proto__", descriptor);
      return false;
    }
    __name(hasKey, "hasKey");
    var INLINE_TABLE = Symbol("inline-table");
    function InlineTable() {
      return Object.defineProperties({}, {
        [_type]: { value: INLINE_TABLE }
      });
    }
    __name(InlineTable, "InlineTable");
    function isInlineTable(obj) {
      if (obj === null || typeof obj !== "object")
        return false;
      return obj[_type] === INLINE_TABLE;
    }
    __name(isInlineTable, "isInlineTable");
    var TABLE = Symbol("table");
    function Table() {
      return Object.defineProperties({}, {
        [_type]: { value: TABLE },
        [_declared]: { value: false, writable: true }
      });
    }
    __name(Table, "Table");
    function isTable(obj) {
      if (obj === null || typeof obj !== "object")
        return false;
      return obj[_type] === TABLE;
    }
    __name(isTable, "isTable");
    var _contentType = Symbol("content-type");
    var INLINE_LIST = Symbol("inline-list");
    function InlineList(type) {
      return Object.defineProperties([], {
        [_type]: { value: INLINE_LIST },
        [_contentType]: { value: type }
      });
    }
    __name(InlineList, "InlineList");
    function isInlineList(obj) {
      if (obj === null || typeof obj !== "object")
        return false;
      return obj[_type] === INLINE_LIST;
    }
    __name(isInlineList, "isInlineList");
    var LIST = Symbol("list");
    function List() {
      return Object.defineProperties([], {
        [_type]: { value: LIST }
      });
    }
    __name(List, "List");
    function isList(obj) {
      if (obj === null || typeof obj !== "object")
        return false;
      return obj[_type] === LIST;
    }
    __name(isList, "isList");
    var _custom;
    try {
      const utilInspect = eval("require('util').inspect");
      _custom = utilInspect.custom;
    } catch (_3) {
    }
    var _inspect = _custom || "inspect";
    var BoxedBigInt = class {
      constructor(value) {
        try {
          this.value = global.BigInt.asIntN(64, value);
        } catch (_3) {
          this.value = null;
        }
        Object.defineProperty(this, _type, { value: INTEGER });
      }
      isNaN() {
        return this.value === null;
      }
      /* istanbul ignore next */
      toString() {
        return String(this.value);
      }
      /* istanbul ignore next */
      [_inspect]() {
        return `[BigInt: ${this.toString()}]}`;
      }
      valueOf() {
        return this.value;
      }
    };
    __name(BoxedBigInt, "BoxedBigInt");
    var INTEGER = Symbol("integer");
    function Integer(value) {
      let num = Number(value);
      if (Object.is(num, -0))
        num = 0;
      if (global.BigInt && !Number.isSafeInteger(num)) {
        return new BoxedBigInt(value);
      } else {
        return Object.defineProperties(new Number(num), {
          isNaN: { value: function() {
            return isNaN(this);
          } },
          [_type]: { value: INTEGER },
          [_inspect]: { value: () => `[Integer: ${value}]` }
        });
      }
    }
    __name(Integer, "Integer");
    function isInteger(obj) {
      if (obj === null || typeof obj !== "object")
        return false;
      return obj[_type] === INTEGER;
    }
    __name(isInteger, "isInteger");
    var FLOAT = Symbol("float");
    function Float(value) {
      return Object.defineProperties(new Number(value), {
        [_type]: { value: FLOAT },
        [_inspect]: { value: () => `[Float: ${value}]` }
      });
    }
    __name(Float, "Float");
    function isFloat(obj) {
      if (obj === null || typeof obj !== "object")
        return false;
      return obj[_type] === FLOAT;
    }
    __name(isFloat, "isFloat");
    function tomlType(value) {
      const type = typeof value;
      if (type === "object") {
        if (value === null)
          return "null";
        if (value instanceof Date)
          return "datetime";
        if (_type in value) {
          switch (value[_type]) {
            case INLINE_TABLE:
              return "inline-table";
            case INLINE_LIST:
              return "inline-list";
            case TABLE:
              return "table";
            case LIST:
              return "list";
            case FLOAT:
              return "float";
            case INTEGER:
              return "integer";
          }
        }
      }
      return type;
    }
    __name(tomlType, "tomlType");
    function makeParserClass(Parser2) {
      class TOMLParser extends Parser2 {
        constructor() {
          super();
          this.ctx = this.obj = Table();
        }
        /* MATCH HELPER */
        atEndOfWord() {
          return this.char === CHAR_NUM || this.char === CTRL_I || this.char === CHAR_SP || this.atEndOfLine();
        }
        atEndOfLine() {
          return this.char === Parser2.END || this.char === CTRL_J || this.char === CTRL_M;
        }
        parseStart() {
          if (this.char === Parser2.END) {
            return null;
          } else if (this.char === CHAR_LSQB) {
            return this.call(this.parseTableOrList);
          } else if (this.char === CHAR_NUM) {
            return this.call(this.parseComment);
          } else if (this.char === CTRL_J || this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
            return null;
          } else if (isAlphaNumQuoteHyphen(this.char)) {
            return this.callNow(this.parseAssignStatement);
          } else {
            throw this.error(new TomlError(`Unknown character "${this.char}"`));
          }
        }
        // HELPER, this strips any whitespace and comments to the end of the line
        // then RETURNS. Last state in a production.
        parseWhitespaceToEOL() {
          if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
            return null;
          } else if (this.char === CHAR_NUM) {
            return this.goto(this.parseComment);
          } else if (this.char === Parser2.END || this.char === CTRL_J) {
            return this.return();
          } else {
            throw this.error(new TomlError("Unexpected character, expected only whitespace or comments till end of line"));
          }
        }
        /* ASSIGNMENT: key = value */
        parseAssignStatement() {
          return this.callNow(this.parseAssign, this.recordAssignStatement);
        }
        recordAssignStatement(kv) {
          let target = this.ctx;
          let finalKey = kv.key.pop();
          for (let kw of kv.key) {
            if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) {
              throw this.error(new TomlError("Can't redefine existing key"));
            }
            target = target[kw] = target[kw] || Table();
          }
          if (hasKey(target, finalKey)) {
            throw this.error(new TomlError("Can't redefine existing key"));
          }
          if (isInteger(kv.value) || isFloat(kv.value)) {
            target[finalKey] = kv.value.valueOf();
          } else {
            target[finalKey] = kv.value;
          }
          return this.goto(this.parseWhitespaceToEOL);
        }
        /* ASSSIGNMENT expression, key = value possibly inside an inline table */
        parseAssign() {
          return this.callNow(this.parseKeyword, this.recordAssignKeyword);
        }
        recordAssignKeyword(key) {
          if (this.state.resultTable) {
            this.state.resultTable.push(key);
          } else {
            this.state.resultTable = [key];
          }
          return this.goto(this.parseAssignKeywordPreDot);
        }
        parseAssignKeywordPreDot() {
          if (this.char === CHAR_PERIOD) {
            return this.next(this.parseAssignKeywordPostDot);
          } else if (this.char !== CHAR_SP && this.char !== CTRL_I) {
            return this.goto(this.parseAssignEqual);
          }
        }
        parseAssignKeywordPostDot() {
          if (this.char !== CHAR_SP && this.char !== CTRL_I) {
            return this.callNow(this.parseKeyword, this.recordAssignKeyword);
          }
        }
        parseAssignEqual() {
          if (this.char === CHAR_EQUALS) {
            return this.next(this.parseAssignPreValue);
          } else {
            throw this.error(new TomlError('Invalid character, expected "="'));
          }
        }
        parseAssignPreValue() {
          if (this.char === CHAR_SP || this.char === CTRL_I) {
            return null;
          } else {
            return this.callNow(this.parseValue, this.recordAssignValue);
          }
        }
        recordAssignValue(value) {
          return this.returnNow({ key: this.state.resultTable, value });
        }
        /* COMMENTS: #...eol */
        parseComment() {
          do {
            if (this.char === Parser2.END || this.char === CTRL_J) {
              return this.return();
            }
          } while (this.nextChar());
        }
        /* TABLES AND LISTS, [foo] and [[foo]] */
        parseTableOrList() {
          if (this.char === CHAR_LSQB) {
            this.next(this.parseList);
          } else {
            return this.goto(this.parseTable);
          }
        }
        /* TABLE [foo.bar.baz] */
        parseTable() {
          this.ctx = this.obj;
          return this.goto(this.parseTableNext);
        }
        parseTableNext() {
          if (this.char === CHAR_SP || this.char === CTRL_I) {
            return null;
          } else {
            return this.callNow(this.parseKeyword, this.parseTableMore);
          }
        }
        parseTableMore(keyword) {
          if (this.char === CHAR_SP || this.char === CTRL_I) {
            return null;
          } else if (this.char === CHAR_RSQB) {
            if (hasKey(this.ctx, keyword) && (!isTable(this.ctx[keyword]) || this.ctx[keyword][_declared])) {
              throw this.error(new TomlError("Can't redefine existing key"));
            } else {
              this.ctx = this.ctx[keyword] = this.ctx[keyword] || Table();
              this.ctx[_declared] = true;
            }
            return this.next(this.parseWhitespaceToEOL);
          } else if (this.char === CHAR_PERIOD) {
            if (!hasKey(this.ctx, keyword)) {
              this.ctx = this.ctx[keyword] = Table();
            } else if (isTable(this.ctx[keyword])) {
              this.ctx = this.ctx[keyword];
            } else if (isList(this.ctx[keyword])) {
              this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1];
            } else {
              throw this.error(new TomlError("Can't redefine existing key"));
            }
            return this.next(this.parseTableNext);
          } else {
            throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
          }
        }
        /* LIST [[a.b.c]] */
        parseList() {
          this.ctx = this.obj;
          return this.goto(this.parseListNext);
        }
        parseListNext() {
          if (this.char === CHAR_SP || this.char === CTRL_I) {
            return null;
          } else {
            return this.callNow(this.parseKeyword, this.parseListMore);
          }
        }
        parseListMore(keyword) {
          if (this.char === CHAR_SP || this.char === CTRL_I) {
            return null;
          } else if (this.char === CHAR_RSQB) {
            if (!hasKey(this.ctx, keyword)) {
              this.ctx[keyword] = List();
            }
            if (isInlineList(this.ctx[keyword])) {
              throw this.error(new TomlError("Can't extend an inline array"));
            } else if (isList(this.ctx[keyword])) {
              const next = Table();
              this.ctx[keyword].push(next);
              this.ctx = next;
            } else {
              throw this.error(new TomlError("Can't redefine an existing key"));
            }
            return this.next(this.parseListEnd);
          } else if (this.char === CHAR_PERIOD) {
            if (!hasKey(this.ctx, keyword)) {
              this.ctx = this.ctx[keyword] = Table();
            } else if (isInlineList(this.ctx[keyword])) {
              throw this.error(new TomlError("Can't extend an inline array"));
            } else if (isInlineTable(this.ctx[keyword])) {
              throw this.error(new TomlError("Can't extend an inline table"));
            } else if (isList(this.ctx[keyword])) {
              this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1];
            } else if (isTable(this.ctx[keyword])) {
              this.ctx = this.ctx[keyword];
            } else {
              throw this.error(new TomlError("Can't redefine an existing key"));
            }
            return this.next(this.parseListNext);
          } else {
            throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
          }
        }
        parseListEnd(keyword) {
          if (this.char === CHAR_RSQB) {
            return this.next(this.parseWhitespaceToEOL);
          } else {
            throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
          }
        }
        /* VALUE string, number, boolean, inline list, inline object */
        parseValue() {
          if (this.char === Parser2.END) {
            throw this.error(new TomlError("Key without value"));
          } else if (this.char === CHAR_QUOT) {
            return this.next(this.parseDoubleString);
          }
          if (this.char === CHAR_APOS) {
            return this.next(this.parseSingleString);
          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
            return this.goto(this.parseNumberSign);
          } else if (this.char === CHAR_i) {
            return this.next(this.parseInf);
          } else if (this.char === CHAR_n) {
            return this.next(this.parseNan);
          } else if (isDigit(this.char)) {
            return this.goto(this.parseNumberOrDateTime);
          } else if (this.char === CHAR_t || this.char === CHAR_f) {
            return this.goto(this.parseBoolean);
          } else if (this.char === CHAR_LSQB) {
            return this.call(this.parseInlineList, this.recordValue);
          } else if (this.char === CHAR_LCUB) {
            return this.call(this.parseInlineTable, this.recordValue);
          } else {
            throw this.error(new TomlError("Unexpected character, expecting string, number, datetime, boolean, inline array or inline table"));
          }
        }
        recordValue(value) {
          return this.returnNow(value);
        }
        parseInf() {
          if (this.char === CHAR_n) {
            return this.next(this.parseInf2);
          } else {
            throw this.error(new TomlError('Unexpected character, expected "inf", "+inf" or "-inf"'));
          }
        }
        parseInf2() {
          if (this.char === CHAR_f) {
            if (this.state.buf === "-") {
              return this.return(-Infinity);
            } else {
              return this.return(Infinity);
            }
          } else {
            throw this.error(new TomlError('Unexpected character, expected "inf", "+inf" or "-inf"'));
          }
        }
        parseNan() {
          if (this.char === CHAR_a) {
            return this.next(this.parseNan2);
          } else {
            throw this.error(new TomlError('Unexpected character, expected "nan"'));
          }
        }
        parseNan2() {
          if (this.char === CHAR_n) {
            return this.return(NaN);
          } else {
            throw this.error(new TomlError('Unexpected character, expected "nan"'));
          }
        }
        /* KEYS, barewords or basic, literal, or dotted */
        parseKeyword() {
          if (this.char === CHAR_QUOT) {
            return this.next(this.parseBasicString);
          } else if (this.char === CHAR_APOS) {
            return this.next(this.parseLiteralString);
          } else {
            return this.goto(this.parseBareKey);
          }
        }
        /* KEYS: barewords */
        parseBareKey() {
          do {
            if (this.char === Parser2.END) {
              throw this.error(new TomlError("Key ended without value"));
            } else if (isAlphaNumHyphen(this.char)) {
              this.consume();
            } else if (this.state.buf.length === 0) {
              throw this.error(new TomlError("Empty bare keys are not allowed"));
            } else {
              return this.returnNow();
            }
          } while (this.nextChar());
        }
        /* STRINGS, single quoted (literal) */
        parseSingleString() {
          if (this.char === CHAR_APOS) {
            return this.next(this.parseLiteralMultiStringMaybe);
          } else {
            return this.goto(this.parseLiteralString);
          }
        }
        parseLiteralString() {
          do {
            if (this.char === CHAR_APOS) {
              return this.return();
            } else if (this.atEndOfLine()) {
              throw this.error(new TomlError("Unterminated string"));
            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I) {
              throw this.errorControlCharInString();
            } else {
              this.consume();
            }
          } while (this.nextChar());
        }
        parseLiteralMultiStringMaybe() {
          if (this.char === CHAR_APOS) {
            return this.next(this.parseLiteralMultiString);
          } else {
            return this.returnNow();
          }
        }
        parseLiteralMultiString() {
          if (this.char === CTRL_M) {
            return null;
          } else if (this.char === CTRL_J) {
            return this.next(this.parseLiteralMultiStringContent);
          } else {
            return this.goto(this.parseLiteralMultiStringContent);
          }
        }
        parseLiteralMultiStringContent() {
          do {
            if (this.char === CHAR_APOS) {
              return this.next(this.parseLiteralMultiEnd);
            } else if (this.char === Parser2.END) {
              throw this.error(new TomlError("Unterminated multi-line string"));
            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) {
              throw this.errorControlCharInString();
            } else {
              this.consume();
            }
          } while (this.nextChar());
        }
        parseLiteralMultiEnd() {
          if (this.char === CHAR_APOS) {
            return this.next(this.parseLiteralMultiEnd2);
          } else {
            this.state.buf += "'";
            return this.goto(this.parseLiteralMultiStringContent);
          }
        }
        parseLiteralMultiEnd2() {
          if (this.char === CHAR_APOS) {
            return this.return();
          } else {
            this.state.buf += "''";
            return this.goto(this.parseLiteralMultiStringContent);
          }
        }
        /* STRINGS double quoted */
        parseDoubleString() {
          if (this.char === CHAR_QUOT) {
            return this.next(this.parseMultiStringMaybe);
          } else {
            return this.goto(this.parseBasicString);
          }
        }
        parseBasicString() {
          do {
            if (this.char === CHAR_BSOL) {
              return this.call(this.parseEscape, this.recordEscapeReplacement);
            } else if (this.char === CHAR_QUOT) {
              return this.return();
            } else if (this.atEndOfLine()) {
              throw this.error(new TomlError("Unterminated string"));
            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I) {
              throw this.errorControlCharInString();
            } else {
              this.consume();
            }
          } while (this.nextChar());
        }
        recordEscapeReplacement(replacement) {
          this.state.buf += replacement;
          return this.goto(this.parseBasicString);
        }
        parseMultiStringMaybe() {
          if (this.char === CHAR_QUOT) {
            return this.next(this.parseMultiString);
          } else {
            return this.returnNow();
          }
        }
        parseMultiString() {
          if (this.char === CTRL_M) {
            return null;
          } else if (this.char === CTRL_J) {
            return this.next(this.parseMultiStringContent);
          } else {
            return this.goto(this.parseMultiStringContent);
          }
        }
        parseMultiStringContent() {
          do {
            if (this.char === CHAR_BSOL) {
              return this.call(this.parseMultiEscape, this.recordMultiEscapeReplacement);
            } else if (this.char === CHAR_QUOT) {
              return this.next(this.parseMultiEnd);
            } else if (this.char === Parser2.END) {
              throw this.error(new TomlError("Unterminated multi-line string"));
            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) {
              throw this.errorControlCharInString();
            } else {
              this.consume();
            }
          } while (this.nextChar());
        }
        errorControlCharInString() {
          let displayCode = "\\u00";
          if (this.char < 16) {
            displayCode += "0";
          }
          displayCode += this.char.toString(16);
          return this.error(new TomlError(`Control characters (codes < 0x1f and 0x7f) are not allowed in strings, use ${displayCode} instead`));
        }
        recordMultiEscapeReplacement(replacement) {
          this.state.buf += replacement;
          return this.goto(this.parseMultiStringContent);
        }
        parseMultiEnd() {
          if (this.char === CHAR_QUOT) {
            return this.next(this.parseMultiEnd2);
          } else {
            this.state.buf += '"';
            return this.goto(this.parseMultiStringContent);
          }
        }
        parseMultiEnd2() {
          if (this.char === CHAR_QUOT) {
            return this.return();
          } else {
            this.state.buf += '""';
            return this.goto(this.parseMultiStringContent);
          }
        }
        parseMultiEscape() {
          if (this.char === CTRL_M || this.char === CTRL_J) {
            return this.next(this.parseMultiTrim);
          } else if (this.char === CHAR_SP || this.char === CTRL_I) {
            return this.next(this.parsePreMultiTrim);
          } else {
            return this.goto(this.parseEscape);
          }
        }
        parsePreMultiTrim() {
          if (this.char === CHAR_SP || this.char === CTRL_I) {
            return null;
          } else if (this.char === CTRL_M || this.char === CTRL_J) {
            return this.next(this.parseMultiTrim);
          } else {
            throw this.error(new TomlError("Can't escape whitespace"));
          }
        }
        parseMultiTrim() {
          if (this.char === CTRL_J || this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
            return null;
          } else {
            return this.returnNow();
          }
        }
        parseEscape() {
          if (this.char in escapes) {
            return this.return(escapes[this.char]);
          } else if (this.char === CHAR_u) {
            return this.call(this.parseSmallUnicode, this.parseUnicodeReturn);
          } else if (this.char === CHAR_U) {
            return this.call(this.parseLargeUnicode, this.parseUnicodeReturn);
          } else {
            throw this.error(new TomlError("Unknown escape character: " + this.char));
          }
        }
        parseUnicodeReturn(char) {
          try {
            const codePoint = parseInt(char, 16);
            if (codePoint >= SURROGATE_FIRST && codePoint <= SURROGATE_LAST) {
              throw this.error(new TomlError("Invalid unicode, character in range 0xD800 - 0xDFFF is reserved"));
            }
            return this.returnNow(String.fromCodePoint(codePoint));
          } catch (err) {
            throw this.error(TomlError.wrap(err));
          }
        }
        parseSmallUnicode() {
          if (!isHexit(this.char)) {
            throw this.error(new TomlError("Invalid character in unicode sequence, expected hex"));
          } else {
            this.consume();
            if (this.state.buf.length >= 4)
              return this.return();
          }
        }
        parseLargeUnicode() {
          if (!isHexit(this.char)) {
            throw this.error(new TomlError("Invalid character in unicode sequence, expected hex"));
          } else {
            this.consume();
            if (this.state.buf.length >= 8)
              return this.return();
          }
        }
        /* NUMBERS */
        parseNumberSign() {
          this.consume();
          return this.next(this.parseMaybeSignedInfOrNan);
        }
        parseMaybeSignedInfOrNan() {
          if (this.char === CHAR_i) {
            return this.next(this.parseInf);
          } else if (this.char === CHAR_n) {
            return this.next(this.parseNan);
          } else {
            return this.callNow(this.parseNoUnder, this.parseNumberIntegerStart);
          }
        }
        parseNumberIntegerStart() {
          if (this.char === CHAR_0) {
            this.consume();
            return this.next(this.parseNumberIntegerExponentOrDecimal);
          } else {
            return this.goto(this.parseNumberInteger);
          }
        }
        parseNumberIntegerExponentOrDecimal() {
          if (this.char === CHAR_PERIOD) {
            this.consume();
            return this.call(this.parseNoUnder, this.parseNumberFloat);
          } else if (this.char === CHAR_E || this.char === CHAR_e) {
            this.consume();
            return this.next(this.parseNumberExponentSign);
          } else {
            return this.returnNow(Integer(this.state.buf));
          }
        }
        parseNumberInteger() {
          if (isDigit(this.char)) {
            this.consume();
          } else if (this.char === CHAR_LOWBAR) {
            return this.call(this.parseNoUnder);
          } else if (this.char === CHAR_E || this.char === CHAR_e) {
            this.consume();
            return this.next(this.parseNumberExponentSign);
          } else if (this.char === CHAR_PERIOD) {
            this.consume();
            return this.call(this.parseNoUnder, this.parseNumberFloat);
          } else {
            const result = Integer(this.state.buf);
            if (result.isNaN()) {
              throw this.error(new TomlError("Invalid number"));
            } else {
              return this.returnNow(result);
            }
          }
        }
        parseNoUnder() {
          if (this.char === CHAR_LOWBAR || this.char === CHAR_PERIOD || this.char === CHAR_E || this.char === CHAR_e) {
            throw this.error(new TomlError("Unexpected character, expected digit"));
          } else if (this.atEndOfWord()) {
            throw this.error(new TomlError("Incomplete number"));
          }
          return this.returnNow();
        }
        parseNoUnderHexOctBinLiteral() {
          if (this.char === CHAR_LOWBAR || this.char === CHAR_PERIOD) {
            throw this.error(new TomlError("Unexpected character, expected digit"));
          } else if (this.atEndOfWord()) {
            throw this.error(new TomlError("Incomplete number"));
          }
          return this.returnNow();
        }
        parseNumberFloat() {
          if (this.char === CHAR_LOWBAR) {
            return this.call(this.parseNoUnder, this.parseNumberFloat);
          } else if (isDigit(this.char)) {
            this.consume();
          } else if (this.char === CHAR_E || this.char === CHAR_e) {
            this.consume();
            return this.next(this.parseNumberExponentSign);
          } else {
            return this.returnNow(Float(this.state.buf));
          }
        }
        parseNumberExponentSign() {
          if (isDigit(this.char)) {
            return this.goto(this.parseNumberExponent);
          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
            this.consume();
            this.call(this.parseNoUnder, this.parseNumberExponent);
          } else {
            throw this.error(new TomlError("Unexpected character, expected -, + or digit"));
          }
        }
        parseNumberExponent() {
          if (isDigit(this.char)) {
            this.consume();
          } else if (this.char === CHAR_LOWBAR) {
            return this.call(this.parseNoUnder);
          } else {
            return this.returnNow(Float(this.state.buf));
          }
        }
        /* NUMBERS or DATETIMES  */
        parseNumberOrDateTime() {
          if (this.char === CHAR_0) {
            this.consume();
            return this.next(this.parseNumberBaseOrDateTime);
          } else {
            return this.goto(this.parseNumberOrDateTimeOnly);
          }
        }
        parseNumberOrDateTimeOnly() {
          if (this.char === CHAR_LOWBAR) {
            return this.call(this.parseNoUnder, this.parseNumberInteger);
          } else if (isDigit(this.char)) {
            this.consume();
            if (this.state.buf.length > 4)
              this.next(this.parseNumberInteger);
          } else if (this.char === CHAR_E || this.char === CHAR_e) {
            this.consume();
            return this.next(this.parseNumberExponentSign);
          } else if (this.char === CHAR_PERIOD) {
            this.consume();
            return this.call(this.parseNoUnder, this.parseNumberFloat);
          } else if (this.char === CHAR_HYPHEN) {
            return this.goto(this.parseDateTime);
          } else if (this.char === CHAR_COLON) {
            return this.goto(this.parseOnlyTimeHour);
          } else {
            return this.returnNow(Integer(this.state.buf));
          }
        }
        parseDateTimeOnly() {
          if (this.state.buf.length < 4) {
            if (isDigit(this.char)) {
              return this.consume();
            } else if (this.char === CHAR_COLON) {
              return this.goto(this.parseOnlyTimeHour);
            } else {
              throw this.error(new TomlError("Expected digit while parsing year part of a date"));
            }
          } else {
            if (this.char === CHAR_HYPHEN) {
              return this.goto(this.parseDateTime);
            } else {
              throw this.error(new TomlError("Expected hyphen (-) while parsing year part of date"));
            }
          }
        }
        parseNumberBaseOrDateTime() {
          if (this.char === CHAR_b) {
            this.consume();
            return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerBin);
          } else if (this.char === CHAR_o) {
            this.consume();
            return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerOct);
          } else if (this.char === CHAR_x) {
            this.consume();
            return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerHex);
          } else if (this.char === CHAR_PERIOD) {
            return this.goto(this.parseNumberInteger);
          } else if (isDigit(this.char)) {
            return this.goto(this.parseDateTimeOnly);
          } else {
            return this.returnNow(Integer(this.state.buf));
          }
        }
        parseIntegerHex() {
          if (isHexit(this.char)) {
            this.consume();
          } else if (this.char === CHAR_LOWBAR) {
            return this.call(this.parseNoUnderHexOctBinLiteral);
          } else {
            const result = Integer(this.state.buf);
            if (result.isNaN()) {
              throw this.error(new TomlError("Invalid number"));
            } else {
              return this.returnNow(result);
            }
          }
        }
        parseIntegerOct() {
          if (isOctit(this.char)) {
            this.consume();
          } else if (this.char === CHAR_LOWBAR) {
            return this.call(this.parseNoUnderHexOctBinLiteral);
          } else {
            const result = Integer(this.state.buf);
            if (result.isNaN()) {
              throw this.error(new TomlError("Invalid number"));
            } else {
              return this.returnNow(result);
            }
          }
        }
        parseIntegerBin() {
          if (isBit(this.char)) {
            this.consume();
          } else if (this.char === CHAR_LOWBAR) {
            return this.call(this.parseNoUnderHexOctBinLiteral);
          } else {
            const result = Integer(this.state.buf);
            if (result.isNaN()) {
              throw this.error(new TomlError("Invalid number"));
            } else {
              return this.returnNow(result);
            }
          }
        }
        /* DATETIME */
        parseDateTime() {
          if (this.state.buf.length < 4) {
            throw this.error(new TomlError("Years less than 1000 must be zero padded to four characters"));
          }
          this.state.result = this.state.buf;
          this.state.buf = "";
          return this.next(this.parseDateMonth);
        }
        parseDateMonth() {
          if (this.char === CHAR_HYPHEN) {
            if (this.state.buf.length < 2) {
              throw this.error(new TomlError("Months less than 10 must be zero padded to two characters"));
            }
            this.state.result += "-" + this.state.buf;
            this.state.buf = "";
            return this.next(this.parseDateDay);
          } else if (isDigit(this.char)) {
            this.consume();
          } else {
            throw this.error(new TomlError("Incomplete datetime"));
          }
        }
        parseDateDay() {
          if (this.char === CHAR_T || this.char === CHAR_SP) {
            if (this.state.buf.length < 2) {
              throw this.error(new TomlError("Days less than 10 must be zero padded to two characters"));
            }
            this.state.result += "-" + this.state.buf;
            this.state.buf = "";
            return this.next(this.parseStartTimeHour);
          } else if (this.atEndOfWord()) {
            return this.returnNow(createDate(this.state.result + "-" + this.state.buf));
          } else if (isDigit(this.char)) {
            this.consume();
          } else {
            throw this.error(new TomlError("Incomplete datetime"));
          }
        }
        parseStartTimeHour() {
          if (this.atEndOfWord()) {
            return this.returnNow(createDate(this.state.result));
          } else {
            return this.goto(this.parseTimeHour);
          }
        }
        parseTimeHour() {
          if (this.char === CHAR_COLON) {
            if (this.state.buf.length < 2) {
              throw this.error(new TomlError("Hours less than 10 must be zero padded to two characters"));
            }
            this.state.result += "T" + this.state.buf;
            this.state.buf = "";
            return this.next(this.parseTimeMin);
          } else if (isDigit(this.char)) {
            this.consume();
          } else {
            throw this.error(new TomlError("Incomplete datetime"));
          }
        }
        parseTimeMin() {
          if (this.state.buf.length < 2 && isDigit(this.char)) {
            this.consume();
          } else if (this.state.buf.length === 2 && this.char === CHAR_COLON) {
            this.state.result += ":" + this.state.buf;
            this.state.buf = "";
            return this.next(this.parseTimeSec);
          } else {
            throw this.error(new TomlError("Incomplete datetime"));
          }
        }
        parseTimeSec() {
          if (isDigit(this.char)) {
            this.consume();
            if (this.state.buf.length === 2) {
              this.state.result += ":" + this.state.buf;
              this.state.buf = "";
              return this.next(this.parseTimeZoneOrFraction);
            }
          } else {
            throw this.error(new TomlError("Incomplete datetime"));
          }
        }
        parseOnlyTimeHour() {
          if (this.char === CHAR_COLON) {
            if (this.state.buf.length < 2) {
              throw this.error(new TomlError("Hours less than 10 must be zero padded to two characters"));
            }
            this.state.result = this.state.buf;
            this.state.buf = "";
            return this.next(this.parseOnlyTimeMin);
          } else {
            throw this.error(new TomlError("Incomplete time"));
          }
        }
        parseOnlyTimeMin() {
          if (this.state.buf.length < 2 && isDigit(this.char)) {
            this.consume();
          } else if (this.state.buf.length === 2 && this.char === CHAR_COLON) {
            this.state.result += ":" + this.state.buf;
            this.state.buf = "";
            return this.next(this.parseOnlyTimeSec);
          } else {
            throw this.error(new TomlError("Incomplete time"));
          }
        }
        parseOnlyTimeSec() {
          if (isDigit(this.char)) {
            this.consume();
            if (this.state.buf.length === 2) {
              return this.next(this.parseOnlyTimeFractionMaybe);
            }
          } else {
            throw this.error(new TomlError("Incomplete time"));
          }
        }
        parseOnlyTimeFractionMaybe() {
          this.state.result += ":" + this.state.buf;
          if (this.char === CHAR_PERIOD) {
            this.state.buf = "";
            this.next(this.parseOnlyTimeFraction);
          } else {
            return this.return(createTime(this.state.result));
          }
        }
        parseOnlyTimeFraction() {
          if (isDigit(this.char)) {
            this.consume();
          } else if (this.atEndOfWord()) {
            if (this.state.buf.length === 0)
              throw this.error(new TomlError("Expected digit in milliseconds"));
            return this.returnNow(createTime(this.state.result + "." + this.state.buf));
          } else {
            throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
          }
        }
        parseTimeZoneOrFraction() {
          if (this.char === CHAR_PERIOD) {
            this.consume();
            this.next(this.parseDateTimeFraction);
          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
            this.consume();
            this.next(this.parseTimeZoneHour);
          } else if (this.char === CHAR_Z) {
            this.consume();
            return this.return(createDateTime(this.state.result + this.state.buf));
          } else if (this.atEndOfWord()) {
            return this.returnNow(createDateTimeFloat(this.state.result + this.state.buf));
          } else {
            throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
          }
        }
        parseDateTimeFraction() {
          if (isDigit(this.char)) {
            this.consume();
          } else if (this.state.buf.length === 1) {
            throw this.error(new TomlError("Expected digit in milliseconds"));
          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
            this.consume();
            this.next(this.parseTimeZoneHour);
          } else if (this.char === CHAR_Z) {
            this.consume();
            return this.return(createDateTime(this.state.result + this.state.buf));
          } else if (this.atEndOfWord()) {
            return this.returnNow(createDateTimeFloat(this.state.result + this.state.buf));
          } else {
            throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
          }
        }
        parseTimeZoneHour() {
          if (isDigit(this.char)) {
            this.consume();
            if (/\d\d$/.test(this.state.buf))
              return this.next(this.parseTimeZoneSep);
          } else {
            throw this.error(new TomlError("Unexpected character in datetime, expected digit"));
          }
        }
        parseTimeZoneSep() {
          if (this.char === CHAR_COLON) {
            this.consume();
            this.next(this.parseTimeZoneMin);
          } else {
            throw this.error(new TomlError("Unexpected character in datetime, expected colon"));
          }
        }
        parseTimeZoneMin() {
          if (isDigit(this.char)) {
            this.consume();
            if (/\d\d$/.test(this.state.buf))
              return this.return(createDateTime(this.state.result + this.state.buf));
          } else {
            throw this.error(new TomlError("Unexpected character in datetime, expected digit"));
          }
        }
        /* BOOLEAN */
        parseBoolean() {
          if (this.char === CHAR_t) {
            this.consume();
            return this.next(this.parseTrue_r);
          } else if (this.char === CHAR_f) {
            this.consume();
            return this.next(this.parseFalse_a);
          }
        }
        parseTrue_r() {
          if (this.char === CHAR_r) {
            this.consume();
            return this.next(this.parseTrue_u);
          } else {
            throw this.error(new TomlError("Invalid boolean, expected true or false"));
          }
        }
        parseTrue_u() {
          if (this.char === CHAR_u) {
            this.consume();
            return this.next(this.parseTrue_e);
          } else {
            throw this.error(new TomlError("Invalid boolean, expected true or false"));
          }
        }
        parseTrue_e() {
          if (this.char === CHAR_e) {
            return this.return(true);
          } else {
            throw this.error(new TomlError("Invalid boolean, expected true or false"));
          }
        }
        parseFalse_a() {
          if (this.char === CHAR_a) {
            this.consume();
            return this.next(this.parseFalse_l);
          } else {
            throw this.error(new TomlError("Invalid boolean, expected true or false"));
          }
        }
        parseFalse_l() {
          if (this.char === CHAR_l) {
            this.consume();
            return this.next(this.parseFalse_s);
          } else {
            throw this.error(new TomlError("Invalid boolean, expected true or false"));
          }
        }
        parseFalse_s() {
          if (this.char === CHAR_s) {
            this.consume();
            return this.next(this.parseFalse_e);
          } else {
            throw this.error(new TomlError("Invalid boolean, expected true or false"));
          }
        }
        parseFalse_e() {
          if (this.char === CHAR_e) {
            return this.return(false);
          } else {
            throw this.error(new TomlError("Invalid boolean, expected true or false"));
          }
        }
        /* INLINE LISTS */
        parseInlineList() {
          if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M || this.char === CTRL_J) {
            return null;
          } else if (this.char === Parser2.END) {
            throw this.error(new TomlError("Unterminated inline array"));
          } else if (this.char === CHAR_NUM) {
            return this.call(this.parseComment);
          } else if (this.char === CHAR_RSQB) {
            return this.return(this.state.resultArr || InlineList());
          } else {
            return this.callNow(this.parseValue, this.recordInlineListValue);
          }
        }
        recordInlineListValue(value) {
          if (this.state.resultArr) {
            const listType = this.state.resultArr[_contentType];
            const valueType = tomlType(value);
            if (listType !== valueType) {
              throw this.error(new TomlError(`Inline lists must be a single type, not a mix of ${listType} and ${valueType}`));
            }
          } else {
            this.state.resultArr = InlineList(tomlType(value));
          }
          if (isFloat(value) || isInteger(value)) {
            this.state.resultArr.push(value.valueOf());
          } else {
            this.state.resultArr.push(value);
          }
          return this.goto(this.parseInlineListNext);
        }
        parseInlineListNext() {
          if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M || this.char === CTRL_J) {
            return null;
          } else if (this.char === CHAR_NUM) {
            return this.call(this.parseComment);
          } else if (this.char === CHAR_COMMA) {
            return this.next(this.parseInlineList);
          } else if (this.char === CHAR_RSQB) {
            return this.goto(this.parseInlineList);
          } else {
            throw this.error(new TomlError("Invalid character, expected whitespace, comma (,) or close bracket (])"));
          }
        }
        /* INLINE TABLE */
        parseInlineTable() {
          if (this.char === CHAR_SP || this.char === CTRL_I) {
            return null;
          } else if (this.char === Parser2.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) {
            throw this.error(new TomlError("Unterminated inline array"));
          } else if (this.char === CHAR_RCUB) {
            return this.return(this.state.resultTable || InlineTable());
          } else {
            if (!this.state.resultTable)
              this.state.resultTable = InlineTable();
            return this.callNow(this.parseAssign, this.recordInlineTableValue);
          }
        }
        recordInlineTableValue(kv) {
          let target = this.state.resultTable;
          let finalKey = kv.key.pop();
          for (let kw of kv.key) {
            if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) {
              throw this.error(new TomlError("Can't redefine existing key"));
            }
            target = target[kw] = target[kw] || Table();
          }
          if (hasKey(target, finalKey)) {
            throw this.error(new TomlError("Can't redefine existing key"));
          }
          if (isInteger(kv.value) || isFloat(kv.value)) {
            target[finalKey] = kv.value.valueOf();
          } else {
            target[finalKey] = kv.value;
          }
          return this.goto(this.parseInlineTableNext);
        }
        parseInlineTableNext() {
          if (this.char === CHAR_SP || this.char === CTRL_I) {
            return null;
          } else if (this.char === Parser2.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) {
            throw this.error(new TomlError("Unterminated inline array"));
          } else if (this.char === CHAR_COMMA) {
            return this.next(this.parseInlineTable);
          } else if (this.char === CHAR_RCUB) {
            return this.goto(this.parseInlineTable);
          } else {
            throw this.error(new TomlError("Invalid character, expected whitespace, comma (,) or close bracket (])"));
          }
        }
      }
      __name(TOMLParser, "TOMLParser");
      return TOMLParser;
    }
    __name(makeParserClass, "makeParserClass");
  }
});

// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-pretty-error.js
var require_parse_pretty_error2 = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-pretty-error.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = prettyError;
    function prettyError(err, buf) {
      if (err.pos == null || err.line == null)
        return err;
      let msg = err.message;
      msg += ` at row ${err.line + 1}, col ${err.col + 1}, pos ${err.pos}:
`;
      if (buf && buf.split) {
        const lines = buf.split(/\n/);
        const lineNumWidth = String(Math.min(lines.length, err.line + 3)).length;
        let linePadding = " ";
        while (linePadding.length < lineNumWidth)
          linePadding += " ";
        for (let ii = Math.max(0, err.line - 1); ii < Math.min(lines.length, err.line + 2); ++ii) {
          let lineNum = String(ii + 1);
          if (lineNum.length < lineNumWidth)
            lineNum = " " + lineNum;
          if (err.line === ii) {
            msg += lineNum + "> " + lines[ii] + "\n";
            msg += linePadding + "  ";
            for (let hh = 0; hh < err.col; ++hh) {
              msg += " ";
            }
            msg += "^\n";
          } else {
            msg += lineNum + ": " + lines[ii] + "\n";
          }
        }
      }
      err.message = msg + "\n";
      return err;
    }
    __name(prettyError, "prettyError");
  }
});

// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-string.js
var require_parse_string2 = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-string.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = parseString;
    var TOMLParser = require_toml_parser2();
    var prettyError = require_parse_pretty_error2();
    function parseString(str) {
      if (global.Buffer && global.Buffer.isBuffer(str)) {
        str = str.toString("utf8");
      }
      const parser2 = new TOMLParser();
      try {
        parser2.parse(str);
        return parser2.finish();
      } catch (err) {
        throw prettyError(err, str);
      }
    }
    __name(parseString, "parseString");
  }
});

// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-async.js
var require_parse_async2 = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-async.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = parseAsync;
    var TOMLParser = require_toml_parser2();
    var prettyError = require_parse_pretty_error2();
    function parseAsync(str, opts) {
      if (!opts)
        opts = {};
      const index = 0;
      const blocksize = opts.blocksize || 40960;
      const parser2 = new TOMLParser();
      return new Promise((resolve19, reject) => {
        setImmediate(parseAsyncNext, index, blocksize, resolve19, reject);
      });
      function parseAsyncNext(index2, blocksize2, resolve19, reject) {
        if (index2 >= str.length) {
          try {
            return resolve19(parser2.finish());
          } catch (err) {
            return reject(prettyError(err, str));
          }
        }
        try {
          parser2.parse(str.slice(index2, index2 + blocksize2));
          setImmediate(parseAsyncNext, index2 + blocksize2, blocksize2, resolve19, reject);
        } catch (err) {
          reject(prettyError(err, str));
        }
      }
      __name(parseAsyncNext, "parseAsyncNext");
    }
    __name(parseAsync, "parseAsync");
  }
});

// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-stream.js
var require_parse_stream2 = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-stream.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = parseStream;
    var stream2 = require("stream");
    var TOMLParser = require_toml_parser2();
    function parseStream(stm) {
      if (stm) {
        return parseReadable(stm);
      } else {
        return parseTransform(stm);
      }
    }
    __name(parseStream, "parseStream");
    function parseReadable(stm) {
      const parser2 = new TOMLParser();
      stm.setEncoding("utf8");
      return new Promise((resolve19, reject) => {
        let readable;
        let ended = false;
        let errored = false;
        function finish() {
          ended = true;
          if (readable)
            return;
          try {
            resolve19(parser2.finish());
          } catch (err) {
            reject(err);
          }
        }
        __name(finish, "finish");
        function error2(err) {
          errored = true;
          reject(err);
        }
        __name(error2, "error");
        stm.once("end", finish);
        stm.once("error", error2);
        readNext();
        function readNext() {
          readable = true;
          let data;
          while ((data = stm.read()) !== null) {
            try {
              parser2.parse(data);
            } catch (err) {
              return error2(err);
            }
          }
          readable = false;
          if (ended)
            return finish();
          if (errored)
            return;
          stm.once("readable", readNext);
        }
        __name(readNext, "readNext");
      });
    }
    __name(parseReadable, "parseReadable");
    function parseTransform() {
      const parser2 = new TOMLParser();
      return new stream2.Transform({
        objectMode: true,
        transform(chunk, encoding, cb) {
          try {
            parser2.parse(chunk.toString(encoding));
          } catch (err) {
            this.emit("error", err);
          }
          cb();
        },
        flush(cb) {
          try {
            this.push(parser2.finish());
          } catch (err) {
            this.emit("error", err);
          }
          cb();
        }
      });
    }
    __name(parseTransform, "parseTransform");
  }
});

// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse.js
var require_parse8 = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = require_parse_string2();
    module3.exports.async = require_parse_async2();
    module3.exports.stream = require_parse_stream2();
    module3.exports.prettyError = require_parse_pretty_error2();
  }
});

// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/stringify.js
var require_stringify3 = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/stringify.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = stringify;
    module3.exports.value = stringifyInline;
    function stringify(obj) {
      if (obj === null)
        throw typeError("null");
      if (obj === void 0)
        throw typeError("undefined");
      if (typeof obj !== "object")
        throw typeError(typeof obj);
      if (typeof obj.toJSON === "function")
        obj = obj.toJSON();
      if (obj == null)
        return null;
      const type = tomlType2(obj);
      if (type !== "table")
        throw typeError(type);
      return stringifyObject("", "", obj);
    }
    __name(stringify, "stringify");
    function typeError(type) {
      return new Error("Can only stringify objects, not " + type);
    }
    __name(typeError, "typeError");
    function arrayOneTypeError() {
      return new Error("Array values can't have mixed types");
    }
    __name(arrayOneTypeError, "arrayOneTypeError");
    function getInlineKeys(obj) {
      return Object.keys(obj).filter((key) => isInline(obj[key]));
    }
    __name(getInlineKeys, "getInlineKeys");
    function getComplexKeys(obj) {
      return Object.keys(obj).filter((key) => !isInline(obj[key]));
    }
    __name(getComplexKeys, "getComplexKeys");
    function toJSON(obj) {
      let nobj = Array.isArray(obj) ? [] : Object.prototype.hasOwnProperty.call(obj, "__proto__") ? { ["__proto__"]: void 0 } : {};
      for (let prop of Object.keys(obj)) {
        if (obj[prop] && typeof obj[prop].toJSON === "function" && !("toISOString" in obj[prop])) {
          nobj[prop] = obj[prop].toJSON();
        } else {
          nobj[prop] = obj[prop];
        }
      }
      return nobj;
    }
    __name(toJSON, "toJSON");
    function stringifyObject(prefix, indent, obj) {
      obj = toJSON(obj);
      var inlineKeys;
      var complexKeys;
      inlineKeys = getInlineKeys(obj);
      complexKeys = getComplexKeys(obj);
      var result = [];
      var inlineIndent = indent || "";
      inlineKeys.forEach((key) => {
        var type = tomlType2(obj[key]);
        if (type !== "undefined" && type !== "null") {
          result.push(inlineIndent + stringifyKey(key) + " = " + stringifyAnyInline(obj[key], true));
        }
      });
      if (result.length > 0)
        result.push("");
      var complexIndent = prefix && inlineKeys.length > 0 ? indent + "  " : "";
      complexKeys.forEach((key) => {
        result.push(stringifyComplex(prefix, complexIndent, key, obj[key]));
      });
      return result.join("\n");
    }
    __name(stringifyObject, "stringifyObject");
    function isInline(value) {
      switch (tomlType2(value)) {
        case "undefined":
        case "null":
        case "integer":
        case "nan":
        case "float":
        case "boolean":
        case "string":
        case "datetime":
          return true;
        case "array":
          return value.length === 0 || tomlType2(value[0]) !== "table";
        case "table":
          return Object.keys(value).length === 0;
        default:
          return false;
      }
    }
    __name(isInline, "isInline");
    function tomlType2(value) {
      if (value === void 0) {
        return "undefined";
      } else if (value === null) {
        return "null";
      } else if (typeof value === "bigint" || Number.isInteger(value) && !Object.is(value, -0)) {
        return "integer";
      } else if (typeof value === "number") {
        return "float";
      } else if (typeof value === "boolean") {
        return "boolean";
      } else if (typeof value === "string") {
        return "string";
      } else if ("toISOString" in value) {
        return isNaN(value) ? "undefined" : "datetime";
      } else if (Array.isArray(value)) {
        return "array";
      } else {
        return "table";
      }
    }
    __name(tomlType2, "tomlType");
    function stringifyKey(key) {
      var keyStr = String(key);
      if (/^[-A-Za-z0-9_]+$/.test(keyStr)) {
        return keyStr;
      } else {
        return stringifyBasicString(keyStr);
      }
    }
    __name(stringifyKey, "stringifyKey");
    function stringifyBasicString(str) {
      return '"' + escapeString(str).replace(/"/g, '\\"') + '"';
    }
    __name(stringifyBasicString, "stringifyBasicString");
    function stringifyLiteralString(str) {
      return "'" + str + "'";
    }
    __name(stringifyLiteralString, "stringifyLiteralString");
    function numpad(num, str) {
      while (str.length < num)
        str = "0" + str;
      return str;
    }
    __name(numpad, "numpad");
    function escapeString(str) {
      return str.replace(/\\/g, "\\\\").replace(/[\b]/g, "\\b").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\f/g, "\\f").replace(/\r/g, "\\r").replace(/([\u0000-\u001f\u007f])/, (c2) => "\\u" + numpad(4, c2.codePointAt(0).toString(16)));
    }
    __name(escapeString, "escapeString");
    function stringifyMultilineString(str) {
      let escaped = str.split(/\n/).map((str2) => {
        return escapeString(str2).replace(/"(?="")/g, '\\"');
      }).join("\n");
      if (escaped.slice(-1) === '"')
        escaped += "\\\n";
      return '"""\n' + escaped + '"""';
    }
    __name(stringifyMultilineString, "stringifyMultilineString");
    function stringifyAnyInline(value, multilineOk) {
      let type = tomlType2(value);
      if (type === "string") {
        if (multilineOk && /\n/.test(value)) {
          type = "string-multiline";
        } else if (!/[\b\t\n\f\r']/.test(value) && /"/.test(value)) {
          type = "string-literal";
        }
      }
      return stringifyInline(value, type);
    }
    __name(stringifyAnyInline, "stringifyAnyInline");
    function stringifyInline(value, type) {
      if (!type)
        type = tomlType2(value);
      switch (type) {
        case "string-multiline":
          return stringifyMultilineString(value);
        case "string":
          return stringifyBasicString(value);
        case "string-literal":
          return stringifyLiteralString(value);
        case "integer":
          return stringifyInteger(value);
        case "float":
          return stringifyFloat(value);
        case "boolean":
          return stringifyBoolean(value);
        case "datetime":
          return stringifyDatetime(value);
        case "array":
          return stringifyInlineArray(value.filter((_3) => tomlType2(_3) !== "null" && tomlType2(_3) !== "undefined" && tomlType2(_3) !== "nan"));
        case "table":
          return stringifyInlineTable(value);
        default:
          throw typeError(type);
      }
    }
    __name(stringifyInline, "stringifyInline");
    function stringifyInteger(value) {
      return String(value).replace(/\B(?=(\d{3})+(?!\d))/g, "_");
    }
    __name(stringifyInteger, "stringifyInteger");
    function stringifyFloat(value) {
      if (value === Infinity) {
        return "inf";
      } else if (value === -Infinity) {
        return "-inf";
      } else if (Object.is(value, NaN)) {
        return "nan";
      } else if (Object.is(value, -0)) {
        return "-0.0";
      }
      var chunks = String(value).split(".");
      var int = chunks[0];
      var dec = chunks[1] || 0;
      return stringifyInteger(int) + "." + dec;
    }
    __name(stringifyFloat, "stringifyFloat");
    function stringifyBoolean(value) {
      return String(value);
    }
    __name(stringifyBoolean, "stringifyBoolean");
    function stringifyDatetime(value) {
      return value.toISOString();
    }
    __name(stringifyDatetime, "stringifyDatetime");
    function isNumber(type) {
      return type === "float" || type === "integer";
    }
    __name(isNumber, "isNumber");
    function arrayType(values) {
      var contentType = tomlType2(values[0]);
      if (values.every((_3) => tomlType2(_3) === contentType))
        return contentType;
      if (values.every((_3) => isNumber(tomlType2(_3))))
        return "float";
      return "mixed";
    }
    __name(arrayType, "arrayType");
    function validateArray(values) {
      const type = arrayType(values);
      if (type === "mixed") {
        throw arrayOneTypeError();
      }
      return type;
    }
    __name(validateArray, "validateArray");
    function stringifyInlineArray(values) {
      values = toJSON(values);
      const type = validateArray(values);
      var result = "[";
      var stringified = values.map((_3) => stringifyInline(_3, type));
      if (stringified.join(", ").length > 60 || /\n/.test(stringified)) {
        result += "\n  " + stringified.join(",\n  ") + "\n";
      } else {
        result += " " + stringified.join(", ") + (stringified.length > 0 ? " " : "");
      }
      return result + "]";
    }
    __name(stringifyInlineArray, "stringifyInlineArray");
    function stringifyInlineTable(value) {
      value = toJSON(value);
      var result = [];
      Object.keys(value).forEach((key) => {
        result.push(stringifyKey(key) + " = " + stringifyAnyInline(value[key], false));
      });
      return "{ " + result.join(", ") + (result.length > 0 ? " " : "") + "}";
    }
    __name(stringifyInlineTable, "stringifyInlineTable");
    function stringifyComplex(prefix, indent, key, value) {
      var valueType = tomlType2(value);
      if (valueType === "array") {
        return stringifyArrayOfTables(prefix, indent, key, value);
      } else if (valueType === "table") {
        return stringifyComplexTable(prefix, indent, key, value);
      } else {
        throw typeError(valueType);
      }
    }
    __name(stringifyComplex, "stringifyComplex");
    function stringifyArrayOfTables(prefix, indent, key, values) {
      values = toJSON(values);
      validateArray(values);
      var firstValueType = tomlType2(values[0]);
      if (firstValueType !== "table")
        throw typeError(firstValueType);
      var fullKey = prefix + stringifyKey(key);
      var result = "";
      values.forEach((table) => {
        if (result.length > 0)
          result += "\n";
        result += indent + "[[" + fullKey + "]]\n";
        result += stringifyObject(fullKey + ".", indent, table);
      });
      return result;
    }
    __name(stringifyArrayOfTables, "stringifyArrayOfTables");
    function stringifyComplexTable(prefix, indent, key, value) {
      var fullKey = prefix + stringifyKey(key);
      var result = "";
      if (getInlineKeys(value).length > 0) {
        result += indent + "[" + fullKey + "]\n";
      }
      return result + stringifyObject(fullKey + ".", indent, value);
    }
    __name(stringifyComplexTable, "stringifyComplexTable");
  }
});

// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/toml.js
var require_toml2 = __commonJS({
  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/toml.js"(exports2) {
    "use strict";
    init_import_meta_url();
    exports2.parse = require_parse8();
    exports2.stringify = require_stringify3();
  }
});

// ../../node_modules/.pnpm/@miniflare+watcher@2.14.2/node_modules/@miniflare/watcher/dist/src/index.js
var require_src7 = __commonJS({
  "../../node_modules/.pnpm/@miniflare+watcher@2.14.2/node_modules/@miniflare/watcher/dist/src/index.js"(exports2) {
    init_import_meta_url();
    var __create2 = Object.create;
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __getProtoOf2 = Object.getPrototypeOf;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __markAsModule = /* @__PURE__ */ __name((target) => __defProp2(target, "__esModule", { value: true }), "__markAsModule");
    var __export2 = /* @__PURE__ */ __name((target, all2) => {
      __markAsModule(target);
      for (var name in all2)
        __defProp2(target, name, { get: all2[name], enumerable: true });
    }, "__export");
    var __reExport2 = /* @__PURE__ */ __name((target, module22, desc) => {
      if (module22 && typeof module22 === "object" || typeof module22 === "function") {
        for (let key of __getOwnPropNames2(module22))
          if (!__hasOwnProp2.call(target, key) && key !== "default")
            __defProp2(target, key, { get: () => module22[key], enumerable: !(desc = __getOwnPropDesc2(module22, key)) || desc.enumerable });
      }
      return target;
    }, "__reExport");
    var __toModule = /* @__PURE__ */ __name((module22) => {
      return __reExport2(__markAsModule(__defProp2(module22 != null ? __create2(__getProtoOf2(module22)) : {}, "default", module22 && module22.__esModule && "default" in module22 ? { get: () => module22.default, enumerable: true } : { value: module22, enumerable: true })), module22);
    }, "__toModule");
    __export2(exports2, {
      Watcher: () => Watcher
    });
    var import_assert6 = __toModule(require("assert"));
    var import_fs12 = __toModule(require("fs"));
    var import_path18 = __toModule(require("path"));
    var import_util8 = __toModule(require("util"));
    var log2 = (0, import_util8.debuglog)("mf-watch");
    function withinDir(dir, file) {
      const rel = import_path18.default.relative(dir, file);
      return !!rel && !rel.startsWith("..") && !import_path18.default.isAbsolute(rel);
    }
    __name(withinDir, "withinDir");
    function walkDirs(root, callback) {
      callback(root);
      for (const name of import_fs12.default.readdirSync(root)) {
        const filePath = import_path18.default.join(root, name);
        if (!import_fs12.default.statSync(filePath).isDirectory())
          continue;
        walkDirs(filePath, callback);
      }
    }
    __name(walkDirs, "walkDirs");
    var PathWatcher = /* @__PURE__ */ __name(class {
      constructor(options29, filePath, callback) {
        this.options = options29;
        this.filePath = filePath;
        this.callback = callback;
      }
      watchFileListener;
      watcher;
      watchers;
      lastMtimes;
      get watching() {
        return !!(this.watchFileListener || this.watcher || this.watchers || this.lastMtimes);
      }
      startCreateWatcher() {
        (0, import_assert6.default)(!this.watching);
        log2(`${this.filePath}: polling for create...`);
        this.watchFileListener = (curr) => {
          if (curr.mtimeMs === 0)
            return;
          log2(`${this.filePath}: created, tidying up temporary watcher...`);
          import_fs12.default.unwatchFile(this.filePath, this.watchFileListener);
          this.watchFileListener = void 0;
          this.callback();
          void this.start();
        };
        import_fs12.default.watchFile(this.filePath, { interval: this.options.createPollInterval }, this.watchFileListener);
      }
      startPollingWatcher() {
        (0, import_assert6.default)(!this.watching);
        log2(`${this.filePath}: polling...`);
        this.watchFileListener = (curr, prev) => {
          log2(`${this.filePath}: ${prev.mtimeMs} -> ${curr.mtimeMs}`);
          if (curr.mtimeMs === 0) {
            this.callback();
            this.dispose();
            this.startCreateWatcher();
          } else if (curr.mtimeMs !== prev.mtimeMs) {
            this.callback();
          }
        };
        import_fs12.default.watchFile(this.filePath, { interval: this.options.pollInterval }, this.watchFileListener);
      }
      listener = (event, fileName) => {
        log2(`${this.filePath}: ${event}: ${fileName}`);
        if (fileName) {
          try {
            const resolved = import_path18.default.resolve(this.filePath, fileName);
            const mtime = import_fs12.default.statSync(resolved).mtimeMs;
            const previousMtime = this.lastMtimes?.get(resolved);
            if (previousMtime === mtime) {
              log2(`${this.filePath}: ${resolved}: ignored spurious event`);
              return;
            }
            this.lastMtimes?.set(resolved, mtime);
          } catch {
          }
        }
        this.callback();
        if (!import_fs12.default.existsSync(this.filePath)) {
          this.dispose();
          this.startCreateWatcher();
        }
      };
      startDeletedWatcher() {
        this.watchFileListener = (curr) => {
          if (curr.mtimeMs === 0) {
            this.callback();
            this.dispose();
            this.startCreateWatcher();
          }
        };
        import_fs12.default.watchFile(this.filePath, { interval: this.options.pollInterval }, this.watchFileListener);
      }
      startPlatformRecursiveWatcher() {
        (0, import_assert6.default)(!this.watching);
        log2(`${this.filePath}: recursively watching with platform...`);
        this.lastMtimes = /* @__PURE__ */ new Map();
        this.watcher = import_fs12.default.watch(this.filePath, { recursive: true }, this.listener);
        this.startDeletedWatcher();
      }
      startRecursiveWatcher() {
        (0, import_assert6.default)(!this.watching);
        log2(`${this.filePath}: recursively watching...`);
        const watchers = this.watchers = /* @__PURE__ */ new Map();
        this.lastMtimes = /* @__PURE__ */ new Map();
        const update = /* @__PURE__ */ __name((dir, event, fileName) => {
          let dirIsDirectory = false;
          try {
            dirIsDirectory = import_fs12.default.statSync(dir).isDirectory();
          } catch {
          }
          if (!dirIsDirectory) {
            log2(`${this.filePath}: ${dir} is no longer a directory, resetting...`);
            this.callback();
            this.dispose();
            this.start();
            return;
          }
          const filePath = import_path18.default.join(dir, fileName);
          this.listener(event, filePath);
          try {
            if (import_fs12.default.statSync(filePath).isDirectory()) {
              walkDirs(filePath, walkCallback);
            }
          } catch (e3) {
            if (e3.code !== "ENOENT")
              throw e3;
            for (const [watchedPath, watcher] of watchers.entries()) {
              if (filePath === watchedPath || withinDir(filePath, watchedPath)) {
                watcher.close();
                watchers.delete(watchedPath);
              }
            }
          }
          log2(`${this.filePath}: watching ${[...watchers.keys()].join(",")}`);
        }, "update");
        const walkCallback = /* @__PURE__ */ __name((dir) => {
          if (!watchers.has(dir)) {
            watchers.set(dir, import_fs12.default.watch(dir, update.bind(this, dir)));
          }
        }, "walkCallback");
        try {
          walkDirs(this.filePath, walkCallback);
          this.startDeletedWatcher();
        } catch (e3) {
          if (e3.code !== "ENOENT")
            throw e3;
          this.dispose();
          this.startCreateWatcher();
        }
      }
      start() {
        try {
          if (import_fs12.default.statSync(this.filePath).isDirectory()) {
            if (this.options.forceRecursive) {
              return this.startRecursiveWatcher();
            } else {
              return this.startPlatformRecursiveWatcher();
            }
          } else {
            return this.startPollingWatcher();
          }
        } catch (e3) {
          this.dispose();
          if (e3.code === "ENOENT") {
            return this.startCreateWatcher();
          }
          if (e3.code === "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM") {
            return this.startRecursiveWatcher();
          }
          throw e3;
        }
      }
      dispose() {
        log2(`${this.filePath}: disposing...`);
        if (this.watchFileListener) {
          import_fs12.default.unwatchFile(this.filePath, this.watchFileListener);
          this.watchFileListener = void 0;
        }
        this.watcher?.close();
        this.watcher = void 0;
        if (this.watchers) {
          for (const watcher of this.watchers.values())
            watcher.close();
          this.watchers = void 0;
        }
        this.lastMtimes = void 0;
        (0, import_assert6.default)(!this.watching);
      }
    }, "PathWatcher");
    var Watcher = /* @__PURE__ */ __name(class {
      #watchers = /* @__PURE__ */ new Map();
      #callback;
      #options;
      constructor(callback, options29) {
        this.#callback = callback;
        this.#options = {
          debounce: options29?.debounce ?? 50,
          pollInterval: options29?.pollInterval ?? 250,
          createPollInterval: options29?.createPollInterval ?? 1e3,
          forceRecursive: options29?.forceRecursive ?? false
        };
      }
      watch(paths) {
        if (typeof paths === "string")
          paths = [paths];
        for (const rawPath of paths) {
          const resolved = import_path18.default.resolve(rawPath);
          if (this.#watchers.has(resolved)) {
            log2(`${resolved}: already watching`);
            continue;
          }
          log2(`${resolved}: watching...`);
          let debounceHandle;
          const callback = /* @__PURE__ */ __name(() => {
            clearTimeout(debounceHandle);
            debounceHandle = setTimeout(this.#callback, this.#options.debounce, resolved);
          }, "callback");
          const watcher = new PathWatcher(this.#options, resolved, callback);
          this.#watchers.set(resolved, watcher);
          watcher.start();
        }
      }
      unwatch(paths) {
        if (typeof paths === "string")
          paths = [paths];
        for (const rawPath of paths) {
          const resolved = import_path18.default.resolve(rawPath);
          log2(`${resolved}: unwatching...`);
          this.#watchers.get(resolved)?.dispose();
          this.#watchers.delete(resolved);
        }
      }
      dispose() {
        for (const watcher of this.#watchers.values())
          watcher.dispose();
        this.#watchers.clear();
      }
    }, "Watcher");
  }
});

// ../../node_modules/.pnpm/@miniflare+core@2.14.2/node_modules/@miniflare/core/dist/src/index.js
var require_src8 = __commonJS({
  "../../node_modules/.pnpm/@miniflare+core@2.14.2/node_modules/@miniflare/core/dist/src/index.js"(exports2) {
    init_import_meta_url();
    var __create2 = Object.create;
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __getProtoOf2 = Object.getPrototypeOf;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __defNormalProp = /* @__PURE__ */ __name((obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value, "__defNormalProp");
    var __markAsModule = /* @__PURE__ */ __name((target) => __defProp2(target, "__esModule", { value: true }), "__markAsModule");
    var __export2 = /* @__PURE__ */ __name((target, all2) => {
      __markAsModule(target);
      for (var name in all2)
        __defProp2(target, name, { get: all2[name], enumerable: true });
    }, "__export");
    var __reExport2 = /* @__PURE__ */ __name((target, module22, desc) => {
      if (module22 && typeof module22 === "object" || typeof module22 === "function") {
        for (let key of __getOwnPropNames2(module22))
          if (!__hasOwnProp2.call(target, key) && key !== "default")
            __defProp2(target, key, { get: () => module22[key], enumerable: !(desc = __getOwnPropDesc2(module22, key)) || desc.enumerable });
      }
      return target;
    }, "__reExport");
    var __toModule = /* @__PURE__ */ __name((module22) => {
      return __reExport2(__markAsModule(__defProp2(module22 != null ? __create2(__getProtoOf2(module22)) : {}, "default", module22 && module22.__esModule && "default" in module22 ? { get: () => module22.default, enumerable: true } : { value: module22, enumerable: true })), module22);
    }, "__toModule");
    var __decorateClass = /* @__PURE__ */ __name((decorators, target, key, kind) => {
      var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc2(target, key) : target;
      for (var i = decorators.length - 1, decorator; i >= 0; i--)
        if (decorator = decorators[i])
          result = (kind ? decorator(target, key, result) : decorator(result)) || result;
      if (kind && result)
        __defProp2(target, key, result);
      return result;
    }, "__decorateClass");
    var __publicField = /* @__PURE__ */ __name((obj, key, value) => {
      __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
      return value;
    }, "__publicField");
    __export2(exports2, {
      AbortSignal: () => AbortSignal2,
      BindingsPlugin: () => BindingsPlugin,
      Body: () => Body,
      BuildError: () => BuildError,
      BuildPlugin: () => BuildPlugin,
      CompressionStream: () => CompressionStream,
      CorePlugin: () => CorePlugin,
      CryptoKey: () => CryptoKey,
      DOMException: () => DOMException2,
      DOM_EXCEPTION_NAMES: () => DOM_EXCEPTION_NAMES,
      DecompressionStream: () => DecompressionStream,
      DigestStream: () => DigestStream,
      ExecutionContext: () => ExecutionContext2,
      FetchError: () => FetchError,
      FetchEvent: () => FetchEvent,
      Fetcher: () => Fetcher,
      FixedLengthStream: () => FixedLengthStream,
      Headers: () => import_undici28.Headers,
      IdentityTransformStream: () => IdentityTransformStream,
      MiniflareCore: () => MiniflareCore,
      MiniflareCoreError: () => MiniflareCoreError,
      Navigator: () => Navigator,
      PluginStorageFactory: () => PluginStorageFactory,
      PromiseRejectionEvent: () => PromiseRejectionEvent,
      QueueEvent: () => QueueEvent,
      ReloadEvent: () => ReloadEvent,
      Request: () => Request3,
      Response: () => Response9,
      Router: () => Router,
      RouterError: () => RouterError,
      ScheduledController: () => ScheduledController,
      ScheduledEvent: () => ScheduledEvent,
      Scheduler: () => Scheduler,
      ServiceWorkerGlobalScope: () => ServiceWorkerGlobalScope,
      WorkerGlobalScope: () => WorkerGlobalScope,
      _buildUnknownProtocolWarning: () => _buildUnknownProtocolWarning,
      _deepEqual: () => _deepEqual,
      _getBodyLength: () => _getBodyLength,
      _getURLList: () => _getURLList,
      _headersFromIncomingRequest: () => _headersFromIncomingRequest,
      _isBodyStream: () => _isBodyStream,
      _isByteStream: () => _isByteStream,
      _isDisturbedStream: () => _isDisturbedStream,
      _isFixedLengthStream: () => _isFixedLengthStream,
      _kInner: () => _kInner,
      _kLoopHeader: () => _kLoopHeader,
      _populateBuildConfig: () => _populateBuildConfig,
      _urlFromRequestInput: () => _urlFromRequestInput,
      atob: () => atob2,
      btoa: () => btoa2,
      createCompatFetch: () => createCompatFetch,
      createCrypto: () => createCrypto,
      createDate: () => createDate2,
      createFetchMock: () => createFetchMock,
      createTimer: () => createTimer,
      fetch: () => fetch15,
      getRangeResponse: () => getRangeResponse,
      kAddModuleFetchListener: () => kAddModuleFetchListener,
      kAddModuleQueueListener: () => kAddModuleQueueListener,
      kAddModuleScheduledListener: () => kAddModuleScheduledListener,
      kDispatchFetch: () => kDispatchFetch,
      kDispatchQueue: () => kDispatchQueue,
      kDispatchScheduled: () => kDispatchScheduled,
      kDispose: () => kDispose,
      kWaitUntil: () => kWaitUntil2,
      logResponse: () => logResponse,
      parseRanges: () => parseRanges,
      waitUntilAll: () => waitUntilAll,
      withImmutableHeaders: () => withImmutableHeaders,
      withInputGating: () => withInputGating,
      withStringFormDataFiles: () => withStringFormDataFiles,
      withWaitUntil: () => withWaitUntil
    });
    var import_promises32 = __toModule(require("fs/promises"));
    var import_path62 = __toModule(require("path"));
    var import_url42 = __toModule(require("url"));
    var import_shared12 = __toModule(require_src6());
    var has = Object.prototype.hasOwnProperty;
    function dequal(foo, bar) {
      var ctor, len;
      if (foo === bar)
        return true;
      if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
        if (ctor === Date)
          return foo.getTime() === bar.getTime();
        if (ctor === RegExp)
          return foo.toString() === bar.toString();
        if (ctor === Array) {
          if ((len = foo.length) === bar.length) {
            while (len-- && dequal(foo[len], bar[len]))
              ;
          }
          return len === -1;
        }
        if (!ctor || typeof foo === "object") {
          len = 0;
          for (ctor in foo) {
            if (has.call(foo, ctor) && ++len && !has.call(bar, ctor))
              return false;
            if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor]))
              return false;
          }
          return Object.keys(bar).length === len;
        }
      }
      return foo !== foo && bar !== bar;
    }
    __name(dequal, "dequal");
    var import_colors22 = __toModule(require_colors2());
    var import_shared = __toModule(require_src6());
    var MiniflareCoreError = /* @__PURE__ */ __name(class extends import_shared.MiniflareError {
    }, "MiniflareCoreError");
    var import_path18 = __toModule(require("path"));
    function pathsToString(set) {
      return [...set].map((filePath) => import_path18.default.relative("", filePath)).sort().join(", ");
    }
    __name(pathsToString, "pathsToString");
    function formatSize(bytes) {
      if (bytes >= 524288)
        return `${(bytes / 1048576).toFixed(2)}MiB`;
      if (bytes >= 512)
        return `${(bytes / 1024).toFixed(2)}KiB`;
      return `${bytes}B`;
    }
    __name(formatSize, "formatSize");
    var import_assert22 = __toModule(require("assert"));
    var import_promises21 = __toModule(require("fs/promises"));
    var import_path22 = __toModule(require("path"));
    var import_shared8 = __toModule(require_src6());
    var import_dotenv2 = __toModule(require_main4());
    var import_crypto2 = __toModule(require("crypto"));
    var import_web2 = __toModule(require("stream/web"));
    var import_shared3 = __toModule(require_src6());
    var DOM_EXCEPTION_NAMES = {
      IndexSizeError: 1,
      DOMStringSizeError: 2,
      HierarchyRequestError: 3,
      WrongDocumentError: 4,
      InvalidCharacterError: 5,
      NoDataAllowedError: 6,
      NoModificationAllowedError: 7,
      NotFoundError: 8,
      NotSupportedError: 9,
      InUseAttributeError: 10,
      InvalidStateError: 11,
      SyntaxError: 12,
      InvalidModificationError: 13,
      NamespaceError: 14,
      InvalidAccessError: 15,
      ValidationError: 16,
      TypeMismatchError: 17,
      SecurityError: 18,
      NetworkError: 19,
      AbortError: 20,
      URLMismatchError: 21,
      QuotaExceededError: 22,
      TimeoutError: 23,
      InvalidNodeTypeError: 24,
      DataCloneError: 25
    };
    var DOMException2 = /* @__PURE__ */ __name(class extends Error {
      constructor(message, name = "Error") {
        super(message);
        this.name = name;
      }
      get code() {
        return DOM_EXCEPTION_NAMES[this.name] ?? 0;
      }
    }, "DOMException");
    __publicField(DOMException2, "INDEX_SIZE_ERR", 1);
    __publicField(DOMException2, "DOMSTRING_SIZE_ERR", 2);
    __publicField(DOMException2, "HIERARCHY_REQUEST_ERR", 3);
    __publicField(DOMException2, "WRONG_DOCUMENT_ERR", 4);
    __publicField(DOMException2, "INVALID_CHARACTER_ERR", 5);
    __publicField(DOMException2, "NO_DATA_ALLOWED_ERR", 6);
    __publicField(DOMException2, "NO_MODIFICATION_ALLOWED_ERR", 7);
    __publicField(DOMException2, "NOT_FOUND_ERR", 8);
    __publicField(DOMException2, "NOT_SUPPORTED_ERR", 9);
    __publicField(DOMException2, "INUSE_ATTRIBUTE_ERR", 10);
    __publicField(DOMException2, "INVALID_STATE_ERR", 11);
    __publicField(DOMException2, "SYNTAX_ERR", 12);
    __publicField(DOMException2, "INVALID_MODIFICATION_ERR", 13);
    __publicField(DOMException2, "NAMESPACE_ERR", 14);
    __publicField(DOMException2, "INVALID_ACCESS_ERR", 15);
    __publicField(DOMException2, "VALIDATION_ERR", 16);
    __publicField(DOMException2, "TYPE_MISMATCH_ERR", 17);
    __publicField(DOMException2, "SECURITY_ERR", 18);
    __publicField(DOMException2, "NETWORK_ERR", 19);
    __publicField(DOMException2, "ABORT_ERR", 20);
    __publicField(DOMException2, "URL_MISMATCH_ERR", 21);
    __publicField(DOMException2, "QUOTA_EXCEEDED_ERR", 22);
    __publicField(DOMException2, "TIMEOUT_ERR", 23);
    __publicField(DOMException2, "INVALID_NODE_TYPE_ERR", 24);
    __publicField(DOMException2, "DATA_CLONE_ERR", 25);
    var import_shared2 = __toModule(require_src6());
    function isBufferSource(chunk) {
      return chunk instanceof ArrayBuffer || ArrayBuffer.isView(chunk);
    }
    __name(isBufferSource, "isBufferSource");
    function bufferSourceToArray(chunk) {
      if (chunk instanceof Uint8Array) {
        return chunk;
      } else if (chunk instanceof ArrayBuffer) {
        return new Uint8Array(chunk);
      } else {
        return new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
      }
    }
    __name(bufferSourceToArray, "bufferSourceToArray");
    function buildNotBufferSourceError(value) {
      const isString4 = typeof value === "string";
      return "This TransformStream is being used as a byte stream, but received " + (isString4 ? "a string on its writable side. If you wish to write a string, you'll probably want to explicitly UTF-8-encode it with TextEncoder." : "an object of non-ArrayBuffer/ArrayBufferView type on its writable side.");
    }
    __name(buildNotBufferSourceError, "buildNotBufferSourceError");
    function assertsInRequest(func, assert52) {
      return assert52 ? (...args) => {
        (0, import_shared2.assertInRequest)();
        return func(...args);
      } : func;
    }
    __name(assertsInRequest, "assertsInRequest");
    var CryptoKey = globalThis.CryptoKey ?? import_crypto2.webcrypto.CryptoKey;
    var supportedDigests = ["sha-1", "sha-256", "sha-384", "sha-512", "md5"];
    var DigestStream = /* @__PURE__ */ __name(class extends import_web2.WritableStream {
      digest;
      constructor(algorithm) {
        let name = typeof algorithm === "string" ? algorithm : algorithm?.name;
        if (!(name && supportedDigests.includes(name.toLowerCase()))) {
          throw new DOMException2("Unrecognized name.", "NotSupportedError");
        }
        name = name.replace("-", "");
        let digestResolve;
        const digest2 = new Promise((r3) => digestResolve = r3);
        const hash = (0, import_crypto2.createHash)(name);
        super({
          write(chunk) {
            if (isBufferSource(chunk)) {
              hash.update(bufferSourceToArray(chunk));
            } else {
              throw new TypeError(buildNotBufferSourceError(chunk));
            }
          },
          close() {
            digestResolve((0, import_shared3.viewToBuffer)(hash.digest()));
          }
        });
        this.digest = digest2;
      }
    }, "DigestStream");
    var usesModernEd25519 = (async () => {
      try {
        await import_crypto2.webcrypto.subtle.generateKey({ name: "Ed25519", namedCurve: "Ed25519" }, false, ["sign", "verify"]);
        return true;
      } catch {
        return false;
      }
    })();
    async function ensureValidNodeAlgorithm(algorithm) {
      if (typeof algorithm === "object" && (algorithm.name === "X448" || algorithm.name === "Ed448")) {
        throw new DOMException2("Unrecognized name.", "NotSupportedError");
      }
      if (typeof algorithm === "object" && algorithm.name === "Ed25519" && !await usesModernEd25519) {
        return { name: "NODE-ED25519", namedCurve: "NODE-ED25519" };
      }
      if (typeof algorithm === "object" && algorithm.name === "NODE-ED25519" && "namedCurve" in algorithm && algorithm.namedCurve === "NODE-ED25519" && await usesModernEd25519) {
        return { name: "Ed25519", namedCurve: "Ed25519" };
      }
      return algorithm;
    }
    __name(ensureValidNodeAlgorithm, "ensureValidNodeAlgorithm");
    function ensureValidWorkerKey(key) {
      if (key.algorithm.name === "NODE-ED25519")
        key.algorithm.name = "Ed25519";
      return key;
    }
    __name(ensureValidWorkerKey, "ensureValidWorkerKey");
    async function ensureValidNodeKey(key) {
      if (key.algorithm.name === "Ed25519" && !await usesModernEd25519) {
        return new Proxy(key, {
          get(target, property, receiver) {
            if (property === "algorithm")
              return { name: "NODE-ED25519" };
            return Reflect.get(target, property, receiver);
          }
        });
      }
      return key;
    }
    __name(ensureValidNodeKey, "ensureValidNodeKey");
    var digest = /* @__PURE__ */ __name(function(algorithm, data) {
      const name = typeof algorithm === "string" ? algorithm : algorithm?.name;
      if (name?.toLowerCase() == "md5") {
        if (data instanceof ArrayBuffer)
          data = new Uint8Array(data);
        const hash = (0, import_crypto2.createHash)("md5").update(data);
        return Promise.resolve((0, import_shared3.viewToBuffer)(hash.digest()));
      }
      return import_crypto2.webcrypto.subtle.digest(algorithm, data);
    }, "digest");
    var generateKey = /* @__PURE__ */ __name(async function(algorithm, extractable, keyUsages) {
      algorithm = await ensureValidNodeAlgorithm(algorithm);
      const key = await import_crypto2.webcrypto.subtle.generateKey(algorithm, extractable, keyUsages);
      if (key instanceof CryptoKey) {
        return ensureValidWorkerKey(key);
      } else {
        key.publicKey = ensureValidWorkerKey(key.publicKey);
        key.privateKey = ensureValidWorkerKey(key.privateKey);
        return key;
      }
    }, "generateKey");
    var importKey = /* @__PURE__ */ __name(async function(format22, keyData, algorithm, extractable, keyUsages) {
      const forcePublic = format22 === "raw" && typeof algorithm === "object" && algorithm.name === "NODE-ED25519" && "namedCurve" in algorithm && algorithm.namedCurve === "NODE-ED25519";
      algorithm = await ensureValidNodeAlgorithm(algorithm);
      if (forcePublic)
        algorithm.public = true;
      const key = await import_crypto2.webcrypto.subtle.importKey(format22, keyData, algorithm, extractable, keyUsages);
      return ensureValidWorkerKey(key);
    }, "importKey");
    var exportKey = /* @__PURE__ */ __name(async function(format22, key) {
      key = await ensureValidNodeKey(key);
      return import_crypto2.webcrypto.subtle.exportKey(format22, key);
    }, "exportKey");
    var sign = /* @__PURE__ */ __name(async function(algorithm, key, data) {
      algorithm = await ensureValidNodeAlgorithm(algorithm);
      key = await ensureValidNodeKey(key);
      return import_crypto2.webcrypto.subtle.sign(algorithm, key, data);
    }, "sign");
    var verify = /* @__PURE__ */ __name(async function(algorithm, key, signature, data) {
      algorithm = await ensureValidNodeAlgorithm(algorithm);
      key = await ensureValidNodeKey(key);
      return import_crypto2.webcrypto.subtle.verify(algorithm, key, signature, data);
    }, "verify");
    function createCrypto(blockGlobalRandom = false) {
      const assertingGetRandomValues = assertsInRequest(import_crypto2.webcrypto.getRandomValues.bind(import_crypto2.webcrypto), blockGlobalRandom);
      const assertingGenerateKey = assertsInRequest(generateKey, blockGlobalRandom);
      const subtle = new Proxy(import_crypto2.webcrypto.subtle, {
        get(target, propertyKey, receiver) {
          if (propertyKey === "digest")
            return digest;
          if (propertyKey === "generateKey")
            return assertingGenerateKey;
          if (propertyKey === "importKey")
            return importKey;
          if (propertyKey === "exportKey")
            return exportKey;
          if (propertyKey === "sign")
            return sign;
          if (propertyKey === "timingSafeEqual")
            return import_crypto2.timingSafeEqual;
          if (propertyKey === "verify")
            return verify;
          let result = Reflect.get(target, propertyKey, receiver);
          if (typeof result === "function")
            result = result.bind(import_crypto2.webcrypto.subtle);
          return result;
        }
      });
      return new Proxy(import_crypto2.webcrypto, {
        get(target, propertyKey, receiver) {
          if (propertyKey === "getRandomValues")
            return assertingGetRandomValues;
          if (propertyKey === "subtle")
            return subtle;
          if (propertyKey === "DigestStream")
            return DigestStream;
          let result = Reflect.get(target, propertyKey, receiver);
          if (typeof result === "function")
            result = result.bind(import_crypto2.webcrypto);
          return result;
        }
      });
    }
    __name(createCrypto, "createCrypto");
    var import_shared4 = __toModule(require_src6());
    var originalDateNow = Date.now;
    function requestContextNow() {
      return (0, import_shared4.getRequestContext)()?.currentTime ?? originalDateNow();
    }
    __name(requestContextNow, "requestContextNow");
    function createDate2(actualTime = false) {
      if (actualTime)
        return Date;
      return new Proxy(Date, {
        construct(target, args, newTarget) {
          return Reflect.construct(target, args.length === 0 ? [requestContextNow()] : args, newTarget);
        },
        get(target, propertyKey, receiver) {
          if (propertyKey === "now")
            return requestContextNow;
          return Reflect.get(target, propertyKey, receiver);
        }
      });
    }
    __name(createDate2, "createDate");
    function btoa2(input) {
      input = `${input}`;
      for (let n2 = 0; n2 < input.length; n2++) {
        if (input[n2].charCodeAt(0) > 255) {
          throw new DOMException2("Invalid character", "InvalidCharacterError");
        }
      }
      return Buffer.from(input, "latin1").toString("base64");
    }
    __name(btoa2, "btoa");
    var BASE_64_DIGITS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
    function atob2(input) {
      input = `${input}`.replace(/[\t\n\f\r ]+/g, "");
      for (let n2 = 0; n2 < input.length; n2++) {
        if (!BASE_64_DIGITS.includes(input[n2])) {
          throw new DOMException2("Invalid character", "InvalidCharacterError");
        }
      }
      return Buffer.from(input, "base64").toString("latin1");
    }
    __name(atob2, "atob");
    var import_shared6 = __toModule(require_src6());
    var import_undici32 = __toModule(require_undici2());
    var import_assert6 = __toModule(require("assert"));
    var import_http5 = __toModule(require("http"));
    var import_web3 = __toModule(require("stream/web"));
    var import_url9 = __toModule(require("url"));
    var import_shared5 = __toModule(require_src6());
    var import_colors14 = __toModule(require_colors2());
    var import_set_cookie_parser = __toModule(require_set_cookie());
    var import_undici27 = __toModule(require_undici2());
    var import_web22 = __toModule(require("stream/web"));
    var import_zlib2 = __toModule(require("zlib"));
    var kBodyStreamBrand = Symbol("kBodyStreamBrand");
    function _isByteStream(stream2) {
      for (const symbol of Object.getOwnPropertySymbols(stream2)) {
        if (symbol.description === "kState") {
          const controller = stream2[symbol].controller;
          return controller instanceof import_web22.ReadableByteStreamController;
        }
      }
      return false;
    }
    __name(_isByteStream, "_isByteStream");
    function _isDisturbedStream(stream2) {
      for (const symbol of Object.getOwnPropertySymbols(stream2)) {
        if (symbol.description === "kState") {
          return !!stream2[symbol].disturbed;
        }
      }
      return false;
    }
    __name(_isDisturbedStream, "_isDisturbedStream");
    function convertToByteStream(stream2, clone = false) {
      let reader;
      return new import_web22.ReadableStream({
        type: "bytes",
        start() {
          reader = stream2.getReader();
        },
        async pull(controller) {
          let result = await reader.read();
          while (!result.done && result.value.byteLength === 0) {
            result = await reader.read();
          }
          if (result.done) {
            queueMicrotask(() => {
              controller.close();
              controller.byobRequest?.respond(0);
            });
          } else if (result.value.byteLength > 0) {
            if (clone)
              result.value = result.value.slice();
            controller.enqueue(result.value);
          }
        },
        cancel: (reason) => reader.cancel(reason)
      });
    }
    __name(convertToByteStream, "convertToByteStream");
    function convertToRegularStream(stream2) {
      let reader;
      return new import_web22.ReadableStream({
        start() {
          reader = stream2.getReader();
        },
        async pull(controller) {
          let result = await reader.read();
          while (!result.done && result.value.byteLength === 0) {
            result = await reader.read();
          }
          if (result.done) {
            queueMicrotask(() => controller.close());
          } else if (result.value.byteLength > 0) {
            controller.enqueue(result.value);
          }
        },
        cancel: (reason) => reader.cancel(reason)
      });
    }
    __name(convertToRegularStream, "convertToRegularStream");
    import_web22.ReadableStreamBYOBReader.prototype.readAtLeast = async function(bytes, view) {
      const { byteOffset, byteLength } = view;
      if (isNaN(bytes) || bytes <= 0) {
        throw new TypeError(`Requested invalid minimum number of bytes to read (${bytes}).`);
      }
      if (byteLength <= 0) {
        throw new TypeError('You must call read() on a "byob" reader with a positive-sized TypedArray object.');
      }
      if (bytes > byteLength) {
        throw new TypeError(`Minimum bytes to read (${bytes}) exceeds size of buffer (${byteLength}).`);
      }
      const proto = Object.getPrototypeOf(view);
      const bytesPerElement = proto.BYTES_PER_ELEMENT ?? 1;
      const ctor = proto.constructor;
      let buffer = view.buffer;
      let read = 0;
      let done = false;
      while (read < byteLength && read < bytes) {
        const result = await this.read(new ctor(buffer, byteOffset + read, (byteLength - read) / bytesPerElement));
        if (result.value) {
          buffer = result.value.buffer;
          read += result.value.byteLength;
        }
        if (result.done) {
          done = read === 0;
          break;
        }
      }
      const value = new ctor(buffer, byteOffset, read / bytesPerElement);
      return { value, done };
    };
    var originalTee = import_web22.ReadableStream.prototype.tee;
    import_web22.ReadableStream.prototype.tee = function() {
      if (!(this instanceof import_web22.ReadableStream)) {
        throw new TypeError("Illegal invocation");
      }
      let [stream1, stream2] = originalTee.call(this);
      if (_isByteStream(this)) {
        stream1 = convertToByteStream(stream1, true);
        stream2 = convertToByteStream(stream2, true);
      }
      const branded = this;
      const bodyBrand = branded[kBodyStreamBrand];
      if (bodyBrand !== void 0) {
        Object.defineProperty(stream1, kBodyStreamBrand, { value: bodyBrand });
        Object.defineProperty(stream2, kBodyStreamBrand, { value: bodyBrand });
      }
      const contentLength = branded[kContentLength];
      if (contentLength !== void 0) {
        Object.defineProperty(stream1, kContentLength, { value: contentLength });
        Object.defineProperty(stream2, kContentLength, { value: contentLength });
      }
      return [stream1, stream2];
    };
    var kTransformHook = Symbol("kTransformHook");
    var kFlushHook = Symbol("kFlushHook");
    var IdentityTransformStream = /* @__PURE__ */ __name(class extends import_web22.TransformStream {
      #readableByteStream;
      [kTransformHook];
      [kFlushHook];
      constructor() {
        super({
          transform: (chunk, controller) => {
            if (isBufferSource(chunk)) {
              const array = bufferSourceToArray(chunk);
              if (this[kTransformHook]?.(array, controller) === false)
                return;
              controller.enqueue(array);
            } else {
              controller.error(new TypeError(buildNotBufferSourceError(chunk)));
            }
          },
          flush: (controller) => this[kFlushHook]?.(controller)
        });
      }
      get readable() {
        if (this.#readableByteStream !== void 0)
          return this.#readableByteStream;
        return this.#readableByteStream = convertToByteStream(super.readable);
      }
    }, "IdentityTransformStream");
    var kContentLength = Symbol("kContentLength");
    var FixedLengthStream = /* @__PURE__ */ __name(class extends IdentityTransformStream {
      #expectedLength;
      #bytesWritten = 0;
      constructor(expectedLength) {
        super();
        if (typeof expectedLength !== "number" || expectedLength < 0) {
          throw new TypeError("FixedLengthStream requires a non-negative integer expected length.");
        }
        this.#expectedLength = expectedLength;
        Object.defineProperty(this.readable, kContentLength, {
          value: expectedLength
        });
      }
      [kTransformHook] = (chunk, controller) => {
        this.#bytesWritten += chunk.byteLength;
        if (this.#bytesWritten > this.#expectedLength) {
          controller.error(new TypeError("Attempt to write too many bytes through a FixedLengthStream."));
          return false;
        }
        return true;
      };
      [kFlushHook] = (controller) => {
        if (this.#bytesWritten < this.#expectedLength) {
          controller.error(new TypeError("FixedLengthStream did not see all expected bytes before close()."));
        }
      };
    }, "FixedLengthStream");
    function _isFixedLengthStream(stream2) {
      return stream2[kContentLength] !== void 0;
    }
    __name(_isFixedLengthStream, "_isFixedLengthStream");
    function createTransformerFromTransform(transform) {
      return {
        start(controller) {
          transform.on("data", (chunk) => {
            controller.enqueue(new Uint8Array(chunk));
          });
          transform.on("error", (error2) => {
            controller.error(error2);
          });
        },
        transform(chunk) {
          transform.write(chunk);
        },
        flush() {
          return new Promise((resolve19) => {
            transform.once("close", () => {
              transform.removeAllListeners();
              resolve19();
            });
            transform.end();
          });
        }
      };
    }
    __name(createTransformerFromTransform, "createTransformerFromTransform");
    var CompressionStream = /* @__PURE__ */ __name(class extends import_web22.TransformStream {
      constructor(format22) {
        if (format22 !== "gzip" && format22 !== "deflate") {
          throw new TypeError("The compression format must be either 'deflate' or 'gzip'.");
        }
        const transform = format22 === "gzip" ? import_zlib2.default.createGzip() : import_zlib2.default.createDeflate();
        super(createTransformerFromTransform(transform));
      }
    }, "CompressionStream");
    var DecompressionStream = /* @__PURE__ */ __name(class extends import_web22.TransformStream {
      constructor(format22) {
        if (format22 !== "gzip" && format22 !== "deflate") {
          throw new TypeError("The compression format must be either 'deflate' or 'gzip'.");
        }
        const transform = format22 === "gzip" ? import_zlib2.default.createGunzip() : import_zlib2.default.createInflate();
        super(createTransformerFromTransform(transform));
      }
    }, "DecompressionStream");
    var import_undici28 = __toModule(require_undici2());
    var fetchSymbols = require_symbols7();
    var inspect2 = Symbol.for("nodejs.util.inspect.custom");
    var nonEnumerable = /* @__PURE__ */ Object.create(null);
    nonEnumerable.enumerable = false;
    function makeEnumerable(prototype, instance, keys) {
      for (const key of keys) {
        const descriptor2 = Object.getOwnPropertyDescriptor(prototype, key);
        descriptor2.enumerable = true;
        Object.defineProperty(instance, key, descriptor2);
      }
    }
    __name(makeEnumerable, "makeEnumerable");
    function unimplemented(klass, property) {
      throw new Error(`Failed to get the '${property}' property on '${klass}': the property is not implemented.`);
    }
    __name(unimplemented, "unimplemented");
    import_undici27.Headers.prototype.getAll = function(key) {
      if (key.toLowerCase() !== "set-cookie") {
        throw new TypeError('getAll() can only be used with the header name "Set-Cookie".');
      }
      const value = this.get("set-cookie");
      return value ? (0, import_set_cookie_parser.splitCookiesString)(value) : [];
    };
    function _headersFromIncomingRequest(req) {
      const headers = new import_undici27.Headers();
      for (const [name, values] of Object.entries(req.headers)) {
        if (name === "transfer-encoding" || name === "connection" || name === "keep-alive" || name === "expect") {
          continue;
        }
        if (Array.isArray(values)) {
          for (const value of values)
            headers.append(name, value);
        } else if (values !== void 0) {
          headers.append(name, values);
        }
      }
      return headers;
    }
    __name(_headersFromIncomingRequest, "_headersFromIncomingRequest");
    var _kInner = Symbol("kInner");
    var kBodyStream = Symbol("kBodyStream");
    var kInputGated = Symbol("kInputGated");
    var kFormDataFiles = Symbol("kFormDataFiles");
    var kCloned = Symbol("kCloned");
    var enumerableBodyKeys = ["body", "bodyUsed", "headers"];
    var Body = /* @__PURE__ */ __name(class {
      [_kInner];
      [kInputGated] = false;
      [kFormDataFiles] = true;
      [kCloned] = false;
      [kBodyStream];
      constructor(inner) {
        inner.headers[fetchSymbols.kGuard] = "none";
        this[_kInner] = inner;
        makeEnumerable(Body.prototype, this, enumerableBodyKeys);
        Object.defineProperty(this, _kInner, nonEnumerable);
        Object.defineProperty(this, kInputGated, nonEnumerable);
        Object.defineProperty(this, kFormDataFiles, nonEnumerable);
      }
      [inspect2]() {
        return this[_kInner];
      }
      get headers() {
        return this[_kInner].headers;
      }
      get body() {
        const body = this[_kInner].body;
        if (body === null)
          return body;
        let bodyStream = this[kBodyStream];
        if (bodyStream)
          return bodyStream;
        (0, import_assert6.default)(body instanceof import_web3.ReadableStream);
        if (!this[kInputGated] && _isByteStream(body)) {
          return this[kBodyStream] = body;
        }
        let reader;
        const source = {
          type: "bytes",
          pull: async (controller) => {
            if (reader === void 0)
              reader = body.getReader();
            let { done, value } = await reader.read();
            while (!done && isBufferSource(value) && value.byteLength === 0) {
              ({ done, value } = await reader.read());
            }
            if (this[kInputGated])
              await (0, import_shared5.waitForOpenInputGate)();
            if (isBufferSource(value)) {
              if (value.byteLength) {
                let array = bufferSourceToArray(value);
                if (this[kCloned])
                  array = array.slice();
                controller.enqueue(array);
              }
            } else if (value) {
              return controller.error(new TypeError(buildNotBufferSourceError(value)));
            }
            if (done) {
              controller.close();
              controller.byobRequest?.respond(0);
            }
          },
          cancel: (reason) => reader.cancel(reason)
        };
        bodyStream = new import_web3.ReadableStream(source);
        Object.defineProperty(bodyStream, kBodyStreamBrand, { value: true });
        const maybeContentLength = parseInt(this.headers.get("Content-Length"));
        if (!isNaN(maybeContentLength)) {
          Object.defineProperty(bodyStream, kContentLength, {
            value: maybeContentLength
          });
        }
        return this[kBodyStream] = bodyStream;
      }
      get bodyUsed() {
        return this[_kInner].bodyUsed;
      }
      async arrayBuffer() {
        const body = await this[_kInner].arrayBuffer();
        if (this[kInputGated])
          await (0, import_shared5.waitForOpenInputGate)();
        return body;
      }
      async blob() {
        const body = await this[_kInner].blob();
        if (this[kInputGated])
          await (0, import_shared5.waitForOpenInputGate)();
        return body;
      }
      async formData() {
        const headers = {};
        for (const [key, value] of this.headers)
          headers[key.toLowerCase()] = value;
        if (headers["content-type"] === void 0) {
          throw new TypeError("Parsing a Body as FormData requires a Content-Type header.");
        }
        const formData = new import_undici27.FormData();
        await new Promise(async (resolve19, reject) => {
          try {
            const Busboy = require_lib6();
            const busboy = Busboy({
              headers,
              preservePath: true
            });
            busboy.on("field", (name, value) => {
              formData.append(name, value);
            });
            busboy.on("file", (name, value, info) => {
              const { filename, encoding, mimeType } = info;
              const base642 = encoding.toLowerCase() === "base64";
              const chunks = [];
              let totalLength = 0;
              value.on("data", (chunk) => {
                if (base642)
                  chunk = Buffer.from(chunk.toString(), "base64");
                chunks.push(chunk);
                totalLength += chunk.byteLength;
              });
              value.on("end", () => {
                if (this[kFormDataFiles]) {
                  const file = new import_undici27.File(chunks, filename, { type: mimeType });
                  formData.append(name, file);
                } else {
                  const text = Buffer.concat(chunks, totalLength).toString();
                  formData.append(name, text);
                }
              });
            });
            busboy.on("finish", resolve19);
            const body = this[_kInner].body;
            if (body !== null)
              for await (const chunk of body)
                busboy.write(chunk);
            busboy.end();
          } catch (e3) {
            reject(new TypeError(e3 instanceof Error ? e3.message : String(e3)));
          }
        });
        if (this[kInputGated])
          await (0, import_shared5.waitForOpenInputGate)();
        return formData;
      }
      async json() {
        const body = await this[_kInner].json();
        if (this[kInputGated])
          await (0, import_shared5.waitForOpenInputGate)();
        return body;
      }
      async text() {
        const body = await this[_kInner].text();
        if (this[kInputGated])
          await (0, import_shared5.waitForOpenInputGate)();
        return body;
      }
    }, "Body");
    function withInputGating(body) {
      body[kInputGated] = true;
      return body;
    }
    __name(withInputGating, "withInputGating");
    function withStringFormDataFiles(body) {
      body[kFormDataFiles] = false;
      return body;
    }
    __name(withStringFormDataFiles, "withStringFormDataFiles");
    function _isBodyStream(stream2) {
      return stream2[kBodyStreamBrand] === true;
    }
    __name(_isBodyStream, "_isBodyStream");
    var enumerableRequestKeys = [
      "cf",
      "signal",
      "redirect",
      "url",
      "method"
    ];
    var requestInitKeys = [
      "method",
      "keepalive",
      "headers",
      "body",
      "redirect",
      "integrity",
      "signal",
      "credentials",
      "mode",
      "referrer",
      "referrerPolicy",
      "window",
      "dispatcher",
      "duplex"
    ];
    function cloneRequestInit(init3) {
      const result = {};
      for (const key of requestInitKeys) {
        if (key in init3)
          result[key] = init3[key];
      }
      return result;
    }
    __name(cloneRequestInit, "cloneRequestInit");
    var Request3 = /* @__PURE__ */ __name(class extends Body {
      #cf;
      constructor(input, init3) {
        const contentLength = init3?.body?.[kContentLength];
        const cf = input instanceof Request3 ? init3?.cf ?? input.#cf : init3?.cf;
        if (input instanceof import_undici27.Request && !init3) {
          super(input);
        } else {
          if (input instanceof Request3)
            input = input[_kInner];
          if (init3 instanceof Request3)
            init3 = init3[_kInner];
          init3 = init3 ? cloneRequestInit(init3) : void 0;
          if (init3?.body instanceof ArrayBuffer) {
            init3.body = init3.body.slice(0);
          }
          if (init3?.body instanceof import_web3.ReadableStream) {
            init3.duplex = "half";
            if (_isByteStream(init3.body)) {
              init3.body = convertToRegularStream(init3.body);
            }
          }
          super(new import_undici27.Request(input, init3));
        }
        this.#cf = cf ? (0, import_shared5.nonCircularClone)(cf) : void 0;
        if (contentLength !== void 0) {
          this.headers.set("content-length", contentLength.toString());
        }
        makeEnumerable(Request3.prototype, this, enumerableRequestKeys);
      }
      clone() {
        const innerClone = this[_kInner].clone();
        this[kBodyStream] = void 0;
        const clone = new Request3(innerClone);
        clone[kInputGated] = this[kInputGated];
        clone[kFormDataFiles] = this[kFormDataFiles];
        clone.headers[fetchSymbols.kGuard] = this.headers[fetchSymbols.kGuard];
        clone.#cf = this.cf ? (0, import_shared5.nonCircularClone)(this.cf) : void 0;
        this[kCloned] = true;
        clone[kCloned] = true;
        return clone;
      }
      get method() {
        return this[_kInner].method;
      }
      get url() {
        return this[_kInner].url;
      }
      get redirect() {
        return this[_kInner].redirect;
      }
      get signal() {
        return this[_kInner].signal;
      }
      get cf() {
        return this.#cf;
      }
      get context() {
        return unimplemented("Request", "context");
      }
      get mode() {
        return unimplemented("Request", "mode");
      }
      get credentials() {
        return unimplemented("Request", "credentials");
      }
      get integrity() {
        return unimplemented("Request", "integrity");
      }
      get cache() {
        return unimplemented("Request", "cache");
      }
    }, "Request");
    function withImmutableHeaders(body) {
      body.headers[fetchSymbols.kGuard] = "immutable";
      return body;
    }
    __name(withImmutableHeaders, "withImmutableHeaders");
    var kWaitUntil = Symbol("kWaitUntil");
    var nullBodyStatus = [101, 204, 205, 304];
    var enumerableResponseKeys = [
      "webSocket",
      "url",
      "redirected",
      "ok",
      "statusText",
      "status"
    ];
    var Response9 = /* @__PURE__ */ __name(class extends Body {
      static redirect(url4, status2 = 302) {
        const res = import_undici27.Response.redirect(url4, status2);
        return new Response9(res.body, res);
      }
      static json(data, init3) {
        const res = import_undici27.Response.json(data, init3);
        return new Response9(res.body, res);
      }
      #encodeBody;
      #status;
      #webSocket;
      [kWaitUntil];
      constructor(body, init3) {
        const contentLength = body?.[kContentLength];
        let encodeBody;
        let status2;
        let webSocket;
        if (init3 instanceof import_undici27.Response && body === init3.body) {
          super(init3);
        } else {
          if (body instanceof ArrayBuffer) {
            body = body.slice(0);
          }
          if (body instanceof import_web3.ReadableStream && _isByteStream(body)) {
            body = convertToRegularStream(body);
          }
          if (init3 instanceof Response9) {
            encodeBody = init3.#encodeBody;
            status2 = init3.#status;
            webSocket = init3.#webSocket;
            init3 = init3[_kInner];
          } else if (!(init3 instanceof import_undici27.Response) && init3) {
            encodeBody = init3.encodeBody;
            if (init3.webSocket) {
              if (init3.status !== 101) {
                throw new RangeError("Responses with a WebSocket must have status code 101.");
              }
              status2 = init3.status;
              webSocket = init3.webSocket;
              init3 = { ...init3, status: 200 };
            }
            if (nullBodyStatus.includes(init3.status) && body === "")
              body = null;
          }
          super(new import_undici27.Response(body, init3));
        }
        encodeBody ??= "automatic";
        if (encodeBody !== "automatic" && encodeBody !== "manual") {
          throw new TypeError(`encodeBody: unexpected value: ${encodeBody}`);
        }
        this.#encodeBody = encodeBody;
        this.#status = status2;
        this.#webSocket = webSocket;
        if (contentLength !== void 0) {
          this.headers.set("content-length", contentLength.toString());
        }
        makeEnumerable(Response9.prototype, this, enumerableResponseKeys);
        Object.defineProperty(this, kWaitUntil, nonEnumerable);
      }
      clone() {
        if (this.#webSocket) {
          throw new TypeError("Cannot clone a response to a WebSocket handshake.");
        }
        const innerClone = this[_kInner].clone();
        this[kBodyStream] = void 0;
        const clone = new Response9(innerClone.body, innerClone);
        clone[kInputGated] = this[kInputGated];
        clone[kFormDataFiles] = this[kFormDataFiles];
        clone.#encodeBody = this.#encodeBody;
        clone.#status = this.#status;
        clone[kWaitUntil] = this[kWaitUntil];
        this[kCloned] = true;
        clone[kCloned] = true;
        return clone;
      }
      get encodeBody() {
        return this.#encodeBody;
      }
      get webSocket() {
        return this.#webSocket;
      }
      waitUntil() {
        return this[kWaitUntil] ?? Promise.resolve([]);
      }
      get status() {
        return this.#status ?? this[_kInner].status;
      }
      get statusText() {
        return this[_kInner].statusText;
      }
      get ok() {
        return this[_kInner].ok;
      }
      get redirected() {
        return this[_kInner].redirected;
      }
      get url() {
        return this[_kInner].url;
      }
      get type() {
        return unimplemented("Response", "type");
      }
      get useFinalUrl() {
        return unimplemented("Response", "useFinalUrl");
      }
    }, "Response");
    function withWaitUntil(res, waitUntil) {
      const resWaitUntil = res instanceof Response9 ? res : new Response9(res.body, res);
      resWaitUntil[kWaitUntil] = waitUntil;
      return resWaitUntil;
    }
    __name(withWaitUntil, "withWaitUntil");
    function _getURLList(res) {
      return res[fetchSymbols.kState]?.urlList;
    }
    __name(_getURLList, "_getURLList");
    function _getBodyLength(res) {
      if (res instanceof Response9)
        res = res[_kInner];
      return res[fetchSymbols.kState]?.body?.length ?? void 0;
    }
    __name(_getBodyLength, "_getBodyLength");
    var _kLoopHeader = "MF-Loop";
    var kDefaultHeadersToRemove = [
      "accept",
      "accept-language",
      "sec-fetch-mode",
      "user-agent"
    ];
    var methodsExpectingPayload = ["PUT", "POST", "PATCH"];
    var MiniflareDispatcher = /* @__PURE__ */ __name(class extends import_undici27.Dispatcher {
      constructor(inner, removeHeaders, options29) {
        super(options29);
        this.inner = inner;
        this.removeHeaders = removeHeaders;
      }
      dispatch(options29, handler30) {
        const headers = options29.headers;
        if (Array.isArray(headers)) {
          let i = 0;
          while (i < headers.length) {
            if (this.removeHeaders.includes(headers[i].toLowerCase())) {
              headers.splice(i, 2);
            } else {
              i += 2;
            }
          }
        } else if (headers != null) {
          for (const key in headers) {
            if (this.removeHeaders.includes(key.toLowerCase()))
              delete headers[key];
          }
        }
        return this.inner.dispatch(options29, handler30);
      }
      close(...args) {
        return this.inner.close(...args);
      }
      destroy(...args) {
        return this.inner.destroy(...args);
      }
      get isMockActive() {
        return this.inner.isMockActive ?? false;
      }
    }, "MiniflareDispatcher");
    async function fetch15(input, init3) {
      const ctx = (0, import_shared5.getRequestContext)();
      ctx?.incrementExternalSubrequests();
      await (0, import_shared5.waitForOpenOutputGate)();
      const req = new Request3(input, init3);
      req.headers[fetchSymbols.kGuard] = "none";
      req.headers.delete("host");
      req.headers.delete("cf-connecting-ip");
      req.headers.set(_kLoopHeader, String(ctx?.requestDepth ?? 1));
      if (!methodsExpectingPayload.includes(req.method) && req.headers.get("content-length") === "0") {
        req.headers.delete("content-length");
      }
      const removeHeaders = [];
      for (const header of kDefaultHeadersToRemove) {
        if (!req.headers.has(header))
          removeHeaders.push(header);
      }
      const dispatcher = new MiniflareDispatcher(this instanceof import_undici27.Dispatcher ? this : (0, import_undici27.getGlobalDispatcher)(), removeHeaders);
      const baseRes = await (0, import_undici27.fetch)(req[_kInner], { dispatcher });
      if (baseRes.redirected && ctx) {
        const urlList = _getURLList(baseRes);
        if (urlList)
          ctx.incrementExternalSubrequests(urlList.length - 1);
      }
      const res = new Response9(nullBodyStatus.includes(baseRes.status) ? null : baseRes.body, baseRes);
      res.headers[fetchSymbols.kGuard] = "immutable";
      await (0, import_shared5.waitForOpenInputGate)();
      ctx?.advanceCurrentTime();
      return withInputGating(res);
    }
    __name(fetch15, "fetch");
    function createFetchMock() {
      return new import_undici27.MockAgent();
    }
    __name(createFetchMock, "createFetchMock");
    function _urlFromRequestInput(input) {
      if (input instanceof import_url9.URL)
        return input;
      if (input instanceof Request3 || input instanceof import_undici27.Request) {
        return new import_url9.URL(input.url);
      }
      return new import_url9.URL(input);
    }
    __name(_urlFromRequestInput, "_urlFromRequestInput");
    function _buildUnknownProtocolWarning(url4) {
      let warning = "Worker passed an invalid URL to fetch(). URLs passed to fetch() must begin with either 'http:' or 'https:', not '" + url4.protocol + "'. Due to a historical bug, any other protocol used here will be treated the same as 'http:'. We plan to correct this bug in the future, so please update your Worker to use 'http:' or 'https:' for all fetch() URLs.";
      if (url4.protocol === "ws:" || url4.protocol === "wss:") {
        warning += " Note that fetch() treats WebSockets as a special kind of HTTP request, therefore WebSockets should use 'http:'/'https:', not 'ws:'/'wss:'.";
      }
      return warning;
    }
    __name(_buildUnknownProtocolWarning, "_buildUnknownProtocolWarning");
    function createCompatFetch({
      log: log2,
      compat,
      globalAsyncIO
    }, inner = fetch15) {
      const refusesUnknown = compat.isEnabled("fetch_refuses_unknown_protocols");
      const formDataFiles = compat.isEnabled("formdata_parser_supports_files");
      return async (input, init3) => {
        if (!globalAsyncIO)
          (0, import_shared5.assertInRequest)();
        const url4 = _urlFromRequestInput(input);
        if (url4.protocol !== "http:" && url4.protocol !== "https:") {
          if (refusesUnknown) {
            throw new TypeError(`Fetch API cannot load: ${url4.toString()}`);
          } else {
            log2.warn(_buildUnknownProtocolWarning(url4));
            if (init3) {
              init3 = new Request3(input, init3);
            } else if (input instanceof import_undici27.Request) {
              init3 = new Request3(input);
            } else if (input instanceof Request3) {
              init3 = input;
            }
            input = url4.toString().replace(url4.protocol, "http:");
          }
        }
        let res = await inner(input, init3);
        if (!formDataFiles)
          res = withStringFormDataFiles(res);
        return res;
      };
    }
    __name(createCompatFetch, "createCompatFetch");
    function millisFromHRTime([seconds, nanoseconds]) {
      return `${((seconds * 1e9 + nanoseconds) / 1e6).toFixed(2)}ms`;
    }
    __name(millisFromHRTime, "millisFromHRTime");
    function millisFromCPUTime(microseconds) {
      return `${(microseconds / 1e3).toFixed(2)}ms`;
    }
    __name(millisFromCPUTime, "millisFromCPUTime");
    function colourFromHTTPStatus(status2) {
      if (200 <= status2 && status2 < 300)
        return import_colors14.green;
      if (400 <= status2 && status2 < 500)
        return import_colors14.yellow;
      if (500 <= status2)
        return import_colors14.red;
      return import_colors14.blue;
    }
    __name(colourFromHTTPStatus, "colourFromHTTPStatus");
    async function logResponse(log2, {
      start,
      startCpu,
      method,
      url: url4,
      status: status2,
      waitUntil
    }) {
      const cpuParts = [];
      const responseTime = millisFromHRTime(process.hrtime(start));
      if (startCpu !== void 0) {
        const responseTimeCpu = millisFromCPUTime(process.cpuUsage(startCpu).user);
        cpuParts.push((0, import_colors14.dim)((0, import_colors14.grey)(` (CPU: ~${responseTimeCpu}`)));
      }
      let waitUntilResponse;
      try {
        waitUntilResponse = await waitUntil;
      } catch (e3) {
        waitUntilResponse = [""];
        log2.error(e3);
      }
      const waitUntilTime = millisFromHRTime(process.hrtime(start));
      if (startCpu !== void 0) {
        if (waitUntilResponse?.length) {
          const waitUntilTimeCpu = millisFromCPUTime(process.cpuUsage(startCpu).user);
          cpuParts.push((0, import_colors14.dim)((0, import_colors14.grey)(`, waitUntil: ~${waitUntilTimeCpu}`)));
        }
        cpuParts.push((0, import_colors14.dim)((0, import_colors14.grey)(")")));
      }
      log2.log([
        `${(0, import_colors14.bold)(method)} ${url4} `,
        status2 ? colourFromHTTPStatus(status2)(`${(0, import_colors14.bold)(status2)} ${import_http5.default.STATUS_CODES[status2]} `) : "",
        (0, import_colors14.grey)(`(${responseTime}`),
        waitUntilResponse?.length ? (0, import_colors14.grey)(`, waitUntil: ${waitUntilTime}`) : "",
        (0, import_colors14.grey)(")"),
        ...cpuParts
      ].join(""));
    }
    __name(logResponse, "logResponse");
    var FetchError = /* @__PURE__ */ __name(class extends import_shared6.MiniflareError {
    }, "FetchError");
    var SUGGEST_HANDLER = 'calling addEventListener("fetch", ...)';
    var SUGGEST_HANDLER_MODULES = "exporting a default object containing a `fetch` function property";
    var SUGGEST_RES = "calling `event.respondWith()` with a `Response` or `Promise<Response>` in your handler";
    var SUGGEST_RES_MODULES = "returning a `Response` in your handler";
    var SUGGEST_GLOBAL_BINDING_MODULES = "Attempted to access binding using global in modules.\nYou must use the 2nd `env` parameter passed to exported handlers/Durable Object constructors, or `context.env` with Pages Functions.";
    async function waitUntilAll(promises4) {
      let len = 0;
      let last = [];
      while (len !== promises4.length) {
        len = promises4.length;
        last = await Promise.all(promises4);
      }
      return last;
    }
    __name(waitUntilAll, "waitUntilAll");
    var kResponse = Symbol("kResponse");
    var kPassThrough = Symbol("kPassThrough");
    var kWaitUntil2 = Symbol("kWaitUntil");
    var kSent = Symbol("kSent");
    var FetchEvent = /* @__PURE__ */ __name(class extends Event {
      request;
      [kResponse];
      [kPassThrough] = false;
      [kWaitUntil2] = [];
      [kSent] = false;
      constructor(type, init3) {
        super(type);
        this.request = init3.request;
      }
      respondWith(response) {
        if (!(this instanceof FetchEvent)) {
          throw new TypeError("Illegal invocation");
        }
        if (this[kResponse]) {
          throw new DOMException2("FetchEvent.respondWith() has already been called; it can only be called once.", "InvalidStateError");
        }
        if (this[kSent]) {
          throw new DOMException2("Too late to call FetchEvent.respondWith(). It must be called synchronously in the event handler.", "InvalidStateError");
        }
        this.stopImmediatePropagation();
        this[kResponse] = Promise.resolve(response);
      }
      passThroughOnException() {
        if (!(this instanceof FetchEvent)) {
          throw new TypeError("Illegal invocation");
        }
        this[kPassThrough] = true;
      }
      waitUntil(promise) {
        if (!(this instanceof FetchEvent)) {
          throw new TypeError("Illegal invocation");
        }
        this[kWaitUntil2].push(Promise.resolve(promise));
      }
    }, "FetchEvent");
    var ScheduledEvent = /* @__PURE__ */ __name(class extends Event {
      scheduledTime;
      cron;
      [kWaitUntil2] = [];
      constructor(type, init3) {
        super(type);
        this.scheduledTime = init3.scheduledTime;
        this.cron = init3.cron;
      }
      waitUntil(promise) {
        if (!(this instanceof ScheduledEvent)) {
          throw new TypeError("Illegal invocation");
        }
        this[kWaitUntil2].push(promise);
      }
    }, "ScheduledEvent");
    var QueueEvent = /* @__PURE__ */ __name(class extends Event {
      batch;
      [kWaitUntil2] = [];
      constructor(type, init3) {
        super(type);
        this.batch = init3.batch;
      }
      waitUntil(promise) {
        if (!(this instanceof QueueEvent)) {
          throw new TypeError("Illegal invocation");
        }
        this[kWaitUntil2].push(promise);
      }
    }, "QueueEvent");
    var ExecutionContext2 = /* @__PURE__ */ __name(class {
      #event;
      constructor(event) {
        this.#event = event;
      }
      passThroughOnException() {
        if (!(this instanceof ExecutionContext2)) {
          throw new TypeError("Illegal invocation");
        }
        if (this.#event instanceof FetchEvent)
          this.#event.passThroughOnException();
      }
      waitUntil(promise) {
        if (!(this instanceof ExecutionContext2)) {
          throw new TypeError("Illegal invocation");
        }
        this.#event.waitUntil(promise);
      }
    }, "ExecutionContext");
    var ScheduledController = /* @__PURE__ */ __name(class {
      constructor(scheduledTime, cron) {
        this.scheduledTime = scheduledTime;
        this.cron = cron;
      }
    }, "ScheduledController");
    var kAddModuleFetchListener = Symbol("kAddModuleFetchListener");
    var kAddModuleScheduledListener = Symbol("kAddModuleScheduledListener");
    var kAddModuleQueueListener = Symbol("kAddModuleQueueListener");
    var kDispatchFetch = Symbol("kDispatchFetch");
    var kDispatchScheduled = Symbol("kDispatchScheduled");
    var kDispatchQueue = Symbol("kDispatchQueue");
    var kDispose = Symbol("kDispose");
    var PromiseRejectionEvent = /* @__PURE__ */ __name(class extends Event {
      promise;
      reason;
      constructor(type, init3) {
        super(type, { cancelable: true });
        this.promise = init3.promise;
        this.reason = init3.reason;
      }
    }, "PromiseRejectionEvent");
    function isSpecialEventType(type) {
      return type === "fetch" || type === "scheduled" || type === "trace" || type === "queue";
    }
    __name(isSpecialEventType, "isSpecialEventType");
    var WorkerGlobalScope = /* @__PURE__ */ __name(class extends import_shared6.ThrowingEventTarget {
    }, "WorkerGlobalScope");
    var ServiceWorkerGlobalScope = /* @__PURE__ */ __name(class extends WorkerGlobalScope {
      #log;
      #bindings;
      #modules;
      #logUnhandledRejections;
      #calledAddFetchEventListener = false;
      #unhandledRejection;
      #rejectionHandled;
      global = this;
      self = this;
      constructor(log2, globals, bindings, modules, logUnhandledRejections) {
        super();
        this.#log = log2;
        this.#bindings = bindings;
        this.#modules = modules;
        this.#logUnhandledRejections = logUnhandledRejections;
        this.#unhandledRejection = {
          name: "unhandledRejection",
          set: /* @__PURE__ */ new Set(),
          listener: this.#unhandledRejectionListener
        };
        this.#rejectionHandled = {
          name: "rejectionHandled",
          set: /* @__PURE__ */ new Set(),
          listener: this.#rejectionHandledListener
        };
        if (this.#logUnhandledRejections) {
          this.#maybeAddPromiseListener(this.#unhandledRejection, true);
        }
        Object.assign(this, globals);
        if (modules) {
          for (const key of Object.keys(bindings)) {
            if (key === "__STATIC_CONTENT" || key === "__STATIC_CONTENT_MANIFEST") {
              break;
            }
            Object.defineProperty(this, key, {
              get() {
                throw new ReferenceError(`${key} is not defined.
${SUGGEST_GLOBAL_BINDING_MODULES}`);
              }
            });
          }
        } else {
          Object.assign(this, bindings);
        }
      }
      addEventListener = (type, listener, options29) => {
        if (this.#modules && isSpecialEventType(type)) {
          return this.#log.warn(`When using module syntax, the '${type}' event handler should be declared as an exported function on the root module as opposed to using the global addEventListener().`);
        }
        if (type === "fetch")
          this.#calledAddFetchEventListener = true;
        if (type === "unhandledrejection" && listener) {
          this.#maybeAddPromiseListener(this.#unhandledRejection, listener);
        }
        if (type === "rejectionhandled" && listener) {
          this.#maybeAddPromiseListener(this.#rejectionHandled, listener);
        }
        super.addEventListener(type, listener, options29);
      };
      removeEventListener = (type, listener, options29) => {
        if (this.#modules && isSpecialEventType(type))
          return;
        if (type === "unhandledrejection" && listener) {
          this.#maybeRemovePromiseListener(this.#unhandledRejection, listener);
        }
        if (type === "rejectionhandled" && listener) {
          this.#maybeRemovePromiseListener(this.#rejectionHandled, listener);
        }
        super.removeEventListener(type, listener, options29);
      };
      [kAddModuleFetchListener](listener) {
        this.#calledAddFetchEventListener = true;
        super.addEventListener("fetch", (e3) => {
          const ctx = new ExecutionContext2(e3);
          const res = listener(e3.request, this.#bindings, ctx);
          e3.respondWith(res);
        });
      }
      [kAddModuleScheduledListener](listener) {
        super.addEventListener("scheduled", (e3) => {
          const controller = new ScheduledController(e3.scheduledTime, e3.cron);
          const ctx = new ExecutionContext2(e3);
          const res = listener(controller, this.#bindings, ctx);
          if (res !== void 0)
            e3.waitUntil(Promise.resolve(res));
        });
      }
      [kAddModuleQueueListener](listener) {
        super.addEventListener("queue", (e3) => {
          const res = listener(e3.batch, this.#bindings, new ExecutionContext2(e3));
          if (res !== void 0)
            e3.waitUntil(Promise.resolve(res));
        });
      }
      async [kDispatchFetch](request3, proxy2 = false) {
        const event = new FetchEvent("fetch", {
          request: proxy2 ? request3.clone() : request3
        });
        let res;
        try {
          super.dispatchEvent(event);
          res = await event[kResponse];
        } catch (e3) {
          if (event[kPassThrough]) {
            this.#log.warn(e3.stack);
          } else {
            throw e3;
          }
        } finally {
          event[kSent] = true;
        }
        if (res !== void 0) {
          const validRes = res instanceof Response9 || res instanceof import_undici32.Response;
          if (!validRes) {
            const suggestion = this.#modules ? SUGGEST_RES_MODULES : SUGGEST_RES;
            throw new FetchError("ERR_RESPONSE_TYPE", `Fetch handler didn't respond with a Response object.
Make sure you're ${suggestion}.`);
          }
          const waitUntil2 = waitUntilAll(event[kWaitUntil2]);
          return withWaitUntil(res, waitUntil2);
        }
        if (!proxy2) {
          if (event[kPassThrough]) {
            throw new FetchError("ERR_NO_UPSTREAM", "No upstream to pass-through to specified.\nMake sure you've set the `upstream` option.");
          } else if (this.#calledAddFetchEventListener) {
            const suggestion = this.#modules ? SUGGEST_RES_MODULES : SUGGEST_RES;
            throw new FetchError("ERR_NO_RESPONSE", `No fetch handler responded and no upstream to proxy to specified.
Make sure you're ${suggestion}.`);
          } else {
            const suggestion = this.#modules ? SUGGEST_HANDLER_MODULES : SUGGEST_HANDLER;
            throw new FetchError("ERR_NO_HANDLER", `No fetch handler defined and no upstream to proxy to specified.
Make sure you're ${suggestion}.`);
          }
        }
        const waitUntil = waitUntilAll(event[kWaitUntil2]);
        return withWaitUntil(await fetch15(request3), waitUntil);
      }
      async [kDispatchScheduled](scheduledTime, cron) {
        const event = new ScheduledEvent("scheduled", {
          scheduledTime: scheduledTime ?? Date.now(),
          cron: cron ?? ""
        });
        super.dispatchEvent(event);
        return waitUntilAll(event[kWaitUntil2]);
      }
      async [kDispatchQueue](batch) {
        const event = new QueueEvent("queue", { batch });
        super.dispatchEvent(event);
        return waitUntilAll(event[kWaitUntil2]);
      }
      #maybeAddPromiseListener(listener, member) {
        if (listener.set.size === 0) {
          this.#log.verbose(`Adding process ${listener.name} listener...`);
          process.prependListener(listener.name, listener.listener);
        }
        listener.set.add(member);
      }
      #maybeRemovePromiseListener(listener, member) {
        const registered = listener.set.size > 0;
        listener.set.delete(member);
        if (registered && listener.set.size === 0) {
          this.#log.verbose(`Removing process ${listener.name} listener...`);
          process.removeListener(listener.name, listener.listener);
        }
      }
      #resetPromiseListener(listener) {
        if (listener.set.size > 0) {
          this.#log.verbose(`Removing process ${listener.name} listener...`);
          process.removeListener(listener.name, listener.listener);
        }
        listener.set.clear();
      }
      #unhandledRejectionListener = (reason, promise) => {
        const event = new PromiseRejectionEvent("unhandledrejection", {
          reason,
          promise
        });
        const notCancelled = super.dispatchEvent(event);
        if (notCancelled) {
          if (this.#logUnhandledRejections) {
            this.#log.error((0, import_shared6.prefixError)("Unhandled Promise Rejection", reason));
          } else {
            this.#resetPromiseListener(this.#unhandledRejection);
            Promise.reject(reason);
          }
        }
      };
      #rejectionHandledListener = (promise) => {
        const event = new PromiseRejectionEvent("rejectionhandled", { promise });
        super.dispatchEvent(event);
      };
      [kDispose]() {
        this.#resetPromiseListener(this.#unhandledRejection);
        this.#resetPromiseListener(this.#rejectionHandled);
      }
    }, "ServiceWorkerGlobalScope");
    var Navigator = /* @__PURE__ */ __name(class {
      userAgent = "Cloudflare-Workers";
    }, "Navigator");
    var import_web4 = __toModule(require("stream/web"));
    var import_util8 = __toModule(require("util"));
    var encoder = new import_util8.TextEncoder();
    var rangePrefixRegexp = /^ *bytes *=/i;
    var rangeRegexp = /^ *(?<start>\d+)? *- *(?<end>\d+)? *$/;
    function parseRanges(rangeHeader, length) {
      const prefixMatch = rangePrefixRegexp.exec(rangeHeader);
      if (prefixMatch === null)
        return;
      rangeHeader = rangeHeader.substring(prefixMatch[0].length);
      if (rangeHeader.trimStart() === "")
        return [];
      const ranges = rangeHeader.split(",");
      const result = [];
      for (const range of ranges) {
        const match2 = rangeRegexp.exec(range);
        if (match2 === null)
          return;
        const { start, end } = match2.groups;
        if (start !== void 0 && end !== void 0) {
          const rangeStart = parseInt(start);
          let rangeEnd = parseInt(end);
          if (rangeStart > rangeEnd)
            return;
          if (rangeStart >= length)
            return;
          if (rangeEnd >= length)
            rangeEnd = length - 1;
          result.push([rangeStart, rangeEnd]);
        } else if (start !== void 0 && end === void 0) {
          const rangeStart = parseInt(start);
          if (rangeStart >= length)
            return;
          result.push([rangeStart, length - 1]);
        } else if (start === void 0 && end !== void 0) {
          const suffix = parseInt(end);
          if (suffix >= length)
            return [];
          if (suffix === 0)
            continue;
          result.push([length - suffix, length - 1]);
        } else {
          return;
        }
      }
      return result;
    }
    __name(parseRanges, "parseRanges");
    function getRangeResponse(requestRangeHeader, responseStatus, responseHeaders, responseBody) {
      const ranges = parseRanges(requestRangeHeader, responseBody.byteLength);
      if (ranges === void 0) {
        return new Response9(null, {
          status: 416,
          headers: { "Content-Range": `bytes */${responseBody.byteLength}` }
        });
      } else if (ranges.length === 0) {
        return new Response9(responseBody, {
          status: responseStatus,
          headers: responseHeaders
        });
      } else if (ranges.length === 1) {
        const [start, end] = ranges[0];
        responseHeaders.set("Content-Range", `bytes ${start}-${end}/${responseBody.byteLength}`);
        responseHeaders.set("Content-Length", `${end - start + 1}`);
        return new Response9(responseBody.slice(start, end + 1), {
          status: 206,
          headers: responseHeaders
        });
      } else {
        const contentType = responseHeaders.get("Content-Type");
        const boundary = "miniflare-boundary-" + Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString().padStart(16, "0");
        const stream2 = new import_web4.ReadableStream({
          type: "bytes",
          pull(controller) {
            const range = ranges.shift();
            if (range === void 0) {
              controller.enqueue(encoder.encode(`--${boundary}--`));
              return controller.close();
            }
            const [start, end] = range;
            const header = `--${boundary}\r
Content-Type: ${contentType}\r
Content-Range: bytes ${start}-${end}/${responseBody.byteLength}\r
\r
`;
            controller.enqueue(encoder.encode(header));
            controller.enqueue(responseBody.slice(start, end + 1));
            controller.enqueue(encoder.encode("\r\n"));
          }
        });
        responseHeaders.set("Content-Type", `multipart/byteranges; boundary=${boundary}`);
        return new Response9(stream2, {
          status: 206,
          headers: responseHeaders
        });
      }
    }
    __name(getRangeResponse, "getRangeResponse");
    var import_shared7 = __toModule(require_src6());
    function createTimer(func, blockGlobalTimers = false) {
      return (callback, ms, ...args) => {
        if (blockGlobalTimers)
          (0, import_shared7.assertInRequest)();
        return func(callback ? async (...args2) => {
          await (0, import_shared7.waitForOpenInputGate)();
          callback?.(...args2);
        } : callback, ms, ...args);
      };
    }
    __name(createTimer, "createTimer");
    var AbortSignal2 = globalThis.AbortSignal ?? Object.getPrototypeOf(new AbortController().signal).constructor;
    AbortSignal2.timeout = function(ms) {
      if (arguments.length === 0) {
        throw new TypeError("Failed to execute 'timeout' on 'AbortSignal': parameter 1 is not of type 'integer'.");
      }
      const controller = new AbortController();
      setTimeout(() => controller.abort(), ms);
      return controller.signal;
    };
    var Scheduler = /* @__PURE__ */ __name(class {
      #blockGlobalTimers;
      constructor(blockGlobalTimers = false) {
        this.#blockGlobalTimers = blockGlobalTimers;
      }
      wait(ms, options29) {
        if (this.#blockGlobalTimers)
          (0, import_shared7.assertInRequest)();
        if (arguments.length === 0) {
          throw new TypeError("Failed to execute 'wait' on 'Scheduler': parameter 1 is not of type 'integer'.");
        }
        return new Promise((resolve19, reject) => {
          let resolved = false;
          const timeout = setTimeout(() => (resolved = true) && resolve19(), ms);
          options29?.signal?.addEventListener("abort", () => {
            if (resolved)
              return;
            clearTimeout(timeout);
            reject(new DOMException2("The operation was aborted", "AbortError"));
          });
        });
      }
    }, "Scheduler");
    var kWranglerBindings = Symbol("kWranglerBindings");
    var Fetcher = /* @__PURE__ */ __name(class {
      #service;
      #getServiceFetch;
      #defaultUsageModel;
      constructor(service, getServiceFetch, defaultUsageModel) {
        this.#service = service;
        this.#getServiceFetch = getServiceFetch;
        this.#defaultUsageModel = defaultUsageModel;
      }
      async fetch(input, init3) {
        if (!(this instanceof Fetcher)) {
          throw new TypeError("Illegal invocation");
        }
        const req = new Request3(input, init3);
        let fetch22;
        let usageModel = this.#defaultUsageModel;
        if (typeof this.#service === "function") {
          fetch22 = this.#service;
        } else {
          const serviceFetch = await this.#getServiceFetch(this.#service);
          fetch22 = serviceFetch.fetch;
          usageModel = serviceFetch.usageModel;
        }
        const parentCtx = (0, import_shared8.getRequestContext)();
        const requestDepth = parentCtx?.requestDepth ?? 1;
        const pipelineDepth = (parentCtx?.pipelineDepth ?? 0) + 1;
        const ctx = new import_shared8.RequestContext({
          requestDepth,
          pipelineDepth,
          externalSubrequestLimit: (0, import_shared8.usageModelExternalSubrequestLimit)(usageModel)
        });
        const res = await ctx.runWith(() => fetch22(req));
        return withImmutableHeaders(res);
      }
    }, "Fetcher");
    function getServiceBindingName(log2, service, { name, binding }) {
      if (name !== void 0 && binding !== void 0 && name !== binding) {
        throw new MiniflareCoreError("ERR_SERVICE_NAME_MISMATCH", `Service "${service}" declared with \`name\`="${name}" and \`binding\`="${binding}".
The \`binding\` key should be used to define binding names.`);
      }
      if (name !== void 0) {
        log2.warn(`Service "${service}" declared using deprecated syntax.
The \`name\` key should be removed and renamed to \`binding\`.`);
        return name;
      }
      if (binding !== void 0)
        return binding;
      throw new MiniflareCoreError("ERR_SERVICE_NO_NAME", `Service "${service}" declared with neither \`binding\` nor \`name\` keys.
The \`binding\` key should be used to define binding names.`);
    }
    __name(getServiceBindingName, "getServiceBindingName");
    var _a2;
    var BindingsPlugin = /* @__PURE__ */ __name(class extends import_shared8.Plugin {
      envPath;
      [_a2 = kWranglerBindings];
      envPathDefaultFallback;
      bindings;
      globals;
      wasmBindings;
      textBlobBindings;
      dataBlobBindings;
      serviceBindings;
      #processedServiceBindings;
      #contextPromise;
      #contextResolve;
      #mounts;
      constructor(ctx, options29) {
        super(ctx);
        this.assignOptions(options29);
        if (this.envPathDefaultFallback && this.envPath === void 0) {
          this.envPath = true;
        }
        this.#processedServiceBindings = Object.entries(this.serviceBindings ?? {}).map(([name, options210]) => {
          const service = typeof options210 === "object" ? options210.service : options210;
          const environment = typeof options210 === "object" && options210.environment || "production";
          return { name, service, environment };
        });
        if (this.#processedServiceBindings.length) {
          ctx.log.warn("Service bindings are experimental. There may be breaking changes in the future.");
        }
      }
      #getServiceFetch = async (service) => {
        (0, import_assert22.default)(this.#contextPromise, "beforeReload() must be called before #getServiceFetch()");
        await this.#contextPromise;
        const mount = this.#mounts?.get(service);
        (0, import_assert22.default)(mount?.dispatchFetch);
        return { fetch: mount.dispatchFetch, usageModel: mount.usageModel };
      };
      async setup() {
        const bindings = {};
        const watch6 = [];
        Object.assign(bindings, this[kWranglerBindings]);
        let envPath = this.envPath === true ? ".env" : this.envPath;
        if (envPath) {
          envPath = import_path22.default.resolve(this.ctx.rootPath, envPath);
          try {
            Object.assign(bindings, import_dotenv2.default.parse(await import_promises21.default.readFile(envPath, "utf8")));
          } catch (e3) {
            if (!(e3.code === "ENOENT" && this.envPath === true))
              throw e3;
          }
          watch6.push(envPath);
        }
        if (this.wasmBindings) {
          for (let [name, wasmPath] of Object.entries(this.wasmBindings)) {
            wasmPath = import_path22.default.resolve(this.ctx.rootPath, wasmPath);
            bindings[name] = new WebAssembly.Module(await import_promises21.default.readFile(wasmPath));
            watch6.push(wasmPath);
          }
        }
        if (this.textBlobBindings) {
          for (let [name, textPath] of Object.entries(this.textBlobBindings)) {
            textPath = import_path22.default.resolve(this.ctx.rootPath, textPath);
            bindings[name] = await import_promises21.default.readFile(textPath, "utf-8");
            watch6.push(textPath);
          }
        }
        if (this.dataBlobBindings) {
          for (let [name, dataPath] of Object.entries(this.dataBlobBindings)) {
            dataPath = import_path22.default.resolve(this.ctx.rootPath, dataPath);
            const fileContent = await import_promises21.default.readFile(dataPath);
            bindings[name] = (0, import_shared8.viewToBuffer)(fileContent);
            watch6.push(dataPath);
          }
        }
        for (const { name, service } of this.#processedServiceBindings) {
          bindings[name] = new Fetcher(service, this.#getServiceFetch, this.ctx.usageModel);
        }
        Object.assign(bindings, this.bindings);
        return { globals: this.globals, bindings, watch: watch6 };
      }
      beforeReload() {
        this.#mounts = void 0;
        this.#contextPromise = new Promise((resolve19) => this.#contextResolve = resolve19);
      }
      reload(bindings, moduleExports, mounts) {
        for (const { name, service } of this.#processedServiceBindings) {
          if (typeof service === "string" && !mounts.has(service)) {
            throw new MiniflareCoreError("ERR_SERVICE_NOT_MOUNTED", `Service "${service}" for binding "${name}" not found.
Make sure "${service}" is mounted so Miniflare knows where to find it.`);
          }
        }
        this.#mounts = mounts;
        (0, import_assert22.default)(this.#contextResolve, "beforeReload() must be called before reload()");
        this.#contextResolve();
      }
      dispose() {
        return this.beforeReload();
      }
    }, "BindingsPlugin");
    __decorateClass([
      (0, import_shared8.Option)({
        type: import_shared8.OptionType.STRING,
        name: "env",
        alias: "e",
        description: "Path to .env file",
        logValue(value) {
          if (value === true)
            return ".env";
          if (value === false)
            return void 0;
          return import_path22.default.relative("", value);
        },
        fromWrangler: ({ miniflare }) => miniflare?.env_path
      })
    ], BindingsPlugin.prototype, "envPath", 2);
    __decorateClass([
      (0, import_shared8.Option)({
        type: import_shared8.OptionType.OBJECT,
        logName: "Wrangler Variables",
        fromWrangler: ({ vars }) => {
          if (!vars)
            return;
          return Object.fromEntries(Object.entries(vars).map(([key, value]) => [key, String(value)]));
        }
      })
    ], BindingsPlugin.prototype, _a2, 2);
    __decorateClass([
      (0, import_shared8.Option)({ type: import_shared8.OptionType.NONE })
    ], BindingsPlugin.prototype, "envPathDefaultFallback", 2);
    __decorateClass([
      (0, import_shared8.Option)({
        type: import_shared8.OptionType.OBJECT,
        alias: "b",
        description: "Binds variable/secret to environment",
        logName: "Custom Bindings"
      })
    ], BindingsPlugin.prototype, "bindings", 2);
    __decorateClass([
      (0, import_shared8.Option)({
        type: import_shared8.OptionType.OBJECT,
        description: "Binds variable/secret to global scope",
        logName: "Custom Globals",
        fromWrangler: ({ miniflare }) => miniflare?.globals
      })
    ], BindingsPlugin.prototype, "globals", 2);
    __decorateClass([
      (0, import_shared8.Option)({
        type: import_shared8.OptionType.OBJECT,
        typeFormat: "NAME=PATH",
        name: "wasm",
        description: "WASM module to bind",
        logName: "WASM Bindings",
        fromWrangler: ({ wasm_modules }) => wasm_modules
      })
    ], BindingsPlugin.prototype, "wasmBindings", 2);
    __decorateClass([
      (0, import_shared8.Option)({
        type: import_shared8.OptionType.OBJECT,
        typeFormat: "NAME=PATH",
        name: "text-blob",
        description: "Text blob to bind",
        logName: "Text Blob Bindings",
        fromWrangler: ({ text_blobs }) => text_blobs
      })
    ], BindingsPlugin.prototype, "textBlobBindings", 2);
    __decorateClass([
      (0, import_shared8.Option)({
        type: import_shared8.OptionType.OBJECT,
        typeFormat: "NAME=PATH",
        name: "data-blob",
        description: "Data blob to bind",
        logName: "Data Blob Bindings",
        fromWrangler: ({ data_blobs }) => data_blobs
      })
    ], BindingsPlugin.prototype, "dataBlobBindings", 2);
    __decorateClass([
      (0, import_shared8.Option)({
        type: import_shared8.OptionType.OBJECT,
        typeFormat: "NAME=MOUNT[@ENV]",
        name: "service",
        alias: "S",
        description: "Mounted service to bind",
        fromEntries: (entries) => Object.fromEntries(entries.map(([name, serviceEnvironment]) => {
          const atIndex = serviceEnvironment.indexOf("@");
          if (atIndex === -1) {
            return [name, serviceEnvironment];
          } else {
            const service = serviceEnvironment.substring(0, atIndex);
            const environment = serviceEnvironment.substring(atIndex + 1);
            return [name, { service, environment }];
          }
        })),
        fromWrangler: ({ services, experimental_services }, configDir, log2) => {
          if (experimental_services) {
            log2.warn("Using the `experimental_services` key is deprecated. This key should be renamed to `services`.");
          }
          const allServices = [];
          if (services)
            allServices.push(...services);
          if (experimental_services)
            allServices.push(...experimental_services);
          return allServices?.reduce((services2, { name, binding, service, environment }) => {
            services2[getServiceBindingName(log2, service, { name, binding })] = {
              service,
              environment
            };
            return services2;
          }, {});
        }
      })
    ], BindingsPlugin.prototype, "serviceBindings", 2);
    var import_assert32 = __toModule(require("assert"));
    var import_child_process3 = __toModule(require("child_process"));
    var import_path32 = __toModule(require("path"));
    var import_shared9 = __toModule(require_src6());
    var BuildError = /* @__PURE__ */ __name(class extends import_shared9.MiniflareError {
    }, "BuildError");
    var BuildPlugin = /* @__PURE__ */ __name(class extends import_shared9.Plugin {
      buildCommand;
      buildBasePath;
      buildWatchPaths;
      constructor(ctx, options29) {
        super(ctx);
        this.assignOptions(options29);
      }
      beforeSetup() {
        const buildCommand = this.buildCommand;
        if (!buildCommand)
          return {};
        return new Promise((resolve19, reject) => {
          const build5 = import_child_process3.default.spawn(buildCommand, {
            cwd: this.buildBasePath ? import_path32.default.resolve(this.ctx.rootPath, this.buildBasePath) : this.ctx.rootPath,
            shell: true,
            stdio: "inherit",
            env: { ...process.env, MINIFLARE: "1" }
          });
          build5.on("exit", (exitCode) => {
            if (exitCode !== 0) {
              const error2 = new BuildError(exitCode ?? 0, `Build failed with exit code ${exitCode}`);
              return reject(error2);
            }
            this.ctx.log.info("Build succeeded");
            const watch6 = this.buildWatchPaths?.map((watchPath) => import_path32.default.resolve(this.ctx.rootPath, watchPath));
            resolve19({ watch: watch6 });
          });
        });
      }
    }, "BuildPlugin");
    __decorateClass([
      (0, import_shared9.Option)({
        type: import_shared9.OptionType.STRING,
        alias: "B",
        description: "Command to build project",
        fromWrangler: ({ build: build5 }) => build5?.command
      })
    ], BuildPlugin.prototype, "buildCommand", 2);
    __decorateClass([
      (0, import_shared9.Option)({
        type: import_shared9.OptionType.STRING,
        description: "Working directory for build command",
        fromWrangler: ({ build: build5 }) => build5?.cwd
      })
    ], BuildPlugin.prototype, "buildBasePath", 2);
    __decorateClass([
      (0, import_shared9.Option)({
        type: import_shared9.OptionType.ARRAY,
        description: "Directory to watch for rebuilding on changes",
        fromWrangler: ({ build: build5, miniflare }) => {
          const watchPaths = miniflare?.build_watch_dirs ?? [];
          if (build5?.watch_dir) {
            watchPaths.push(...Array.isArray(build5.watch_dir) ? build5.watch_dir : [build5.watch_dir]);
          }
          if (watchPaths.length)
            return watchPaths;
          if (build5?.command)
            return ["src"];
        }
      })
    ], BuildPlugin.prototype, "buildWatchPaths", 2);
    function _populateBuildConfig(config, configDir, configEnv) {
      if (config.build || config.type !== "webpack" && config.type !== "rust") {
        return;
      }
      config.build = { cwd: configDir, upload: { dir: "" } };
      (0, import_assert32.default)(config.build.upload);
      const env5 = configEnv ? ` --env ${configEnv}` : "";
      if (config.type === "webpack") {
        let packageDir = "";
        if (config.site) {
          packageDir = config.site["entry-point"] ?? "workers-site";
        }
        config.build.command = `wrangler build${env5}`;
        config.build.upload.main = import_path32.default.join(packageDir, "worker", "script.js");
        config.miniflare ??= {};
        config.miniflare.build_watch_dirs = ["src", "index.js"];
      } else if (config.type === "rust") {
        const rustScript = import_path32.default.join(__dirname, "plugins", "rust.js");
        config.build.command = `wrangler build${env5} && ${process.execPath} ${rustScript}`;
        config.build.upload.main = import_path32.default.join("worker", "generated", "script.js");
        config.wasm_modules ??= {};
        config.wasm_modules.wasm = import_path32.default.join(configDir, "worker", "generated", "script.wasm");
      }
    }
    __name(_populateBuildConfig, "_populateBuildConfig");
    var import_buffer = __toModule(require("buffer"));
    var import_promises22 = __toModule(require("fs/promises"));
    var import_path42 = __toModule(require("path"));
    var import_web5 = __toModule(require("stream/web"));
    var import_web6 = __toModule(require("stream/web"));
    var import_url22 = __toModule(require("url"));
    var import_util22 = __toModule(require("util"));
    var import_shared10 = __toModule(require_src6());
    var import_undici42 = __toModule(require_undici2());
    var import_urlpattern_polyfill = __toModule(require_dist3());
    var assert_exports = {};
    __export2(assert_exports, {
      AssertionError: () => AssertionError,
      deepEqual: () => deepEqual,
      deepStrictEqual: () => deepStrictEqual,
      default: () => assert_default,
      doesNotMatch: () => doesNotMatch,
      doesNotReject: () => doesNotReject,
      doesNotThrow: () => doesNotThrow,
      equal: () => equal,
      fail: () => fail,
      ifError: () => ifError,
      match: () => match,
      notDeepEqual: () => notDeepEqual,
      notDeepStrictEqual: () => notDeepStrictEqual,
      notEqual: () => notEqual,
      notStrictEqual: () => notStrictEqual2,
      ok: () => ok,
      rejects: () => rejects,
      strict: () => strict,
      strictEqual: () => strictEqual2,
      throws: () => throws
    });
    var import_node_assert22 = __toModule(require("node:assert"));
    var assert_default = import_node_assert22.default;
    var AssertionError = import_node_assert22.default.AssertionError;
    var deepEqual = import_node_assert22.default.deepEqual;
    var deepStrictEqual = import_node_assert22.default.deepStrictEqual;
    var doesNotMatch = import_node_assert22.default.doesNotMatch;
    var doesNotReject = import_node_assert22.default.doesNotReject;
    var doesNotThrow = import_node_assert22.default.doesNotThrow;
    var equal = import_node_assert22.default.equal;
    var fail = import_node_assert22.default.fail;
    var ifError = import_node_assert22.default.ifError;
    var match = import_node_assert22.default.match;
    var notDeepEqual = import_node_assert22.default.notDeepEqual;
    var notDeepStrictEqual = import_node_assert22.default.notDeepStrictEqual;
    var notEqual = import_node_assert22.default.notEqual;
    var notStrictEqual2 = import_node_assert22.default.notStrictEqual;
    var ok = import_node_assert22.default.ok;
    var rejects = import_node_assert22.default.rejects;
    var strict = import_node_assert22.default.strict;
    var strictEqual2 = import_node_assert22.default.strictEqual;
    var throws = import_node_assert22.default.throws;
    var async_hooks_exports = {};
    __export2(async_hooks_exports, {
      AsyncLocalStorage: () => import_node_async_hooks.AsyncLocalStorage,
      AsyncResource: () => import_node_async_hooks.AsyncResource,
      default: () => async_hooks_default
    });
    var import_node_async_hooks = __toModule(require("node:async_hooks"));
    var async_hooks_default = {
      AsyncLocalStorage: import_node_async_hooks.AsyncLocalStorage,
      AsyncResource: import_node_async_hooks.AsyncResource
    };
    var buffer_exports = {};
    __export2(buffer_exports, {
      Buffer: () => import_node_buffer6.Buffer,
      SlowBuffer: () => import_node_buffer6.SlowBuffer,
      constants: () => import_node_buffer6.constants,
      default: () => buffer_default,
      kMaxLength: () => import_node_buffer6.kMaxLength,
      kStringMaxLength: () => import_node_buffer6.kStringMaxLength
    });
    var import_node_buffer6 = __toModule(require("node:buffer"));
    var buffer_default = {
      Buffer: import_node_buffer6.Buffer,
      constants: import_node_buffer6.constants,
      kMaxLength: import_node_buffer6.kMaxLength,
      kStringMaxLength: import_node_buffer6.kStringMaxLength,
      SlowBuffer: import_node_buffer6.SlowBuffer
    };
    var events_exports = {};
    __export2(events_exports, {
      EventEmitter: () => EventEmitter7,
      EventEmitterAsyncResource: () => EventEmitterAsyncResource,
      captureRejectionSymbol: () => captureRejectionSymbol,
      default: () => events_default,
      defaultMaxListeners: () => defaultMaxListeners,
      errorMonitor: () => errorMonitor,
      getEventListeners: () => getEventListeners,
      listenerCount: () => listenerCount,
      on: () => on,
      once: () => once,
      setMaxListeners: () => setMaxListeners
    });
    var import_node_events6 = __toModule(require("node:events"));
    var events_default = import_node_events6.default;
    var EventEmitter7 = import_node_events6.default.EventEmitter;
    var EventEmitterAsyncResource = import_node_events6.default.EventEmitterAsyncResource;
    var captureRejectionSymbol = import_node_events6.default.captureRejectionSymbol;
    var defaultMaxListeners = import_node_events6.default.defaultMaxListeners;
    var errorMonitor = import_node_events6.default.errorMonitor;
    var getEventListeners = import_node_events6.default.getEventListeners;
    var listenerCount = import_node_events6.default.listenerCount;
    var on = import_node_events6.default.on;
    var once = import_node_events6.default.once;
    var setMaxListeners = import_node_events6.default.setMaxListeners;
    var util_exports = {};
    __export2(util_exports, {
      _extend: () => import_node_util3._extend,
      callbackify: () => import_node_util3.callbackify,
      default: () => util_default,
      format: () => import_node_util3.format,
      inherits: () => import_node_util3.inherits,
      promisify: () => import_node_util3.promisify,
      types: () => import_node_util3.types
    });
    var import_node_util3 = __toModule(require("node:util"));
    var util_default = {
      types: import_node_util3.types,
      callbackify: import_node_util3.callbackify,
      promisify: import_node_util3.promisify,
      format: import_node_util3.format,
      inherits: import_node_util3.inherits,
      _extend: import_node_util3._extend
    };
    function additionalNodeModules(_experimental) {
      const modules = {
        "node:assert": assert_exports,
        "node:async_hooks": async_hooks_exports,
        "node:buffer": buffer_exports,
        "node:events": events_exports,
        "node:util": util_exports
      };
      return modules;
    }
    __name(additionalNodeModules, "additionalNodeModules");
    var DEFAULT_MODULE_RULES2 = [
      { type: "ESModule", include: ["**/*.mjs"] },
      { type: "CommonJS", include: ["**/*.js", "**/*.cjs"] }
    ];
    function proxyStringFormDataFiles(klass) {
      return new Proxy(klass, {
        construct(target, args, newTarget) {
          const value = Reflect.construct(target, args, newTarget);
          return withStringFormDataFiles(value);
        }
      });
    }
    __name(proxyStringFormDataFiles, "proxyStringFormDataFiles");
    function proxyDisableStreamConstructor(klass) {
      return new Proxy(klass, {
        construct() {
          throw new Error(`To use the new ${klass.name}() constructor, enable the streams_enable_constructors feature flag.`);
        }
      });
    }
    __name(proxyDisableStreamConstructor, "proxyDisableStreamConstructor");
    function mapMountEntries([name, pathEnv], relativeTo) {
      let wranglerConfigEnv;
      const atIndex = pathEnv.lastIndexOf("@");
      if (atIndex !== -1) {
        wranglerConfigEnv = pathEnv.substring(atIndex + 1);
        pathEnv = pathEnv.substring(0, atIndex);
      }
      if (relativeTo)
        pathEnv = import_path42.default.resolve(relativeTo, pathEnv);
      return [
        name,
        {
          rootPath: pathEnv,
          wranglerConfigEnv,
          packagePath: true,
          envPathDefaultFallback: true,
          wranglerConfigPath: true
        }
      ];
    }
    __name(mapMountEntries, "mapMountEntries");
    var CorePlugin = /* @__PURE__ */ __name(class extends import_shared10.Plugin {
      script;
      scriptPath;
      wranglerConfigPath;
      wranglerConfigEnv;
      packagePath;
      modules;
      modulesRules;
      compatibilityDate;
      compatibilityFlags;
      usageModel;
      upstream;
      watch;
      debug;
      verbose;
      updateCheck;
      repl;
      rootPath;
      mounts;
      name;
      routes;
      logUnhandledRejections;
      fetchMock;
      globalAsyncIO;
      globalTimers;
      globalRandom;
      actualTime;
      inaccurateCpu;
      processedModuleRules = [];
      upstreamURL;
      #globals;
      #additionalModules;
      constructor(ctx, options29) {
        super(ctx);
        this.assignOptions(options29);
        if (this.mounts && Object.keys(this.mounts).length) {
          ctx.log.warn("Mounts are experimental. There may be breaking changes in the future.");
        }
        const nodejsCompat = ctx.compat.isEnabled("nodejs_compat");
        if (nodejsCompat) {
          const experimental2 = ctx.compat.isEnabled("experimental");
          this.#additionalModules = additionalNodeModules(experimental2);
        }
        const extraGlobals = {};
        let CompatRequest = Request3;
        let CompatResponse = Response9;
        if (!ctx.compat.isEnabled("formdata_parser_supports_files")) {
          CompatRequest = proxyStringFormDataFiles(Request3);
          CompatResponse = proxyStringFormDataFiles(Response9);
        }
        if (ctx.compat.isEnabled("global_navigator")) {
          extraGlobals.navigator = new Navigator();
          extraGlobals.Navigator = Navigator;
        }
        const enableStreamConstructors = ctx.compat.isEnabled("streams_enable_constructors");
        const enableTransformStreamConstructor = ctx.compat.isEnabled("transformstream_enable_standard_constructor");
        let CompatReadableStream = import_web5.ReadableStream;
        let CompatWritableStream = import_web5.WritableStream;
        let CompatTransformStream = import_web5.TransformStream;
        if (!enableStreamConstructors) {
          CompatReadableStream = proxyDisableStreamConstructor(import_web5.ReadableStream);
          CompatWritableStream = proxyDisableStreamConstructor(import_web5.WritableStream);
          if (enableTransformStreamConstructor) {
            CompatTransformStream = proxyDisableStreamConstructor(import_web5.TransformStream);
          }
        }
        if (!enableTransformStreamConstructor) {
          CompatTransformStream = new Proxy(IdentityTransformStream, {
            construct(target, args, newTarget) {
              if (args.length > 0) {
                ctx.log.warn("To use the new TransformStream() constructor with a custom transformer, enable the transformstream_enable_standard_constructor feature flag.");
              }
              return Reflect.construct(target, args, newTarget);
            }
          });
        }
        if (enableStreamConstructors) {
          extraGlobals.ReadableByteStreamController = import_web5.ReadableByteStreamController;
          extraGlobals.ReadableStreamBYOBRequest = import_web5.ReadableStreamBYOBRequest;
          extraGlobals.ReadableStreamDefaultController = import_web5.ReadableStreamDefaultController;
          extraGlobals.WritableStreamDefaultController = import_web5.WritableStreamDefaultController;
          if (enableTransformStreamConstructor) {
            extraGlobals.TransformStreamDefaultController = import_web5.TransformStreamDefaultController;
          }
        }
        try {
          this.upstreamURL = this.upstream === void 0 ? void 0 : new import_url22.URL(this.upstream);
        } catch (e3) {
          throw new MiniflareCoreError("ERR_INVALID_UPSTREAM", `Invalid upstream URL: "${this.upstream}". Make sure you've included the protocol.`);
        }
        const blockGlobalTimers = !this.globalTimers;
        const crypto5 = createCrypto(!this.globalRandom);
        const CompressionStreamImpl = import_web6.default.CompressionStream ?? CompressionStream;
        const DecompressionStreamImpl = import_web6.default.DecompressionStream ?? DecompressionStream;
        if (this.inaccurateCpu) {
          ctx.log.warn("CPU time measurements are experimental, highly inaccurate and not representative of deployed worker performance.\nThey should only be used for relative comparisons and may be removed in the future.");
        }
        this.#globals = {
          console,
          setTimeout: createTimer(setTimeout, blockGlobalTimers),
          setInterval: createTimer(setInterval, blockGlobalTimers),
          clearTimeout: assertsInRequest(clearTimeout, blockGlobalTimers),
          clearInterval: assertsInRequest(clearInterval, blockGlobalTimers),
          queueMicrotask,
          scheduler: new Scheduler(blockGlobalTimers),
          atob: atob2,
          btoa: btoa2,
          Math,
          crypto: crypto5,
          CryptoKey,
          TextDecoder: import_util22.TextDecoder,
          TextEncoder: import_util22.TextEncoder,
          fetch: createCompatFetch(ctx, fetch15.bind(this.fetchMock)),
          Headers: import_undici42.Headers,
          Request: CompatRequest,
          Response: CompatResponse,
          FormData: import_undici42.FormData,
          Blob: import_buffer.Blob,
          File: import_undici42.File,
          URL: import_url22.URL,
          URLSearchParams: import_url22.URLSearchParams,
          URLPattern: import_urlpattern_polyfill.URLPattern,
          ReadableStream: CompatReadableStream,
          WritableStream: CompatWritableStream,
          TransformStream: CompatTransformStream,
          ReadableStreamBYOBReader: import_web5.ReadableStreamBYOBReader,
          ReadableStreamDefaultReader: import_web5.ReadableStreamDefaultReader,
          WritableStreamDefaultWriter: import_web5.WritableStreamDefaultWriter,
          ByteLengthQueuingStrategy: import_web5.ByteLengthQueuingStrategy,
          CountQueuingStrategy: import_web5.CountQueuingStrategy,
          IdentityTransformStream,
          FixedLengthStream,
          CompressionStream: CompressionStreamImpl,
          DecompressionStream: DecompressionStreamImpl,
          TextEncoderStream: import_web5.TextEncoderStream,
          TextDecoderStream: import_web5.TextDecoderStream,
          Event,
          EventTarget,
          AbortController,
          AbortSignal: AbortSignal2,
          FetchEvent,
          ScheduledEvent,
          DOMException: DOMException2,
          WorkerGlobalScope,
          structuredClone: globalThis.structuredClone ?? import_shared10.structuredCloneImpl,
          Date: createDate2(this.actualTime),
          ...extraGlobals,
          ArrayBuffer,
          Atomics,
          BigInt64Array,
          BigUint64Array,
          DataView,
          Float32Array,
          Float64Array,
          Int8Array,
          Int16Array,
          Int32Array,
          Map,
          Set,
          SharedArrayBuffer,
          Uint8Array,
          Uint8ClampedArray,
          Uint16Array,
          Uint32Array,
          WeakMap,
          WeakSet,
          WebAssembly,
          MINIFLARE: true
        };
        if (!this.modules)
          return;
        const finalisedTypes = /* @__PURE__ */ new Set();
        for (const rule of [
          ...this.modulesRules ?? [],
          ...DEFAULT_MODULE_RULES2
        ]) {
          if (finalisedTypes.has(rule.type))
            continue;
          this.processedModuleRules.push({
            type: rule.type,
            include: (0, import_shared10.globsToMatcher)(rule.include)
          });
          if (!rule.fallthrough)
            finalisedTypes.add(rule.type);
        }
      }
      async setup() {
        const globals = this.#globals;
        const additionalModules = this.#additionalModules;
        if (this.script !== void 0) {
          return {
            globals,
            additionalModules,
            script: {
              filePath: this.scriptPath ?? import_shared10.STRING_SCRIPT_PATH,
              code: this.script
            }
          };
        }
        const watch6 = [];
        let scriptPath3 = this.scriptPath;
        if (scriptPath3 === void 0) {
          let packagePath = this.packagePath === true ? "package.json" : this.packagePath;
          if (packagePath) {
            packagePath = import_path42.default.resolve(this.ctx.rootPath, packagePath);
            try {
              const pkg = JSON.parse(await import_promises22.default.readFile(packagePath, "utf8"));
              scriptPath3 = this.modules ? pkg.module : pkg.main;
              scriptPath3 &&= import_path42.default.resolve(import_path42.default.dirname(packagePath), scriptPath3);
            } catch (e3) {
              if (!(e3.code === "ENOENT" && this.packagePath === true))
                throw e3;
            }
            watch6.push(packagePath);
          }
        }
        if (scriptPath3 !== void 0) {
          scriptPath3 = import_path42.default.resolve(this.ctx.rootPath, scriptPath3);
          const code = await import_promises22.default.readFile(scriptPath3, "utf8");
          watch6.push(scriptPath3);
          return {
            globals,
            additionalModules,
            script: { filePath: scriptPath3, code },
            watch: watch6
          };
        }
        return { globals, additionalModules, watch: watch6 };
      }
    }, "CorePlugin");
    __decorateClass([
      (0, import_shared10.Option)({ type: import_shared10.OptionType.NONE, logValue: () => import_shared10.STRING_SCRIPT_PATH })
    ], CorePlugin.prototype, "script", 2);
    __decorateClass([
      (0, import_shared10.Option)({
        type: import_shared10.OptionType.STRING_POSITIONAL,
        name: "script",
        fromWrangler: ({ build: build5 }, configDir) => build5?.upload?.main ? import_path42.default.resolve(configDir, build5?.upload?.dir ?? "dist", build5.upload.main) : void 0
      })
    ], CorePlugin.prototype, "scriptPath", 2);
    __decorateClass([
      (0, import_shared10.Option)({
        type: import_shared10.OptionType.STRING,
        name: "wrangler-config",
        alias: "c",
        description: "Path to wrangler.toml",
        logValue(value) {
          if (value === true)
            return "wrangler.toml";
          if (value === false)
            return void 0;
          return import_path42.default.relative("", value);
        }
      })
    ], CorePlugin.prototype, "wranglerConfigPath", 2);
    __decorateClass([
      (0, import_shared10.Option)({
        type: import_shared10.OptionType.STRING,
        name: "wrangler-env",
        description: "Environment in wrangler.toml to use",
        logName: "Wrangler Environment"
      })
    ], CorePlugin.prototype, "wranglerConfigEnv", 2);
    __decorateClass([
      (0, import_shared10.Option)({
        type: import_shared10.OptionType.STRING,
        name: "package",
        description: "Path to package.json",
        logValue(value) {
          if (value === true)
            return "package.json";
          if (value === false)
            return void 0;
          return import_path42.default.relative("", value);
        }
      })
    ], CorePlugin.prototype, "packagePath", 2);
    __decorateClass([
      (0, import_shared10.Option)({
        type: import_shared10.OptionType.BOOLEAN,
        alias: "m",
        description: "Enable modules",
        fromWrangler: ({ build: build5 }) => build5?.upload?.format && build5.upload.format === "modules"
      })
    ], CorePlugin.prototype, "modules", 2);
    __decorateClass([
      (0, import_shared10.Option)({
        type: import_shared10.OptionType.OBJECT,
        typeFormat: "TYPE=GLOB",
        description: "Modules import rule",
        logValue: (value) => value.map((rule) => `{${rule.type}: ${rule.include.join(", ")}}`).join(", "),
        fromEntries: (entries) => entries.map(([type, include]) => ({
          type,
          include: [include],
          fallthrough: true
        })),
        fromWrangler: ({ build: build5 }) => build5?.upload?.rules?.map(({ type, globs, fallthrough }) => ({
          type,
          include: globs,
          fallthrough
        }))
      })
    ], CorePlugin.prototype, "modulesRules", 2);
    __decorateClass([
      (0, import_shared10.Option)({
        type: import_shared10.OptionType.STRING,
        name: "compat-date",
        description: "Opt into backwards-incompatible changes from",
        fromWrangler: ({ compatibility_date }) => compatibility_date
      })
    ], CorePlugin.prototype, "compatibilityDate", 2);
    __decorateClass([
      (0, import_shared10.Option)({
        type: import_shared10.OptionType.ARRAY,
        name: "compat-flag",
        description: "Control specific backwards-incompatible changes",
        fromWrangler: ({ compatibility_flags }) => compatibility_flags
      })
    ], CorePlugin.prototype, "compatibilityFlags", 2);
    __decorateClass([
      (0, import_shared10.Option)({
        type: import_shared10.OptionType.STRING,
        name: "usage-model",
        description: "Usage model (bundled by default)",
        fromWrangler: ({ usage_model }) => usage_model
      })
    ], CorePlugin.prototype, "usageModel", 2);
    __decorateClass([
      (0, import_shared10.Option)({
        type: import_shared10.OptionType.STRING,
        alias: "u",
        description: "URL of upstream origin",
        fromWrangler: ({ miniflare }) => miniflare?.upstream
      })
    ], CorePlugin.prototype, "upstream", 2);
    __decorateClass([
      (0, import_shared10.Option)({
        type: import_shared10.OptionType.BOOLEAN,
        alias: "w",
        description: "Watch files for changes",
        fromWrangler: ({ miniflare }) => {
          if (miniflare?.watch !== void 0)
            return miniflare.watch;
          if (miniflare?.live_reload)
            return true;
        }
      })
    ], CorePlugin.prototype, "watch", 2);
    __decorateClass([
      (0, import_shared10.Option)({
        type: import_shared10.OptionType.BOOLEAN,
        alias: "d",
        description: "Enable debug logging"
      })
    ], CorePlugin.prototype, "debug", 2);
    __decorateClass([
      (0, import_shared10.Option)({
        type: import_shared10.OptionType.BOOLEAN,
        alias: "V",
        description: "Enable verbose logging"
      })
    ], CorePlugin.prototype, "verbose", 2);
    __decorateClass([
      (0, import_shared10.Option)({
        type: import_shared10.OptionType.BOOLEAN,
        description: "Enable update checker (enabled by default)",
        negatable: true,
        fromWrangler: ({ miniflare }) => miniflare?.update_check
      })
    ], CorePlugin.prototype, "updateCheck", 2);
    __decorateClass([
      (0, import_shared10.Option)({
        type: import_shared10.OptionType.BOOLEAN,
        logName: "REPL",
        description: "Enable interactive REPL"
      })
    ], CorePlugin.prototype, "repl", 2);
    __decorateClass([
      (0, import_shared10.Option)({
        type: import_shared10.OptionType.STRING,
        name: "root",
        description: "Path to resolve files relative to"
      })
    ], CorePlugin.prototype, "rootPath", 2);
    __decorateClass([
      (0, import_shared10.Option)({
        type: import_shared10.OptionType.OBJECT,
        typeFormat: "NAME=PATH[@ENV]",
        description: "Mount additional named workers",
        fromEntries: (entries) => Object.fromEntries(entries.map((entry) => mapMountEntries(entry))),
        fromWrangler: ({ miniflare }, configDir) => miniflare?.mounts && Object.fromEntries(Object.entries(miniflare.mounts).map((entry) => mapMountEntries(entry, configDir)))
      })
    ], CorePlugin.prototype, "mounts", 2);
    __decorateClass([
      (0, import_shared10.Option)({
        type: import_shared10.OptionType.STRING,
        description: "Name of service",
        fromWrangler: ({ name }) => name
      })
    ], CorePlugin.prototype, "name", 2);
    __decorateClass([
      (0, import_shared10.Option)({
        type: import_shared10.OptionType.ARRAY,
        description: "Route to respond with this worker on",
        fromWrangler: ({ route: route2, routes, miniflare }) => {
          const result = [];
          const toPattern = /* @__PURE__ */ __name((route22) => typeof route22 === "string" ? route22 : route22.pattern, "toPattern");
          if (route2)
            result.push(route2);
          if (routes)
            result.push(...routes);
          if (miniflare?.route)
            result.push(miniflare.route);
          if (miniflare?.routes)
            result.push(...miniflare.routes);
          return result.length ? result.map(toPattern) : void 0;
        }
      })
    ], CorePlugin.prototype, "routes", 2);
    __decorateClass([
      (0, import_shared10.Option)({ type: import_shared10.OptionType.NONE })
    ], CorePlugin.prototype, "logUnhandledRejections", 2);
    __decorateClass([
      (0, import_shared10.Option)({ type: import_shared10.OptionType.NONE })
    ], CorePlugin.prototype, "fetchMock", 2);
    __decorateClass([
      (0, import_shared10.Option)({
        type: import_shared10.OptionType.BOOLEAN,
        name: "global-async-io",
        description: "Allow async I/O outside handlers",
        logName: "Allow Global Async I/O",
        fromWrangler: ({ miniflare }) => miniflare?.global_async_io
      })
    ], CorePlugin.prototype, "globalAsyncIO", 2);
    __decorateClass([
      (0, import_shared10.Option)({
        type: import_shared10.OptionType.BOOLEAN,
        description: "Allow setting timers outside handlers",
        logName: "Allow Global Timers",
        fromWrangler: ({ miniflare }) => miniflare?.global_timers
      })
    ], CorePlugin.prototype, "globalTimers", 2);
    __decorateClass([
      (0, import_shared10.Option)({
        type: import_shared10.OptionType.BOOLEAN,
        description: "Allow secure random generation outside handlers",
        logName: "Allow Global Secure Random",
        fromWrangler: ({ miniflare }) => miniflare?.global_random
      })
    ], CorePlugin.prototype, "globalRandom", 2);
    __decorateClass([
      (0, import_shared10.Option)({
        type: import_shared10.OptionType.BOOLEAN,
        description: "Always return correct time from Date methods",
        fromWrangler: ({ miniflare }) => miniflare?.actual_time
      })
    ], CorePlugin.prototype, "actualTime", 2);
    __decorateClass([
      (0, import_shared10.Option)({
        type: import_shared10.OptionType.BOOLEAN,
        description: "Log inaccurate CPU time measurements",
        logName: "Inaccurate CPU Time Measurements",
        fromWrangler: ({ miniflare }) => miniflare?.inaccurate_cpu
      })
    ], CorePlugin.prototype, "inaccurateCpu", 2);
    var import_url32 = __toModule(require("url"));
    var import_shared11 = __toModule(require_src6());
    var RouterError = /* @__PURE__ */ __name(class extends import_shared11.MiniflareError {
    }, "RouterError");
    var A_MORE_SPECIFIC = -1;
    var B_MORE_SPECIFIC = 1;
    var Router = /* @__PURE__ */ __name(class {
      routes = [];
      update(allRoutes) {
        const newRoutes = [];
        for (const [target, routes] of allRoutes) {
          for (const route2 of routes) {
            const hasProtocol = /^[a-z0-9+\-.]+:\/\//i.test(route2);
            let urlInput = route2;
            if (!hasProtocol)
              urlInput = `https://${urlInput}`;
            const url4 = new import_url32.URL(urlInput);
            const protocol = hasProtocol ? url4.protocol : void 0;
            const internationalisedAllowHostnamePrefix = url4.hostname.startsWith("xn--*");
            const allowHostnamePrefix = url4.hostname.startsWith("*") || internationalisedAllowHostnamePrefix;
            const anyHostname = url4.hostname === "*";
            if (allowHostnamePrefix && !anyHostname) {
              let hostname2 = url4.hostname;
              if (internationalisedAllowHostnamePrefix) {
                hostname2 = (0, import_url32.domainToUnicode)(hostname2);
              }
              url4.hostname = hostname2.substring(1);
            }
            const allowPathSuffix = url4.pathname.endsWith("*");
            if (allowPathSuffix) {
              url4.pathname = url4.pathname.substring(0, url4.pathname.length - 1);
            }
            if (url4.search) {
              throw new RouterError("ERR_QUERY_STRING", `Route "${route2}" for "${target}" contains a query string. This is not allowed.`);
            }
            if (url4.toString().includes("*") && !anyHostname) {
              throw new RouterError("ERR_INFIX_WILDCARD", `Route "${route2}" for "${target}" contains an infix wildcard. This is not allowed.`);
            }
            newRoutes.push({
              target,
              route: route2,
              protocol,
              allowHostnamePrefix,
              hostname: anyHostname ? "" : url4.hostname,
              path: url4.pathname,
              allowPathSuffix
            });
          }
        }
        newRoutes.sort((a, b2) => {
          const aHasProtocol = a.protocol !== void 0;
          const bHasProtocol = b2.protocol !== void 0;
          if (aHasProtocol && !bHasProtocol)
            return A_MORE_SPECIFIC;
          if (!aHasProtocol && bHasProtocol)
            return B_MORE_SPECIFIC;
          if (!a.allowHostnamePrefix && b2.allowHostnamePrefix)
            return A_MORE_SPECIFIC;
          if (a.allowHostnamePrefix && !b2.allowHostnamePrefix)
            return B_MORE_SPECIFIC;
          if (!a.allowPathSuffix && b2.allowPathSuffix)
            return A_MORE_SPECIFIC;
          if (a.allowPathSuffix && !b2.allowPathSuffix)
            return B_MORE_SPECIFIC;
          const aPathSegments = a.path.split("/");
          const bPathSegments = b2.path.split("/");
          const aLastSegmentEmpty = aPathSegments[aPathSegments.length - 1] === "";
          const bLastSegmentEmpty = bPathSegments[bPathSegments.length - 1] === "";
          if (aLastSegmentEmpty && !bLastSegmentEmpty)
            return B_MORE_SPECIFIC;
          if (!aLastSegmentEmpty && bLastSegmentEmpty)
            return A_MORE_SPECIFIC;
          if (aPathSegments.length !== bPathSegments.length)
            return bPathSegments.length - aPathSegments.length;
          if (a.path.length !== b2.path.length)
            return b2.path.length - a.path.length;
          return b2.hostname.length - a.hostname.length;
        });
        this.routes = newRoutes;
      }
      match(url4) {
        for (const route2 of this.routes) {
          if (route2.protocol && route2.protocol !== url4.protocol)
            continue;
          if (route2.allowHostnamePrefix) {
            if (!url4.hostname.endsWith(route2.hostname))
              continue;
          } else {
            if (url4.hostname !== route2.hostname)
              continue;
          }
          const path72 = url4.pathname + url4.search;
          if (route2.allowPathSuffix) {
            if (!path72.startsWith(route2.path))
              continue;
          } else {
            if (path72 !== route2.path)
              continue;
          }
          return route2.target;
        }
        return null;
      }
    }, "Router");
    var import_path52 = __toModule(require("path"));
    var PluginStorageFactory = /* @__PURE__ */ __name(class {
      constructor(inner, pluginName, defaultPersistRoot = ".mf") {
        this.inner = inner;
        this.defaultPersistRoot = defaultPersistRoot;
        this.pluginName = pluginName.substring(0, pluginName.length - 6).toLowerCase();
      }
      pluginName;
      storage(namespace, persist) {
        if (persist === void 0 || persist === false) {
          return this.inner.storage(`${this.pluginName}:` + namespace);
        } else if (persist === true) {
          return this.inner.storage(namespace, import_path52.default.join(this.defaultPersistRoot, this.pluginName));
        } else {
          return this.inner.storage(namespace, persist);
        }
      }
      dispose() {
        return this.inner.dispose?.();
      }
    }, "PluginStorageFactory");
    function _deepEqual(a, b2) {
      if (!dequal(a, b2))
        return false;
      if (typeof a === "object") {
        const aSymbols = Object.getOwnPropertySymbols(a);
        for (const aSymbol of aSymbols) {
          if (!(aSymbol in b2) || !dequal(a[aSymbol], b2[aSymbol]))
            return false;
        }
        return aSymbols.length === Object.getOwnPropertySymbols(b2).length;
      }
      return true;
    }
    __name(_deepEqual, "_deepEqual");
    function getPluginEntries(plugins) {
      const entries = Object.entries(plugins);
      let coreIndex = -1;
      let bindingsIndex = -1;
      for (let i = 0; i < entries.length; i++) {
        const [, plugin] = entries[i];
        if (plugin === CorePlugin)
          coreIndex = i;
        else if (plugin === BindingsPlugin)
          bindingsIndex = i;
      }
      if (coreIndex > 0) {
        entries.unshift(...entries.splice(coreIndex, 1));
      }
      if (bindingsIndex !== -1 && bindingsIndex !== entries.length - 1) {
        entries.push(...entries.splice(bindingsIndex, 1));
      }
      return entries;
    }
    __name(getPluginEntries, "getPluginEntries");
    function splitPluginOptions(plugins, options29) {
      const result = {};
      for (const [name, plugin] of plugins) {
        const pluginResult = {};
        for (const key of plugin.prototype.opts?.keys() ?? []) {
          if (key in options29) {
            pluginResult[key] = options29[key];
          }
        }
        result[name] = pluginResult;
      }
      return result;
    }
    __name(splitPluginOptions, "splitPluginOptions");
    function splitWranglerConfig(plugins, overrides, config, configDir, log2) {
      const result = {};
      for (const [name, plugin] of plugins) {
        const pluginResult = {};
        const pluginOverrides = overrides[name];
        for (const [key, meta] of plugin.prototype.opts?.entries() ?? []) {
          if (key in pluginOverrides) {
            pluginResult[key] = pluginOverrides[key];
          } else {
            pluginResult[key] = meta.fromWrangler?.(config, configDir, log2);
          }
        }
        result[name] = pluginResult;
      }
      return result;
    }
    __name(splitWranglerConfig, "splitWranglerConfig");
    var pathResolve = /* @__PURE__ */ __name((p2) => import_path62.default.resolve(p2), "pathResolve");
    function throwNoScriptError(modules) {
      const execName = process.env.MINIFLARE_EXEC_NAME ?? "miniflare";
      const script = modules ? "worker.mjs" : "worker.js";
      const format22 = modules ? "modules" : "service-worker";
      const pkgScriptField = modules ? "module" : "main";
      const lines = [
        "No script defined, either:",
        "- Pass it as a positional argument, if you're using the CLI",
        (0, import_colors22.dim)(`    $ ${execName} dist/${script}`),
        "- Set the script or scriptPath option, if you're using the API",
        (0, import_colors22.dim)(`    new Miniflare({ scriptPath: "dist/${script}" })`),
        `- Set ${pkgScriptField} in package.json`,
        (0, import_colors22.dim)(`    { "${pkgScriptField}": "dist/${script}" }`)
      ];
      if (modules) {
        lines.push("- Set build.upload.main in wrangler.toml", (0, import_colors22.dim)("    [build.upload]"), (0, import_colors22.dim)(`    format = "${format22}"`), (0, import_colors22.dim)(`    dir = "dist"`), (0, import_colors22.dim)(`    main = "${script}"`));
      }
      lines.push("");
      throw new MiniflareCoreError("ERR_NO_SCRIPT", lines.join("\n"));
    }
    __name(throwNoScriptError, "throwNoScriptError");
    var kParentSharedCache = Symbol("kParentSharedCache");
    var ReloadEvent = /* @__PURE__ */ __name(class extends Event {
      plugins;
      initial;
      constructor(type, init3) {
        super(type);
        this.plugins = init3.plugins;
        this.initial = init3.initial;
      }
    }, "ReloadEvent");
    var MiniflareCore = /* @__PURE__ */ __name(class extends import_shared12.TypedEventTarget {
      #originalPlugins;
      #plugins;
      #previousSetOptions;
      #overrides;
      #previousOptions;
      #sharedCache;
      #ctx;
      #pluginStorages;
      #compat;
      #previousRootPath;
      #previousUsageModel;
      #previousGlobalAsyncIO;
      #instances;
      #mounts;
      #router;
      #wranglerConfigPath;
      #watching;
      #beforeSetupWatch;
      #setupWatch;
      #setupResults;
      #scriptWatchPaths = /* @__PURE__ */ new Set();
      #reloaded = false;
      #globalScope;
      #bindings;
      #moduleExports;
      #watcher;
      #watcherCallbackMutex;
      #previousWatchPaths;
      #previousFetchMock;
      constructor(plugins, ctx, options29 = {}) {
        super();
        this.#originalPlugins = plugins;
        this.#plugins = getPluginEntries(plugins);
        this.#previousSetOptions = options29;
        this.#overrides = splitPluginOptions(this.#plugins, options29);
        this.#sharedCache = ctx[kParentSharedCache] ?? /* @__PURE__ */ new Map();
        this.#ctx = ctx;
        this.#pluginStorages = /* @__PURE__ */ new Map();
        this.#initPromise = this.#init().then(() => this.#reload());
      }
      get #isMount() {
        return this.#ctx[kParentSharedCache] !== void 0;
      }
      #updateWatch(data, name, result) {
        if (this.#watching && result?.watch) {
          const resolved = result.watch.map(pathResolve);
          data.set(name, new Set(resolved));
        } else {
          data.delete(name);
        }
      }
      async #runBeforeSetup(name) {
        const instance = this.#instances[name];
        if (!instance.beforeSetup)
          return false;
        this.#ctx.log.verbose(`- beforeSetup(${name})`);
        const result = await instance.beforeSetup();
        this.#updateWatch(this.#beforeSetupWatch, name, result);
        return true;
      }
      async #runSetup(name) {
        const instance = this.#instances[name];
        if (!instance.setup)
          return false;
        this.#ctx.log.verbose(`- setup(${name})`);
        const result = await instance.setup(this.getPluginStorage(name));
        this.#updateWatch(this.#setupWatch, name, result);
        this.#setupResults.set(name, result ?? {});
        return true;
      }
      #initPromise;
      async #init(reloadAll = false) {
        this.#ctx.log.debug("Initialising worker...");
        const previous = this.#previousOptions;
        let options29 = this.#overrides;
        const rootPath = options29.CorePlugin.rootPath ?? process.cwd();
        const originalConfigPath = options29.CorePlugin.wranglerConfigPath;
        const configEnv = options29.CorePlugin.wranglerConfigEnv;
        let configPath = originalConfigPath === true ? "wrangler.toml" : originalConfigPath;
        if (configPath) {
          configPath = import_path62.default.resolve(rootPath, configPath);
          this.#wranglerConfigPath = configPath;
          try {
            const configData = await import_promises32.default.readFile(configPath, "utf8");
            const toml = require_toml2();
            const config = toml.parse(configData);
            if (configEnv && config.env && configEnv in config.env) {
              Object.assign(config, config.env[configEnv]);
            }
            const configDir = import_path62.default.dirname(configPath);
            _populateBuildConfig(config, configDir, configEnv);
            options29 = splitWranglerConfig(this.#plugins, this.#overrides, config, configDir, this.#ctx.log);
          } catch (e3) {
            if (!(e3.code === "ENOENT" && originalConfigPath === true)) {
              throw e3;
            }
          }
        }
        this.#watching ??= options29.CorePlugin.watch ?? false;
        const {
          compatibilityDate,
          compatibilityFlags,
          usageModel,
          globalAsyncIO,
          fetchMock
        } = options29.CorePlugin;
        let ctxUpdate = this.#previousRootPath && this.#previousRootPath !== rootPath || this.#previousUsageModel !== usageModel || this.#previousGlobalAsyncIO !== globalAsyncIO || this.#previousFetchMock !== fetchMock || reloadAll;
        this.#previousRootPath = rootPath;
        if (this.#compat) {
          if (this.#compat.update(compatibilityDate, compatibilityFlags)) {
            ctxUpdate = true;
          }
        } else {
          this.#compat = new import_shared12.Compatibility(compatibilityDate, compatibilityFlags);
        }
        const queueBroker = this.#ctx.queueBroker;
        const queueEventDispatcher = /* @__PURE__ */ __name(async (batch) => {
          await this.dispatchQueue(batch);
          this.#ctx.log.info(`${batch.queue} (${batch.messages.length} Messages) OK`);
        }, "queueEventDispatcher");
        const ctx = {
          log: this.#ctx.log,
          compat: this.#compat,
          rootPath,
          usageModel,
          globalAsyncIO,
          fetchMock,
          queueEventDispatcher,
          queueBroker,
          sharedCache: this.#sharedCache
        };
        (0, import_shared12.logOptions)(this.#plugins, this.#ctx.log, options29);
        const enabled = this.#compat.enabled;
        this.#ctx.log.debug(`Enabled Compatibility Flags:${enabled.length === 0 ? " <none>" : ""}`);
        for (const flag of enabled)
          this.#ctx.log.debug(`- ${flag}`);
        this.#instances ??= {};
        this.#beforeSetupWatch ??= /* @__PURE__ */ new Map();
        let ranBeforeSetup = false;
        for (const [name, plugin] of this.#plugins) {
          if (previous !== void 0 && !ctxUpdate && _deepEqual(previous[name], options29[name])) {
            continue;
          }
          const existingInstance = this.#instances[name];
          if (existingInstance?.dispose) {
            this.#ctx.log.verbose(`- dispose(${name})`);
            await existingInstance.dispose();
          }
          const instance = new plugin(ctx, options29[name]);
          this.#instances[name] = instance;
          if (await this.#runBeforeSetup(name))
            ranBeforeSetup = true;
        }
        this.#setupWatch ??= /* @__PURE__ */ new Map();
        this.#setupResults ??= /* @__PURE__ */ new Map();
        for (const [name] of this.#plugins) {
          if (previous !== void 0 && !ctxUpdate && _deepEqual(previous[name], options29[name]) && !(ranBeforeSetup && this.#setupResults.get(name)?.script)) {
            continue;
          }
          await this.#runSetup(name);
        }
        this.#previousOptions = options29;
        this.#mounts ??= /* @__PURE__ */ new Map();
        const mounts = options29.CorePlugin.mounts;
        if (mounts) {
          const defaultMountOptions = { watch: this.#watching || void 0 };
          const kvPersist = (0, import_shared12.resolveStoragePersist)(rootPath, options29.KVPlugin?.kvPersist);
          const cachePersist = (0, import_shared12.resolveStoragePersist)(rootPath, options29.CachePlugin?.cachePersist);
          const durableObjectsPersist = (0, import_shared12.resolveStoragePersist)(rootPath, options29.DurableObjectsPlugin?.durableObjectsPersist);
          if (kvPersist !== void 0) {
            defaultMountOptions.kvPersist = kvPersist;
          }
          if (cachePersist !== void 0) {
            defaultMountOptions.cachePersist = cachePersist;
          }
          if (durableObjectsPersist !== void 0) {
            defaultMountOptions.durableObjectsPersist = durableObjectsPersist;
          }
          for (const [name, rawOptions] of Object.entries(mounts)) {
            if (name === "") {
              throw new MiniflareCoreError("ERR_MOUNT_NO_NAME", "Mount name cannot be empty");
            }
            const mountOptions = typeof rawOptions === "string" ? {
              ...defaultMountOptions,
              rootPath: rawOptions,
              packagePath: true,
              envPathDefaultFallback: true,
              wranglerConfigPath: true
            } : {
              ...defaultMountOptions,
              ...rawOptions
            };
            if ("mounts" in mountOptions || this.#isMount) {
              throw new MiniflareCoreError("ERR_MOUNT_NESTED", "Nested mounts are unsupported");
            }
            let mount = this.#mounts.get(name);
            if (mount) {
              this.#ctx.log.verbose(`Updating mount "${name}"...`);
              await mount.setOptions(mountOptions, false);
            } else {
              this.#ctx.log.debug(`Mounting "${name}"...`);
              let log2 = this.#ctx.log;
              if (Object.getPrototypeOf(this.#ctx.log) === import_shared12.Log.prototype) {
                log2 = new import_shared12.Log(this.#ctx.log.level, { suffix: name });
              }
              const ctx2 = {
                ...this.#ctx,
                log: log2,
                scriptRunForModuleExports: false,
                [kParentSharedCache]: this.#sharedCache
              };
              mount = new MiniflareCore(this.#originalPlugins, ctx2, mountOptions);
              mount.addEventListener("reload", async (event) => {
                if (!event.initial) {
                  try {
                    await this.#updateRouter();
                    await this.#reload();
                  } catch (e3) {
                    this.#ctx.log.error(e3);
                  }
                }
              });
              try {
                await mount.getPlugins();
              } catch (e3) {
                throw new MiniflareCoreError("ERR_MOUNT", `Error mounting "${name}"`, e3);
              }
              this.#mounts.set(name, mount);
            }
          }
        }
        for (const [name, mount] of [...this.#mounts]) {
          if (mounts === void 0 || !(name in mounts)) {
            this.#ctx.log.debug(`Unmounting "${name}"...`);
            await mount.dispose();
            this.#mounts.delete(name);
          }
        }
        await this.#updateRouter();
        if (this.#ctx.scriptRequired && !this.#setupResults.get("CorePlugin")?.script && this.#mounts.size === 0) {
          throwNoScriptError(options29.CorePlugin.modules);
        }
      }
      async #updateRouter() {
        const allRoutes = /* @__PURE__ */ new Map();
        const { CorePlugin: CorePlugin2 } = this.#instances;
        if (CorePlugin2.name) {
          const routes = CorePlugin2.routes;
          if (routes)
            allRoutes.set(CorePlugin2.name, routes);
        }
        for (const [name, mount] of this.#mounts) {
          const { CorePlugin: CorePlugin3 } = await mount.getPlugins();
          if (CorePlugin3.name !== void 0 && CorePlugin3.name !== name) {
            throw new MiniflareCoreError("ERR_MOUNT_NAME_MISMATCH", `Mounted name "${name}" must match service name "${CorePlugin3.name}"`);
          }
          const routes = CorePlugin3.routes;
          if (routes)
            allRoutes.set(name, routes);
        }
        this.#router ??= new Router();
        this.#router.update(allRoutes);
        if (this.#mounts.size) {
          this.#ctx.log.debug(`Mount Routes:${this.#router.routes.length === 0 ? " <none>" : ""}`);
          for (let i = 0; i < this.#router.routes.length; i++) {
            const route2 = this.#router.routes[i];
            this.#ctx.log.debug(`${i + 1}. ${route2.route} => ${route2.target}`);
          }
        }
      }
      async #runAllBeforeReloads() {
        for (const [name] of this.#plugins) {
          const instance = this.#instances[name];
          if (instance.beforeReload) {
            this.#ctx.log.verbose(`- beforeReload(${name})`);
            await instance.beforeReload();
          }
        }
      }
      async #runAllReloads(mounts) {
        const bindings = this.#bindings;
        const exports3 = this.#moduleExports;
        for (const [name] of this.#plugins) {
          const instance = this.#instances[name];
          if (instance.reload) {
            this.#ctx.log.verbose(`- reload(${name})`);
            await instance.reload(bindings ?? {}, exports3 ?? {}, mounts);
          }
        }
      }
      async #reload(dispatchReloadEvent = true) {
        this.#ctx.log.debug("Reloading worker...");
        const globals = {};
        const bindings = {};
        const newWatchPaths = /* @__PURE__ */ new Set();
        if (this.#wranglerConfigPath)
          newWatchPaths.add(this.#wranglerConfigPath);
        this.#ctx.queueBroker.resetConsumers();
        await this.#runAllBeforeReloads();
        if (!this.#isMount) {
          for (const mount of this.#mounts.values()) {
            await mount.#runAllBeforeReloads();
          }
          this.#sharedCache.clear();
        }
        let script = void 0;
        let requiresModuleExports = false;
        const additionalModules = {};
        for (const [name] of this.#plugins) {
          const result = this.#setupResults.get(name);
          Object.assign(globals, result?.globals);
          Object.assign(bindings, result?.bindings);
          if (result?.script) {
            if (script) {
              throw new TypeError("Multiple plugins returned a script");
            }
            script = result.script;
          }
          if (result?.requiresModuleExports)
            requiresModuleExports = true;
          if (result?.additionalModules) {
            Object.assign(additionalModules, result.additionalModules);
          }
          const beforeSetupWatch = this.#beforeSetupWatch.get(name);
          if (beforeSetupWatch)
            (0, import_shared12.addAll)(newWatchPaths, beforeSetupWatch);
          const setupWatch = this.#setupWatch.get(name);
          if (setupWatch)
            (0, import_shared12.addAll)(newWatchPaths, setupWatch);
        }
        const { modules, processedModuleRules, logUnhandledRejections } = this.#instances.CorePlugin;
        this.#globalScope?.[kDispose]();
        const globalScope = new ServiceWorkerGlobalScope(this.#ctx.log, globals, bindings, modules, logUnhandledRejections);
        this.#globalScope = globalScope;
        this.#bindings = bindings;
        this.#moduleExports = {};
        const rules = modules ? processedModuleRules : void 0;
        let res = void 0;
        if (script && (!this.#ctx.scriptRunForModuleExports || modules && requiresModuleExports)) {
          if (!this.#ctx.scriptRunner) {
            throw new TypeError("Running scripts requires a script runner");
          }
          this.#ctx.log.verbose("Running script...");
          res = await this.#ctx.scriptRunner.run(globalScope, script, rules, additionalModules, this.#compat);
          this.#scriptWatchPaths.clear();
          this.#scriptWatchPaths.add(script.filePath);
          if (res.watch) {
            (0, import_shared12.addAll)(newWatchPaths, res.watch);
            (0, import_shared12.addAll)(this.#scriptWatchPaths, res.watch);
          }
          this.#moduleExports = res.exports;
          if (res.exports) {
            const defaults = res.exports.default;
            const fetchListener = defaults?.fetch?.bind(defaults);
            if (fetchListener) {
              globalScope[kAddModuleFetchListener](fetchListener);
            }
            const scheduledListener = defaults?.scheduled?.bind(defaults);
            if (scheduledListener) {
              globalScope[kAddModuleScheduledListener](scheduledListener);
            }
            const queueListener = defaults?.queue?.bind(defaults);
            if (queueListener) {
              globalScope[kAddModuleQueueListener](queueListener);
            }
          }
        }
        if (!this.#isMount) {
          const mounts = /* @__PURE__ */ new Map();
          const name = this.#instances.CorePlugin.name;
          if (name) {
            mounts.set(name, {
              moduleExports: this.#moduleExports,
              dispatchFetch: (request3) => this[kDispatchFetch](request3, true),
              usageModel: this.#instances.CorePlugin.usageModel
            });
          }
          for (const [name2, mount] of this.#mounts) {
            mounts.set(name2, {
              moduleExports: await mount.getModuleExports(),
              dispatchFetch: (request3) => mount[kDispatchFetch](request3, true),
              usageModel: mount.#instances.CorePlugin.usageModel
            });
          }
          await this.#runAllReloads(mounts);
          for (const mount of this.#mounts.values()) {
            await mount.#runAllReloads(mounts);
          }
        }
        if (dispatchReloadEvent) {
          const reloadEvent = new ReloadEvent("reload", {
            plugins: this.#instances,
            initial: !this.#reloaded
          });
          this.dispatchEvent(reloadEvent);
        }
        this.#reloaded = true;
        if (res) {
          this.#ctx.log.info(`Worker reloaded!${res.bundleSize !== void 0 ? ` (${formatSize(res.bundleSize)})` : ""}`);
          if (res.bundleSize !== void 0 && res.bundleSize > 1048576) {
            this.#ctx.log.warn("Worker's uncompressed size exceeds the 1MiB limit! Note that your worker will be compressed during upload so you may still be able to deploy it.");
          }
        }
        if (this.#watching) {
          let watcher = this.#watcher;
          if (!watcher) {
            const {
              Watcher
            } = require_src7();
            this.#watcherCallbackMutex = new import_shared12.Mutex();
            watcher = new Watcher(this.#watcherCallback.bind(this));
            this.#watcher = watcher;
          }
          const unwatchedPaths = /* @__PURE__ */ new Set();
          const watchedPaths = /* @__PURE__ */ new Set();
          for (const watchedPath of this.#previousWatchPaths ?? []) {
            if (!newWatchPaths.has(watchedPath)) {
              unwatchedPaths.add(watchedPath);
            }
          }
          for (const newWatchedPath of newWatchPaths) {
            if (!this.#previousWatchPaths?.has(newWatchedPath)) {
              watchedPaths.add(newWatchedPath);
            }
          }
          if (unwatchedPaths.size > 0) {
            this.#ctx.log.debug(`Unwatching ${pathsToString(unwatchedPaths)}...`);
            watcher.unwatch(unwatchedPaths);
          }
          if (watchedPaths.size > 0) {
            this.#ctx.log.debug(`Watching ${pathsToString(newWatchPaths)}...`);
            watcher.watch(watchedPaths);
          }
          this.#previousWatchPaths = newWatchPaths;
        }
      }
      #ignoreScriptUpdates = false;
      #ignoreScriptUpdatesTimeout;
      #watcherCallback(eventPath) {
        this.#ctx.log.debug(`${import_path62.default.relative("", eventPath)} changed...`);
        if (this.#ignoreScriptUpdates && this.#scriptWatchPaths.has(eventPath)) {
          this.#ctx.log.verbose("Ignoring script change after build...");
          return;
        }
        const promise = this.#watcherCallbackMutex.runWith(async () => {
          if (eventPath === this.#wranglerConfigPath) {
            await this.#init();
          }
          let ranBeforeSetup = false;
          for (const [name] of this.#plugins) {
            if (this.#beforeSetupWatch.get(name)?.has(eventPath)) {
              await this.#runBeforeSetup(name);
              ranBeforeSetup = true;
              this.#ignoreScriptUpdates = true;
              clearTimeout(this.#ignoreScriptUpdatesTimeout);
              this.#ignoreScriptUpdatesTimeout = setTimeout(() => this.#ignoreScriptUpdates = false, 1e3);
            }
            if (this.#setupWatch.get(name)?.has(eventPath)) {
              await this.#runSetup(name);
            }
          }
          if (ranBeforeSetup) {
            for (const [name] of this.#plugins) {
              if (this.#setupResults.get(name)?.script) {
                await this.#runSetup(name);
              }
            }
          }
          if (!this.#watcherCallbackMutex.hasWaiting) {
            await this.#reload();
          }
        });
        promise.catch((e3) => this.#ctx.log.error(e3));
      }
      get log() {
        return this.#ctx.log;
      }
      async reload() {
        await this.#initPromise;
        await this.#init(true);
        await this.#reload();
      }
      async setOptions(options29, dispatchReloadEvent = true) {
        await this.#initPromise;
        options29 = { ...this.#previousSetOptions, ...options29 };
        this.#previousSetOptions = options29;
        this.#overrides = splitPluginOptions(this.#plugins, options29);
        await this.#init();
        await this.#reload(dispatchReloadEvent);
      }
      getPluginStorage(name) {
        let storage = this.#pluginStorages.get(name);
        if (storage)
          return storage;
        this.#pluginStorages.set(name, storage = new PluginStorageFactory(this.#ctx.storageFactory, name));
        return storage;
      }
      async getPlugins() {
        await this.#initPromise;
        return this.#instances;
      }
      async getGlobalScope() {
        await this.#initPromise;
        return this.#globalScope;
      }
      async getBindings() {
        await this.#initPromise;
        return this.#bindings;
      }
      async getModuleExports() {
        await this.#initPromise;
        return this.#moduleExports;
      }
      async getMount(name) {
        await this.#initPromise;
        return this.#mounts.get(name);
      }
      #matchMount(url4) {
        if (this.#mounts?.size) {
          const mountMatch = this.#router.match(url4);
          const name = this.#instances.CorePlugin.name;
          if (mountMatch !== null && mountMatch !== name) {
            return this.#mounts.get(mountMatch);
          }
        }
      }
      async dispatchFetch(input, init3) {
        await this.#initPromise;
        let request3 = input instanceof Request3 && !init3 ? input : new Request3(input, init3);
        const url4 = new import_url42.URL(request3.url);
        const mount = this.#matchMount(url4);
        if (mount)
          return mount.dispatchFetch(request3);
        const { upstreamURL, usageModel } = this.#instances.CorePlugin;
        if (upstreamURL && !url4.toString().startsWith(upstreamURL.toString())) {
          let path72 = url4.pathname + url4.search;
          if (path72.startsWith("/"))
            path72 = path72.substring(1);
          const newURL = new import_url42.URL(path72, upstreamURL);
          request3 = new Request3(newURL, request3);
        }
        const requestDepth = (parseInt(request3.headers.get(_kLoopHeader)) || 0) + 1;
        request3.headers.delete(_kLoopHeader);
        return new import_shared12.RequestContext({
          requestDepth,
          pipelineDepth: 1,
          externalSubrequestLimit: (0, import_shared12.usageModelExternalSubrequestLimit)(usageModel)
        }).runWith(() => this[kDispatchFetch](request3, !!upstreamURL));
      }
      async [kDispatchFetch](request3, proxy2) {
        await this.#initPromise;
        if (!this.#compat.isEnabled("formdata_parser_supports_files")) {
          request3 = withStringFormDataFiles(request3);
        }
        request3 = withImmutableHeaders(request3);
        return this.#globalScope[kDispatchFetch](request3, proxy2);
      }
      async dispatchScheduled(scheduledTime, cron, url4) {
        await this.#initPromise;
        if (url4 !== void 0) {
          if (typeof url4 === "string")
            url4 = new import_url42.URL(url4);
          const mount = this.#matchMount(url4);
          if (mount)
            return mount.dispatchScheduled(scheduledTime, cron);
        }
        const { usageModel } = this.#instances.CorePlugin;
        const globalScope = this.#globalScope;
        return new import_shared12.RequestContext({
          externalSubrequestLimit: (0, import_shared12.usageModelExternalSubrequestLimit)(usageModel)
        }).runWith(() => globalScope[kDispatchScheduled](scheduledTime, cron));
      }
      async dispatchQueue(batch) {
        await this.#initPromise;
        const { usageModel } = this.#instances.CorePlugin;
        const globalScope = this.#globalScope;
        return new import_shared12.RequestContext({
          externalSubrequestLimit: (0, import_shared12.usageModelExternalSubrequestLimit)(usageModel)
        }).runWith(() => globalScope[kDispatchQueue](batch));
      }
      async dispose() {
        await this.#initPromise;
        for (const [name] of this.#plugins) {
          const instance = this.#instances?.[name];
          if (instance?.dispose) {
            this.#ctx.log.verbose(`- dispose(${name})`);
            await instance.dispose();
          }
        }
        this.#watcher?.dispose();
        if (this.#mounts) {
          for (const [name, mount] of this.#mounts) {
            this.#ctx.log.debug(`Unmounting "${name}"...`);
            await mount.dispose();
          }
          this.#mounts.clear();
        }
        if (!this.#isMount)
          this.#sharedCache.clear();
      }
    }, "MiniflareCore");
  }
});

// ../../node_modules/.pnpm/html-rewriter-wasm@0.4.1/node_modules/html-rewriter-wasm/dist/html_rewriter.js
var require_html_rewriter = __commonJS({
  "../../node_modules/.pnpm/html-rewriter-wasm@0.4.1/node_modules/html-rewriter-wasm/dist/html_rewriter.js"(exports2, module3) {
    init_import_meta_url();
    var imports = {};
    imports["__wbindgen_placeholder__"] = module3.exports;
    var wasm;
    var { awaitPromise, setWasmExports, wrap: wrap4 } = require(String.raw`./asyncify.js`);
    var { TextDecoder: TextDecoder2, TextEncoder: TextEncoder4 } = require(String.raw`util`);
    var heap = new Array(32).fill(void 0);
    heap.push(void 0, null, true, false);
    function getObject(idx) {
      return heap[idx];
    }
    __name(getObject, "getObject");
    var heap_next = heap.length;
    function dropObject(idx) {
      if (idx < 36)
        return;
      heap[idx] = heap_next;
      heap_next = idx;
    }
    __name(dropObject, "dropObject");
    function takeObject(idx) {
      const ret = getObject(idx);
      dropObject(idx);
      return ret;
    }
    __name(takeObject, "takeObject");
    var cachedTextDecoder = new TextDecoder2("utf-8", { ignoreBOM: true, fatal: true });
    cachedTextDecoder.decode();
    var cachegetUint8Memory0 = null;
    function getUint8Memory0() {
      if (cachegetUint8Memory0 === null || cachegetUint8Memory0.buffer !== wasm.memory.buffer) {
        cachegetUint8Memory0 = new Uint8Array(wasm.memory.buffer);
      }
      return cachegetUint8Memory0;
    }
    __name(getUint8Memory0, "getUint8Memory0");
    function getStringFromWasm0(ptr, len) {
      return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
    }
    __name(getStringFromWasm0, "getStringFromWasm0");
    function addHeapObject(obj) {
      if (heap_next === heap.length)
        heap.push(heap.length + 1);
      const idx = heap_next;
      heap_next = heap[idx];
      heap[idx] = obj;
      return idx;
    }
    __name(addHeapObject, "addHeapObject");
    function debugString(val) {
      const type = typeof val;
      if (type == "number" || type == "boolean" || val == null) {
        return `${val}`;
      }
      if (type == "string") {
        return `"${val}"`;
      }
      if (type == "symbol") {
        const description = val.description;
        if (description == null) {
          return "Symbol";
        } else {
          return `Symbol(${description})`;
        }
      }
      if (type == "function") {
        const name = val.name;
        if (typeof name == "string" && name.length > 0) {
          return `Function(${name})`;
        } else {
          return "Function";
        }
      }
      if (Array.isArray(val)) {
        const length = val.length;
        let debug = "[";
        if (length > 0) {
          debug += debugString(val[0]);
        }
        for (let i = 1; i < length; i++) {
          debug += ", " + debugString(val[i]);
        }
        debug += "]";
        return debug;
      }
      const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
      let className;
      if (builtInMatches.length > 1) {
        className = builtInMatches[1];
      } else {
        return toString.call(val);
      }
      if (className == "Object") {
        try {
          return "Object(" + JSON.stringify(val) + ")";
        } catch (_3) {
          return "Object";
        }
      }
      if (val instanceof Error) {
        return `${val.name}: ${val.message}
${val.stack}`;
      }
      return className;
    }
    __name(debugString, "debugString");
    var WASM_VECTOR_LEN = 0;
    var cachedTextEncoder = new TextEncoder4("utf-8");
    var encodeString = typeof cachedTextEncoder.encodeInto === "function" ? function(arg, view) {
      return cachedTextEncoder.encodeInto(arg, view);
    } : function(arg, view) {
      const buf = cachedTextEncoder.encode(arg);
      view.set(buf);
      return {
        read: arg.length,
        written: buf.length
      };
    };
    function passStringToWasm0(arg, malloc, realloc) {
      if (realloc === void 0) {
        const buf = cachedTextEncoder.encode(arg);
        const ptr2 = malloc(buf.length);
        getUint8Memory0().subarray(ptr2, ptr2 + buf.length).set(buf);
        WASM_VECTOR_LEN = buf.length;
        return ptr2;
      }
      let len = arg.length;
      let ptr = malloc(len);
      const mem = getUint8Memory0();
      let offset = 0;
      for (; offset < len; offset++) {
        const code = arg.charCodeAt(offset);
        if (code > 127)
          break;
        mem[ptr + offset] = code;
      }
      if (offset !== len) {
        if (offset !== 0) {
          arg = arg.slice(offset);
        }
        ptr = realloc(ptr, len, len = offset + arg.length * 3);
        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
        const ret = encodeString(arg, view);
        offset += ret.written;
      }
      WASM_VECTOR_LEN = offset;
      return ptr;
    }
    __name(passStringToWasm0, "passStringToWasm0");
    var cachegetInt32Memory0 = null;
    function getInt32Memory0() {
      if (cachegetInt32Memory0 === null || cachegetInt32Memory0.buffer !== wasm.memory.buffer) {
        cachegetInt32Memory0 = new Int32Array(wasm.memory.buffer);
      }
      return cachegetInt32Memory0;
    }
    __name(getInt32Memory0, "getInt32Memory0");
    function isLikeNone(x2) {
      return x2 === void 0 || x2 === null;
    }
    __name(isLikeNone, "isLikeNone");
    var stack_pointer = 32;
    function addBorrowedObject(obj) {
      if (stack_pointer == 1)
        throw new Error("out of js stack");
      heap[--stack_pointer] = obj;
      return stack_pointer;
    }
    __name(addBorrowedObject, "addBorrowedObject");
    function passArray8ToWasm0(arg, malloc) {
      const ptr = malloc(arg.length * 1);
      getUint8Memory0().set(arg, ptr / 1);
      WASM_VECTOR_LEN = arg.length;
      return ptr;
    }
    __name(passArray8ToWasm0, "passArray8ToWasm0");
    function handleError(f, args) {
      try {
        return f.apply(this, args);
      } catch (e3) {
        wasm.__wbindgen_exn_store(addHeapObject(e3));
      }
    }
    __name(handleError, "handleError");
    var Comment = class {
      static __wrap(ptr) {
        const obj = Object.create(Comment.prototype);
        obj.ptr = ptr;
        return obj;
      }
      __destroy_into_raw() {
        const ptr = this.ptr;
        this.ptr = 0;
        return ptr;
      }
      free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_comment_free(ptr);
      }
      /**
      * @param {string} content
      * @param {any | undefined} content_type
      */
      before(content, content_type) {
        var ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        wasm.comment_before(this.ptr, ptr0, len0, isLikeNone(content_type) ? 0 : addHeapObject(content_type));
        return this;
      }
      /**
      * @param {string} content
      * @param {any | undefined} content_type
      */
      after(content, content_type) {
        var ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        wasm.comment_after(this.ptr, ptr0, len0, isLikeNone(content_type) ? 0 : addHeapObject(content_type));
        return this;
      }
      /**
      * @param {string} content
      * @param {any | undefined} content_type
      */
      replace(content, content_type) {
        var ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        wasm.comment_replace(this.ptr, ptr0, len0, isLikeNone(content_type) ? 0 : addHeapObject(content_type));
        return this;
      }
      /**
      */
      remove() {
        wasm.comment_remove(this.ptr);
        return this;
      }
      /**
      * @returns {boolean}
      */
      get removed() {
        var ret = wasm.comment_removed(this.ptr);
        return ret !== 0;
      }
      /**
      * @returns {string}
      */
      get text() {
        try {
          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
          wasm.comment_text(retptr, this.ptr);
          var r0 = getInt32Memory0()[retptr / 4 + 0];
          var r1 = getInt32Memory0()[retptr / 4 + 1];
          return getStringFromWasm0(r0, r1);
        } finally {
          wasm.__wbindgen_add_to_stack_pointer(16);
          wasm.__wbindgen_free(r0, r1);
        }
      }
      /**
      * @param {string} text
      */
      set text(text) {
        var ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        wasm.comment_set_text(this.ptr, ptr0, len0);
      }
    };
    __name(Comment, "Comment");
    module3.exports.Comment = Comment;
    var Doctype = class {
      static __wrap(ptr) {
        const obj = Object.create(Doctype.prototype);
        obj.ptr = ptr;
        return obj;
      }
      __destroy_into_raw() {
        const ptr = this.ptr;
        this.ptr = 0;
        return ptr;
      }
      free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_doctype_free(ptr);
      }
      /**
      * @returns {any}
      */
      get name() {
        var ret = wasm.doctype_name(this.ptr);
        return takeObject(ret);
      }
      /**
      * @returns {any}
      */
      get publicId() {
        var ret = wasm.doctype_public_id(this.ptr);
        return takeObject(ret);
      }
      /**
      * @returns {any}
      */
      get systemId() {
        var ret = wasm.doctype_system_id(this.ptr);
        return takeObject(ret);
      }
    };
    __name(Doctype, "Doctype");
    module3.exports.Doctype = Doctype;
    var DocumentEnd = class {
      static __wrap(ptr) {
        const obj = Object.create(DocumentEnd.prototype);
        obj.ptr = ptr;
        return obj;
      }
      __destroy_into_raw() {
        const ptr = this.ptr;
        this.ptr = 0;
        return ptr;
      }
      free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_documentend_free(ptr);
      }
      /**
      * @param {string} content
      * @param {any | undefined} content_type
      */
      append(content, content_type) {
        var ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        wasm.documentend_append(this.ptr, ptr0, len0, isLikeNone(content_type) ? 0 : addHeapObject(content_type));
        return this;
      }
    };
    __name(DocumentEnd, "DocumentEnd");
    module3.exports.DocumentEnd = DocumentEnd;
    var Element2 = class {
      static __wrap(ptr) {
        const obj = Object.create(Element2.prototype);
        obj.ptr = ptr;
        return obj;
      }
      __destroy_into_raw() {
        const ptr = this.ptr;
        this.ptr = 0;
        return ptr;
      }
      free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_element_free(ptr);
      }
      /**
      * @param {string} content
      * @param {any | undefined} content_type
      */
      before(content, content_type) {
        var ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        wasm.element_before(this.ptr, ptr0, len0, isLikeNone(content_type) ? 0 : addHeapObject(content_type));
        return this;
      }
      /**
      * @param {string} content
      * @param {any | undefined} content_type
      */
      after(content, content_type) {
        var ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        wasm.element_after(this.ptr, ptr0, len0, isLikeNone(content_type) ? 0 : addHeapObject(content_type));
        return this;
      }
      /**
      * @param {string} content
      * @param {any | undefined} content_type
      */
      replace(content, content_type) {
        var ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        wasm.element_replace(this.ptr, ptr0, len0, isLikeNone(content_type) ? 0 : addHeapObject(content_type));
        return this;
      }
      /**
      */
      remove() {
        wasm.element_remove(this.ptr);
        return this;
      }
      /**
      * @returns {boolean}
      */
      get removed() {
        var ret = wasm.element_removed(this.ptr);
        return ret !== 0;
      }
      /**
      * @returns {string}
      */
      get tagName() {
        try {
          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
          wasm.element_tag_name(retptr, this.ptr);
          var r0 = getInt32Memory0()[retptr / 4 + 0];
          var r1 = getInt32Memory0()[retptr / 4 + 1];
          return getStringFromWasm0(r0, r1);
        } finally {
          wasm.__wbindgen_add_to_stack_pointer(16);
          wasm.__wbindgen_free(r0, r1);
        }
      }
      /**
      * @param {string} name
      */
      set tagName(name) {
        var ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        wasm.element_set_tag_name(this.ptr, ptr0, len0);
      }
      /**
      * @returns {any}
      */
      get namespaceURI() {
        var ret = wasm.element_namespace_uri(this.ptr);
        return takeObject(ret);
      }
      /**
      * @returns {any}
      */
      get attributes() {
        var ret = wasm.element_attributes(this.ptr);
        return takeObject(ret)[Symbol.iterator]();
      }
      /**
      * @param {string} name
      * @returns {any}
      */
      getAttribute(name) {
        var ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        var ret = wasm.element_getAttribute(this.ptr, ptr0, len0);
        return takeObject(ret);
      }
      /**
      * @param {string} name
      * @returns {boolean}
      */
      hasAttribute(name) {
        var ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        var ret = wasm.element_hasAttribute(this.ptr, ptr0, len0);
        return ret !== 0;
      }
      /**
      * @param {string} name
      * @param {string} value
      */
      setAttribute(name, value) {
        var ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        var ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len1 = WASM_VECTOR_LEN;
        wasm.element_setAttribute(this.ptr, ptr0, len0, ptr1, len1);
        return this;
      }
      /**
      * @param {string} name
      */
      removeAttribute(name) {
        var ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        wasm.element_removeAttribute(this.ptr, ptr0, len0);
        return this;
      }
      /**
      * @param {string} content
      * @param {any | undefined} content_type
      */
      prepend(content, content_type) {
        var ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        wasm.element_prepend(this.ptr, ptr0, len0, isLikeNone(content_type) ? 0 : addHeapObject(content_type));
        return this;
      }
      /**
      * @param {string} content
      * @param {any | undefined} content_type
      */
      append(content, content_type) {
        var ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        wasm.element_append(this.ptr, ptr0, len0, isLikeNone(content_type) ? 0 : addHeapObject(content_type));
        return this;
      }
      /**
      * @param {string} content
      * @param {any | undefined} content_type
      */
      setInnerContent(content, content_type) {
        var ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        wasm.element_setInnerContent(this.ptr, ptr0, len0, isLikeNone(content_type) ? 0 : addHeapObject(content_type));
        return this;
      }
      /**
      */
      removeAndKeepContent() {
        wasm.element_removeAndKeepContent(this.ptr);
        return this;
      }
      /**
      * @param {any} handler
      */
      onEndTag(handler30) {
        wasm.element_onEndTag(this.ptr, addHeapObject(handler30.bind(this)));
      }
    };
    __name(Element2, "Element");
    module3.exports.Element = Element2;
    var EndTag = class {
      static __wrap(ptr) {
        const obj = Object.create(EndTag.prototype);
        obj.ptr = ptr;
        return obj;
      }
      __destroy_into_raw() {
        const ptr = this.ptr;
        this.ptr = 0;
        return ptr;
      }
      free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_endtag_free(ptr);
      }
      /**
      * @returns {string}
      */
      get name() {
        try {
          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
          wasm.endtag_name(retptr, this.ptr);
          var r0 = getInt32Memory0()[retptr / 4 + 0];
          var r1 = getInt32Memory0()[retptr / 4 + 1];
          return getStringFromWasm0(r0, r1);
        } finally {
          wasm.__wbindgen_add_to_stack_pointer(16);
          wasm.__wbindgen_free(r0, r1);
        }
      }
      /**
      * @param {string} name
      */
      set name(name) {
        var ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        wasm.endtag_set_name(this.ptr, ptr0, len0);
      }
      /**
      * @param {string} content
      * @param {any | undefined} content_type
      */
      before(content, content_type) {
        var ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        wasm.endtag_before(this.ptr, ptr0, len0, isLikeNone(content_type) ? 0 : addHeapObject(content_type));
        return this;
      }
      /**
      * @param {string} content
      * @param {any | undefined} content_type
      */
      after(content, content_type) {
        var ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        wasm.endtag_after(this.ptr, ptr0, len0, isLikeNone(content_type) ? 0 : addHeapObject(content_type));
        return this;
      }
      /**
      */
      remove() {
        wasm.endtag_remove(this.ptr);
        return this;
      }
    };
    __name(EndTag, "EndTag");
    module3.exports.EndTag = EndTag;
    var HTMLRewriter2 = class {
      static __wrap(ptr) {
        const obj = Object.create(HTMLRewriter2.prototype);
        obj.ptr = ptr;
        return obj;
      }
      __destroy_into_raw() {
        const ptr = this.ptr;
        this.ptr = 0;
        return ptr;
      }
      free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_htmlrewriter_free(ptr);
      }
      /**
      * @param {any} output_sink
      * @param {any | undefined} options
      */
      constructor(output_sink, options29) {
        try {
          var ret = wasm.htmlrewriter_new(addBorrowedObject(output_sink), isLikeNone(options29) ? 0 : addHeapObject(options29));
          return HTMLRewriter2.__wrap(ret);
        } finally {
          heap[stack_pointer++] = void 0;
        }
      }
      /**
      * @param {string} selector
      * @param {any} handlers
      */
      on(selector, handlers2) {
        var ptr0 = passStringToWasm0(selector, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        wasm.htmlrewriter_on(this.ptr, ptr0, len0, addHeapObject(handlers2));
        return this;
      }
      /**
      * @param {any} handlers
      */
      onDocument(handlers2) {
        wasm.htmlrewriter_onDocument(this.ptr, addHeapObject(handlers2));
        return this;
      }
      /**
      * @param {Uint8Array} chunk
      */
      async write(chunk) {
        var ptr0 = passArray8ToWasm0(chunk, wasm.__wbindgen_malloc);
        var len0 = WASM_VECTOR_LEN;
        await wrap4(this, wasm.htmlrewriter_write, this.ptr, ptr0, len0);
      }
      /**
      */
      async end() {
        await wrap4(this, wasm.htmlrewriter_end, this.ptr);
      }
      /**
      * @returns {number}
      */
      get asyncifyStackPtr() {
        var ret = wasm.htmlrewriter_asyncify_stack_ptr(this.ptr);
        return ret;
      }
    };
    __name(HTMLRewriter2, "HTMLRewriter");
    module3.exports.HTMLRewriter = HTMLRewriter2;
    var TextChunk = class {
      static __wrap(ptr) {
        const obj = Object.create(TextChunk.prototype);
        obj.ptr = ptr;
        return obj;
      }
      __destroy_into_raw() {
        const ptr = this.ptr;
        this.ptr = 0;
        return ptr;
      }
      free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_textchunk_free(ptr);
      }
      /**
      * @param {string} content
      * @param {any | undefined} content_type
      */
      before(content, content_type) {
        var ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        wasm.textchunk_before(this.ptr, ptr0, len0, isLikeNone(content_type) ? 0 : addHeapObject(content_type));
        return this;
      }
      /**
      * @param {string} content
      * @param {any | undefined} content_type
      */
      after(content, content_type) {
        var ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        wasm.textchunk_after(this.ptr, ptr0, len0, isLikeNone(content_type) ? 0 : addHeapObject(content_type));
        return this;
      }
      /**
      * @param {string} content
      * @param {any | undefined} content_type
      */
      replace(content, content_type) {
        var ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        var len0 = WASM_VECTOR_LEN;
        wasm.textchunk_replace(this.ptr, ptr0, len0, isLikeNone(content_type) ? 0 : addHeapObject(content_type));
        return this;
      }
      /**
      */
      remove() {
        wasm.textchunk_remove(this.ptr);
        return this;
      }
      /**
      * @returns {boolean}
      */
      get removed() {
        var ret = wasm.textchunk_removed(this.ptr);
        return ret !== 0;
      }
      /**
      * @returns {string}
      */
      get text() {
        try {
          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
          wasm.textchunk_text(retptr, this.ptr);
          var r0 = getInt32Memory0()[retptr / 4 + 0];
          var r1 = getInt32Memory0()[retptr / 4 + 1];
          return getStringFromWasm0(r0, r1);
        } finally {
          wasm.__wbindgen_add_to_stack_pointer(16);
          wasm.__wbindgen_free(r0, r1);
        }
      }
      /**
      * @returns {boolean}
      */
      get lastInTextNode() {
        var ret = wasm.textchunk_last_in_text_node(this.ptr);
        return ret !== 0;
      }
    };
    __name(TextChunk, "TextChunk");
    module3.exports.TextChunk = TextChunk;
    module3.exports.__wbindgen_object_drop_ref = function(arg0) {
      takeObject(arg0);
    };
    module3.exports.__wbg_html_cd9a0f328493678b = function(arg0) {
      var ret = getObject(arg0).html;
      return isLikeNone(ret) ? 16777215 : ret ? 1 : 0;
    };
    module3.exports.__wbindgen_string_new = function(arg0, arg1) {
      var ret = getStringFromWasm0(arg0, arg1);
      return addHeapObject(ret);
    };
    module3.exports.__wbg_documentend_new = function(arg0) {
      var ret = DocumentEnd.__wrap(arg0);
      return addHeapObject(ret);
    };
    module3.exports.__wbg_awaitPromise_39a1101fd8518869 = function(arg0, arg1) {
      awaitPromise(arg0, getObject(arg1));
    };
    module3.exports.__wbindgen_object_clone_ref = function(arg0) {
      var ret = getObject(arg0);
      return addHeapObject(ret);
    };
    module3.exports.__wbg_element_c38470ed972aea27 = function(arg0) {
      var ret = getObject(arg0).element;
      return isLikeNone(ret) ? 0 : addHeapObject(ret);
    };
    module3.exports.__wbg_comments_ba86bc03331d9378 = function(arg0) {
      var ret = getObject(arg0).comments;
      return isLikeNone(ret) ? 0 : addHeapObject(ret);
    };
    module3.exports.__wbg_text_7800bf26cb443911 = function(arg0) {
      var ret = getObject(arg0).text;
      return isLikeNone(ret) ? 0 : addHeapObject(ret);
    };
    module3.exports.__wbg_element_new = function(arg0) {
      var ret = Element2.__wrap(arg0);
      return addHeapObject(ret);
    };
    module3.exports.__wbg_comment_new = function(arg0) {
      var ret = Comment.__wrap(arg0);
      return addHeapObject(ret);
    };
    module3.exports.__wbg_textchunk_new = function(arg0) {
      var ret = TextChunk.__wrap(arg0);
      return addHeapObject(ret);
    };
    module3.exports.__wbg_doctype_ac58c0964a59b61b = function(arg0) {
      var ret = getObject(arg0).doctype;
      return isLikeNone(ret) ? 0 : addHeapObject(ret);
    };
    module3.exports.__wbg_comments_94d876f6c0502e82 = function(arg0) {
      var ret = getObject(arg0).comments;
      return isLikeNone(ret) ? 0 : addHeapObject(ret);
    };
    module3.exports.__wbg_text_4606a16c30e4ae91 = function(arg0) {
      var ret = getObject(arg0).text;
      return isLikeNone(ret) ? 0 : addHeapObject(ret);
    };
    module3.exports.__wbg_end_34efb9402eac8a4e = function(arg0) {
      var ret = getObject(arg0).end;
      return isLikeNone(ret) ? 0 : addHeapObject(ret);
    };
    module3.exports.__wbg_doctype_new = function(arg0) {
      var ret = Doctype.__wrap(arg0);
      return addHeapObject(ret);
    };
    module3.exports.__wbg_endtag_new = function(arg0) {
      var ret = EndTag.__wrap(arg0);
      return addHeapObject(ret);
    };
    module3.exports.__wbg_enableEsiTags_de6b91cc61a25874 = function(arg0) {
      var ret = getObject(arg0).enableEsiTags;
      return isLikeNone(ret) ? 16777215 : ret ? 1 : 0;
    };
    module3.exports.__wbg_String_60c4ba333b5ca1c6 = function(arg0, arg1) {
      var ret = String(getObject(arg1));
      var ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
      var len0 = WASM_VECTOR_LEN;
      getInt32Memory0()[arg0 / 4 + 1] = len0;
      getInt32Memory0()[arg0 / 4 + 0] = ptr0;
    };
    module3.exports.__wbg_new_4fee7e2900033464 = function() {
      var ret = new Array();
      return addHeapObject(ret);
    };
    module3.exports.__wbg_push_ba9b5e3c25cff8f9 = function(arg0, arg1) {
      var ret = getObject(arg0).push(getObject(arg1));
      return ret;
    };
    module3.exports.__wbg_call_6c4ea719458624eb = function() {
      return handleError(function(arg0, arg1, arg2) {
        var ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
        return addHeapObject(ret);
      }, arguments);
    };
    module3.exports.__wbg_new_917809a3e20a4b00 = function(arg0, arg1) {
      var ret = new TypeError(getStringFromWasm0(arg0, arg1));
      return addHeapObject(ret);
    };
    module3.exports.__wbg_instanceof_Promise_c6535fc791fcc4d2 = function(arg0) {
      var obj = getObject(arg0);
      var ret = obj instanceof Promise || Object.prototype.toString.call(obj) === "[object Promise]";
      return ret;
    };
    module3.exports.__wbg_buffer_89a8560ab6a3d9c6 = function(arg0) {
      var ret = getObject(arg0).buffer;
      return addHeapObject(ret);
    };
    module3.exports.__wbg_newwithbyteoffsetandlength_e45d8b33c02dc3b5 = function(arg0, arg1, arg2) {
      var ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
      return addHeapObject(ret);
    };
    module3.exports.__wbg_new_bd2e1d010adb8a1a = function(arg0) {
      var ret = new Uint8Array(getObject(arg0));
      return addHeapObject(ret);
    };
    module3.exports.__wbindgen_debug_string = function(arg0, arg1) {
      var ret = debugString(getObject(arg1));
      var ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
      var len0 = WASM_VECTOR_LEN;
      getInt32Memory0()[arg0 / 4 + 1] = len0;
      getInt32Memory0()[arg0 / 4 + 0] = ptr0;
    };
    module3.exports.__wbindgen_throw = function(arg0, arg1) {
      throw new Error(getStringFromWasm0(arg0, arg1));
    };
    module3.exports.__wbindgen_rethrow = function(arg0) {
      throw takeObject(arg0);
    };
    module3.exports.__wbindgen_memory = function() {
      var ret = wasm.memory;
      return addHeapObject(ret);
    };
    var path67 = require("path").join(__dirname, "html_rewriter_bg.wasm");
    var bytes = require("fs").readFileSync(path67);
    var wasmModule = new WebAssembly.Module(bytes);
    var wasmInstance = new WebAssembly.Instance(wasmModule, imports);
    wasm = wasmInstance.exports;
    setWasmExports(wasm);
    module3.exports.__wasm = wasm;
  }
});

// ../../node_modules/.pnpm/@miniflare+html-rewriter@2.14.2/node_modules/@miniflare/html-rewriter/dist/src/index.js
var require_src9 = __commonJS({
  "../../node_modules/.pnpm/@miniflare+html-rewriter@2.14.2/node_modules/@miniflare/html-rewriter/dist/src/index.js"(exports2) {
    init_import_meta_url();
    var __create2 = Object.create;
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __getProtoOf2 = Object.getPrototypeOf;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __markAsModule = /* @__PURE__ */ __name((target) => __defProp2(target, "__esModule", { value: true }), "__markAsModule");
    var __export2 = /* @__PURE__ */ __name((target, all2) => {
      __markAsModule(target);
      for (var name in all2)
        __defProp2(target, name, { get: all2[name], enumerable: true });
    }, "__export");
    var __reExport2 = /* @__PURE__ */ __name((target, module22, desc) => {
      if (module22 && typeof module22 === "object" || typeof module22 === "function") {
        for (let key of __getOwnPropNames2(module22))
          if (!__hasOwnProp2.call(target, key) && key !== "default")
            __defProp2(target, key, { get: () => module22[key], enumerable: !(desc = __getOwnPropDesc2(module22, key)) || desc.enumerable });
      }
      return target;
    }, "__reExport");
    var __toModule = /* @__PURE__ */ __name((module22) => {
      return __reExport2(__markAsModule(__defProp2(module22 != null ? __create2(__getProtoOf2(module22)) : {}, "default", module22 && module22.__esModule && "default" in module22 ? { get: () => module22.default, enumerable: true } : { value: module22, enumerable: true })), module22);
    }, "__toModule");
    __export2(exports2, {
      HTMLRewriter: () => HTMLRewriter2,
      HTMLRewriterPlugin: () => HTMLRewriterPlugin,
      withEnableEsiTags: () => withEnableEsiTags
    });
    var import_shared = __toModule(require_src6());
    var import_web2 = __toModule(require("stream/web"));
    var import_core19 = __toModule(require_src8());
    var import_undici27 = __toModule(require_undici2());
    var kEnableEsiTags = Symbol("kEnableEsiTags");
    var HTMLRewriter2 = /* @__PURE__ */ __name(class {
      #elementHandlers = [];
      #documentHandlers = [];
      [kEnableEsiTags] = false;
      on(selector, handlers2) {
        this.#elementHandlers.push([selector, handlers2]);
        return this;
      }
      onDocument(handlers2) {
        this.#documentHandlers.push(handlers2);
        return this;
      }
      transform(response) {
        const body = response.body;
        if (body === null)
          return new import_core19.Response(body, response);
        if (response instanceof import_undici27.Response) {
          response = new import_core19.Response(response.body, response);
        }
        let rewriter;
        const transformStream = new import_web2.TransformStream({
          start: async (controller) => {
            const {
              HTMLRewriter: BaseHTMLRewriter
            } = require_html_rewriter();
            rewriter = new BaseHTMLRewriter((output) => {
              if (output.length !== 0)
                controller.enqueue(output);
            }, { enableEsiTags: this[kEnableEsiTags] });
            for (const [selector, handlers2] of this.#elementHandlers) {
              rewriter.on(selector, handlers2);
            }
            for (const handlers2 of this.#documentHandlers) {
              rewriter.onDocument(handlers2);
            }
          },
          transform: (chunk) => rewriter.write(chunk),
          flush: () => rewriter.end()
        });
        const promise = body.pipeTo(transformStream.writable);
        promise.catch(() => {
        }).finally(() => rewriter.free());
        const res = new import_core19.Response(transformStream.readable, response);
        res.headers.delete("Content-Length");
        return res;
      }
    }, "HTMLRewriter");
    function withEnableEsiTags(rewriter) {
      rewriter[kEnableEsiTags] = true;
      return rewriter;
    }
    __name(withEnableEsiTags, "withEnableEsiTags");
    var ESIHTMLRewriter = new Proxy(HTMLRewriter2, {
      construct(target, args, newTarget) {
        const value = Reflect.construct(target, args, newTarget);
        return withEnableEsiTags(value);
      }
    });
    var HTMLRewriterPlugin = /* @__PURE__ */ __name(class extends import_shared.Plugin {
      constructor(ctx) {
        super(ctx);
      }
      setup() {
        const enableEsiFlags = this.ctx.compat.isEnabled("html_rewriter_treats_esi_include_as_void_tag");
        const impl = enableEsiFlags ? ESIHTMLRewriter : HTMLRewriter2;
        return { globals: { HTMLRewriter: impl } };
      }
    }, "HTMLRewriterPlugin");
  }
});

// ../pages-shared/environment-polyfills/miniflare.ts
var miniflare_exports = {};
__export(miniflare_exports, {
  default: () => miniflare_default
});
var miniflare_default;
var init_miniflare = __esm({
  "../pages-shared/environment-polyfills/miniflare.ts"() {
    init_import_meta_url();
    init_environment_polyfills();
    miniflare_default = /* @__PURE__ */ __name(async () => {
      const { HTMLRewriter: HTMLRewriter2 } = await Promise.resolve().then(() => __toESM(require_src9()));
      const mf = await import("miniflare");
      polyfill({
        fetch: mf.fetch,
        Headers: mf.Headers,
        Request: mf.Request,
        Response: mf.Response,
        HTMLRewriter: HTMLRewriter2
      });
    }, "default");
  }
});

// ../pages-shared/asset-server/responses.ts
function mergeHeaders(base, extra) {
  const baseHeaders = new Headers(base ?? {});
  const extraHeaders = new Headers(extra ?? {});
  return new Headers({
    ...Object.fromEntries(baseHeaders.entries()),
    ...Object.fromEntries(extraHeaders.entries())
  });
}
function stripLeadingDoubleSlashes(location) {
  return location.replace(/^(\/|%2F|%2f|%5C|%5c|%09|\s|\\)+(.*)/, "/$2");
}
var OkResponse, MovedPermanentlyResponse, FoundResponse, NotModifiedResponse, PermanentRedirectResponse, NotFoundResponse, MethodNotAllowedResponse, NotAcceptableResponse, InternalServerErrorResponse, SeeOtherResponse, TemporaryRedirectResponse;
var init_responses = __esm({
  "../pages-shared/asset-server/responses.ts"() {
    init_import_meta_url();
    __name(mergeHeaders, "mergeHeaders");
    __name(stripLeadingDoubleSlashes, "stripLeadingDoubleSlashes");
    OkResponse = class extends Response {
      constructor(...[body, init3]) {
        super(body, {
          ...init3,
          status: 200,
          statusText: "OK"
        });
      }
    };
    __name(OkResponse, "OkResponse");
    MovedPermanentlyResponse = class extends Response {
      constructor(location, init3, {
        preventLeadingDoubleSlash = true
      } = {
        preventLeadingDoubleSlash: true
      }) {
        location = preventLeadingDoubleSlash ? stripLeadingDoubleSlashes(location) : location;
        super(`Redirecting to ${location}`, {
          ...init3,
          status: 301,
          statusText: "Moved Permanently",
          headers: mergeHeaders(init3?.headers, {
            location
          })
        });
      }
    };
    __name(MovedPermanentlyResponse, "MovedPermanentlyResponse");
    FoundResponse = class extends Response {
      constructor(location, init3, {
        preventLeadingDoubleSlash = true
      } = {
        preventLeadingDoubleSlash: true
      }) {
        location = preventLeadingDoubleSlash ? stripLeadingDoubleSlashes(location) : location;
        super(`Redirecting to ${location}`, {
          ...init3,
          status: 302,
          statusText: "Found",
          headers: mergeHeaders(init3?.headers, {
            location
          })
        });
      }
    };
    __name(FoundResponse, "FoundResponse");
    NotModifiedResponse = class extends Response {
      constructor(...[_body, _init]) {
        super(void 0, {
          status: 304,
          statusText: "Not Modified"
        });
      }
    };
    __name(NotModifiedResponse, "NotModifiedResponse");
    PermanentRedirectResponse = class extends Response {
      constructor(location, init3, {
        preventLeadingDoubleSlash = true
      } = {
        preventLeadingDoubleSlash: true
      }) {
        location = preventLeadingDoubleSlash ? stripLeadingDoubleSlashes(location) : location;
        super(void 0, {
          ...init3,
          status: 308,
          statusText: "Permanent Redirect",
          headers: mergeHeaders(init3?.headers, {
            location
          })
        });
      }
    };
    __name(PermanentRedirectResponse, "PermanentRedirectResponse");
    NotFoundResponse = class extends Response {
      constructor(...[body, init3]) {
        super(body, {
          ...init3,
          status: 404,
          statusText: "Not Found"
        });
      }
    };
    __name(NotFoundResponse, "NotFoundResponse");
    MethodNotAllowedResponse = class extends Response {
      constructor(...[body, init3]) {
        super(body, {
          ...init3,
          status: 405,
          statusText: "Method Not Allowed"
        });
      }
    };
    __name(MethodNotAllowedResponse, "MethodNotAllowedResponse");
    NotAcceptableResponse = class extends Response {
      constructor(...[body, init3]) {
        super(body, {
          ...init3,
          status: 406,
          statusText: "Not Acceptable"
        });
      }
    };
    __name(NotAcceptableResponse, "NotAcceptableResponse");
    InternalServerErrorResponse = class extends Response {
      constructor(err, init3) {
        let body = void 0;
        if (globalThis.DEBUG) {
          body = `${err.message}

${err.stack}`;
        }
        super(body, {
          ...init3,
          status: 500,
          statusText: "Internal Server Error"
        });
      }
    };
    __name(InternalServerErrorResponse, "InternalServerErrorResponse");
    SeeOtherResponse = class extends Response {
      constructor(location, init3, {
        preventLeadingDoubleSlash = true
      } = {
        preventLeadingDoubleSlash: true
      }) {
        location = preventLeadingDoubleSlash ? stripLeadingDoubleSlashes(location) : location;
        super(`Redirecting to ${location}`, {
          ...init3,
          status: 303,
          statusText: "See Other",
          headers: mergeHeaders(init3?.headers, { location })
        });
      }
    };
    __name(SeeOtherResponse, "SeeOtherResponse");
    TemporaryRedirectResponse = class extends Response {
      constructor(location, init3, {
        preventLeadingDoubleSlash = true
      } = {
        preventLeadingDoubleSlash: true
      }) {
        location = preventLeadingDoubleSlash ? stripLeadingDoubleSlashes(location) : location;
        super(`Redirecting to ${location}`, {
          ...init3,
          status: 307,
          statusText: "Temporary Redirect",
          headers: mergeHeaders(init3?.headers, { location })
        });
      }
    };
    __name(TemporaryRedirectResponse, "TemporaryRedirectResponse");
  }
});

// ../pages-shared/asset-server/rulesEngine.ts
var ESCAPE_REGEX_CHARACTERS, escapeRegex, HOST_PLACEHOLDER_REGEX, PLACEHOLDER_REGEX2, replacer, generateRulesMatcher;
var init_rulesEngine = __esm({
  "../pages-shared/asset-server/rulesEngine.ts"() {
    init_import_meta_url();
    ESCAPE_REGEX_CHARACTERS = /[-/\\^$*+?.()|[\]{}]/g;
    escapeRegex = /* @__PURE__ */ __name((str) => {
      return str.replace(ESCAPE_REGEX_CHARACTERS, "\\$&");
    }, "escapeRegex");
    HOST_PLACEHOLDER_REGEX = /(?<=^https:\\\/\\\/[^/]*?):([A-Za-z]\w*)(?=\\)/g;
    PLACEHOLDER_REGEX2 = /:([A-Za-z]\w*)/g;
    replacer = /* @__PURE__ */ __name((str, replacements) => {
      for (const [replacement, value] of Object.entries(replacements)) {
        str = str.replaceAll(`:${replacement}`, value);
      }
      return str;
    }, "replacer");
    generateRulesMatcher = /* @__PURE__ */ __name((rules, replacerFn = (match) => match) => {
      if (!rules)
        return () => [];
      const compiledRules = Object.entries(rules).map(([rule, match]) => {
        const crossHost = rule.startsWith("https://");
        rule = rule.split("*").map(escapeRegex).join("(?<splat>.*)");
        const host_matches = rule.matchAll(HOST_PLACEHOLDER_REGEX);
        for (const host_match of host_matches) {
          rule = rule.split(host_match[0]).join(`(?<${host_match[1]}>[^/.]+)`);
        }
        const path_matches = rule.matchAll(PLACEHOLDER_REGEX2);
        for (const path_match of path_matches) {
          rule = rule.split(path_match[0]).join(`(?<${path_match[1]}>[^/]+)`);
        }
        rule = "^" + rule + "$";
        try {
          const regExp = new RegExp(rule);
          return [{ crossHost, regExp }, match];
        } catch {
        }
      }).filter((value) => value !== void 0);
      return ({ request: request3 }) => {
        const { pathname, hostname: hostname2 } = new URL(request3.url);
        return compiledRules.map(([{ crossHost, regExp }, match]) => {
          const test = crossHost ? `https://${hostname2}${pathname}` : pathname;
          const result = regExp.exec(test);
          if (result) {
            return replacerFn(match, result.groups || {});
          }
        }).filter((value) => value !== void 0);
      };
    }, "generateRulesMatcher");
  }
});

// ../pages-shared/asset-server/handler.ts
var handler_exports = {};
__export(handler_exports, {
  ANALYTICS_VERSION: () => ANALYTICS_VERSION2,
  ASSET_PRESERVATION_CACHE_V1: () => ASSET_PRESERVATION_CACHE_V1,
  ASSET_PRESERVATION_CACHE_V2: () => ASSET_PRESERVATION_CACHE_V2,
  CACHE_CONTROL_BROWSER: () => CACHE_CONTROL_BROWSER,
  CACHE_PRESERVATION_WRITE_FREQUENCY: () => CACHE_PRESERVATION_WRITE_FREQUENCY,
  HEADERS_VERSION: () => HEADERS_VERSION2,
  HEADERS_VERSION_V1: () => HEADERS_VERSION_V1,
  REDIRECTS_VERSION: () => REDIRECTS_VERSION2,
  generateHandler: () => generateHandler,
  isPreservationCacheResponseExpiring: () => isPreservationCacheResponseExpiring,
  normaliseHeaders: () => normaliseHeaders,
  parseQualityWeightedList: () => parseQualityWeightedList
});
function normaliseHeaders(headers) {
  if (headers.version === HEADERS_VERSION2) {
    return headers.rules;
  } else if (headers.version === HEADERS_VERSION_V1) {
    return Object.keys(headers.rules).reduce(
      (acc, key) => {
        acc[key] = {
          set: headers.rules[key]
        };
        return acc;
      },
      {}
    );
  } else {
    return {};
  }
}
async function generateHandler({
  request: request3,
  metadata,
  xServerEnvHeader,
  xDeploymentIdHeader,
  logError,
  setMetrics,
  findAssetEntryForPath,
  getAssetKey,
  negotiateContent,
  fetchAsset,
  generateNotFoundResponse = /* @__PURE__ */ __name(async (notFoundRequest, notFoundFindAssetEntryForPath, notFoundServeAsset) => {
    let assetEntry;
    if (assetEntry = await notFoundFindAssetEntryForPath("/index.html")) {
      return notFoundServeAsset(assetEntry, { preserve: false });
    }
    return new NotFoundResponse();
  }, "generateNotFoundResponse"),
  attachAdditionalHeaders = /* @__PURE__ */ __name(() => {
  }, "attachAdditionalHeaders"),
  caches,
  waitUntil
}) {
  const url4 = new URL(request3.url);
  const { protocol, host, search } = url4;
  let { pathname } = url4;
  const earlyHintsCache = metadata.deploymentId ? await caches?.open(`eh:${metadata.deploymentId}`) : void 0;
  const headerRules = metadata.headers ? normaliseHeaders(metadata.headers) : {};
  const staticRules = metadata.redirects?.version === REDIRECTS_VERSION2 ? metadata.redirects.staticRules || {} : {};
  const staticRedirectsMatcher = /* @__PURE__ */ __name(() => {
    const withHostMatch = staticRules[`https://${host}${pathname}`];
    const withoutHostMatch = staticRules[pathname];
    if (withHostMatch && withoutHostMatch) {
      if (withHostMatch.lineNumber < withoutHostMatch.lineNumber) {
        return withHostMatch;
      } else {
        return withoutHostMatch;
      }
    }
    return withHostMatch || withoutHostMatch;
  }, "staticRedirectsMatcher");
  const generateRedirectsMatcher = /* @__PURE__ */ __name(() => generateRulesMatcher(
    metadata.redirects?.version === REDIRECTS_VERSION2 ? metadata.redirects.rules : {},
    ({ status: status2, to }, replacements) => ({
      status: status2,
      to: replacer(to, replacements)
    })
  ), "generateRedirectsMatcher");
  let assetEntry;
  async function generateResponse() {
    const match = staticRedirectsMatcher() || generateRedirectsMatcher()({ request: request3 })[0];
    if (match) {
      if (match.status === 200) {
        pathname = new URL(match.to, request3.url).pathname;
      } else {
        const { status: status2, to } = match;
        const destination = new URL(to, request3.url);
        const location = destination.origin === new URL(request3.url).origin ? `${destination.pathname}${destination.search || search}${destination.hash}` : `${destination.href}${destination.search ? "" : search}${destination.hash}`;
        switch (status2) {
          case 301:
            return new MovedPermanentlyResponse(location, void 0, {
              preventLeadingDoubleSlash: false
            });
          case 303:
            return new SeeOtherResponse(location, void 0, {
              preventLeadingDoubleSlash: false
            });
          case 307:
            return new TemporaryRedirectResponse(location, void 0, {
              preventLeadingDoubleSlash: false
            });
          case 308:
            return new PermanentRedirectResponse(location, void 0, {
              preventLeadingDoubleSlash: false
            });
          case 302:
          default:
            return new FoundResponse(location, void 0, {
              preventLeadingDoubleSlash: false
            });
        }
      }
    }
    if (!request3.method.match(/^(get|head)$/i)) {
      return new MethodNotAllowedResponse();
    }
    try {
      pathname = globalThis.decodeURIComponent(pathname);
    } catch (err) {
    }
    if (pathname.endsWith("/")) {
      if (assetEntry = await findAssetEntryForPath(`${pathname}index.html`)) {
        return serveAsset(assetEntry);
      } else if (pathname.endsWith("/index/")) {
        return new PermanentRedirectResponse(
          `/${pathname.slice(1, -"index/".length)}${search}`
        );
      } else if (assetEntry = await findAssetEntryForPath(
        `${pathname.replace(/\/$/, ".html")}`
      )) {
        return new PermanentRedirectResponse(
          `/${pathname.slice(1, -1)}${search}`
        );
      } else {
        return notFound();
      }
    }
    if (assetEntry = await findAssetEntryForPath(pathname)) {
      if (pathname.endsWith(".html")) {
        const extensionlessPath = pathname.slice(0, -".html".length);
        if (extensionlessPath.endsWith("/index")) {
          return new PermanentRedirectResponse(
            `${extensionlessPath.replace(/\/index$/, "/")}${search}`
          );
        } else if (await findAssetEntryForPath(extensionlessPath) || extensionlessPath === "/") {
          return serveAsset(assetEntry);
        } else {
          return new PermanentRedirectResponse(`${extensionlessPath}${search}`);
        }
      } else {
        return serveAsset(assetEntry);
      }
    } else if (pathname.endsWith("/index")) {
      return new PermanentRedirectResponse(
        `/${pathname.slice(1, -"index".length)}${search}`
      );
    } else if (assetEntry = await findAssetEntryForPath(`${pathname}.html`)) {
      return serveAsset(assetEntry);
    }
    if (assetEntry = await findAssetEntryForPath(`${pathname}/index.html`)) {
      return new PermanentRedirectResponse(`${pathname}/${search}`);
    } else {
      return notFound();
    }
  }
  __name(generateResponse, "generateResponse");
  function isNullBodyStatus(status2) {
    return [101, 204, 205, 304].includes(status2);
  }
  __name(isNullBodyStatus, "isNullBodyStatus");
  async function attachHeaders(response) {
    const existingHeaders = new Headers(response.headers);
    const extraHeaders = new Headers({
      "access-control-allow-origin": "*",
      "referrer-policy": "strict-origin-when-cross-origin",
      ...existingHeaders.has("content-type") ? { "x-content-type-options": "nosniff" } : {}
    });
    const headers = new Headers({
      // But we intentionally override existing headers
      ...Object.fromEntries(existingHeaders.entries()),
      ...Object.fromEntries(extraHeaders.entries())
    });
    if (earlyHintsCache && isHTMLContentType(response.headers.get("Content-Type"))) {
      const preEarlyHintsHeaders = new Headers(headers);
      const earlyHintsCacheKey = `${protocol}//${host}${pathname}`;
      const earlyHintsResponse = await earlyHintsCache.match(
        earlyHintsCacheKey
      );
      if (earlyHintsResponse) {
        const earlyHintsLinkHeader = earlyHintsResponse.headers.get("Link");
        if (earlyHintsLinkHeader) {
          headers.set("Link", earlyHintsLinkHeader);
          if (setMetrics)
            setMetrics({ earlyHintsResult: "used-hit" });
        } else {
          if (setMetrics)
            setMetrics({ earlyHintsResult: "notused-hit" });
        }
      } else {
        if (setMetrics)
          setMetrics({ earlyHintsResult: "notused-miss" });
        const clonedResponse = response.clone();
        if (waitUntil) {
          waitUntil(
            (async () => {
              try {
                const links = [];
                const transformedResponse = new HTMLRewriter().on("link[rel~=preconnect],link[rel~=preload]", {
                  element(element) {
                    for (const [attributeName] of element.attributes) {
                      if (!ALLOWED_EARLY_HINT_LINK_ATTRIBUTES.includes(
                        attributeName.toLowerCase()
                      )) {
                        return;
                      }
                    }
                    const href = element.getAttribute("href") || void 0;
                    const rel = element.getAttribute("rel") || void 0;
                    const as = element.getAttribute("as") || void 0;
                    if (href && !href.startsWith("data:") && rel) {
                      links.push({ href, rel, as });
                    }
                  }
                }).transform(clonedResponse);
                await transformedResponse.text();
                links.forEach(({ href, rel, as }) => {
                  let link = `<${href}>; rel="${rel}"`;
                  if (as) {
                    link += `; as=${as}`;
                  }
                  preEarlyHintsHeaders.append("Link", link);
                });
                const linkHeader = preEarlyHintsHeaders.get("Link");
                if (linkHeader) {
                  await earlyHintsCache.put(
                    earlyHintsCacheKey,
                    new Response(null, {
                      headers: {
                        Link: linkHeader,
                        "Cache-Control": "max-age=2592000"
                        // 30 days
                      }
                    })
                  );
                }
              } catch (err) {
              }
            })()
          );
        }
      }
    } else {
      if (setMetrics)
        setMetrics({ earlyHintsResult: "disabled" });
    }
    const headersMatcher = generateRulesMatcher(
      headerRules,
      ({ set = {}, unset = [] }, replacements) => {
        const replacedSet = {};
        Object.keys(set).forEach((key) => {
          replacedSet[key] = replacer(set[key], replacements);
        });
        return {
          set: replacedSet,
          unset
        };
      }
    );
    const matches = headersMatcher({ request: request3 });
    const setMap = /* @__PURE__ */ new Set();
    matches.forEach(({ set = {}, unset = [] }) => {
      unset.forEach((key) => {
        headers.delete(key);
      });
      Object.keys(set).forEach((key) => {
        if (setMap.has(key.toLowerCase())) {
          headers.append(key, set[key]);
        } else {
          headers.set(key, set[key]);
          setMap.add(key.toLowerCase());
        }
      });
    });
    return new Response(
      isNullBodyStatus(response.status) ? null : response.body,
      {
        headers,
        status: response.status,
        statusText: response.statusText
      }
    );
  }
  __name(attachHeaders, "attachHeaders");
  return await attachHeaders(await generateResponse());
  async function serveAsset(servingAssetEntry, options29 = { preserve: true }) {
    let content;
    try {
      content = negotiateContent(request3, servingAssetEntry);
    } catch (err) {
      return new NotAcceptableResponse();
    }
    const assetKey = getAssetKey(servingAssetEntry, content);
    const etag = `"${assetKey}"`;
    const weakEtag = `W/${etag}`;
    const ifNoneMatch = request3.headers.get("if-none-match");
    if (ifNoneMatch === weakEtag || ifNoneMatch === etag) {
      return new NotModifiedResponse();
    }
    try {
      const asset = await fetchAsset(assetKey);
      const headers = {
        etag,
        "content-type": asset.contentType
      };
      let encodeBody = "automatic";
      if (xServerEnvHeader) {
        headers["x-server-env"] = xServerEnvHeader;
      }
      if (xDeploymentIdHeader && metadata.deploymentId) {
        headers["x-deployment-id"] = metadata.deploymentId;
      }
      if (content.encoding) {
        encodeBody = "manual";
        headers["cache-control"] = "no-transform";
        headers["content-encoding"] = content.encoding;
      }
      const response = new OkResponse(
        request3.method === "HEAD" ? null : asset.body,
        {
          headers,
          encodeBody
        }
      );
      if (isCacheable(request3)) {
        response.headers.append("cache-control", CACHE_CONTROL_BROWSER);
      }
      attachAdditionalHeaders(response, content, servingAssetEntry, asset);
      if (isPreview(new URL(request3.url))) {
        response.headers.set("x-robots-tag", "noindex");
      }
      if (options29.preserve && waitUntil && caches) {
        waitUntil(
          (async () => {
            try {
              const assetPreservationCacheV2 = await caches.open(
                ASSET_PRESERVATION_CACHE_V2
              );
              const match = await assetPreservationCacheV2.match(request3);
              if (!match || assetKey !== await match.text() || isPreservationCacheResponseExpiring(match)) {
                const preservedResponse = new Response(assetKey, response);
                preservedResponse.headers.set(
                  "cache-control",
                  CACHE_CONTROL_PRESERVATION
                );
                preservedResponse.headers.set("x-robots-tag", "noindex");
                await assetPreservationCacheV2.put(
                  request3.url,
                  preservedResponse
                );
              }
            } catch (err) {
              logError(err);
            }
          })()
        );
      }
      if (isHTMLContentType(asset.contentType) && metadata.analytics?.version === ANALYTICS_VERSION2) {
        return new HTMLRewriter().on("body", {
          element(e3) {
            e3.append(
              `<!-- Cloudflare Pages Analytics --><script defer src='https://static.cloudflareinsights.com/beacon.min.js' data-cf-beacon='{"token": "${metadata.analytics?.token}"}'></script><!-- Cloudflare Pages Analytics -->`,
              { html: true }
            );
          }
        }).transform(response);
      }
      return response;
    } catch (err) {
      logError(err);
      return new InternalServerErrorResponse(err);
    }
  }
  __name(serveAsset, "serveAsset");
  async function notFound() {
    if (caches) {
      try {
        const assetPreservationCacheV2 = await caches.open(
          ASSET_PRESERVATION_CACHE_V2
        );
        let preservedResponse = await assetPreservationCacheV2.match(
          request3.url
        );
        const cutoffDate = /* @__PURE__ */ new Date("2024-05-17");
        if (!preservedResponse && Date.now() < cutoffDate.getTime()) {
          const assetPreservationCacheV1 = await caches.open(
            ASSET_PRESERVATION_CACHE_V1
          );
          preservedResponse = await assetPreservationCacheV1.match(request3.url);
          if (preservedResponse) {
            if (setMetrics) {
              setMetrics({ preservationCacheResult: "checked-hit" });
            }
            return preservedResponse;
          }
        }
        if (preservedResponse) {
          if (setMetrics) {
            setMetrics({ preservationCacheResult: "checked-hit" });
          }
          const assetKey = await preservedResponse.text();
          if (isNullBodyStatus(preservedResponse.status)) {
            return new Response(null, preservedResponse);
          }
          if (assetKey) {
            const asset = await fetchAsset(assetKey);
            if (asset) {
              return new Response(asset.body, preservedResponse);
            } else {
              logError(
                new Error(
                  `preservation cache contained assetKey that does not exist in storage: ${assetKey}`
                )
              );
            }
          } else {
            logError(new Error(`cached response had no assetKey: ${assetKey}`));
          }
        } else {
          if (setMetrics) {
            setMetrics({ preservationCacheResult: "checked-miss" });
          }
        }
      } catch (err) {
        logError(err);
      }
    } else {
      if (setMetrics)
        setMetrics({ preservationCacheResult: "disabled" });
    }
    let cwd2 = pathname;
    while (cwd2) {
      cwd2 = cwd2.slice(0, cwd2.lastIndexOf("/"));
      if (assetEntry = await findAssetEntryForPath(`${cwd2}/404.html`)) {
        let content;
        try {
          content = negotiateContent(request3, assetEntry);
        } catch (err) {
          return new NotAcceptableResponse();
        }
        const assetKey = getAssetKey(assetEntry, content);
        try {
          const { body, contentType } = await fetchAsset(assetKey);
          const response = new NotFoundResponse(body);
          response.headers.set("content-type", contentType);
          return response;
        } catch (err) {
          logError(err);
          return new InternalServerErrorResponse(err);
        }
      }
    }
    return await generateNotFoundResponse(
      request3,
      findAssetEntryForPath,
      serveAsset
    );
  }
  __name(notFound, "notFound");
}
function parseQualityWeightedList(list = "") {
  const items = {};
  list.replace(/\s/g, "").split(",").forEach((el) => {
    const [item, weight] = el.split(";q=");
    items[item] = weight ? parseFloat(weight) : 1;
  });
  return items;
}
function isCacheable(request3) {
  return !request3.headers.has("authorization") && !request3.headers.has("range");
}
function isPreview(url4) {
  if (url4.hostname.endsWith(".pages.dev")) {
    return url4.hostname.split(".").length > 3 ? true : false;
  }
  return false;
}
function isPreservationCacheResponseExpiring(response) {
  const ageHeader = response.headers.get("age");
  if (!ageHeader)
    return false;
  try {
    const age = parseInt(ageHeader);
    const jitter = Math.floor(Math.random() * 43200);
    if (age > CACHE_PRESERVATION_WRITE_FREQUENCY + jitter)
      return true;
  } catch {
    return false;
  }
  return false;
}
function isHTMLContentType(contentType) {
  return contentType?.toLowerCase().startsWith("text/html") || false;
}
var ASSET_PRESERVATION_CACHE_V1, ASSET_PRESERVATION_CACHE_V2, CACHE_CONTROL_PRESERVATION, CACHE_PRESERVATION_WRITE_FREQUENCY, CACHE_CONTROL_BROWSER, REDIRECTS_VERSION2, HEADERS_VERSION2, HEADERS_VERSION_V1, ANALYTICS_VERSION2, ALLOWED_EARLY_HINT_LINK_ATTRIBUTES;
var init_handler = __esm({
  "../pages-shared/asset-server/handler.ts"() {
    init_import_meta_url();
    init_responses();
    init_rulesEngine();
    ASSET_PRESERVATION_CACHE_V1 = "assetPreservationCache";
    ASSET_PRESERVATION_CACHE_V2 = "assetPreservationCacheV2";
    CACHE_CONTROL_PRESERVATION = "public, s-maxage=604800";
    CACHE_PRESERVATION_WRITE_FREQUENCY = 86400;
    CACHE_CONTROL_BROWSER = "public, max-age=0, must-revalidate";
    REDIRECTS_VERSION2 = 1;
    HEADERS_VERSION2 = 2;
    HEADERS_VERSION_V1 = 1;
    ANALYTICS_VERSION2 = 1;
    ALLOWED_EARLY_HINT_LINK_ATTRIBUTES = ["rel", "as", "href"];
    __name(normaliseHeaders, "normaliseHeaders");
    __name(generateHandler, "generateHandler");
    __name(parseQualityWeightedList, "parseQualityWeightedList");
    __name(isCacheable, "isCacheable");
    __name(isPreview, "isPreview");
    __name(isPreservationCacheResponseExpiring, "isPreservationCacheResponseExpiring");
    __name(isHTMLContentType, "isHTMLContentType");
  }
});

// src/miniflare-cli/assets.ts
var assets_exports = {};
__export(assets_exports, {
  default: () => generateASSETSBinding
});
async function generateASSETSBinding(options29) {
  const assetsFetch = options29.directory !== void 0 ? await generateAssetsFetch(options29.directory, options29.log) : invalidAssetsFetch;
  return async function(miniflareRequest) {
    if (options29.proxyPort) {
      try {
        const url4 = new URL(miniflareRequest.url);
        url4.host = `localhost:${options29.proxyPort}`;
        const proxyRequest = new import_miniflare6.Request(url4, miniflareRequest);
        if (proxyRequest.headers.get("Upgrade") === "websocket") {
          proxyRequest.headers.delete("Sec-WebSocket-Accept");
          proxyRequest.headers.delete("Sec-WebSocket-Key");
        }
        return await (0, import_miniflare6.fetch)(proxyRequest, {
          dispatcher: new ProxyDispatcher(miniflareRequest.headers.get("Host"))
        });
      } catch (thrown) {
        options29.log.error(new Error(`Could not proxy request: ${thrown}`));
        return new import_miniflare6.Response(`[wrangler] Could not proxy request: ${thrown}`, {
          status: 502
        });
      }
    } else {
      try {
        return await assetsFetch(miniflareRequest);
      } catch (thrown) {
        options29.log.error(new Error(`Could not serve static asset: ${thrown}`));
        return new import_miniflare6.Response(
          `[wrangler] Could not serve static asset: ${thrown}`,
          { status: 502 }
        );
      }
    }
  };
}
async function generateAssetsFetch(directory, log2) {
  directory = (0, import_node_path22.resolve)(directory);
  const polyfill2 = (await Promise.resolve().then(() => (init_miniflare(), miniflare_exports))).default;
  await polyfill2();
  const { generateHandler: generateHandler3, parseQualityWeightedList: parseQualityWeightedList2 } = await Promise.resolve().then(() => (init_handler(), handler_exports));
  const headersFile = (0, import_node_path22.join)(directory, "_headers");
  const redirectsFile = (0, import_node_path22.join)(directory, "_redirects");
  const workerFile = (0, import_node_path22.join)(directory, "_worker.js");
  const ignoredFiles = [headersFile, redirectsFile, workerFile];
  let redirects;
  if ((0, import_node_fs13.existsSync)(redirectsFile)) {
    const contents = (0, import_node_fs13.readFileSync)(redirectsFile, "utf-8");
    redirects = parseRedirects(contents);
  }
  let headers;
  if ((0, import_node_fs13.existsSync)(headersFile)) {
    const contents = (0, import_node_fs13.readFileSync)(headersFile, "utf-8");
    headers = parseHeaders(contents);
  }
  let metadata = createMetadataObject({
    redirects,
    headers,
    logger: log2
  });
  (0, import_chokidar.watch)([headersFile, redirectsFile], { persistent: true }).on(
    "change",
    (path67) => {
      switch (path67) {
        case headersFile: {
          log2.log("_headers modified. Re-evaluating...");
          const contents = (0, import_node_fs13.readFileSync)(headersFile).toString();
          headers = parseHeaders(contents);
          break;
        }
        case redirectsFile: {
          log2.log("_redirects modified. Re-evaluating...");
          const contents = (0, import_node_fs13.readFileSync)(redirectsFile).toString();
          redirects = parseRedirects(contents);
          break;
        }
      }
      metadata = createMetadataObject({
        redirects,
        headers,
        logger: log2
      });
    }
  );
  const generateResponse = /* @__PURE__ */ __name(async (request3) => {
    const assetKeyEntryMap = /* @__PURE__ */ new Map();
    return await generateHandler3({
      request: request3,
      metadata,
      xServerEnvHeader: "dev",
      logError: console.error,
      findAssetEntryForPath: async (path67) => {
        const filepath = (0, import_node_path22.resolve)((0, import_node_path22.join)(directory, path67));
        if (!filepath.startsWith(directory)) {
          return null;
        }
        if ((0, import_node_fs13.existsSync)(filepath) && (0, import_node_fs13.lstatSync)(filepath).isFile() && !ignoredFiles.includes(filepath)) {
          const hash = hashFile(filepath);
          assetKeyEntryMap.set(hash, filepath);
          return hash;
        }
        return null;
      },
      getAssetKey: (assetEntry) => {
        return assetEntry;
      },
      negotiateContent: (contentRequest) => {
        let rawAcceptEncoding;
        if (contentRequest.cf && "clientAcceptEncoding" in contentRequest.cf && contentRequest.cf.clientAcceptEncoding) {
          rawAcceptEncoding = contentRequest.cf.clientAcceptEncoding;
        } else {
          rawAcceptEncoding = contentRequest.headers.get("Accept-Encoding") || void 0;
        }
        const acceptEncoding = parseQualityWeightedList2(rawAcceptEncoding);
        if (acceptEncoding["identity"] === 0 || acceptEncoding["*"] === 0 && acceptEncoding["identity"] === void 0) {
          throw new Error("No acceptable encodings available");
        }
        return { encoding: null };
      },
      fetchAsset: async (assetKey) => {
        const filepath = assetKeyEntryMap.get(assetKey);
        if (!filepath) {
          throw new Error(
            "Could not fetch asset. Please file an issue on GitHub (https://github.com/cloudflare/workers-sdk/issues/new/choose) with reproduction steps."
          );
        }
        const body = (0, import_node_fs13.readFileSync)(filepath);
        let contentType = (0, import_mime.getType)(filepath) || "application/octet-stream";
        if (contentType.startsWith("text/") && !contentType.includes("charset")) {
          contentType = `${contentType}; charset=utf-8`;
        }
        return { body, contentType };
      }
    });
  }, "generateResponse");
  return async (input, init3) => {
    const request3 = new import_miniflare6.Request(input, init3);
    return await generateResponse(request3);
  };
}
var import_node_assert9, import_node_fs13, import_node_path22, import_chokidar, import_mime, import_miniflare6, import_undici5, ProxyDispatcher, invalidAssetsFetch;
var init_assets = __esm({
  "src/miniflare-cli/assets.ts"() {
    init_import_meta_url();
    import_node_assert9 = __toESM(require("node:assert"));
    import_node_fs13 = require("node:fs");
    import_node_path22 = require("node:path");
    init_createMetadataObject();
    init_parseHeaders();
    init_parseRedirects();
    import_chokidar = require("chokidar");
    import_mime = __toESM(require_mime2());
    import_miniflare6 = require("miniflare");
    import_undici5 = __toESM(require_undici());
    init_hash();
    __name(generateASSETSBinding, "generateASSETSBinding");
    ProxyDispatcher = class extends import_undici5.Dispatcher {
      constructor(host) {
        super();
        this.host = host;
      }
      dispatcher = (0, import_undici5.getGlobalDispatcher)();
      dispatch(options29, handler30) {
        if (this.host !== null) {
          ProxyDispatcher.reinstateHostHeader(options29.headers, this.host);
        }
        return this.dispatcher.dispatch(options29, handler30);
      }
      close() {
        return this.dispatcher.close();
      }
      destroy() {
        return this.dispatcher.destroy();
      }
      /**
       * Ensure that the request contains a Host header, which would have been deleted
       * by the `fetch()` function before calling `dispatcher.dispatch()`.
       */
      static reinstateHostHeader(headers, host) {
        (0, import_node_assert9.default)(headers, "Expected all proxy requests to contain headers.");
        (0, import_node_assert9.default)(
          !Array.isArray(headers),
          "Expected proxy request headers to be a hash object"
        );
        (0, import_node_assert9.default)(
          Object.keys(headers).every((h2) => h2.toLowerCase() !== "host"),
          "Expected Host header to have been deleted."
        );
        headers["Host"] = host;
      }
    };
    __name(ProxyDispatcher, "ProxyDispatcher");
    __name(generateAssetsFetch, "generateAssetsFetch");
    invalidAssetsFetch = /* @__PURE__ */ __name(() => {
      throw new Error(
        "Trying to fetch assets directly when there is no `directory` option specified."
      );
    }, "invalidAssetsFetch");
  }
});

// ../../node_modules/.pnpm/lodash.isequal@4.5.0/node_modules/lodash.isequal/index.js
var require_lodash2 = __commonJS({
  "../../node_modules/.pnpm/lodash.isequal@4.5.0/node_modules/lodash.isequal/index.js"(exports2, module3) {
    init_import_meta_url();
    var LARGE_ARRAY_SIZE = 200;
    var HASH_UNDEFINED = "__lodash_hash_undefined__";
    var COMPARE_PARTIAL_FLAG = 1;
    var COMPARE_UNORDERED_FLAG = 2;
    var MAX_SAFE_INTEGER = 9007199254740991;
    var argsTag = "[object Arguments]";
    var arrayTag = "[object Array]";
    var asyncTag = "[object AsyncFunction]";
    var boolTag = "[object Boolean]";
    var dateTag = "[object Date]";
    var errorTag = "[object Error]";
    var funcTag = "[object Function]";
    var genTag = "[object GeneratorFunction]";
    var mapTag = "[object Map]";
    var numberTag = "[object Number]";
    var nullTag = "[object Null]";
    var objectTag = "[object Object]";
    var promiseTag = "[object Promise]";
    var proxyTag = "[object Proxy]";
    var regexpTag = "[object RegExp]";
    var setTag2 = "[object Set]";
    var stringTag = "[object String]";
    var symbolTag = "[object Symbol]";
    var undefinedTag = "[object Undefined]";
    var weakMapTag = "[object WeakMap]";
    var arrayBufferTag = "[object ArrayBuffer]";
    var dataViewTag = "[object DataView]";
    var float32Tag = "[object Float32Array]";
    var float64Tag = "[object Float64Array]";
    var int8Tag = "[object Int8Array]";
    var int16Tag = "[object Int16Array]";
    var int32Tag = "[object Int32Array]";
    var uint8Tag = "[object Uint8Array]";
    var uint8ClampedTag = "[object Uint8ClampedArray]";
    var uint16Tag = "[object Uint16Array]";
    var uint32Tag = "[object Uint32Array]";
    var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
    var reIsHostCtor = /^\[object .+?Constructor\]$/;
    var reIsUint = /^(?:0|[1-9]\d*)$/;
    var typedArrayTags = {};
    typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
    typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag2] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
    var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
    var freeSelf = typeof self == "object" && self && self.Object === Object && self;
    var root = freeGlobal || freeSelf || Function("return this")();
    var freeExports = typeof exports2 == "object" && exports2 && !exports2.nodeType && exports2;
    var freeModule = freeExports && typeof module3 == "object" && module3 && !module3.nodeType && module3;
    var moduleExports = freeModule && freeModule.exports === freeExports;
    var freeProcess = moduleExports && freeGlobal.process;
    var nodeUtil = function() {
      try {
        return freeProcess && freeProcess.binding && freeProcess.binding("util");
      } catch (e3) {
      }
    }();
    var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
    function arrayFilter(array, predicate) {
      var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
      while (++index < length) {
        var value = array[index];
        if (predicate(value, index, array)) {
          result[resIndex++] = value;
        }
      }
      return result;
    }
    __name(arrayFilter, "arrayFilter");
    function arrayPush(array, values) {
      var index = -1, length = values.length, offset = array.length;
      while (++index < length) {
        array[offset + index] = values[index];
      }
      return array;
    }
    __name(arrayPush, "arrayPush");
    function arraySome(array, predicate) {
      var index = -1, length = array == null ? 0 : array.length;
      while (++index < length) {
        if (predicate(array[index], index, array)) {
          return true;
        }
      }
      return false;
    }
    __name(arraySome, "arraySome");
    function baseTimes(n2, iteratee) {
      var index = -1, result = Array(n2);
      while (++index < n2) {
        result[index] = iteratee(index);
      }
      return result;
    }
    __name(baseTimes, "baseTimes");
    function baseUnary(func) {
      return function(value) {
        return func(value);
      };
    }
    __name(baseUnary, "baseUnary");
    function cacheHas(cache2, key) {
      return cache2.has(key);
    }
    __name(cacheHas, "cacheHas");
    function getValue(object, key) {
      return object == null ? void 0 : object[key];
    }
    __name(getValue, "getValue");
    function mapToArray(map) {
      var index = -1, result = Array(map.size);
      map.forEach(function(value, key) {
        result[++index] = [key, value];
      });
      return result;
    }
    __name(mapToArray, "mapToArray");
    function overArg(func, transform) {
      return function(arg) {
        return func(transform(arg));
      };
    }
    __name(overArg, "overArg");
    function setToArray(set) {
      var index = -1, result = Array(set.size);
      set.forEach(function(value) {
        result[++index] = value;
      });
      return result;
    }
    __name(setToArray, "setToArray");
    var arrayProto = Array.prototype;
    var funcProto = Function.prototype;
    var objectProto = Object.prototype;
    var coreJsData = root["__core-js_shared__"];
    var funcToString = funcProto.toString;
    var hasOwnProperty2 = objectProto.hasOwnProperty;
    var maskSrcKey = function() {
      var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
      return uid ? "Symbol(src)_1." + uid : "";
    }();
    var nativeObjectToString = objectProto.toString;
    var reIsNative = RegExp(
      "^" + funcToString.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
    );
    var Buffer3 = moduleExports ? root.Buffer : void 0;
    var Symbol2 = root.Symbol;
    var Uint8Array2 = root.Uint8Array;
    var propertyIsEnumerable = objectProto.propertyIsEnumerable;
    var splice = arrayProto.splice;
    var symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0;
    var nativeGetSymbols = Object.getOwnPropertySymbols;
    var nativeIsBuffer = Buffer3 ? Buffer3.isBuffer : void 0;
    var nativeKeys = overArg(Object.keys, Object);
    var DataView2 = getNative(root, "DataView");
    var Map2 = getNative(root, "Map");
    var Promise2 = getNative(root, "Promise");
    var Set2 = getNative(root, "Set");
    var WeakMap2 = getNative(root, "WeakMap");
    var nativeCreate = getNative(Object, "create");
    var dataViewCtorString = toSource(DataView2);
    var mapCtorString = toSource(Map2);
    var promiseCtorString = toSource(Promise2);
    var setCtorString = toSource(Set2);
    var weakMapCtorString = toSource(WeakMap2);
    var symbolProto = Symbol2 ? Symbol2.prototype : void 0;
    var symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
    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]);
      }
    }
    __name(Hash, "Hash");
    function hashClear() {
      this.__data__ = nativeCreate ? nativeCreate(null) : {};
      this.size = 0;
    }
    __name(hashClear, "hashClear");
    function hashDelete(key) {
      var result = this.has(key) && delete this.__data__[key];
      this.size -= result ? 1 : 0;
      return result;
    }
    __name(hashDelete, "hashDelete");
    function hashGet(key) {
      var data = this.__data__;
      if (nativeCreate) {
        var result = data[key];
        return result === HASH_UNDEFINED ? void 0 : result;
      }
      return hasOwnProperty2.call(data, key) ? data[key] : void 0;
    }
    __name(hashGet, "hashGet");
    function hashHas(key) {
      var data = this.__data__;
      return nativeCreate ? data[key] !== void 0 : hasOwnProperty2.call(data, key);
    }
    __name(hashHas, "hashHas");
    function hashSet(key, value) {
      var data = this.__data__;
      this.size += this.has(key) ? 0 : 1;
      data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
      return this;
    }
    __name(hashSet, "hashSet");
    Hash.prototype.clear = hashClear;
    Hash.prototype["delete"] = hashDelete;
    Hash.prototype.get = hashGet;
    Hash.prototype.has = hashHas;
    Hash.prototype.set = hashSet;
    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]);
      }
    }
    __name(ListCache, "ListCache");
    function listCacheClear() {
      this.__data__ = [];
      this.size = 0;
    }
    __name(listCacheClear, "listCacheClear");
    function listCacheDelete(key) {
      var data = this.__data__, index = assocIndexOf(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;
    }
    __name(listCacheDelete, "listCacheDelete");
    function listCacheGet(key) {
      var data = this.__data__, index = assocIndexOf(data, key);
      return index < 0 ? void 0 : data[index][1];
    }
    __name(listCacheGet, "listCacheGet");
    function listCacheHas(key) {
      return assocIndexOf(this.__data__, key) > -1;
    }
    __name(listCacheHas, "listCacheHas");
    function listCacheSet(key, value) {
      var data = this.__data__, index = assocIndexOf(data, key);
      if (index < 0) {
        ++this.size;
        data.push([key, value]);
      } else {
        data[index][1] = value;
      }
      return this;
    }
    __name(listCacheSet, "listCacheSet");
    ListCache.prototype.clear = listCacheClear;
    ListCache.prototype["delete"] = listCacheDelete;
    ListCache.prototype.get = listCacheGet;
    ListCache.prototype.has = listCacheHas;
    ListCache.prototype.set = listCacheSet;
    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]);
      }
    }
    __name(MapCache, "MapCache");
    function mapCacheClear() {
      this.size = 0;
      this.__data__ = {
        "hash": new Hash(),
        "map": new (Map2 || ListCache)(),
        "string": new Hash()
      };
    }
    __name(mapCacheClear, "mapCacheClear");
    function mapCacheDelete(key) {
      var result = getMapData(this, key)["delete"](key);
      this.size -= result ? 1 : 0;
      return result;
    }
    __name(mapCacheDelete, "mapCacheDelete");
    function mapCacheGet(key) {
      return getMapData(this, key).get(key);
    }
    __name(mapCacheGet, "mapCacheGet");
    function mapCacheHas(key) {
      return getMapData(this, key).has(key);
    }
    __name(mapCacheHas, "mapCacheHas");
    function mapCacheSet(key, value) {
      var data = getMapData(this, key), size = data.size;
      data.set(key, value);
      this.size += data.size == size ? 0 : 1;
      return this;
    }
    __name(mapCacheSet, "mapCacheSet");
    MapCache.prototype.clear = mapCacheClear;
    MapCache.prototype["delete"] = mapCacheDelete;
    MapCache.prototype.get = mapCacheGet;
    MapCache.prototype.has = mapCacheHas;
    MapCache.prototype.set = mapCacheSet;
    function SetCache(values) {
      var index = -1, length = values == null ? 0 : values.length;
      this.__data__ = new MapCache();
      while (++index < length) {
        this.add(values[index]);
      }
    }
    __name(SetCache, "SetCache");
    function setCacheAdd(value) {
      this.__data__.set(value, HASH_UNDEFINED);
      return this;
    }
    __name(setCacheAdd, "setCacheAdd");
    function setCacheHas(value) {
      return this.__data__.has(value);
    }
    __name(setCacheHas, "setCacheHas");
    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
    SetCache.prototype.has = setCacheHas;
    function Stack(entries) {
      var data = this.__data__ = new ListCache(entries);
      this.size = data.size;
    }
    __name(Stack, "Stack");
    function stackClear() {
      this.__data__ = new ListCache();
      this.size = 0;
    }
    __name(stackClear, "stackClear");
    function stackDelete(key) {
      var data = this.__data__, result = data["delete"](key);
      this.size = data.size;
      return result;
    }
    __name(stackDelete, "stackDelete");
    function stackGet(key) {
      return this.__data__.get(key);
    }
    __name(stackGet, "stackGet");
    function stackHas(key) {
      return this.__data__.has(key);
    }
    __name(stackHas, "stackHas");
    function stackSet(key, value) {
      var data = this.__data__;
      if (data instanceof ListCache) {
        var pairs = data.__data__;
        if (!Map2 || pairs.length < LARGE_ARRAY_SIZE - 1) {
          pairs.push([key, value]);
          this.size = ++data.size;
          return this;
        }
        data = this.__data__ = new MapCache(pairs);
      }
      data.set(key, value);
      this.size = data.size;
      return this;
    }
    __name(stackSet, "stackSet");
    Stack.prototype.clear = stackClear;
    Stack.prototype["delete"] = stackDelete;
    Stack.prototype.get = stackGet;
    Stack.prototype.has = stackHas;
    Stack.prototype.set = stackSet;
    function arrayLikeKeys(value, inherited) {
      var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
      for (var key in value) {
        if ((inherited || hasOwnProperty2.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(key, length)))) {
          result.push(key);
        }
      }
      return result;
    }
    __name(arrayLikeKeys, "arrayLikeKeys");
    function assocIndexOf(array, key) {
      var length = array.length;
      while (length--) {
        if (eq(array[length][0], key)) {
          return length;
        }
      }
      return -1;
    }
    __name(assocIndexOf, "assocIndexOf");
    function baseGetAllKeys(object, keysFunc, symbolsFunc) {
      var result = keysFunc(object);
      return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
    }
    __name(baseGetAllKeys, "baseGetAllKeys");
    function baseGetTag(value) {
      if (value == null) {
        return value === void 0 ? undefinedTag : nullTag;
      }
      return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString2(value);
    }
    __name(baseGetTag, "baseGetTag");
    function baseIsArguments(value) {
      return isObjectLike(value) && baseGetTag(value) == argsTag;
    }
    __name(baseIsArguments, "baseIsArguments");
    function baseIsEqual(value, other, bitmask, customizer, stack) {
      if (value === other) {
        return true;
      }
      if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
        return value !== value && other !== other;
      }
      return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
    }
    __name(baseIsEqual, "baseIsEqual");
    function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
      var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other);
      objTag = objTag == argsTag ? objectTag : objTag;
      othTag = othTag == argsTag ? objectTag : othTag;
      var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
      if (isSameTag && isBuffer(object)) {
        if (!isBuffer(other)) {
          return false;
        }
        objIsArr = true;
        objIsObj = false;
      }
      if (isSameTag && !objIsObj) {
        stack || (stack = new Stack());
        return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
      }
      if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
        var objIsWrapped = objIsObj && hasOwnProperty2.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty2.call(other, "__wrapped__");
        if (objIsWrapped || othIsWrapped) {
          var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
          stack || (stack = new Stack());
          return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
        }
      }
      if (!isSameTag) {
        return false;
      }
      stack || (stack = new Stack());
      return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
    }
    __name(baseIsEqualDeep, "baseIsEqualDeep");
    function baseIsNative(value) {
      if (!isObject2(value) || isMasked(value)) {
        return false;
      }
      var pattern = isFunction2(value) ? reIsNative : reIsHostCtor;
      return pattern.test(toSource(value));
    }
    __name(baseIsNative, "baseIsNative");
    function baseIsTypedArray(value) {
      return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
    }
    __name(baseIsTypedArray, "baseIsTypedArray");
    function baseKeys(object) {
      if (!isPrototype(object)) {
        return nativeKeys(object);
      }
      var result = [];
      for (var key in Object(object)) {
        if (hasOwnProperty2.call(object, key) && key != "constructor") {
          result.push(key);
        }
      }
      return result;
    }
    __name(baseKeys, "baseKeys");
    function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
      var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length;
      if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
        return false;
      }
      var stacked = stack.get(array);
      if (stacked && stack.get(other)) {
        return stacked == other;
      }
      var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : void 0;
      stack.set(array, other);
      stack.set(other, array);
      while (++index < arrLength) {
        var arrValue = array[index], othValue = other[index];
        if (customizer) {
          var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
        }
        if (compared !== void 0) {
          if (compared) {
            continue;
          }
          result = false;
          break;
        }
        if (seen) {
          if (!arraySome(other, function(othValue2, othIndex) {
            if (!cacheHas(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"](array);
      stack["delete"](other);
      return result;
    }
    __name(equalArrays, "equalArrays");
    function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
      switch (tag) {
        case dataViewTag:
          if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
            return false;
          }
          object = object.buffer;
          other = other.buffer;
        case arrayBufferTag:
          if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) {
            return false;
          }
          return true;
        case boolTag:
        case dateTag:
        case numberTag:
          return eq(+object, +other);
        case errorTag:
          return object.name == other.name && object.message == other.message;
        case regexpTag:
        case stringTag:
          return object == other + "";
        case mapTag:
          var convert = mapToArray;
        case setTag2:
          var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
          convert || (convert = setToArray);
          if (object.size != other.size && !isPartial) {
            return false;
          }
          var stacked = stack.get(object);
          if (stacked) {
            return stacked == other;
          }
          bitmask |= COMPARE_UNORDERED_FLAG;
          stack.set(object, other);
          var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
          stack["delete"](object);
          return result;
        case symbolTag:
          if (symbolValueOf) {
            return symbolValueOf.call(object) == symbolValueOf.call(other);
          }
      }
      return false;
    }
    __name(equalByTag, "equalByTag");
    function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
      var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
      if (objLength != othLength && !isPartial) {
        return false;
      }
      var index = objLength;
      while (index--) {
        var key = objProps[index];
        if (!(isPartial ? key in other : hasOwnProperty2.call(other, key))) {
          return false;
        }
      }
      var stacked = stack.get(object);
      if (stacked && stack.get(other)) {
        return stacked == other;
      }
      var result = true;
      stack.set(object, other);
      stack.set(other, object);
      var skipCtor = isPartial;
      while (++index < objLength) {
        key = objProps[index];
        var objValue = object[key], othValue = other[key];
        if (customizer) {
          var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, 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 = object.constructor, othCtor = other.constructor;
        if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
          result = false;
        }
      }
      stack["delete"](object);
      stack["delete"](other);
      return result;
    }
    __name(equalObjects, "equalObjects");
    function getAllKeys(object) {
      return baseGetAllKeys(object, keys, getSymbols);
    }
    __name(getAllKeys, "getAllKeys");
    function getMapData(map, key) {
      var data = map.__data__;
      return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
    }
    __name(getMapData, "getMapData");
    function getNative(object, key) {
      var value = getValue(object, key);
      return baseIsNative(value) ? value : void 0;
    }
    __name(getNative, "getNative");
    function getRawTag(value) {
      var isOwn = hasOwnProperty2.call(value, symToStringTag), tag = value[symToStringTag];
      try {
        value[symToStringTag] = void 0;
        var unmasked = true;
      } catch (e3) {
      }
      var result = nativeObjectToString.call(value);
      if (unmasked) {
        if (isOwn) {
          value[symToStringTag] = tag;
        } else {
          delete value[symToStringTag];
        }
      }
      return result;
    }
    __name(getRawTag, "getRawTag");
    var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
      if (object == null) {
        return [];
      }
      object = Object(object);
      return arrayFilter(nativeGetSymbols(object), function(symbol) {
        return propertyIsEnumerable.call(object, symbol);
      });
    };
    var getTag = baseGetTag;
    if (DataView2 && getTag(new DataView2(new ArrayBuffer(1))) != dataViewTag || Map2 && getTag(new Map2()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set2 && getTag(new Set2()) != setTag2 || WeakMap2 && getTag(new WeakMap2()) != weakMapTag) {
      getTag = /* @__PURE__ */ __name(function(value) {
        var result = baseGetTag(value), Ctor = result == objectTag ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
        if (ctorString) {
          switch (ctorString) {
            case dataViewCtorString:
              return dataViewTag;
            case mapCtorString:
              return mapTag;
            case promiseCtorString:
              return promiseTag;
            case setCtorString:
              return setTag2;
            case weakMapCtorString:
              return weakMapTag;
          }
        }
        return result;
      }, "getTag");
    }
    function isIndex(value, length) {
      length = length == null ? MAX_SAFE_INTEGER : length;
      return !!length && (typeof value == "number" || reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
    }
    __name(isIndex, "isIndex");
    function isKeyable(value) {
      var type = typeof value;
      return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
    }
    __name(isKeyable, "isKeyable");
    function isMasked(func) {
      return !!maskSrcKey && maskSrcKey in func;
    }
    __name(isMasked, "isMasked");
    function isPrototype(value) {
      var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto;
      return value === proto;
    }
    __name(isPrototype, "isPrototype");
    function objectToString2(value) {
      return nativeObjectToString.call(value);
    }
    __name(objectToString2, "objectToString");
    function toSource(func) {
      if (func != null) {
        try {
          return funcToString.call(func);
        } catch (e3) {
        }
        try {
          return func + "";
        } catch (e3) {
        }
      }
      return "";
    }
    __name(toSource, "toSource");
    function eq(value, other) {
      return value === other || value !== value && other !== other;
    }
    __name(eq, "eq");
    var isArguments = baseIsArguments(function() {
      return arguments;
    }()) ? baseIsArguments : function(value) {
      return isObjectLike(value) && hasOwnProperty2.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
    };
    var isArray = Array.isArray;
    function isArrayLike(value) {
      return value != null && isLength(value.length) && !isFunction2(value);
    }
    __name(isArrayLike, "isArrayLike");
    var isBuffer = nativeIsBuffer || stubFalse;
    function isEqual(value, other) {
      return baseIsEqual(value, other);
    }
    __name(isEqual, "isEqual");
    function isFunction2(value) {
      if (!isObject2(value)) {
        return false;
      }
      var tag = baseGetTag(value);
      return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
    }
    __name(isFunction2, "isFunction");
    function isLength(value) {
      return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
    }
    __name(isLength, "isLength");
    function isObject2(value) {
      var type = typeof value;
      return value != null && (type == "object" || type == "function");
    }
    __name(isObject2, "isObject");
    function isObjectLike(value) {
      return value != null && typeof value == "object";
    }
    __name(isObjectLike, "isObjectLike");
    var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
    function keys(object) {
      return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
    }
    __name(keys, "keys");
    function stubArray() {
      return [];
    }
    __name(stubArray, "stubArray");
    function stubFalse() {
      return false;
    }
    __name(stubFalse, "stubFalse");
    module3.exports = isEqual;
  }
});

// ../../node_modules/.pnpm/arr-rotate@1.0.0/node_modules/arr-rotate/index.js
var require_arr_rotate = __commonJS({
  "../../node_modules/.pnpm/arr-rotate@1.0.0/node_modules/arr-rotate/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = (input, n2) => {
      if (!Array.isArray(input)) {
        throw new TypeError(`Expected an array, got ${typeof input}`);
      }
      const x2 = input.slice();
      const num = typeof n2 === "number" ? n2 : 0;
      return x2.splice(-num % x2.length).concat(x2);
    };
  }
});

// ../../node_modules/.pnpm/figures@3.2.0/node_modules/figures/index.js
var require_figures3 = __commonJS({
  "../../node_modules/.pnpm/figures@3.2.0/node_modules/figures/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var escapeStringRegexp = require_escape_string_regexp2();
    var { platform: platform2 } = process;
    var main2 = {
      tick: "\u2714",
      cross: "\u2716",
      star: "\u2605",
      square: "\u2587",
      squareSmall: "\u25FB",
      squareSmallFilled: "\u25FC",
      play: "\u25B6",
      circle: "\u25EF",
      circleFilled: "\u25C9",
      circleDotted: "\u25CC",
      circleDouble: "\u25CE",
      circleCircle: "\u24DE",
      circleCross: "\u24E7",
      circlePipe: "\u24BE",
      circleQuestionMark: "?\u20DD",
      bullet: "\u25CF",
      dot: "\u2024",
      line: "\u2500",
      ellipsis: "\u2026",
      pointer: "\u276F",
      pointerSmall: "\u203A",
      info: "\u2139",
      warning: "\u26A0",
      hamburger: "\u2630",
      smiley: "\u32E1",
      mustache: "\u0DF4",
      heart: "\u2665",
      nodejs: "\u2B22",
      arrowUp: "\u2191",
      arrowDown: "\u2193",
      arrowLeft: "\u2190",
      arrowRight: "\u2192",
      radioOn: "\u25C9",
      radioOff: "\u25EF",
      checkboxOn: "\u2612",
      checkboxOff: "\u2610",
      checkboxCircleOn: "\u24E7",
      checkboxCircleOff: "\u24BE",
      questionMarkPrefix: "?\u20DD",
      oneHalf: "\xBD",
      oneThird: "\u2153",
      oneQuarter: "\xBC",
      oneFifth: "\u2155",
      oneSixth: "\u2159",
      oneSeventh: "\u2150",
      oneEighth: "\u215B",
      oneNinth: "\u2151",
      oneTenth: "\u2152",
      twoThirds: "\u2154",
      twoFifths: "\u2156",
      threeQuarters: "\xBE",
      threeFifths: "\u2157",
      threeEighths: "\u215C",
      fourFifths: "\u2158",
      fiveSixths: "\u215A",
      fiveEighths: "\u215D",
      sevenEighths: "\u215E"
    };
    var windows = {
      tick: "\u221A",
      cross: "\xD7",
      star: "*",
      square: "\u2588",
      squareSmall: "[ ]",
      squareSmallFilled: "[\u2588]",
      play: "\u25BA",
      circle: "( )",
      circleFilled: "(*)",
      circleDotted: "( )",
      circleDouble: "( )",
      circleCircle: "(\u25CB)",
      circleCross: "(\xD7)",
      circlePipe: "(\u2502)",
      circleQuestionMark: "(?)",
      bullet: "*",
      dot: ".",
      line: "\u2500",
      ellipsis: "...",
      pointer: ">",
      pointerSmall: "\xBB",
      info: "i",
      warning: "\u203C",
      hamburger: "\u2261",
      smiley: "\u263A",
      mustache: "\u250C\u2500\u2510",
      heart: main2.heart,
      nodejs: "\u2666",
      arrowUp: main2.arrowUp,
      arrowDown: main2.arrowDown,
      arrowLeft: main2.arrowLeft,
      arrowRight: main2.arrowRight,
      radioOn: "(*)",
      radioOff: "( )",
      checkboxOn: "[\xD7]",
      checkboxOff: "[ ]",
      checkboxCircleOn: "(\xD7)",
      checkboxCircleOff: "( )",
      questionMarkPrefix: "\uFF1F",
      oneHalf: "1/2",
      oneThird: "1/3",
      oneQuarter: "1/4",
      oneFifth: "1/5",
      oneSixth: "1/6",
      oneSeventh: "1/7",
      oneEighth: "1/8",
      oneNinth: "1/9",
      oneTenth: "1/10",
      twoThirds: "2/3",
      twoFifths: "2/5",
      threeQuarters: "3/4",
      threeFifths: "3/5",
      threeEighths: "3/8",
      fourFifths: "4/5",
      fiveSixths: "5/6",
      fiveEighths: "5/8",
      sevenEighths: "7/8"
    };
    if (platform2 === "linux") {
      main2.questionMarkPrefix = "?";
    }
    var figures = platform2 === "win32" ? windows : main2;
    var fn2 = /* @__PURE__ */ __name((string) => {
      if (figures === main2) {
        return string;
      }
      for (const [key, value] of Object.entries(main2)) {
        if (value === figures[key]) {
          continue;
        }
        string = string.replace(new RegExp(escapeStringRegexp(value), "g"), figures[key]);
      }
      return string;
    }, "fn");
    module3.exports = Object.assign(fn2, figures);
    module3.exports.main = main2;
    module3.exports.windows = windows;
  }
});

// ../../node_modules/.pnpm/ink-select-input@4.2.1_ink@3.2.0_react@17.0.2/node_modules/ink-select-input/build/Indicator.js
var require_Indicator = __commonJS({
  "../../node_modules/.pnpm/ink-select-input@4.2.1_ink@3.2.0_react@17.0.2/node_modules/ink-select-input/build/Indicator.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    var React19 = require_react();
    var ink_1 = require_build2();
    var figures = require_figures3();
    var Indicator = /* @__PURE__ */ __name(({ isSelected = false }) => React19.createElement(ink_1.Box, { marginRight: 1 }, isSelected ? React19.createElement(ink_1.Text, { color: "blue" }, figures.pointer) : React19.createElement(ink_1.Text, null, " ")), "Indicator");
    exports2.default = Indicator;
  }
});

// ../../node_modules/.pnpm/ink-select-input@4.2.1_ink@3.2.0_react@17.0.2/node_modules/ink-select-input/build/Item.js
var require_Item = __commonJS({
  "../../node_modules/.pnpm/ink-select-input@4.2.1_ink@3.2.0_react@17.0.2/node_modules/ink-select-input/build/Item.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    var React19 = require_react();
    var ink_1 = require_build2();
    var Item = /* @__PURE__ */ __name(({ isSelected = false, label }) => React19.createElement(ink_1.Text, { color: isSelected ? "blue" : void 0 }, label), "Item");
    exports2.default = Item;
  }
});

// ../../node_modules/.pnpm/ink-select-input@4.2.1_ink@3.2.0_react@17.0.2/node_modules/ink-select-input/build/SelectInput.js
var require_SelectInput = __commonJS({
  "../../node_modules/.pnpm/ink-select-input@4.2.1_ink@3.2.0_react@17.0.2/node_modules/ink-select-input/build/SelectInput.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    var React19 = require_react();
    var react_1 = require_react();
    var isEqual = require_lodash2();
    var arrayRotate = require_arr_rotate();
    var ink_1 = require_build2();
    var Indicator_1 = require_Indicator();
    var Item_1 = require_Item();
    function SelectInput4({ items = [], isFocused = true, initialIndex = 0, indicatorComponent = Indicator_1.default, itemComponent = Item_1.default, limit: customLimit, onSelect, onHighlight }) {
      const [rotateIndex, setRotateIndex] = react_1.useState(0);
      const [selectedIndex, setSelectedIndex] = react_1.useState(initialIndex);
      const hasLimit = typeof customLimit === "number" && items.length > customLimit;
      const limit = hasLimit ? Math.min(customLimit, items.length) : items.length;
      const previousItems = react_1.useRef(items);
      react_1.useEffect(() => {
        if (!isEqual(previousItems.current.map((item) => item.value), items.map((item) => item.value))) {
          setRotateIndex(0);
          setSelectedIndex(0);
        }
        previousItems.current = items;
      }, [items]);
      ink_1.useInput(react_1.useCallback((input, key) => {
        if (input === "k" || key.upArrow) {
          const lastIndex = (hasLimit ? limit : items.length) - 1;
          const atFirstIndex = selectedIndex === 0;
          const nextIndex = hasLimit ? selectedIndex : lastIndex;
          const nextRotateIndex = atFirstIndex ? rotateIndex + 1 : rotateIndex;
          const nextSelectedIndex = atFirstIndex ? nextIndex : selectedIndex - 1;
          setRotateIndex(nextRotateIndex);
          setSelectedIndex(nextSelectedIndex);
          const slicedItems2 = hasLimit ? arrayRotate(items, nextRotateIndex).slice(0, limit) : items;
          if (typeof onHighlight === "function") {
            onHighlight(slicedItems2[nextSelectedIndex]);
          }
        }
        if (input === "j" || key.downArrow) {
          const atLastIndex = selectedIndex === (hasLimit ? limit : items.length) - 1;
          const nextIndex = hasLimit ? selectedIndex : 0;
          const nextRotateIndex = atLastIndex ? rotateIndex - 1 : rotateIndex;
          const nextSelectedIndex = atLastIndex ? nextIndex : selectedIndex + 1;
          setRotateIndex(nextRotateIndex);
          setSelectedIndex(nextSelectedIndex);
          const slicedItems2 = hasLimit ? arrayRotate(items, nextRotateIndex).slice(0, limit) : items;
          if (typeof onHighlight === "function") {
            onHighlight(slicedItems2[nextSelectedIndex]);
          }
        }
        if (key.return) {
          const slicedItems2 = hasLimit ? arrayRotate(items, rotateIndex).slice(0, limit) : items;
          if (typeof onSelect === "function") {
            onSelect(slicedItems2[selectedIndex]);
          }
        }
      }, [
        hasLimit,
        limit,
        rotateIndex,
        selectedIndex,
        items,
        onSelect,
        onHighlight
      ]), { isActive: isFocused });
      const slicedItems = hasLimit ? arrayRotate(items, rotateIndex).slice(0, limit) : items;
      return React19.createElement(ink_1.Box, { flexDirection: "column" }, slicedItems.map((item, index) => {
        var _a2;
        const isSelected = index === selectedIndex;
        return React19.createElement(
          ink_1.Box,
          { key: (_a2 = item.key) !== null && _a2 !== void 0 ? _a2 : item.value },
          React19.createElement(indicatorComponent, { isSelected }),
          React19.createElement(itemComponent, { ...item, isSelected })
        );
      }));
    }
    __name(SelectInput4, "SelectInput");
    exports2.default = SelectInput4;
  }
});

// ../../node_modules/.pnpm/ink-select-input@4.2.1_ink@3.2.0_react@17.0.2/node_modules/ink-select-input/build/index.js
var require_build3 = __commonJS({
  "../../node_modules/.pnpm/ink-select-input@4.2.1_ink@3.2.0_react@17.0.2/node_modules/ink-select-input/build/index.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    var SelectInput_1 = require_SelectInput();
    exports2.default = SelectInput_1.default;
    var Indicator_1 = require_Indicator();
    Object.defineProperty(exports2, "Indicator", { enumerable: true, get: function() {
      return Indicator_1.default;
    } });
    var Item_1 = require_Item();
    Object.defineProperty(exports2, "Item", { enumerable: true, get: function() {
      return Item_1.default;
    } });
  }
});

// ../../node_modules/.pnpm/shell-quote@1.8.1/node_modules/shell-quote/quote.js
var require_quote = __commonJS({
  "../../node_modules/.pnpm/shell-quote@1.8.1/node_modules/shell-quote/quote.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = /* @__PURE__ */ __name(function quote2(xs) {
      return xs.map(function(s) {
        if (s && typeof s === "object") {
          return s.op.replace(/(.)/g, "\\$1");
        }
        if (/["\s]/.test(s) && !/'/.test(s)) {
          return "'" + s.replace(/(['\\])/g, "\\$1") + "'";
        }
        if (/["'\s]/.test(s)) {
          return '"' + s.replace(/(["\\$`!])/g, "\\$1") + '"';
        }
        return String(s).replace(/([A-Za-z]:)?([#!"$&'()*,:;<=>?@[\\\]^`{|}])/g, "$1\\$2");
      }).join(" ");
    }, "quote");
  }
});

// ../../node_modules/.pnpm/shell-quote@1.8.1/node_modules/shell-quote/parse.js
var require_parse9 = __commonJS({
  "../../node_modules/.pnpm/shell-quote@1.8.1/node_modules/shell-quote/parse.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var CONTROL = "(?:" + [
      "\\|\\|",
      "\\&\\&",
      ";;",
      "\\|\\&",
      "\\<\\(",
      "\\<\\<\\<",
      ">>",
      ">\\&",
      "<\\&",
      "[&;()|<>]"
    ].join("|") + ")";
    var controlRE = new RegExp("^" + CONTROL + "$");
    var META = "|&;()<> \\t";
    var SINGLE_QUOTE = '"((\\\\"|[^"])*?)"';
    var DOUBLE_QUOTE = "'((\\\\'|[^'])*?)'";
    var hash = /^#$/;
    var SQ = "'";
    var DQ = '"';
    var DS = "$";
    var TOKEN = "";
    var mult = 4294967296;
    for (i = 0; i < 4; i++) {
      TOKEN += (mult * Math.random()).toString(16);
    }
    var i;
    var startsWithToken = new RegExp("^" + TOKEN);
    function matchAll(s, r3) {
      var origIndex = r3.lastIndex;
      var matches = [];
      var matchObj;
      while (matchObj = r3.exec(s)) {
        matches.push(matchObj);
        if (r3.lastIndex === matchObj.index) {
          r3.lastIndex += 1;
        }
      }
      r3.lastIndex = origIndex;
      return matches;
    }
    __name(matchAll, "matchAll");
    function getVar(env5, pre, key) {
      var r3 = typeof env5 === "function" ? env5(key) : env5[key];
      if (typeof r3 === "undefined" && key != "") {
        r3 = "";
      } else if (typeof r3 === "undefined") {
        r3 = "$";
      }
      if (typeof r3 === "object") {
        return pre + TOKEN + JSON.stringify(r3) + TOKEN;
      }
      return pre + r3;
    }
    __name(getVar, "getVar");
    function parseInternal(string, env5, opts) {
      if (!opts) {
        opts = {};
      }
      var BS = opts.escape || "\\";
      var BAREWORD = "(\\" + BS + `['"` + META + `]|[^\\s'"` + META + "])+";
      var chunker = new RegExp([
        "(" + CONTROL + ")",
        // control chars
        "(" + BAREWORD + "|" + SINGLE_QUOTE + "|" + DOUBLE_QUOTE + ")+"
      ].join("|"), "g");
      var matches = matchAll(string, chunker);
      if (matches.length === 0) {
        return [];
      }
      if (!env5) {
        env5 = {};
      }
      var commented = false;
      return matches.map(function(match) {
        var s = match[0];
        if (!s || commented) {
          return void 0;
        }
        if (controlRE.test(s)) {
          return { op: s };
        }
        var quote2 = false;
        var esc = false;
        var out = "";
        var isGlob = false;
        var i2;
        function parseEnvVar() {
          i2 += 1;
          var varend;
          var varname;
          var char = s.charAt(i2);
          if (char === "{") {
            i2 += 1;
            if (s.charAt(i2) === "}") {
              throw new Error("Bad substitution: " + s.slice(i2 - 2, i2 + 1));
            }
            varend = s.indexOf("}", i2);
            if (varend < 0) {
              throw new Error("Bad substitution: " + s.slice(i2));
            }
            varname = s.slice(i2, varend);
            i2 = varend;
          } else if (/[*@#?$!_-]/.test(char)) {
            varname = char;
            i2 += 1;
          } else {
            var slicedFromI = s.slice(i2);
            varend = slicedFromI.match(/[^\w\d_]/);
            if (!varend) {
              varname = slicedFromI;
              i2 = s.length;
            } else {
              varname = slicedFromI.slice(0, varend.index);
              i2 += varend.index - 1;
            }
          }
          return getVar(env5, "", varname);
        }
        __name(parseEnvVar, "parseEnvVar");
        for (i2 = 0; i2 < s.length; i2++) {
          var c2 = s.charAt(i2);
          isGlob = isGlob || !quote2 && (c2 === "*" || c2 === "?");
          if (esc) {
            out += c2;
            esc = false;
          } else if (quote2) {
            if (c2 === quote2) {
              quote2 = false;
            } else if (quote2 == SQ) {
              out += c2;
            } else {
              if (c2 === BS) {
                i2 += 1;
                c2 = s.charAt(i2);
                if (c2 === DQ || c2 === BS || c2 === DS) {
                  out += c2;
                } else {
                  out += BS + c2;
                }
              } else if (c2 === DS) {
                out += parseEnvVar();
              } else {
                out += c2;
              }
            }
          } else if (c2 === DQ || c2 === SQ) {
            quote2 = c2;
          } else if (controlRE.test(c2)) {
            return { op: s };
          } else if (hash.test(c2)) {
            commented = true;
            var commentObj = { comment: string.slice(match.index + i2 + 1) };
            if (out.length) {
              return [out, commentObj];
            }
            return [commentObj];
          } else if (c2 === BS) {
            esc = true;
          } else if (c2 === DS) {
            out += parseEnvVar();
          } else {
            out += c2;
          }
        }
        if (isGlob) {
          return { op: "glob", pattern: out };
        }
        return out;
      }).reduce(function(prev, arg) {
        return typeof arg === "undefined" ? prev : prev.concat(arg);
      }, []);
    }
    __name(parseInternal, "parseInternal");
    module3.exports = /* @__PURE__ */ __name(function parse7(s, env5, opts) {
      var mapped = parseInternal(s, env5, opts);
      if (typeof env5 !== "function") {
        return mapped;
      }
      return mapped.reduce(function(acc, s2) {
        if (typeof s2 === "object") {
          return acc.concat(s2);
        }
        var xs = s2.split(RegExp("(" + TOKEN + ".*?" + TOKEN + ")", "g"));
        if (xs.length === 1) {
          return acc.concat(xs[0]);
        }
        return acc.concat(xs.filter(Boolean).map(function(x2) {
          if (startsWithToken.test(x2)) {
            return JSON.parse(x2.split(TOKEN)[1]);
          }
          return x2;
        }));
      }, []);
    }, "parse");
  }
});

// ../../node_modules/.pnpm/shell-quote@1.8.1/node_modules/shell-quote/index.js
var require_shell_quote = __commonJS({
  "../../node_modules/.pnpm/shell-quote@1.8.1/node_modules/shell-quote/index.js"(exports2) {
    "use strict";
    init_import_meta_url();
    exports2.quote = require_quote();
    exports2.parse = require_parse9();
  }
});

// ../../node_modules/.pnpm/picocolors@1.0.0/node_modules/picocolors/picocolors.js
var require_picocolors = __commonJS({
  "../../node_modules/.pnpm/picocolors@1.0.0/node_modules/picocolors/picocolors.js"(exports2, module3) {
    init_import_meta_url();
    var tty2 = require("tty");
    var isColorSupported = !("NO_COLOR" in process.env || process.argv.includes("--no-color")) && ("FORCE_COLOR" in process.env || process.argv.includes("--color") || process.platform === "win32" || tty2.isatty(1) && process.env.TERM !== "dumb" || "CI" in process.env);
    var formatter = /* @__PURE__ */ __name((open3, close2, replace = open3) => (input) => {
      let string = "" + input;
      let index = string.indexOf(close2, open3.length);
      return ~index ? open3 + replaceClose(string, close2, replace, index) + close2 : open3 + string + close2;
    }, "formatter");
    var replaceClose = /* @__PURE__ */ __name((string, close2, replace, index) => {
      let start = string.substring(0, index) + replace;
      let end = string.substring(index + close2.length);
      let nextIndex = end.indexOf(close2);
      return ~nextIndex ? start + replaceClose(end, close2, replace, nextIndex) : start + end;
    }, "replaceClose");
    var createColors = /* @__PURE__ */ __name((enabled = isColorSupported) => ({
      isColorSupported: enabled,
      reset: enabled ? (s) => `\x1B[0m${s}\x1B[0m` : String,
      bold: enabled ? formatter("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m") : String,
      dim: enabled ? formatter("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m") : String,
      italic: enabled ? formatter("\x1B[3m", "\x1B[23m") : String,
      underline: enabled ? formatter("\x1B[4m", "\x1B[24m") : String,
      inverse: enabled ? formatter("\x1B[7m", "\x1B[27m") : String,
      hidden: enabled ? formatter("\x1B[8m", "\x1B[28m") : String,
      strikethrough: enabled ? formatter("\x1B[9m", "\x1B[29m") : String,
      black: enabled ? formatter("\x1B[30m", "\x1B[39m") : String,
      red: enabled ? formatter("\x1B[31m", "\x1B[39m") : String,
      green: enabled ? formatter("\x1B[32m", "\x1B[39m") : String,
      yellow: enabled ? formatter("\x1B[33m", "\x1B[39m") : String,
      blue: enabled ? formatter("\x1B[34m", "\x1B[39m") : String,
      magenta: enabled ? formatter("\x1B[35m", "\x1B[39m") : String,
      cyan: enabled ? formatter("\x1B[36m", "\x1B[39m") : String,
      white: enabled ? formatter("\x1B[37m", "\x1B[39m") : String,
      gray: enabled ? formatter("\x1B[90m", "\x1B[39m") : String,
      bgBlack: enabled ? formatter("\x1B[40m", "\x1B[49m") : String,
      bgRed: enabled ? formatter("\x1B[41m", "\x1B[49m") : String,
      bgGreen: enabled ? formatter("\x1B[42m", "\x1B[49m") : String,
      bgYellow: enabled ? formatter("\x1B[43m", "\x1B[49m") : String,
      bgBlue: enabled ? formatter("\x1B[44m", "\x1B[49m") : String,
      bgMagenta: enabled ? formatter("\x1B[45m", "\x1B[49m") : String,
      bgCyan: enabled ? formatter("\x1B[46m", "\x1B[49m") : String,
      bgWhite: enabled ? formatter("\x1B[47m", "\x1B[49m") : String
    }), "createColors");
    module3.exports = createColors();
    module3.exports.createColors = createColors;
  }
});

// ../../node_modules/.pnpm/eastasianwidth@0.2.0/node_modules/eastasianwidth/eastasianwidth.js
var require_eastasianwidth = __commonJS({
  "../../node_modules/.pnpm/eastasianwidth@0.2.0/node_modules/eastasianwidth/eastasianwidth.js"(exports2, module3) {
    init_import_meta_url();
    var eaw = {};
    if ("undefined" == typeof module3) {
      window.eastasianwidth = eaw;
    } else {
      module3.exports = eaw;
    }
    eaw.eastAsianWidth = function(character) {
      var x2 = character.charCodeAt(0);
      var y2 = character.length == 2 ? character.charCodeAt(1) : 0;
      var codePoint = x2;
      if (55296 <= x2 && x2 <= 56319 && (56320 <= y2 && y2 <= 57343)) {
        x2 &= 1023;
        y2 &= 1023;
        codePoint = x2 << 10 | y2;
        codePoint += 65536;
      }
      if (12288 == codePoint || 65281 <= codePoint && codePoint <= 65376 || 65504 <= codePoint && codePoint <= 65510) {
        return "F";
      }
      if (8361 == codePoint || 65377 <= codePoint && codePoint <= 65470 || 65474 <= codePoint && codePoint <= 65479 || 65482 <= codePoint && codePoint <= 65487 || 65490 <= codePoint && codePoint <= 65495 || 65498 <= codePoint && codePoint <= 65500 || 65512 <= codePoint && codePoint <= 65518) {
        return "H";
      }
      if (4352 <= codePoint && codePoint <= 4447 || 4515 <= codePoint && codePoint <= 4519 || 4602 <= codePoint && codePoint <= 4607 || 9001 <= codePoint && codePoint <= 9002 || 11904 <= codePoint && codePoint <= 11929 || 11931 <= codePoint && codePoint <= 12019 || 12032 <= codePoint && codePoint <= 12245 || 12272 <= codePoint && codePoint <= 12283 || 12289 <= codePoint && codePoint <= 12350 || 12353 <= codePoint && codePoint <= 12438 || 12441 <= codePoint && codePoint <= 12543 || 12549 <= codePoint && codePoint <= 12589 || 12593 <= codePoint && codePoint <= 12686 || 12688 <= codePoint && codePoint <= 12730 || 12736 <= codePoint && codePoint <= 12771 || 12784 <= codePoint && codePoint <= 12830 || 12832 <= codePoint && codePoint <= 12871 || 12880 <= codePoint && codePoint <= 13054 || 13056 <= codePoint && codePoint <= 19903 || 19968 <= codePoint && codePoint <= 42124 || 42128 <= codePoint && codePoint <= 42182 || 43360 <= codePoint && codePoint <= 43388 || 44032 <= codePoint && codePoint <= 55203 || 55216 <= codePoint && codePoint <= 55238 || 55243 <= codePoint && codePoint <= 55291 || 63744 <= codePoint && codePoint <= 64255 || 65040 <= codePoint && codePoint <= 65049 || 65072 <= codePoint && codePoint <= 65106 || 65108 <= codePoint && codePoint <= 65126 || 65128 <= codePoint && codePoint <= 65131 || 110592 <= codePoint && codePoint <= 110593 || 127488 <= codePoint && codePoint <= 127490 || 127504 <= codePoint && codePoint <= 127546 || 127552 <= codePoint && codePoint <= 127560 || 127568 <= codePoint && codePoint <= 127569 || 131072 <= codePoint && codePoint <= 194367 || 177984 <= codePoint && codePoint <= 196605 || 196608 <= codePoint && codePoint <= 262141) {
        return "W";
      }
      if (32 <= codePoint && codePoint <= 126 || 162 <= codePoint && codePoint <= 163 || 165 <= codePoint && codePoint <= 166 || 172 == codePoint || 175 == codePoint || 10214 <= codePoint && codePoint <= 10221 || 10629 <= codePoint && codePoint <= 10630) {
        return "Na";
      }
      if (161 == codePoint || 164 == codePoint || 167 <= codePoint && codePoint <= 168 || 170 == codePoint || 173 <= codePoint && codePoint <= 174 || 176 <= codePoint && codePoint <= 180 || 182 <= codePoint && codePoint <= 186 || 188 <= codePoint && codePoint <= 191 || 198 == codePoint || 208 == codePoint || 215 <= codePoint && codePoint <= 216 || 222 <= codePoint && codePoint <= 225 || 230 == codePoint || 232 <= codePoint && codePoint <= 234 || 236 <= codePoint && codePoint <= 237 || 240 == codePoint || 242 <= codePoint && codePoint <= 243 || 247 <= codePoint && codePoint <= 250 || 252 == codePoint || 254 == codePoint || 257 == codePoint || 273 == codePoint || 275 == codePoint || 283 == codePoint || 294 <= codePoint && codePoint <= 295 || 299 == codePoint || 305 <= codePoint && codePoint <= 307 || 312 == codePoint || 319 <= codePoint && codePoint <= 322 || 324 == codePoint || 328 <= codePoint && codePoint <= 331 || 333 == codePoint || 338 <= codePoint && codePoint <= 339 || 358 <= codePoint && codePoint <= 359 || 363 == codePoint || 462 == codePoint || 464 == codePoint || 466 == codePoint || 468 == codePoint || 470 == codePoint || 472 == codePoint || 474 == codePoint || 476 == codePoint || 593 == codePoint || 609 == codePoint || 708 == codePoint || 711 == codePoint || 713 <= codePoint && codePoint <= 715 || 717 == codePoint || 720 == codePoint || 728 <= codePoint && codePoint <= 731 || 733 == codePoint || 735 == codePoint || 768 <= codePoint && codePoint <= 879 || 913 <= codePoint && codePoint <= 929 || 931 <= codePoint && codePoint <= 937 || 945 <= codePoint && codePoint <= 961 || 963 <= codePoint && codePoint <= 969 || 1025 == codePoint || 1040 <= codePoint && codePoint <= 1103 || 1105 == codePoint || 8208 == codePoint || 8211 <= codePoint && codePoint <= 8214 || 8216 <= codePoint && codePoint <= 8217 || 8220 <= codePoint && codePoint <= 8221 || 8224 <= codePoint && codePoint <= 8226 || 8228 <= codePoint && codePoint <= 8231 || 8240 == codePoint || 8242 <= codePoint && codePoint <= 8243 || 8245 == codePoint || 8251 == codePoint || 8254 == codePoint || 8308 == codePoint || 8319 == codePoint || 8321 <= codePoint && codePoint <= 8324 || 8364 == codePoint || 8451 == codePoint || 8453 == codePoint || 8457 == codePoint || 8467 == codePoint || 8470 == codePoint || 8481 <= codePoint && codePoint <= 8482 || 8486 == codePoint || 8491 == codePoint || 8531 <= codePoint && codePoint <= 8532 || 8539 <= codePoint && codePoint <= 8542 || 8544 <= codePoint && codePoint <= 8555 || 8560 <= codePoint && codePoint <= 8569 || 8585 == codePoint || 8592 <= codePoint && codePoint <= 8601 || 8632 <= codePoint && codePoint <= 8633 || 8658 == codePoint || 8660 == codePoint || 8679 == codePoint || 8704 == codePoint || 8706 <= codePoint && codePoint <= 8707 || 8711 <= codePoint && codePoint <= 8712 || 8715 == codePoint || 8719 == codePoint || 8721 == codePoint || 8725 == codePoint || 8730 == codePoint || 8733 <= codePoint && codePoint <= 8736 || 8739 == codePoint || 8741 == codePoint || 8743 <= codePoint && codePoint <= 8748 || 8750 == codePoint || 8756 <= codePoint && codePoint <= 8759 || 8764 <= codePoint && codePoint <= 8765 || 8776 == codePoint || 8780 == codePoint || 8786 == codePoint || 8800 <= codePoint && codePoint <= 8801 || 8804 <= codePoint && codePoint <= 8807 || 8810 <= codePoint && codePoint <= 8811 || 8814 <= codePoint && codePoint <= 8815 || 8834 <= codePoint && codePoint <= 8835 || 8838 <= codePoint && codePoint <= 8839 || 8853 == codePoint || 8857 == codePoint || 8869 == codePoint || 8895 == codePoint || 8978 == codePoint || 9312 <= codePoint && codePoint <= 9449 || 9451 <= codePoint && codePoint <= 9547 || 9552 <= codePoint && codePoint <= 9587 || 9600 <= codePoint && codePoint <= 9615 || 9618 <= codePoint && codePoint <= 9621 || 9632 <= codePoint && codePoint <= 9633 || 9635 <= codePoint && codePoint <= 9641 || 9650 <= codePoint && codePoint <= 9651 || 9654 <= codePoint && codePoint <= 9655 || 9660 <= codePoint && codePoint <= 9661 || 9664 <= codePoint && codePoint <= 9665 || 9670 <= codePoint && codePoint <= 9672 || 9675 == codePoint || 9678 <= codePoint && codePoint <= 9681 || 9698 <= codePoint && codePoint <= 9701 || 9711 == codePoint || 9733 <= codePoint && codePoint <= 9734 || 9737 == codePoint || 9742 <= codePoint && codePoint <= 9743 || 9748 <= codePoint && codePoint <= 9749 || 9756 == codePoint || 9758 == codePoint || 9792 == codePoint || 9794 == codePoint || 9824 <= codePoint && codePoint <= 9825 || 9827 <= codePoint && codePoint <= 9829 || 9831 <= codePoint && codePoint <= 9834 || 9836 <= codePoint && codePoint <= 9837 || 9839 == codePoint || 9886 <= codePoint && codePoint <= 9887 || 9918 <= codePoint && codePoint <= 9919 || 9924 <= codePoint && codePoint <= 9933 || 9935 <= codePoint && codePoint <= 9953 || 9955 == codePoint || 9960 <= codePoint && codePoint <= 9983 || 10045 == codePoint || 10071 == codePoint || 10102 <= codePoint && codePoint <= 10111 || 11093 <= codePoint && codePoint <= 11097 || 12872 <= codePoint && codePoint <= 12879 || 57344 <= codePoint && codePoint <= 63743 || 65024 <= codePoint && codePoint <= 65039 || 65533 == codePoint || 127232 <= codePoint && codePoint <= 127242 || 127248 <= codePoint && codePoint <= 127277 || 127280 <= codePoint && codePoint <= 127337 || 127344 <= codePoint && codePoint <= 127386 || 917760 <= codePoint && codePoint <= 917999 || 983040 <= codePoint && codePoint <= 1048573 || 1048576 <= codePoint && codePoint <= 1114109) {
        return "A";
      }
      return "N";
    };
    eaw.characterLength = function(character) {
      var code = this.eastAsianWidth(character);
      if (code == "F" || code == "W" || code == "A") {
        return 2;
      } else {
        return 1;
      }
    };
    function stringToArray(string) {
      return string.match(/[\uD800-\uDBFF][\uDC00-\uDFFF]|[^\uD800-\uDFFF]/g) || [];
    }
    __name(stringToArray, "stringToArray");
    eaw.length = function(string) {
      var characters = stringToArray(string);
      var len = 0;
      for (var i = 0; i < characters.length; i++) {
        len = len + this.characterLength(characters[i]);
      }
      return len;
    };
    eaw.slice = function(text, start, end) {
      textLen = eaw.length(text);
      start = start ? start : 0;
      end = end ? end : 1;
      if (start < 0) {
        start = textLen + start;
      }
      if (end < 0) {
        end = textLen + end;
      }
      var result = "";
      var eawLen = 0;
      var chars = stringToArray(text);
      for (var i = 0; i < chars.length; i++) {
        var char = chars[i];
        var charLen = eaw.length(char);
        if (eawLen >= start - (charLen == 2 ? 1 : 0)) {
          if (eawLen + charLen <= end) {
            result += char;
          } else {
            break;
          }
        }
        eawLen += charLen;
      }
      return result;
    };
  }
});

// ../../node_modules/.pnpm/emoji-regex@9.2.2/node_modules/emoji-regex/index.js
var require_emoji_regex2 = __commonJS({
  "../../node_modules/.pnpm/emoji-regex@9.2.2/node_modules/emoji-regex/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = function() {
      return /\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62(?:\uDB40\uDC77\uDB40\uDC6C\uDB40\uDC73|\uDB40\uDC73\uDB40\uDC63\uDB40\uDC74|\uDB40\uDC65\uDB40\uDC6E\uDB40\uDC67)\uDB40\uDC7F|(?:\uD83E\uDDD1\uD83C\uDFFF\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB-\uDFFE])|(?:\uD83E\uDDD1\uD83C\uDFFE\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFD\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFC\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFB\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFC-\uDFFF])|\uD83D\uDC68(?:\uD83C\uDFFB(?:\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF]))|\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFC-\uDFFF])|[\u2695\u2696\u2708]\uFE0F|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))?|(?:\uD83C[\uDFFC-\uDFFF])\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF]))|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83D\uDC68|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFE])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])\uFE0F|\u200D(?:(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D[\uDC66\uDC67])|\uD83D[\uDC66\uDC67])|\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC)?|(?:\uD83D\uDC69(?:\uD83C\uDFFB\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|(?:\uD83C[\uDFFC-\uDFFF])\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69]))|\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1)(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC69(?:\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83E\uDDD1(?:\u200D(?:\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D[\uDC66\uDC67])|\uD83D\uDC69\u200D\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D\uDC41\uFE0F\u200D\uD83D\uDDE8|\uD83E\uDDD1(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|\uD83D\uDC69(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|\uD83D\uDE36\u200D\uD83C\uDF2B|\uD83C\uDFF3\uFE0F\u200D\u26A7|\uD83D\uDC3B\u200D\u2744|(?:(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC6F|\uD83E[\uDD3C\uDDDE\uDDDF])\u200D[\u2640\u2642]|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|\uD83C\uDFF4\u200D\u2620|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])\u200D[\u2640\u2642]|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u2600-\u2604\u260E\u2611\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26B0\u26B1\u26C8\u26CF\u26D1\u26D3\u26E9\u26F0\u26F1\u26F4\u26F7\u26F8\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u3030\u303D\u3297\u3299]|\uD83C[\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]|\uD83D[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3])\uFE0F|\uD83C\uDFF3\uFE0F\u200D\uD83C\uDF08|\uD83D\uDC69\u200D\uD83D\uDC67|\uD83D\uDC69\u200D\uD83D\uDC66|\uD83D\uDE35\u200D\uD83D\uDCAB|\uD83D\uDE2E\u200D\uD83D\uDCA8|\uD83D\uDC15\u200D\uD83E\uDDBA|\uD83E\uDDD1(?:\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC|\uD83C\uDFFB)?|\uD83D\uDC69(?:\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC|\uD83C\uDFFB)?|\uD83C\uDDFD\uD83C\uDDF0|\uD83C\uDDF6\uD83C\uDDE6|\uD83C\uDDF4\uD83C\uDDF2|\uD83D\uDC08\u200D\u2B1B|\u2764\uFE0F\u200D(?:\uD83D\uDD25|\uD83E\uDE79)|\uD83D\uDC41\uFE0F|\uD83C\uDFF3\uFE0F|\uD83C\uDDFF(?:\uD83C[\uDDE6\uDDF2\uDDFC])|\uD83C\uDDFE(?:\uD83C[\uDDEA\uDDF9])|\uD83C\uDDFC(?:\uD83C[\uDDEB\uDDF8])|\uD83C\uDDFB(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA])|\uD83C\uDDFA(?:\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF])|\uD83C\uDDF9(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF])|\uD83C\uDDF8(?:\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF])|\uD83C\uDDF7(?:\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC])|\uD83C\uDDF5(?:\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE])|\uD83C\uDDF3(?:\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF])|\uD83C\uDDF2(?:\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF])|\uD83C\uDDF1(?:\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE])|\uD83C\uDDF0(?:\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF])|\uD83C\uDDEF(?:\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5])|\uD83C\uDDEE(?:\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9])|\uD83C\uDDED(?:\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA])|\uD83C\uDDEC(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE])|\uD83C\uDDEB(?:\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7])|\uD83C\uDDEA(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA])|\uD83C\uDDE9(?:\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF])|\uD83C\uDDE8(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF])|\uD83C\uDDE7(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF])|\uD83C\uDDE6(?:\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF])|[#\*0-9]\uFE0F\u20E3|\u2764\uFE0F|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])|\uD83C\uDFF4|(?:[\u270A\u270B]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0C\uDD0F\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5])(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u261D\u270C\u270D]|\uD83D[\uDD74\uDD90])(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])|[\u270A\u270B]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC08\uDC15\uDC3B\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE2E\uDE35\uDE36\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0C\uDD0F\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5]|\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD]|\uD83D\uDC6F|\uD83E[\uDD3C\uDDDE\uDDDF]|[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB]|\uD83E[\uDD0D\uDD0E\uDD10-\uDD17\uDD1D\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78\uDD7A-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCB\uDDD0\uDDE0-\uDDFF\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6]|(?:[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u270A\u270B\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF93\uDFA0-\uDFCA\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF4\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC3E\uDC40\uDC42-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDD7A\uDD95\uDD96\uDDA4\uDDFB-\uDE4F\uDE80-\uDEC5\uDECC\uDED0-\uDED2\uDED5-\uDED7\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB]|\uD83E[\uDD0C-\uDD3A\uDD3C-\uDD45\uDD47-\uDD78\uDD7A-\uDDCB\uDDCD-\uDDFF\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6])|(?:[#\*0-9\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23E9-\u23F3\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB-\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u261D\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692-\u2697\u2699\u269B\u269C\u26A0\u26A1\u26A7\u26AA\u26AB\u26B0\u26B1\u26BD\u26BE\u26C4\u26C5\u26C8\u26CE\u26CF\u26D1\u26D3\u26D4\u26E9\u26EA\u26F0-\u26F5\u26F7-\u26FA\u26FD\u2702\u2705\u2708-\u270D\u270F\u2712\u2714\u2716\u271D\u2721\u2728\u2733\u2734\u2744\u2747\u274C\u274E\u2753-\u2755\u2757\u2763\u2764\u2795-\u2797\u27A1\u27B0\u27BF\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B50\u2B55\u3030\u303D\u3297\u3299]|\uD83C[\uDC04\uDCCF\uDD70\uDD71\uDD7E\uDD7F\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE02\uDE1A\uDE2F\uDE32-\uDE3A\uDE50\uDE51\uDF00-\uDF21\uDF24-\uDF93\uDF96\uDF97\uDF99-\uDF9B\uDF9E-\uDFF0\uDFF3-\uDFF5\uDFF7-\uDFFF]|\uD83D[\uDC00-\uDCFD\uDCFF-\uDD3D\uDD49-\uDD4E\uDD50-\uDD67\uDD6F\uDD70\uDD73-\uDD7A\uDD87\uDD8A-\uDD8D\uDD90\uDD95\uDD96\uDDA4\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA-\uDE4F\uDE80-\uDEC5\uDECB-\uDED2\uDED5-\uDED7\uDEE0-\uDEE5\uDEE9\uDEEB\uDEEC\uDEF0\uDEF3-\uDEFC\uDFE0-\uDFEB]|\uD83E[\uDD0C-\uDD3A\uDD3C-\uDD45\uDD47-\uDD78\uDD7A-\uDDCB\uDDCD-\uDDFF\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6])\uFE0F|(?:[\u261D\u26F9\u270A-\u270D]|\uD83C[\uDF85\uDFC2-\uDFC4\uDFC7\uDFCA-\uDFCC]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66-\uDC78\uDC7C\uDC81-\uDC83\uDC85-\uDC87\uDC8F\uDC91\uDCAA\uDD74\uDD75\uDD7A\uDD90\uDD95\uDD96\uDE45-\uDE47\uDE4B-\uDE4F\uDEA3\uDEB4-\uDEB6\uDEC0\uDECC]|\uD83E[\uDD0C\uDD0F\uDD18-\uDD1F\uDD26\uDD30-\uDD39\uDD3C-\uDD3E\uDD77\uDDB5\uDDB6\uDDB8\uDDB9\uDDBB\uDDCD-\uDDCF\uDDD1-\uDDDD])/g;
    };
  }
});

// ../../node_modules/.pnpm/object-hash@2.2.0/node_modules/object-hash/index.js
var require_object_hash = __commonJS({
  "../../node_modules/.pnpm/object-hash@2.2.0/node_modules/object-hash/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var crypto5 = require("crypto");
    exports2 = module3.exports = objectHash;
    function objectHash(object, options29) {
      options29 = applyDefaults(object, options29);
      return hash(object, options29);
    }
    __name(objectHash, "objectHash");
    exports2.sha1 = function(object) {
      return objectHash(object);
    };
    exports2.keys = function(object) {
      return objectHash(object, { excludeValues: true, algorithm: "sha1", encoding: "hex" });
    };
    exports2.MD5 = function(object) {
      return objectHash(object, { algorithm: "md5", encoding: "hex" });
    };
    exports2.keysMD5 = function(object) {
      return objectHash(object, { algorithm: "md5", encoding: "hex", excludeValues: true });
    };
    var hashes = crypto5.getHashes ? crypto5.getHashes().slice() : ["sha1", "md5"];
    hashes.push("passthrough");
    var encodings = ["buffer", "hex", "binary", "base64"];
    function applyDefaults(object, sourceOptions) {
      sourceOptions = sourceOptions || {};
      var options29 = {};
      options29.algorithm = sourceOptions.algorithm || "sha1";
      options29.encoding = sourceOptions.encoding || "hex";
      options29.excludeValues = sourceOptions.excludeValues ? true : false;
      options29.algorithm = options29.algorithm.toLowerCase();
      options29.encoding = options29.encoding.toLowerCase();
      options29.ignoreUnknown = sourceOptions.ignoreUnknown !== true ? false : true;
      options29.respectType = sourceOptions.respectType === false ? false : true;
      options29.respectFunctionNames = sourceOptions.respectFunctionNames === false ? false : true;
      options29.respectFunctionProperties = sourceOptions.respectFunctionProperties === false ? false : true;
      options29.unorderedArrays = sourceOptions.unorderedArrays !== true ? false : true;
      options29.unorderedSets = sourceOptions.unorderedSets === false ? false : true;
      options29.unorderedObjects = sourceOptions.unorderedObjects === false ? false : true;
      options29.replacer = sourceOptions.replacer || void 0;
      options29.excludeKeys = sourceOptions.excludeKeys || void 0;
      if (typeof object === "undefined") {
        throw new Error("Object argument required.");
      }
      for (var i = 0; i < hashes.length; ++i) {
        if (hashes[i].toLowerCase() === options29.algorithm.toLowerCase()) {
          options29.algorithm = hashes[i];
        }
      }
      if (hashes.indexOf(options29.algorithm) === -1) {
        throw new Error('Algorithm "' + options29.algorithm + '"  not supported. supported values: ' + hashes.join(", "));
      }
      if (encodings.indexOf(options29.encoding) === -1 && options29.algorithm !== "passthrough") {
        throw new Error('Encoding "' + options29.encoding + '"  not supported. supported values: ' + encodings.join(", "));
      }
      return options29;
    }
    __name(applyDefaults, "applyDefaults");
    function isNativeFunction(f) {
      if (typeof f !== "function") {
        return false;
      }
      var exp = /^function\s+\w*\s*\(\s*\)\s*{\s+\[native code\]\s+}$/i;
      return exp.exec(Function.prototype.toString.call(f)) != null;
    }
    __name(isNativeFunction, "isNativeFunction");
    function hash(object, options29) {
      var hashingStream;
      if (options29.algorithm !== "passthrough") {
        hashingStream = crypto5.createHash(options29.algorithm);
      } else {
        hashingStream = new PassThrough();
      }
      if (typeof hashingStream.write === "undefined") {
        hashingStream.write = hashingStream.update;
        hashingStream.end = hashingStream.update;
      }
      var hasher = typeHasher(options29, hashingStream);
      hasher.dispatch(object);
      if (!hashingStream.update) {
        hashingStream.end("");
      }
      if (hashingStream.digest) {
        return hashingStream.digest(options29.encoding === "buffer" ? void 0 : options29.encoding);
      }
      var buf = hashingStream.read();
      if (options29.encoding === "buffer") {
        return buf;
      }
      return buf.toString(options29.encoding);
    }
    __name(hash, "hash");
    exports2.writeToStream = function(object, options29, stream2) {
      if (typeof stream2 === "undefined") {
        stream2 = options29;
        options29 = {};
      }
      options29 = applyDefaults(object, options29);
      return typeHasher(options29, stream2).dispatch(object);
    };
    function typeHasher(options29, writeTo, context2) {
      context2 = context2 || [];
      var write = /* @__PURE__ */ __name(function(str) {
        if (writeTo.update) {
          return writeTo.update(str, "utf8");
        } else {
          return writeTo.write(str, "utf8");
        }
      }, "write");
      return {
        dispatch: function(value) {
          if (options29.replacer) {
            value = options29.replacer(value);
          }
          var type = typeof value;
          if (value === null) {
            type = "null";
          }
          return this["_" + type](value);
        },
        _object: function(object) {
          var pattern = /\[object (.*)\]/i;
          var objString = Object.prototype.toString.call(object);
          var objType = pattern.exec(objString);
          if (!objType) {
            objType = "unknown:[" + objString + "]";
          } else {
            objType = objType[1];
          }
          objType = objType.toLowerCase();
          var objectNumber = null;
          if ((objectNumber = context2.indexOf(object)) >= 0) {
            return this.dispatch("[CIRCULAR:" + objectNumber + "]");
          } else {
            context2.push(object);
          }
          if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(object)) {
            write("buffer:");
            return write(object);
          }
          if (objType !== "object" && objType !== "function" && objType !== "asyncfunction") {
            if (this["_" + objType]) {
              this["_" + objType](object);
            } else if (options29.ignoreUnknown) {
              return write("[" + objType + "]");
            } else {
              throw new Error('Unknown object type "' + objType + '"');
            }
          } else {
            var keys = Object.keys(object);
            if (options29.unorderedObjects) {
              keys = keys.sort();
            }
            if (options29.respectType !== false && !isNativeFunction(object)) {
              keys.splice(0, 0, "prototype", "__proto__", "constructor");
            }
            if (options29.excludeKeys) {
              keys = keys.filter(function(key) {
                return !options29.excludeKeys(key);
              });
            }
            write("object:" + keys.length + ":");
            var self2 = this;
            return keys.forEach(function(key) {
              self2.dispatch(key);
              write(":");
              if (!options29.excludeValues) {
                self2.dispatch(object[key]);
              }
              write(",");
            });
          }
        },
        _array: function(arr, unordered) {
          unordered = typeof unordered !== "undefined" ? unordered : options29.unorderedArrays !== false;
          var self2 = this;
          write("array:" + arr.length + ":");
          if (!unordered || arr.length <= 1) {
            return arr.forEach(function(entry) {
              return self2.dispatch(entry);
            });
          }
          var contextAdditions = [];
          var entries = arr.map(function(entry) {
            var strm = new PassThrough();
            var localContext = context2.slice();
            var hasher = typeHasher(options29, strm, localContext);
            hasher.dispatch(entry);
            contextAdditions = contextAdditions.concat(localContext.slice(context2.length));
            return strm.read().toString();
          });
          context2 = context2.concat(contextAdditions);
          entries.sort();
          return this._array(entries, false);
        },
        _date: function(date) {
          return write("date:" + date.toJSON());
        },
        _symbol: function(sym) {
          return write("symbol:" + sym.toString());
        },
        _error: function(err) {
          return write("error:" + err.toString());
        },
        _boolean: function(bool) {
          return write("bool:" + bool.toString());
        },
        _string: function(string) {
          write("string:" + string.length + ":");
          write(string.toString());
        },
        _function: function(fn2) {
          write("fn:");
          if (isNativeFunction(fn2)) {
            this.dispatch("[native]");
          } else {
            this.dispatch(fn2.toString());
          }
          if (options29.respectFunctionNames !== false) {
            this.dispatch("function-name:" + String(fn2.name));
          }
          if (options29.respectFunctionProperties) {
            this._object(fn2);
          }
        },
        _number: function(number) {
          return write("number:" + number.toString());
        },
        _xml: function(xml) {
          return write("xml:" + xml.toString());
        },
        _null: function() {
          return write("Null");
        },
        _undefined: function() {
          return write("Undefined");
        },
        _regexp: function(regex2) {
          return write("regex:" + regex2.toString());
        },
        _uint8array: function(arr) {
          write("uint8array:");
          return this.dispatch(Array.prototype.slice.call(arr));
        },
        _uint8clampedarray: function(arr) {
          write("uint8clampedarray:");
          return this.dispatch(Array.prototype.slice.call(arr));
        },
        _int8array: function(arr) {
          write("uint8array:");
          return this.dispatch(Array.prototype.slice.call(arr));
        },
        _uint16array: function(arr) {
          write("uint16array:");
          return this.dispatch(Array.prototype.slice.call(arr));
        },
        _int16array: function(arr) {
          write("uint16array:");
          return this.dispatch(Array.prototype.slice.call(arr));
        },
        _uint32array: function(arr) {
          write("uint32array:");
          return this.dispatch(Array.prototype.slice.call(arr));
        },
        _int32array: function(arr) {
          write("uint32array:");
          return this.dispatch(Array.prototype.slice.call(arr));
        },
        _float32array: function(arr) {
          write("float32array:");
          return this.dispatch(Array.prototype.slice.call(arr));
        },
        _float64array: function(arr) {
          write("float64array:");
          return this.dispatch(Array.prototype.slice.call(arr));
        },
        _arraybuffer: function(arr) {
          write("arraybuffer:");
          return this.dispatch(new Uint8Array(arr));
        },
        _url: function(url4) {
          return write("url:" + url4.toString(), "utf8");
        },
        _map: function(map) {
          write("map:");
          var arr = Array.from(map);
          return this._array(arr, options29.unorderedSets !== false);
        },
        _set: function(set) {
          write("set:");
          var arr = Array.from(set);
          return this._array(arr, options29.unorderedSets !== false);
        },
        _file: function(file) {
          write("file:");
          return this.dispatch([file.name, file.size, file.type, file.lastModfied]);
        },
        _blob: function() {
          if (options29.ignoreUnknown) {
            return write("[blob]");
          }
          throw Error('Hashing Blob objects is currently not supported\n(see https://github.com/puleos/object-hash/issues/26)\nUse "options.replacer" or "options.ignoreUnknown"\n');
        },
        _domwindow: function() {
          return write("domwindow");
        },
        _bigint: function(number) {
          return write("bigint:" + number.toString());
        },
        /* Node.js standard native objects */
        _process: function() {
          return write("process");
        },
        _timer: function() {
          return write("timer");
        },
        _pipe: function() {
          return write("pipe");
        },
        _tcp: function() {
          return write("tcp");
        },
        _udp: function() {
          return write("udp");
        },
        _tty: function() {
          return write("tty");
        },
        _statwatcher: function() {
          return write("statwatcher");
        },
        _securecontext: function() {
          return write("securecontext");
        },
        _connection: function() {
          return write("connection");
        },
        _zlib: function() {
          return write("zlib");
        },
        _context: function() {
          return write("context");
        },
        _nodescript: function() {
          return write("nodescript");
        },
        _httpparser: function() {
          return write("httpparser");
        },
        _dataview: function() {
          return write("dataview");
        },
        _signal: function() {
          return write("signal");
        },
        _fsevent: function() {
          return write("fsevent");
        },
        _tlswrap: function() {
          return write("tlswrap");
        }
      };
    }
    __name(typeHasher, "typeHasher");
    function PassThrough() {
      return {
        buf: "",
        write: function(b2) {
          this.buf += b2;
        },
        end: function(b2) {
          this.buf += b2;
        },
        read: function() {
          return this.buf;
        }
      };
    }
    __name(PassThrough, "PassThrough");
  }
});

// ../../node_modules/.pnpm/ink-table@3.0.0_ink@3.2.0_react@17.0.2/node_modules/ink-table/dist/index.js
var require_dist4 = __commonJS({
  "../../node_modules/.pnpm/ink-table@3.0.0_ink@3.2.0_react@17.0.2/node_modules/ink-table/dist/index.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Skeleton = exports2.Cell = exports2.Header = void 0;
    var react_1 = __importDefault(require_react());
    var ink_1 = require_build2();
    var object_hash_1 = require_object_hash();
    var Table10 = class extends react_1.default.Component {
      constructor() {
        super(...arguments);
        this.header = row({
          cell: this.getConfig().skeleton,
          padding: this.getConfig().padding,
          skeleton: {
            component: this.getConfig().skeleton,
            // chars
            line: "\u2500",
            left: "\u250C",
            right: "\u2510",
            cross: "\u252C"
          }
        });
        this.heading = row({
          cell: this.getConfig().header,
          padding: this.getConfig().padding,
          skeleton: {
            component: this.getConfig().skeleton,
            // chars
            line: " ",
            left: "\u2502",
            right: "\u2502",
            cross: "\u2502"
          }
        });
        this.separator = row({
          cell: this.getConfig().skeleton,
          padding: this.getConfig().padding,
          skeleton: {
            component: this.getConfig().skeleton,
            // chars
            line: "\u2500",
            left: "\u251C",
            right: "\u2524",
            cross: "\u253C"
          }
        });
        this.data = row({
          cell: this.getConfig().cell,
          padding: this.getConfig().padding,
          skeleton: {
            component: this.getConfig().skeleton,
            // chars
            line: " ",
            left: "\u2502",
            right: "\u2502",
            cross: "\u2502"
          }
        });
        this.footer = row({
          cell: this.getConfig().skeleton,
          padding: this.getConfig().padding,
          skeleton: {
            component: this.getConfig().skeleton,
            // chars
            line: "\u2500",
            left: "\u2514",
            right: "\u2518",
            cross: "\u2534"
          }
        });
      }
      /**
       * Merges provided configuration with defaults.
       */
      getConfig() {
        return {
          data: this.props.data,
          columns: this.props.columns || this.getDataKeys(),
          padding: this.props.padding || 1,
          header: this.props.header || Header,
          cell: this.props.cell || Cell,
          skeleton: this.props.skeleton || Skeleton
        };
      }
      /**
       * Gets all keyes used in data by traversing through the data.
       */
      getDataKeys() {
        let keys = /* @__PURE__ */ new Set();
        for (const data of this.props.data) {
          for (const key in data) {
            keys.add(key);
          }
        }
        return Array.from(keys);
      }
      /**
       * Calculates the width of each column by finding
       * the longest value in a cell of a particular column.
       *
       * Returns a list of column names and their widths.
       */
      getColumns() {
        const { columns, padding } = this.getConfig();
        const widths = columns.map((key) => {
          const header = String(key).length;
          const data = this.props.data.map((data2) => {
            const value = data2[key];
            if (value == void 0 || value == null)
              return 0;
            return String(value).length;
          });
          const width = Math.max(...data, header) + padding * 2;
          return {
            column: key,
            width,
            key: String(key)
          };
        });
        return widths;
      }
      /**
       * Returns a (data) row representing the headings.
       */
      getHeadings() {
        const { columns } = this.getConfig();
        const headings = columns.reduce((acc, column) => ({ ...acc, [column]: column }), {});
        return headings;
      }
      /* Render */
      render() {
        const columns = this.getColumns();
        const headings = this.getHeadings();
        return react_1.default.createElement(
          ink_1.Box,
          { flexDirection: "column" },
          this.header({ key: "header", columns, data: {} }),
          this.heading({ key: "heading", columns, data: headings }),
          this.props.data.map((row2, index) => {
            const key = `row-${object_hash_1.sha1(row2)}-${index}`;
            return react_1.default.createElement(
              ink_1.Box,
              { flexDirection: "column", key },
              this.separator({ key: `separator-${key}`, columns, data: {} }),
              this.data({ key: `data-${key}`, columns, data: row2 })
            );
          }),
          this.footer({ key: "footer", columns, data: {} })
        );
      }
    };
    __name(Table10, "Table");
    exports2.default = Table10;
    function row(config) {
      const skeleton = config.skeleton;
      return (props) => react_1.default.createElement(
        ink_1.Box,
        { flexDirection: "row" },
        react_1.default.createElement(skeleton.component, null, skeleton.left),
        intersperse(
          (i) => {
            const key = `${props.key}-hseparator-${i}`;
            return react_1.default.createElement(skeleton.component, { key }, skeleton.cross);
          },
          // Values.
          props.columns.map((column) => {
            const value = props.data[column.column];
            if (value == void 0 || value == null) {
              const key = `${props.key}-empty-${column.key}`;
              return react_1.default.createElement(config.cell, { key }, skeleton.line.repeat(column.width));
            } else {
              const key = `${props.key}-cell-${column.key}`;
              const ml = config.padding;
              const mr = column.width - String(value).length - config.padding;
              return (
                /* prettier-ignore */
                react_1.default.createElement(config.cell, { key }, `${skeleton.line.repeat(ml)}${String(value)}${skeleton.line.repeat(mr)}`)
              );
            }
          })
        ),
        react_1.default.createElement(skeleton.component, null, skeleton.right)
      );
    }
    __name(row, "row");
    function Header(props) {
      return react_1.default.createElement(ink_1.Text, { bold: true, color: "blue" }, props.children);
    }
    __name(Header, "Header");
    exports2.Header = Header;
    function Cell(props) {
      return react_1.default.createElement(ink_1.Text, null, props.children);
    }
    __name(Cell, "Cell");
    exports2.Cell = Cell;
    function Skeleton(props) {
      return react_1.default.createElement(ink_1.Text, { bold: true }, props.children);
    }
    __name(Skeleton, "Skeleton");
    exports2.Skeleton = Skeleton;
    function intersperse(intersperser, elements) {
      let interspersed = elements.reduce((acc, element, index) => {
        if (acc.length === 0)
          return [element];
        return [...acc, intersperser(index), element];
      }, []);
      return interspersed;
    }
    __name(intersperse, "intersperse");
  }
});

// ../../node_modules/.pnpm/ignore@5.2.0/node_modules/ignore/index.js
var require_ignore = __commonJS({
  "../../node_modules/.pnpm/ignore@5.2.0/node_modules/ignore/index.js"(exports2, module3) {
    init_import_meta_url();
    function makeArray(subject) {
      return Array.isArray(subject) ? subject : [subject];
    }
    __name(makeArray, "makeArray");
    var EMPTY = "";
    var SPACE = " ";
    var ESCAPE = "\\";
    var REGEX_TEST_BLANK_LINE = /^\s+$/;
    var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
    var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
    var REGEX_SPLITALL_CRLF = /\r?\n/g;
    var REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
    var SLASH = "/";
    var KEY_IGNORE = typeof Symbol !== "undefined" ? Symbol.for("node-ignore") : "node-ignore";
    var define2 = /* @__PURE__ */ __name((object, key, value) => Object.defineProperty(object, key, { value }), "define");
    var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
    var RETURN_FALSE = /* @__PURE__ */ __name(() => false, "RETURN_FALSE");
    var sanitizeRange = /* @__PURE__ */ __name((range) => range.replace(
      REGEX_REGEXP_RANGE,
      (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY
    ), "sanitizeRange");
    var cleanRangeBackSlash = /* @__PURE__ */ __name((slashes) => {
      const { length } = slashes;
      return slashes.slice(0, length - length % 2);
    }, "cleanRangeBackSlash");
    var REPLACERS = [
      // > Trailing spaces are ignored unless they are quoted with backslash ("\")
      [
        // (a\ ) -> (a )
        // (a  ) -> (a)
        // (a \ ) -> (a  )
        /\\?\s+$/,
        (match) => match.indexOf("\\") === 0 ? SPACE : EMPTY
      ],
      // replace (\ ) with ' '
      [
        /\\\s/g,
        () => SPACE
      ],
      // Escape metacharacters
      // which is written down by users but means special for regular expressions.
      // > There are 12 characters with special meanings:
      // > - the backslash \,
      // > - the caret ^,
      // > - the dollar sign $,
      // > - the period or dot .,
      // > - the vertical bar or pipe symbol |,
      // > - the question mark ?,
      // > - the asterisk or star *,
      // > - the plus sign +,
      // > - the opening parenthesis (,
      // > - the closing parenthesis ),
      // > - and the opening square bracket [,
      // > - the opening curly brace {,
      // > These special characters are often called "metacharacters".
      [
        /[\\$.|*+(){^]/g,
        (match) => `\\${match}`
      ],
      [
        // > a question mark (?) matches a single character
        /(?!\\)\?/g,
        () => "[^/]"
      ],
      // leading slash
      [
        // > A leading slash matches the beginning of the pathname.
        // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
        // A leading slash matches the beginning of the pathname
        /^\//,
        () => "^"
      ],
      // replace special metacharacter slash after the leading slash
      [
        /\//g,
        () => "\\/"
      ],
      [
        // > A leading "**" followed by a slash means match in all directories.
        // > For example, "**/foo" matches file or directory "foo" anywhere,
        // > the same as pattern "foo".
        // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
        // >   under directory "foo".
        // Notice that the '*'s have been replaced as '\\*'
        /^\^*\\\*\\\*\\\//,
        // '**/foo' <-> 'foo'
        () => "^(?:.*\\/)?"
      ],
      // starting
      [
        // there will be no leading '/'
        //   (which has been replaced by section "leading slash")
        // If starts with '**', adding a '^' to the regular expression also works
        /^(?=[^^])/,
        /* @__PURE__ */ __name(function startingReplacer() {
          return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
        }, "startingReplacer")
      ],
      // two globstars
      [
        // Use lookahead assertions so that we could match more than one `'/**'`
        /\\\/\\\*\\\*(?=\\\/|$)/g,
        // Zero, one or several directories
        // should not use '*', or it will be replaced by the next replacer
        // Check if it is not the last `'/**'`
        (_3, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
      ],
      // intermediate wildcards
      [
        // Never replace escaped '*'
        // ignore rule '\*' will match the path '*'
        // 'abc.*/' -> go
        // 'abc.*'  -> skip this rule
        /(^|[^\\]+)\\\*(?=.+)/g,
        // '*.js' matches '.js'
        // '*.js' doesn't match 'abc'
        (_3, p1) => `${p1}[^\\/]*`
      ],
      [
        // unescape, revert step 3 except for back slash
        // For example, if a user escape a '\\*',
        // after step 3, the result will be '\\\\\\*'
        /\\\\\\(?=[$.|*+(){^])/g,
        () => ESCAPE
      ],
      [
        // '\\\\' -> '\\'
        /\\\\/g,
        () => ESCAPE
      ],
      [
        // > The range notation, e.g. [a-zA-Z],
        // > can be used to match one of the characters in a range.
        // `\` is escaped by step 3
        /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
        (match, leadEscape, range, endEscape, close2) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close2}` : close2 === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
      ],
      // ending
      [
        // 'js' will not match 'js.'
        // 'ab' will not match 'abc'
        /(?:[^*])$/,
        // WTF!
        // https://git-scm.com/docs/gitignore
        // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
        // which re-fixes #24, #38
        // > If there is a separator at the end of the pattern then the pattern
        // > will only match directories, otherwise the pattern can match both
        // > files and directories.
        // 'js*' will not match 'a.js'
        // 'js/' will not match 'a.js'
        // 'js' will match 'a.js' and 'a.js/'
        (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
      ],
      // trailing wildcard
      [
        /(\^|\\\/)?\\\*$/,
        (_3, p1) => {
          const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
          return `${prefix}(?=$|\\/$)`;
        }
      ]
    ];
    var regexCache = /* @__PURE__ */ Object.create(null);
    var makeRegex = /* @__PURE__ */ __name((pattern, ignoreCase) => {
      let source = regexCache[pattern];
      if (!source) {
        source = REPLACERS.reduce(
          (prev, current) => prev.replace(current[0], current[1].bind(pattern)),
          pattern
        );
        regexCache[pattern] = source;
      }
      return ignoreCase ? new RegExp(source, "i") : new RegExp(source);
    }, "makeRegex");
    var isString4 = /* @__PURE__ */ __name((subject) => typeof subject === "string", "isString");
    var checkPattern = /* @__PURE__ */ __name((pattern) => pattern && isString4(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && pattern.indexOf("#") !== 0, "checkPattern");
    var splitPattern = /* @__PURE__ */ __name((pattern) => pattern.split(REGEX_SPLITALL_CRLF), "splitPattern");
    var IgnoreRule = class {
      constructor(origin, pattern, negative, regex2) {
        this.origin = origin;
        this.pattern = pattern;
        this.negative = negative;
        this.regex = regex2;
      }
    };
    __name(IgnoreRule, "IgnoreRule");
    var createRule = /* @__PURE__ */ __name((pattern, ignoreCase) => {
      const origin = pattern;
      let negative = false;
      if (pattern.indexOf("!") === 0) {
        negative = true;
        pattern = pattern.substr(1);
      }
      pattern = pattern.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
      const regex2 = makeRegex(pattern, ignoreCase);
      return new IgnoreRule(
        origin,
        pattern,
        negative,
        regex2
      );
    }, "createRule");
    var throwError = /* @__PURE__ */ __name((message, Ctor) => {
      throw new Ctor(message);
    }, "throwError");
    var checkPath = /* @__PURE__ */ __name((path67, originalPath, doThrow) => {
      if (!isString4(path67)) {
        return doThrow(
          `path must be a string, but got \`${originalPath}\``,
          TypeError
        );
      }
      if (!path67) {
        return doThrow(`path must not be empty`, TypeError);
      }
      if (checkPath.isNotRelative(path67)) {
        const r3 = "`path.relative()`d";
        return doThrow(
          `path should be a ${r3} string, but got "${originalPath}"`,
          RangeError
        );
      }
      return true;
    }, "checkPath");
    var isNotRelative = /* @__PURE__ */ __name((path67) => REGEX_TEST_INVALID_PATH.test(path67), "isNotRelative");
    checkPath.isNotRelative = isNotRelative;
    checkPath.convert = (p2) => p2;
    var Ignore = class {
      constructor({
        ignorecase = true,
        ignoreCase = ignorecase,
        allowRelativePaths = false
      } = {}) {
        define2(this, KEY_IGNORE, true);
        this._rules = [];
        this._ignoreCase = ignoreCase;
        this._allowRelativePaths = allowRelativePaths;
        this._initCache();
      }
      _initCache() {
        this._ignoreCache = /* @__PURE__ */ Object.create(null);
        this._testCache = /* @__PURE__ */ Object.create(null);
      }
      _addPattern(pattern) {
        if (pattern && pattern[KEY_IGNORE]) {
          this._rules = this._rules.concat(pattern._rules);
          this._added = true;
          return;
        }
        if (checkPattern(pattern)) {
          const rule = createRule(pattern, this._ignoreCase);
          this._added = true;
          this._rules.push(rule);
        }
      }
      // @param {Array<string> | string | Ignore} pattern
      add(pattern) {
        this._added = false;
        makeArray(
          isString4(pattern) ? splitPattern(pattern) : pattern
        ).forEach(this._addPattern, this);
        if (this._added) {
          this._initCache();
        }
        return this;
      }
      // legacy
      addPattern(pattern) {
        return this.add(pattern);
      }
      //          |           ignored : unignored
      // negative |   0:0   |   0:1   |   1:0   |   1:1
      // -------- | ------- | ------- | ------- | --------
      //     0    |  TEST   |  TEST   |  SKIP   |    X
      //     1    |  TESTIF |  SKIP   |  TEST   |    X
      // - SKIP: always skip
      // - TEST: always test
      // - TESTIF: only test if checkUnignored
      // - X: that never happen
      // @param {boolean} whether should check if the path is unignored,
      //   setting `checkUnignored` to `false` could reduce additional
      //   path matching.
      // @returns {TestResult} true if a file is ignored
      _testOne(path67, checkUnignored) {
        let ignored = false;
        let unignored = false;
        this._rules.forEach((rule) => {
          const { negative } = rule;
          if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
            return;
          }
          const matched = rule.regex.test(path67);
          if (matched) {
            ignored = !negative;
            unignored = negative;
          }
        });
        return {
          ignored,
          unignored
        };
      }
      // @returns {TestResult}
      _test(originalPath, cache2, checkUnignored, slices) {
        const path67 = originalPath && checkPath.convert(originalPath);
        checkPath(
          path67,
          originalPath,
          this._allowRelativePaths ? RETURN_FALSE : throwError
        );
        return this._t(path67, cache2, checkUnignored, slices);
      }
      _t(path67, cache2, checkUnignored, slices) {
        if (path67 in cache2) {
          return cache2[path67];
        }
        if (!slices) {
          slices = path67.split(SLASH);
        }
        slices.pop();
        if (!slices.length) {
          return cache2[path67] = this._testOne(path67, checkUnignored);
        }
        const parent = this._t(
          slices.join(SLASH) + SLASH,
          cache2,
          checkUnignored,
          slices
        );
        return cache2[path67] = parent.ignored ? parent : this._testOne(path67, checkUnignored);
      }
      ignores(path67) {
        return this._test(path67, this._ignoreCache, false).ignored;
      }
      createFilter() {
        return (path67) => !this.ignores(path67);
      }
      filter(paths) {
        return makeArray(paths).filter(this.createFilter());
      }
      // @returns {TestResult}
      test(path67) {
        return this._test(path67, this._testCache, true);
      }
    };
    __name(Ignore, "Ignore");
    var factory = /* @__PURE__ */ __name((options29) => new Ignore(options29), "factory");
    var isPathValid = /* @__PURE__ */ __name((path67) => checkPath(path67 && checkPath.convert(path67), path67, RETURN_FALSE), "isPathValid");
    factory.isPathValid = isPathValid;
    factory.default = factory;
    module3.exports = factory;
    if (
      // Detect `process` so that it can run in browsers.
      typeof process !== "undefined" && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === "win32")
    ) {
      const makePosix = /* @__PURE__ */ __name((str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/"), "makePosix");
      checkPath.convert = makePosix;
      const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
      checkPath.isNotRelative = (path67) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path67) || isNotRelative(path67);
    }
  }
});

// ../../node_modules/.pnpm/cli-spinners@2.6.1/node_modules/cli-spinners/spinners.json
var require_spinners = __commonJS({
  "../../node_modules/.pnpm/cli-spinners@2.6.1/node_modules/cli-spinners/spinners.json"(exports2, module3) {
    module3.exports = {
      dots: {
        interval: 80,
        frames: [
          "\u280B",
          "\u2819",
          "\u2839",
          "\u2838",
          "\u283C",
          "\u2834",
          "\u2826",
          "\u2827",
          "\u2807",
          "\u280F"
        ]
      },
      dots2: {
        interval: 80,
        frames: [
          "\u28FE",
          "\u28FD",
          "\u28FB",
          "\u28BF",
          "\u287F",
          "\u28DF",
          "\u28EF",
          "\u28F7"
        ]
      },
      dots3: {
        interval: 80,
        frames: [
          "\u280B",
          "\u2819",
          "\u281A",
          "\u281E",
          "\u2816",
          "\u2826",
          "\u2834",
          "\u2832",
          "\u2833",
          "\u2813"
        ]
      },
      dots4: {
        interval: 80,
        frames: [
          "\u2804",
          "\u2806",
          "\u2807",
          "\u280B",
          "\u2819",
          "\u2838",
          "\u2830",
          "\u2820",
          "\u2830",
          "\u2838",
          "\u2819",
          "\u280B",
          "\u2807",
          "\u2806"
        ]
      },
      dots5: {
        interval: 80,
        frames: [
          "\u280B",
          "\u2819",
          "\u281A",
          "\u2812",
          "\u2802",
          "\u2802",
          "\u2812",
          "\u2832",
          "\u2834",
          "\u2826",
          "\u2816",
          "\u2812",
          "\u2810",
          "\u2810",
          "\u2812",
          "\u2813",
          "\u280B"
        ]
      },
      dots6: {
        interval: 80,
        frames: [
          "\u2801",
          "\u2809",
          "\u2819",
          "\u281A",
          "\u2812",
          "\u2802",
          "\u2802",
          "\u2812",
          "\u2832",
          "\u2834",
          "\u2824",
          "\u2804",
          "\u2804",
          "\u2824",
          "\u2834",
          "\u2832",
          "\u2812",
          "\u2802",
          "\u2802",
          "\u2812",
          "\u281A",
          "\u2819",
          "\u2809",
          "\u2801"
        ]
      },
      dots7: {
        interval: 80,
        frames: [
          "\u2808",
          "\u2809",
          "\u280B",
          "\u2813",
          "\u2812",
          "\u2810",
          "\u2810",
          "\u2812",
          "\u2816",
          "\u2826",
          "\u2824",
          "\u2820",
          "\u2820",
          "\u2824",
          "\u2826",
          "\u2816",
          "\u2812",
          "\u2810",
          "\u2810",
          "\u2812",
          "\u2813",
          "\u280B",
          "\u2809",
          "\u2808"
        ]
      },
      dots8: {
        interval: 80,
        frames: [
          "\u2801",
          "\u2801",
          "\u2809",
          "\u2819",
          "\u281A",
          "\u2812",
          "\u2802",
          "\u2802",
          "\u2812",
          "\u2832",
          "\u2834",
          "\u2824",
          "\u2804",
          "\u2804",
          "\u2824",
          "\u2820",
          "\u2820",
          "\u2824",
          "\u2826",
          "\u2816",
          "\u2812",
          "\u2810",
          "\u2810",
          "\u2812",
          "\u2813",
          "\u280B",
          "\u2809",
          "\u2808",
          "\u2808"
        ]
      },
      dots9: {
        interval: 80,
        frames: [
          "\u28B9",
          "\u28BA",
          "\u28BC",
          "\u28F8",
          "\u28C7",
          "\u2867",
          "\u2857",
          "\u284F"
        ]
      },
      dots10: {
        interval: 80,
        frames: [
          "\u2884",
          "\u2882",
          "\u2881",
          "\u2841",
          "\u2848",
          "\u2850",
          "\u2860"
        ]
      },
      dots11: {
        interval: 100,
        frames: [
          "\u2801",
          "\u2802",
          "\u2804",
          "\u2840",
          "\u2880",
          "\u2820",
          "\u2810",
          "\u2808"
        ]
      },
      dots12: {
        interval: 80,
        frames: [
          "\u2880\u2800",
          "\u2840\u2800",
          "\u2804\u2800",
          "\u2882\u2800",
          "\u2842\u2800",
          "\u2805\u2800",
          "\u2883\u2800",
          "\u2843\u2800",
          "\u280D\u2800",
          "\u288B\u2800",
          "\u284B\u2800",
          "\u280D\u2801",
          "\u288B\u2801",
          "\u284B\u2801",
          "\u280D\u2809",
          "\u280B\u2809",
          "\u280B\u2809",
          "\u2809\u2819",
          "\u2809\u2819",
          "\u2809\u2829",
          "\u2808\u2899",
          "\u2808\u2859",
          "\u2888\u2829",
          "\u2840\u2899",
          "\u2804\u2859",
          "\u2882\u2829",
          "\u2842\u2898",
          "\u2805\u2858",
          "\u2883\u2828",
          "\u2843\u2890",
          "\u280D\u2850",
          "\u288B\u2820",
          "\u284B\u2880",
          "\u280D\u2841",
          "\u288B\u2801",
          "\u284B\u2801",
          "\u280D\u2809",
          "\u280B\u2809",
          "\u280B\u2809",
          "\u2809\u2819",
          "\u2809\u2819",
          "\u2809\u2829",
          "\u2808\u2899",
          "\u2808\u2859",
          "\u2808\u2829",
          "\u2800\u2899",
          "\u2800\u2859",
          "\u2800\u2829",
          "\u2800\u2898",
          "\u2800\u2858",
          "\u2800\u2828",
          "\u2800\u2890",
          "\u2800\u2850",
          "\u2800\u2820",
          "\u2800\u2880",
          "\u2800\u2840"
        ]
      },
      dots8Bit: {
        interval: 80,
        frames: [
          "\u2800",
          "\u2801",
          "\u2802",
          "\u2803",
          "\u2804",
          "\u2805",
          "\u2806",
          "\u2807",
          "\u2840",
          "\u2841",
          "\u2842",
          "\u2843",
          "\u2844",
          "\u2845",
          "\u2846",
          "\u2847",
          "\u2808",
          "\u2809",
          "\u280A",
          "\u280B",
          "\u280C",
          "\u280D",
          "\u280E",
          "\u280F",
          "\u2848",
          "\u2849",
          "\u284A",
          "\u284B",
          "\u284C",
          "\u284D",
          "\u284E",
          "\u284F",
          "\u2810",
          "\u2811",
          "\u2812",
          "\u2813",
          "\u2814",
          "\u2815",
          "\u2816",
          "\u2817",
          "\u2850",
          "\u2851",
          "\u2852",
          "\u2853",
          "\u2854",
          "\u2855",
          "\u2856",
          "\u2857",
          "\u2818",
          "\u2819",
          "\u281A",
          "\u281B",
          "\u281C",
          "\u281D",
          "\u281E",
          "\u281F",
          "\u2858",
          "\u2859",
          "\u285A",
          "\u285B",
          "\u285C",
          "\u285D",
          "\u285E",
          "\u285F",
          "\u2820",
          "\u2821",
          "\u2822",
          "\u2823",
          "\u2824",
          "\u2825",
          "\u2826",
          "\u2827",
          "\u2860",
          "\u2861",
          "\u2862",
          "\u2863",
          "\u2864",
          "\u2865",
          "\u2866",
          "\u2867",
          "\u2828",
          "\u2829",
          "\u282A",
          "\u282B",
          "\u282C",
          "\u282D",
          "\u282E",
          "\u282F",
          "\u2868",
          "\u2869",
          "\u286A",
          "\u286B",
          "\u286C",
          "\u286D",
          "\u286E",
          "\u286F",
          "\u2830",
          "\u2831",
          "\u2832",
          "\u2833",
          "\u2834",
          "\u2835",
          "\u2836",
          "\u2837",
          "\u2870",
          "\u2871",
          "\u2872",
          "\u2873",
          "\u2874",
          "\u2875",
          "\u2876",
          "\u2877",
          "\u2838",
          "\u2839",
          "\u283A",
          "\u283B",
          "\u283C",
          "\u283D",
          "\u283E",
          "\u283F",
          "\u2878",
          "\u2879",
          "\u287A",
          "\u287B",
          "\u287C",
          "\u287D",
          "\u287E",
          "\u287F",
          "\u2880",
          "\u2881",
          "\u2882",
          "\u2883",
          "\u2884",
          "\u2885",
          "\u2886",
          "\u2887",
          "\u28C0",
          "\u28C1",
          "\u28C2",
          "\u28C3",
          "\u28C4",
          "\u28C5",
          "\u28C6",
          "\u28C7",
          "\u2888",
          "\u2889",
          "\u288A",
          "\u288B",
          "\u288C",
          "\u288D",
          "\u288E",
          "\u288F",
          "\u28C8",
          "\u28C9",
          "\u28CA",
          "\u28CB",
          "\u28CC",
          "\u28CD",
          "\u28CE",
          "\u28CF",
          "\u2890",
          "\u2891",
          "\u2892",
          "\u2893",
          "\u2894",
          "\u2895",
          "\u2896",
          "\u2897",
          "\u28D0",
          "\u28D1",
          "\u28D2",
          "\u28D3",
          "\u28D4",
          "\u28D5",
          "\u28D6",
          "\u28D7",
          "\u2898",
          "\u2899",
          "\u289A",
          "\u289B",
          "\u289C",
          "\u289D",
          "\u289E",
          "\u289F",
          "\u28D8",
          "\u28D9",
          "\u28DA",
          "\u28DB",
          "\u28DC",
          "\u28DD",
          "\u28DE",
          "\u28DF",
          "\u28A0",
          "\u28A1",
          "\u28A2",
          "\u28A3",
          "\u28A4",
          "\u28A5",
          "\u28A6",
          "\u28A7",
          "\u28E0",
          "\u28E1",
          "\u28E2",
          "\u28E3",
          "\u28E4",
          "\u28E5",
          "\u28E6",
          "\u28E7",
          "\u28A8",
          "\u28A9",
          "\u28AA",
          "\u28AB",
          "\u28AC",
          "\u28AD",
          "\u28AE",
          "\u28AF",
          "\u28E8",
          "\u28E9",
          "\u28EA",
          "\u28EB",
          "\u28EC",
          "\u28ED",
          "\u28EE",
          "\u28EF",
          "\u28B0",
          "\u28B1",
          "\u28B2",
          "\u28B3",
          "\u28B4",
          "\u28B5",
          "\u28B6",
          "\u28B7",
          "\u28F0",
          "\u28F1",
          "\u28F2",
          "\u28F3",
          "\u28F4",
          "\u28F5",
          "\u28F6",
          "\u28F7",
          "\u28B8",
          "\u28B9",
          "\u28BA",
          "\u28BB",
          "\u28BC",
          "\u28BD",
          "\u28BE",
          "\u28BF",
          "\u28F8",
          "\u28F9",
          "\u28FA",
          "\u28FB",
          "\u28FC",
          "\u28FD",
          "\u28FE",
          "\u28FF"
        ]
      },
      line: {
        interval: 130,
        frames: [
          "-",
          "\\",
          "|",
          "/"
        ]
      },
      line2: {
        interval: 100,
        frames: [
          "\u2802",
          "-",
          "\u2013",
          "\u2014",
          "\u2013",
          "-"
        ]
      },
      pipe: {
        interval: 100,
        frames: [
          "\u2524",
          "\u2518",
          "\u2534",
          "\u2514",
          "\u251C",
          "\u250C",
          "\u252C",
          "\u2510"
        ]
      },
      simpleDots: {
        interval: 400,
        frames: [
          ".  ",
          ".. ",
          "...",
          "   "
        ]
      },
      simpleDotsScrolling: {
        interval: 200,
        frames: [
          ".  ",
          ".. ",
          "...",
          " ..",
          "  .",
          "   "
        ]
      },
      star: {
        interval: 70,
        frames: [
          "\u2736",
          "\u2738",
          "\u2739",
          "\u273A",
          "\u2739",
          "\u2737"
        ]
      },
      star2: {
        interval: 80,
        frames: [
          "+",
          "x",
          "*"
        ]
      },
      flip: {
        interval: 70,
        frames: [
          "_",
          "_",
          "_",
          "-",
          "`",
          "`",
          "'",
          "\xB4",
          "-",
          "_",
          "_",
          "_"
        ]
      },
      hamburger: {
        interval: 100,
        frames: [
          "\u2631",
          "\u2632",
          "\u2634"
        ]
      },
      growVertical: {
        interval: 120,
        frames: [
          "\u2581",
          "\u2583",
          "\u2584",
          "\u2585",
          "\u2586",
          "\u2587",
          "\u2586",
          "\u2585",
          "\u2584",
          "\u2583"
        ]
      },
      growHorizontal: {
        interval: 120,
        frames: [
          "\u258F",
          "\u258E",
          "\u258D",
          "\u258C",
          "\u258B",
          "\u258A",
          "\u2589",
          "\u258A",
          "\u258B",
          "\u258C",
          "\u258D",
          "\u258E"
        ]
      },
      balloon: {
        interval: 140,
        frames: [
          " ",
          ".",
          "o",
          "O",
          "@",
          "*",
          " "
        ]
      },
      balloon2: {
        interval: 120,
        frames: [
          ".",
          "o",
          "O",
          "\xB0",
          "O",
          "o",
          "."
        ]
      },
      noise: {
        interval: 100,
        frames: [
          "\u2593",
          "\u2592",
          "\u2591"
        ]
      },
      bounce: {
        interval: 120,
        frames: [
          "\u2801",
          "\u2802",
          "\u2804",
          "\u2802"
        ]
      },
      boxBounce: {
        interval: 120,
        frames: [
          "\u2596",
          "\u2598",
          "\u259D",
          "\u2597"
        ]
      },
      boxBounce2: {
        interval: 100,
        frames: [
          "\u258C",
          "\u2580",
          "\u2590",
          "\u2584"
        ]
      },
      triangle: {
        interval: 50,
        frames: [
          "\u25E2",
          "\u25E3",
          "\u25E4",
          "\u25E5"
        ]
      },
      arc: {
        interval: 100,
        frames: [
          "\u25DC",
          "\u25E0",
          "\u25DD",
          "\u25DE",
          "\u25E1",
          "\u25DF"
        ]
      },
      circle: {
        interval: 120,
        frames: [
          "\u25E1",
          "\u2299",
          "\u25E0"
        ]
      },
      squareCorners: {
        interval: 180,
        frames: [
          "\u25F0",
          "\u25F3",
          "\u25F2",
          "\u25F1"
        ]
      },
      circleQuarters: {
        interval: 120,
        frames: [
          "\u25F4",
          "\u25F7",
          "\u25F6",
          "\u25F5"
        ]
      },
      circleHalves: {
        interval: 50,
        frames: [
          "\u25D0",
          "\u25D3",
          "\u25D1",
          "\u25D2"
        ]
      },
      squish: {
        interval: 100,
        frames: [
          "\u256B",
          "\u256A"
        ]
      },
      toggle: {
        interval: 250,
        frames: [
          "\u22B6",
          "\u22B7"
        ]
      },
      toggle2: {
        interval: 80,
        frames: [
          "\u25AB",
          "\u25AA"
        ]
      },
      toggle3: {
        interval: 120,
        frames: [
          "\u25A1",
          "\u25A0"
        ]
      },
      toggle4: {
        interval: 100,
        frames: [
          "\u25A0",
          "\u25A1",
          "\u25AA",
          "\u25AB"
        ]
      },
      toggle5: {
        interval: 100,
        frames: [
          "\u25AE",
          "\u25AF"
        ]
      },
      toggle6: {
        interval: 300,
        frames: [
          "\u101D",
          "\u1040"
        ]
      },
      toggle7: {
        interval: 80,
        frames: [
          "\u29BE",
          "\u29BF"
        ]
      },
      toggle8: {
        interval: 100,
        frames: [
          "\u25CD",
          "\u25CC"
        ]
      },
      toggle9: {
        interval: 100,
        frames: [
          "\u25C9",
          "\u25CE"
        ]
      },
      toggle10: {
        interval: 100,
        frames: [
          "\u3282",
          "\u3280",
          "\u3281"
        ]
      },
      toggle11: {
        interval: 50,
        frames: [
          "\u29C7",
          "\u29C6"
        ]
      },
      toggle12: {
        interval: 120,
        frames: [
          "\u2617",
          "\u2616"
        ]
      },
      toggle13: {
        interval: 80,
        frames: [
          "=",
          "*",
          "-"
        ]
      },
      arrow: {
        interval: 100,
        frames: [
          "\u2190",
          "\u2196",
          "\u2191",
          "\u2197",
          "\u2192",
          "\u2198",
          "\u2193",
          "\u2199"
        ]
      },
      arrow2: {
        interval: 80,
        frames: [
          "\u2B06\uFE0F ",
          "\u2197\uFE0F ",
          "\u27A1\uFE0F ",
          "\u2198\uFE0F ",
          "\u2B07\uFE0F ",
          "\u2199\uFE0F ",
          "\u2B05\uFE0F ",
          "\u2196\uFE0F "
        ]
      },
      arrow3: {
        interval: 120,
        frames: [
          "\u25B9\u25B9\u25B9\u25B9\u25B9",
          "\u25B8\u25B9\u25B9\u25B9\u25B9",
          "\u25B9\u25B8\u25B9\u25B9\u25B9",
          "\u25B9\u25B9\u25B8\u25B9\u25B9",
          "\u25B9\u25B9\u25B9\u25B8\u25B9",
          "\u25B9\u25B9\u25B9\u25B9\u25B8"
        ]
      },
      bouncingBar: {
        interval: 80,
        frames: [
          "[    ]",
          "[=   ]",
          "[==  ]",
          "[=== ]",
          "[ ===]",
          "[  ==]",
          "[   =]",
          "[    ]",
          "[   =]",
          "[  ==]",
          "[ ===]",
          "[====]",
          "[=== ]",
          "[==  ]",
          "[=   ]"
        ]
      },
      bouncingBall: {
        interval: 80,
        frames: [
          "( \u25CF    )",
          "(  \u25CF   )",
          "(   \u25CF  )",
          "(    \u25CF )",
          "(     \u25CF)",
          "(    \u25CF )",
          "(   \u25CF  )",
          "(  \u25CF   )",
          "( \u25CF    )",
          "(\u25CF     )"
        ]
      },
      smiley: {
        interval: 200,
        frames: [
          "\u{1F604} ",
          "\u{1F61D} "
        ]
      },
      monkey: {
        interval: 300,
        frames: [
          "\u{1F648} ",
          "\u{1F648} ",
          "\u{1F649} ",
          "\u{1F64A} "
        ]
      },
      hearts: {
        interval: 100,
        frames: [
          "\u{1F49B} ",
          "\u{1F499} ",
          "\u{1F49C} ",
          "\u{1F49A} ",
          "\u2764\uFE0F "
        ]
      },
      clock: {
        interval: 100,
        frames: [
          "\u{1F55B} ",
          "\u{1F550} ",
          "\u{1F551} ",
          "\u{1F552} ",
          "\u{1F553} ",
          "\u{1F554} ",
          "\u{1F555} ",
          "\u{1F556} ",
          "\u{1F557} ",
          "\u{1F558} ",
          "\u{1F559} ",
          "\u{1F55A} "
        ]
      },
      earth: {
        interval: 180,
        frames: [
          "\u{1F30D} ",
          "\u{1F30E} ",
          "\u{1F30F} "
        ]
      },
      material: {
        interval: 17,
        frames: [
          "\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581",
          "\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581",
          "\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581",
          "\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581",
          "\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581",
          "\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581",
          "\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581",
          "\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581",
          "\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581",
          "\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581",
          "\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588",
          "\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588",
          "\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588",
          "\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588",
          "\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588",
          "\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588",
          "\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588",
          "\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588",
          "\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588",
          "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581",
          "\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581\u2581",
          "\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581\u2581",
          "\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581",
          "\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581\u2581",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581\u2581",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2581",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2588",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581",
          "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581"
        ]
      },
      moon: {
        interval: 80,
        frames: [
          "\u{1F311} ",
          "\u{1F312} ",
          "\u{1F313} ",
          "\u{1F314} ",
          "\u{1F315} ",
          "\u{1F316} ",
          "\u{1F317} ",
          "\u{1F318} "
        ]
      },
      runner: {
        interval: 140,
        frames: [
          "\u{1F6B6} ",
          "\u{1F3C3} "
        ]
      },
      pong: {
        interval: 80,
        frames: [
          "\u2590\u2802       \u258C",
          "\u2590\u2808       \u258C",
          "\u2590 \u2802      \u258C",
          "\u2590 \u2820      \u258C",
          "\u2590  \u2840     \u258C",
          "\u2590  \u2820     \u258C",
          "\u2590   \u2802    \u258C",
          "\u2590   \u2808    \u258C",
          "\u2590    \u2802   \u258C",
          "\u2590    \u2820   \u258C",
          "\u2590     \u2840  \u258C",
          "\u2590     \u2820  \u258C",
          "\u2590      \u2802 \u258C",
          "\u2590      \u2808 \u258C",
          "\u2590       \u2802\u258C",
          "\u2590       \u2820\u258C",
          "\u2590       \u2840\u258C",
          "\u2590      \u2820 \u258C",
          "\u2590      \u2802 \u258C",
          "\u2590     \u2808  \u258C",
          "\u2590     \u2802  \u258C",
          "\u2590    \u2820   \u258C",
          "\u2590    \u2840   \u258C",
          "\u2590   \u2820    \u258C",
          "\u2590   \u2802    \u258C",
          "\u2590  \u2808     \u258C",
          "\u2590  \u2802     \u258C",
          "\u2590 \u2820      \u258C",
          "\u2590 \u2840      \u258C",
          "\u2590\u2820       \u258C"
        ]
      },
      shark: {
        interval: 120,
        frames: [
          "\u2590|\\____________\u258C",
          "\u2590_|\\___________\u258C",
          "\u2590__|\\__________\u258C",
          "\u2590___|\\_________\u258C",
          "\u2590____|\\________\u258C",
          "\u2590_____|\\_______\u258C",
          "\u2590______|\\______\u258C",
          "\u2590_______|\\_____\u258C",
          "\u2590________|\\____\u258C",
          "\u2590_________|\\___\u258C",
          "\u2590__________|\\__\u258C",
          "\u2590___________|\\_\u258C",
          "\u2590____________|\\\u258C",
          "\u2590____________/|\u258C",
          "\u2590___________/|_\u258C",
          "\u2590__________/|__\u258C",
          "\u2590_________/|___\u258C",
          "\u2590________/|____\u258C",
          "\u2590_______/|_____\u258C",
          "\u2590______/|______\u258C",
          "\u2590_____/|_______\u258C",
          "\u2590____/|________\u258C",
          "\u2590___/|_________\u258C",
          "\u2590__/|__________\u258C",
          "\u2590_/|___________\u258C",
          "\u2590/|____________\u258C"
        ]
      },
      dqpb: {
        interval: 100,
        frames: [
          "d",
          "q",
          "p",
          "b"
        ]
      },
      weather: {
        interval: 100,
        frames: [
          "\u2600\uFE0F ",
          "\u2600\uFE0F ",
          "\u2600\uFE0F ",
          "\u{1F324} ",
          "\u26C5\uFE0F ",
          "\u{1F325} ",
          "\u2601\uFE0F ",
          "\u{1F327} ",
          "\u{1F328} ",
          "\u{1F327} ",
          "\u{1F328} ",
          "\u{1F327} ",
          "\u{1F328} ",
          "\u26C8 ",
          "\u{1F328} ",
          "\u{1F327} ",
          "\u{1F328} ",
          "\u2601\uFE0F ",
          "\u{1F325} ",
          "\u26C5\uFE0F ",
          "\u{1F324} ",
          "\u2600\uFE0F ",
          "\u2600\uFE0F "
        ]
      },
      christmas: {
        interval: 400,
        frames: [
          "\u{1F332}",
          "\u{1F384}"
        ]
      },
      grenade: {
        interval: 80,
        frames: [
          "\u060C  ",
          "\u2032  ",
          " \xB4 ",
          " \u203E ",
          "  \u2E0C",
          "  \u2E0A",
          "  |",
          "  \u204E",
          "  \u2055",
          " \u0DF4 ",
          "  \u2053",
          "   ",
          "   ",
          "   "
        ]
      },
      point: {
        interval: 125,
        frames: [
          "\u2219\u2219\u2219",
          "\u25CF\u2219\u2219",
          "\u2219\u25CF\u2219",
          "\u2219\u2219\u25CF",
          "\u2219\u2219\u2219"
        ]
      },
      layer: {
        interval: 150,
        frames: [
          "-",
          "=",
          "\u2261"
        ]
      },
      betaWave: {
        interval: 80,
        frames: [
          "\u03C1\u03B2\u03B2\u03B2\u03B2\u03B2\u03B2",
          "\u03B2\u03C1\u03B2\u03B2\u03B2\u03B2\u03B2",
          "\u03B2\u03B2\u03C1\u03B2\u03B2\u03B2\u03B2",
          "\u03B2\u03B2\u03B2\u03C1\u03B2\u03B2\u03B2",
          "\u03B2\u03B2\u03B2\u03B2\u03C1\u03B2\u03B2",
          "\u03B2\u03B2\u03B2\u03B2\u03B2\u03C1\u03B2",
          "\u03B2\u03B2\u03B2\u03B2\u03B2\u03B2\u03C1"
        ]
      },
      fingerDance: {
        interval: 160,
        frames: [
          "\u{1F918} ",
          "\u{1F91F} ",
          "\u{1F596} ",
          "\u270B ",
          "\u{1F91A} ",
          "\u{1F446} "
        ]
      },
      fistBump: {
        interval: 80,
        frames: [
          "\u{1F91C}\u3000\u3000\u3000\u3000\u{1F91B} ",
          "\u{1F91C}\u3000\u3000\u3000\u3000\u{1F91B} ",
          "\u{1F91C}\u3000\u3000\u3000\u3000\u{1F91B} ",
          "\u3000\u{1F91C}\u3000\u3000\u{1F91B}\u3000 ",
          "\u3000\u3000\u{1F91C}\u{1F91B}\u3000\u3000 ",
          "\u3000\u{1F91C}\u2728\u{1F91B}\u3000\u3000 ",
          "\u{1F91C}\u3000\u2728\u3000\u{1F91B}\u3000 "
        ]
      },
      soccerHeader: {
        interval: 80,
        frames: [
          " \u{1F9D1}\u26BD\uFE0F       \u{1F9D1} ",
          "\u{1F9D1}  \u26BD\uFE0F      \u{1F9D1} ",
          "\u{1F9D1}   \u26BD\uFE0F     \u{1F9D1} ",
          "\u{1F9D1}    \u26BD\uFE0F    \u{1F9D1} ",
          "\u{1F9D1}     \u26BD\uFE0F   \u{1F9D1} ",
          "\u{1F9D1}      \u26BD\uFE0F  \u{1F9D1} ",
          "\u{1F9D1}       \u26BD\uFE0F\u{1F9D1}  ",
          "\u{1F9D1}      \u26BD\uFE0F  \u{1F9D1} ",
          "\u{1F9D1}     \u26BD\uFE0F   \u{1F9D1} ",
          "\u{1F9D1}    \u26BD\uFE0F    \u{1F9D1} ",
          "\u{1F9D1}   \u26BD\uFE0F     \u{1F9D1} ",
          "\u{1F9D1}  \u26BD\uFE0F      \u{1F9D1} "
        ]
      },
      mindblown: {
        interval: 160,
        frames: [
          "\u{1F610} ",
          "\u{1F610} ",
          "\u{1F62E} ",
          "\u{1F62E} ",
          "\u{1F626} ",
          "\u{1F626} ",
          "\u{1F627} ",
          "\u{1F627} ",
          "\u{1F92F} ",
          "\u{1F4A5} ",
          "\u2728 ",
          "\u3000 ",
          "\u3000 ",
          "\u3000 "
        ]
      },
      speaker: {
        interval: 160,
        frames: [
          "\u{1F508} ",
          "\u{1F509} ",
          "\u{1F50A} ",
          "\u{1F509} "
        ]
      },
      orangePulse: {
        interval: 100,
        frames: [
          "\u{1F538} ",
          "\u{1F536} ",
          "\u{1F7E0} ",
          "\u{1F7E0} ",
          "\u{1F536} "
        ]
      },
      bluePulse: {
        interval: 100,
        frames: [
          "\u{1F539} ",
          "\u{1F537} ",
          "\u{1F535} ",
          "\u{1F535} ",
          "\u{1F537} "
        ]
      },
      orangeBluePulse: {
        interval: 100,
        frames: [
          "\u{1F538} ",
          "\u{1F536} ",
          "\u{1F7E0} ",
          "\u{1F7E0} ",
          "\u{1F536} ",
          "\u{1F539} ",
          "\u{1F537} ",
          "\u{1F535} ",
          "\u{1F535} ",
          "\u{1F537} "
        ]
      },
      timeTravel: {
        interval: 100,
        frames: [
          "\u{1F55B} ",
          "\u{1F55A} ",
          "\u{1F559} ",
          "\u{1F558} ",
          "\u{1F557} ",
          "\u{1F556} ",
          "\u{1F555} ",
          "\u{1F554} ",
          "\u{1F553} ",
          "\u{1F552} ",
          "\u{1F551} ",
          "\u{1F550} "
        ]
      },
      aesthetic: {
        interval: 80,
        frames: [
          "\u25B0\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1",
          "\u25B0\u25B0\u25B1\u25B1\u25B1\u25B1\u25B1",
          "\u25B0\u25B0\u25B0\u25B1\u25B1\u25B1\u25B1",
          "\u25B0\u25B0\u25B0\u25B0\u25B1\u25B1\u25B1",
          "\u25B0\u25B0\u25B0\u25B0\u25B0\u25B1\u25B1",
          "\u25B0\u25B0\u25B0\u25B0\u25B0\u25B0\u25B1",
          "\u25B0\u25B0\u25B0\u25B0\u25B0\u25B0\u25B0",
          "\u25B0\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1"
        ]
      }
    };
  }
});

// ../../node_modules/.pnpm/cli-spinners@2.6.1/node_modules/cli-spinners/index.js
var require_cli_spinners = __commonJS({
  "../../node_modules/.pnpm/cli-spinners@2.6.1/node_modules/cli-spinners/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var spinners = Object.assign({}, require_spinners());
    var spinnersList = Object.keys(spinners);
    Object.defineProperty(spinners, "random", {
      get() {
        const randomIndex = Math.floor(Math.random() * spinnersList.length);
        const spinnerName = spinnersList[randomIndex];
        return spinners[spinnerName];
      }
    });
    module3.exports = spinners;
  }
});

// ../../node_modules/.pnpm/ink-spinner@4.0.3_ink@3.2.0_react@17.0.2/node_modules/ink-spinner/build/index.js
var require_build4 = __commonJS({
  "../../node_modules/.pnpm/ink-spinner@4.0.3_ink@3.2.0_react@17.0.2/node_modules/ink-spinner/build/index.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    var React19 = require_react();
    var react_1 = require_react();
    var ink_1 = require_build2();
    var spinners = require_cli_spinners();
    var Spinner2 = /* @__PURE__ */ __name(({ type = "dots" }) => {
      const [frame, setFrame] = react_1.useState(0);
      const spinner2 = spinners[type];
      react_1.useEffect(() => {
        const timer = setInterval(() => {
          setFrame((previousFrame) => {
            const isLastFrame = previousFrame === spinner2.frames.length - 1;
            return isLastFrame ? 0 : previousFrame + 1;
          });
        }, spinner2.interval);
        return () => {
          clearInterval(timer);
        };
      }, [spinner2]);
      return React19.createElement(ink_1.Text, null, spinner2.frames[frame]);
    }, "Spinner");
    exports2.default = Spinner2;
  }
});

// ../../node_modules/.pnpm/eventemitter3@4.0.7/node_modules/eventemitter3/index.js
var require_eventemitter3 = __commonJS({
  "../../node_modules/.pnpm/eventemitter3@4.0.7/node_modules/eventemitter3/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var has = Object.prototype.hasOwnProperty;
    var prefix = "~";
    function Events() {
    }
    __name(Events, "Events");
    if (Object.create) {
      Events.prototype = /* @__PURE__ */ Object.create(null);
      if (!new Events().__proto__)
        prefix = false;
    }
    function EE(fn2, context2, once) {
      this.fn = fn2;
      this.context = context2;
      this.once = once || false;
    }
    __name(EE, "EE");
    function addListener(emitter, event, fn2, context2, once) {
      if (typeof fn2 !== "function") {
        throw new TypeError("The listener must be a function");
      }
      var listener = new EE(fn2, context2 || emitter, once), evt = prefix ? prefix + event : event;
      if (!emitter._events[evt])
        emitter._events[evt] = listener, emitter._eventsCount++;
      else if (!emitter._events[evt].fn)
        emitter._events[evt].push(listener);
      else
        emitter._events[evt] = [emitter._events[evt], listener];
      return emitter;
    }
    __name(addListener, "addListener");
    function clearEvent(emitter, evt) {
      if (--emitter._eventsCount === 0)
        emitter._events = new Events();
      else
        delete emitter._events[evt];
    }
    __name(clearEvent, "clearEvent");
    function EventEmitter7() {
      this._events = new Events();
      this._eventsCount = 0;
    }
    __name(EventEmitter7, "EventEmitter");
    EventEmitter7.prototype.eventNames = /* @__PURE__ */ __name(function eventNames() {
      var names = [], events2, name;
      if (this._eventsCount === 0)
        return names;
      for (name in events2 = this._events) {
        if (has.call(events2, name))
          names.push(prefix ? name.slice(1) : name);
      }
      if (Object.getOwnPropertySymbols) {
        return names.concat(Object.getOwnPropertySymbols(events2));
      }
      return names;
    }, "eventNames");
    EventEmitter7.prototype.listeners = /* @__PURE__ */ __name(function listeners(event) {
      var evt = prefix ? prefix + event : event, handlers2 = this._events[evt];
      if (!handlers2)
        return [];
      if (handlers2.fn)
        return [handlers2.fn];
      for (var i = 0, l2 = handlers2.length, ee = new Array(l2); i < l2; i++) {
        ee[i] = handlers2[i].fn;
      }
      return ee;
    }, "listeners");
    EventEmitter7.prototype.listenerCount = /* @__PURE__ */ __name(function listenerCount(event) {
      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
      if (!listeners)
        return 0;
      if (listeners.fn)
        return 1;
      return listeners.length;
    }, "listenerCount");
    EventEmitter7.prototype.emit = /* @__PURE__ */ __name(function emit(event, a1, a2, a3, a4, a5) {
      var evt = prefix ? prefix + event : event;
      if (!this._events[evt])
        return false;
      var listeners = this._events[evt], len = arguments.length, args, i;
      if (listeners.fn) {
        if (listeners.once)
          this.removeListener(event, listeners.fn, void 0, true);
        switch (len) {
          case 1:
            return listeners.fn.call(listeners.context), true;
          case 2:
            return listeners.fn.call(listeners.context, a1), true;
          case 3:
            return listeners.fn.call(listeners.context, a1, a2), true;
          case 4:
            return listeners.fn.call(listeners.context, a1, a2, a3), true;
          case 5:
            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
          case 6:
            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
        }
        for (i = 1, args = new Array(len - 1); i < len; i++) {
          args[i - 1] = arguments[i];
        }
        listeners.fn.apply(listeners.context, args);
      } else {
        var length = listeners.length, j2;
        for (i = 0; i < length; i++) {
          if (listeners[i].once)
            this.removeListener(event, listeners[i].fn, void 0, true);
          switch (len) {
            case 1:
              listeners[i].fn.call(listeners[i].context);
              break;
            case 2:
              listeners[i].fn.call(listeners[i].context, a1);
              break;
            case 3:
              listeners[i].fn.call(listeners[i].context, a1, a2);
              break;
            case 4:
              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
              break;
            default:
              if (!args)
                for (j2 = 1, args = new Array(len - 1); j2 < len; j2++) {
                  args[j2 - 1] = arguments[j2];
                }
              listeners[i].fn.apply(listeners[i].context, args);
          }
        }
      }
      return true;
    }, "emit");
    EventEmitter7.prototype.on = /* @__PURE__ */ __name(function on(event, fn2, context2) {
      return addListener(this, event, fn2, context2, false);
    }, "on");
    EventEmitter7.prototype.once = /* @__PURE__ */ __name(function once(event, fn2, context2) {
      return addListener(this, event, fn2, context2, true);
    }, "once");
    EventEmitter7.prototype.removeListener = /* @__PURE__ */ __name(function removeListener(event, fn2, context2, once) {
      var evt = prefix ? prefix + event : event;
      if (!this._events[evt])
        return this;
      if (!fn2) {
        clearEvent(this, evt);
        return this;
      }
      var listeners = this._events[evt];
      if (listeners.fn) {
        if (listeners.fn === fn2 && (!once || listeners.once) && (!context2 || listeners.context === context2)) {
          clearEvent(this, evt);
        }
      } else {
        for (var i = 0, events2 = [], length = listeners.length; i < length; i++) {
          if (listeners[i].fn !== fn2 || once && !listeners[i].once || context2 && listeners[i].context !== context2) {
            events2.push(listeners[i]);
          }
        }
        if (events2.length)
          this._events[evt] = events2.length === 1 ? events2[0] : events2;
        else
          clearEvent(this, evt);
      }
      return this;
    }, "removeListener");
    EventEmitter7.prototype.removeAllListeners = /* @__PURE__ */ __name(function removeAllListeners(event) {
      var evt;
      if (event) {
        evt = prefix ? prefix + event : event;
        if (this._events[evt])
          clearEvent(this, evt);
      } else {
        this._events = new Events();
        this._eventsCount = 0;
      }
      return this;
    }, "removeAllListeners");
    EventEmitter7.prototype.off = EventEmitter7.prototype.removeListener;
    EventEmitter7.prototype.addListener = EventEmitter7.prototype.on;
    EventEmitter7.prefixed = prefix;
    EventEmitter7.EventEmitter = EventEmitter7;
    if ("undefined" !== typeof module3) {
      module3.exports = EventEmitter7;
    }
  }
});

// ../../node_modules/.pnpm/minimatch@5.1.0/node_modules/minimatch/lib/path.js
var require_path = __commonJS({
  "../../node_modules/.pnpm/minimatch@5.1.0/node_modules/minimatch/lib/path.js"(exports2, module3) {
    init_import_meta_url();
    var isWindows2 = typeof process === "object" && process && process.platform === "win32";
    module3.exports = isWindows2 ? { sep: "\\" } : { sep: "/" };
  }
});

// ../../node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js
var require_balanced_match = __commonJS({
  "../../node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = balanced;
    function balanced(a, b2, str) {
      if (a instanceof RegExp)
        a = maybeMatch(a, str);
      if (b2 instanceof RegExp)
        b2 = maybeMatch(b2, str);
      var r3 = range(a, b2, str);
      return r3 && {
        start: r3[0],
        end: r3[1],
        pre: str.slice(0, r3[0]),
        body: str.slice(r3[0] + a.length, r3[1]),
        post: str.slice(r3[1] + b2.length)
      };
    }
    __name(balanced, "balanced");
    function maybeMatch(reg, str) {
      var m2 = str.match(reg);
      return m2 ? m2[0] : null;
    }
    __name(maybeMatch, "maybeMatch");
    balanced.range = range;
    function range(a, b2, str) {
      var begs, beg, left2, right2, result;
      var ai2 = str.indexOf(a);
      var bi = str.indexOf(b2, ai2 + 1);
      var i = ai2;
      if (ai2 >= 0 && bi > 0) {
        if (a === b2) {
          return [ai2, bi];
        }
        begs = [];
        left2 = str.length;
        while (i >= 0 && !result) {
          if (i == ai2) {
            begs.push(i);
            ai2 = str.indexOf(a, i + 1);
          } else if (begs.length == 1) {
            result = [begs.pop(), bi];
          } else {
            beg = begs.pop();
            if (beg < left2) {
              left2 = beg;
              right2 = bi;
            }
            bi = str.indexOf(b2, i + 1);
          }
          i = ai2 < bi && ai2 >= 0 ? ai2 : bi;
        }
        if (begs.length) {
          result = [left2, right2];
        }
      }
      return result;
    }
    __name(range, "range");
  }
});

// ../../node_modules/.pnpm/brace-expansion@2.0.1/node_modules/brace-expansion/index.js
var require_brace_expansion = __commonJS({
  "../../node_modules/.pnpm/brace-expansion@2.0.1/node_modules/brace-expansion/index.js"(exports2, module3) {
    init_import_meta_url();
    var balanced = require_balanced_match();
    module3.exports = expandTop;
    var escSlash = "\0SLASH" + Math.random() + "\0";
    var escOpen = "\0OPEN" + Math.random() + "\0";
    var escClose = "\0CLOSE" + Math.random() + "\0";
    var escComma = "\0COMMA" + Math.random() + "\0";
    var escPeriod = "\0PERIOD" + Math.random() + "\0";
    function numeric(str) {
      return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
    }
    __name(numeric, "numeric");
    function escapeBraces(str) {
      return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
    }
    __name(escapeBraces, "escapeBraces");
    function unescapeBraces(str) {
      return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
    }
    __name(unescapeBraces, "unescapeBraces");
    function parseCommaParts(str) {
      if (!str)
        return [""];
      var parts = [];
      var m2 = balanced("{", "}", str);
      if (!m2)
        return str.split(",");
      var pre = m2.pre;
      var body = m2.body;
      var post = m2.post;
      var p2 = pre.split(",");
      p2[p2.length - 1] += "{" + body + "}";
      var postParts = parseCommaParts(post);
      if (post.length) {
        p2[p2.length - 1] += postParts.shift();
        p2.push.apply(p2, postParts);
      }
      parts.push.apply(parts, p2);
      return parts;
    }
    __name(parseCommaParts, "parseCommaParts");
    function expandTop(str) {
      if (!str)
        return [];
      if (str.substr(0, 2) === "{}") {
        str = "\\{\\}" + str.substr(2);
      }
      return expand(escapeBraces(str), true).map(unescapeBraces);
    }
    __name(expandTop, "expandTop");
    function embrace(str) {
      return "{" + str + "}";
    }
    __name(embrace, "embrace");
    function isPadded(el) {
      return /^-?0\d/.test(el);
    }
    __name(isPadded, "isPadded");
    function lte(i, y2) {
      return i <= y2;
    }
    __name(lte, "lte");
    function gte(i, y2) {
      return i >= y2;
    }
    __name(gte, "gte");
    function expand(str, isTop) {
      var expansions = [];
      var m2 = balanced("{", "}", str);
      if (!m2)
        return [str];
      var pre = m2.pre;
      var post = m2.post.length ? expand(m2.post, false) : [""];
      if (/\$$/.test(m2.pre)) {
        for (var k2 = 0; k2 < post.length; k2++) {
          var expansion = pre + "{" + m2.body + "}" + post[k2];
          expansions.push(expansion);
        }
      } else {
        var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m2.body);
        var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m2.body);
        var isSequence = isNumericSequence || isAlphaSequence;
        var isOptions = m2.body.indexOf(",") >= 0;
        if (!isSequence && !isOptions) {
          if (m2.post.match(/,.*\}/)) {
            str = m2.pre + "{" + m2.body + escClose + m2.post;
            return expand(str);
          }
          return [str];
        }
        var n2;
        if (isSequence) {
          n2 = m2.body.split(/\.\./);
        } else {
          n2 = parseCommaParts(m2.body);
          if (n2.length === 1) {
            n2 = expand(n2[0], false).map(embrace);
            if (n2.length === 1) {
              return post.map(function(p2) {
                return m2.pre + n2[0] + p2;
              });
            }
          }
        }
        var N2;
        if (isSequence) {
          var x2 = numeric(n2[0]);
          var y2 = numeric(n2[1]);
          var width = Math.max(n2[0].length, n2[1].length);
          var incr = n2.length == 3 ? Math.abs(numeric(n2[2])) : 1;
          var test = lte;
          var reverse = y2 < x2;
          if (reverse) {
            incr *= -1;
            test = gte;
          }
          var pad2 = n2.some(isPadded);
          N2 = [];
          for (var i = x2; test(i, y2); i += incr) {
            var c2;
            if (isAlphaSequence) {
              c2 = String.fromCharCode(i);
              if (c2 === "\\")
                c2 = "";
            } else {
              c2 = String(i);
              if (pad2) {
                var need = width - c2.length;
                if (need > 0) {
                  var z2 = new Array(need + 1).join("0");
                  if (i < 0)
                    c2 = "-" + z2 + c2.slice(1);
                  else
                    c2 = z2 + c2;
                }
              }
            }
            N2.push(c2);
          }
        } else {
          N2 = [];
          for (var j2 = 0; j2 < n2.length; j2++) {
            N2.push.apply(N2, expand(n2[j2], false));
          }
        }
        for (var j2 = 0; j2 < N2.length; j2++) {
          for (var k2 = 0; k2 < post.length; k2++) {
            var expansion = pre + N2[j2] + post[k2];
            if (!isTop || isSequence || expansion)
              expansions.push(expansion);
          }
        }
      }
      return expansions;
    }
    __name(expand, "expand");
  }
});

// ../../node_modules/.pnpm/minimatch@5.1.0/node_modules/minimatch/minimatch.js
var require_minimatch = __commonJS({
  "../../node_modules/.pnpm/minimatch@5.1.0/node_modules/minimatch/minimatch.js"(exports2, module3) {
    init_import_meta_url();
    var minimatch = module3.exports = (p2, pattern, options29 = {}) => {
      assertValidPattern(pattern);
      if (!options29.nocomment && pattern.charAt(0) === "#") {
        return false;
      }
      return new Minimatch2(pattern, options29).match(p2);
    };
    module3.exports = minimatch;
    var path67 = require_path();
    minimatch.sep = path67.sep;
    var GLOBSTAR = Symbol("globstar **");
    minimatch.GLOBSTAR = GLOBSTAR;
    var expand = require_brace_expansion();
    var plTypes = {
      "!": { open: "(?:(?!(?:", close: "))[^/]*?)" },
      "?": { open: "(?:", close: ")?" },
      "+": { open: "(?:", close: ")+" },
      "*": { open: "(?:", close: ")*" },
      "@": { open: "(?:", close: ")" }
    };
    var qmark = "[^/]";
    var star = qmark + "*?";
    var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
    var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
    var charSet = /* @__PURE__ */ __name((s) => s.split("").reduce((set, c2) => {
      set[c2] = true;
      return set;
    }, {}), "charSet");
    var reSpecials = charSet("().*{}+?[]^$\\!");
    var addPatternStartSet = charSet("[.(");
    var slashSplit = /\/+/;
    minimatch.filter = (pattern, options29 = {}) => (p2, i, list) => minimatch(p2, pattern, options29);
    var ext = /* @__PURE__ */ __name((a, b2 = {}) => {
      const t3 = {};
      Object.keys(a).forEach((k2) => t3[k2] = a[k2]);
      Object.keys(b2).forEach((k2) => t3[k2] = b2[k2]);
      return t3;
    }, "ext");
    minimatch.defaults = (def) => {
      if (!def || typeof def !== "object" || !Object.keys(def).length) {
        return minimatch;
      }
      const orig = minimatch;
      const m2 = /* @__PURE__ */ __name((p2, pattern, options29) => orig(p2, pattern, ext(def, options29)), "m");
      m2.Minimatch = /* @__PURE__ */ __name(class Minimatch extends orig.Minimatch {
        constructor(pattern, options29) {
          super(pattern, ext(def, options29));
        }
      }, "Minimatch");
      m2.Minimatch.defaults = (options29) => orig.defaults(ext(def, options29)).Minimatch;
      m2.filter = (pattern, options29) => orig.filter(pattern, ext(def, options29));
      m2.defaults = (options29) => orig.defaults(ext(def, options29));
      m2.makeRe = (pattern, options29) => orig.makeRe(pattern, ext(def, options29));
      m2.braceExpand = (pattern, options29) => orig.braceExpand(pattern, ext(def, options29));
      m2.match = (list, pattern, options29) => orig.match(list, pattern, ext(def, options29));
      return m2;
    };
    minimatch.braceExpand = (pattern, options29) => braceExpand(pattern, options29);
    var braceExpand = /* @__PURE__ */ __name((pattern, options29 = {}) => {
      assertValidPattern(pattern);
      if (options29.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
        return [pattern];
      }
      return expand(pattern);
    }, "braceExpand");
    var MAX_PATTERN_LENGTH = 1024 * 64;
    var assertValidPattern = /* @__PURE__ */ __name((pattern) => {
      if (typeof pattern !== "string") {
        throw new TypeError("invalid pattern");
      }
      if (pattern.length > MAX_PATTERN_LENGTH) {
        throw new TypeError("pattern is too long");
      }
    }, "assertValidPattern");
    var SUBPARSE = Symbol("subparse");
    minimatch.makeRe = (pattern, options29) => new Minimatch2(pattern, options29 || {}).makeRe();
    minimatch.match = (list, pattern, options29 = {}) => {
      const mm = new Minimatch2(pattern, options29);
      list = list.filter((f) => mm.match(f));
      if (mm.options.nonull && !list.length) {
        list.push(pattern);
      }
      return list;
    };
    var globUnescape = /* @__PURE__ */ __name((s) => s.replace(/\\(.)/g, "$1"), "globUnescape");
    var regExpEscape = /* @__PURE__ */ __name((s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), "regExpEscape");
    var Minimatch2 = class {
      constructor(pattern, options29) {
        assertValidPattern(pattern);
        if (!options29)
          options29 = {};
        this.options = options29;
        this.set = [];
        this.pattern = pattern;
        this.windowsPathsNoEscape = !!options29.windowsPathsNoEscape || options29.allowWindowsEscape === false;
        if (this.windowsPathsNoEscape) {
          this.pattern = this.pattern.replace(/\\/g, "/");
        }
        this.regexp = null;
        this.negate = false;
        this.comment = false;
        this.empty = false;
        this.partial = !!options29.partial;
        this.make();
      }
      debug() {
      }
      make() {
        const pattern = this.pattern;
        const options29 = this.options;
        if (!options29.nocomment && pattern.charAt(0) === "#") {
          this.comment = true;
          return;
        }
        if (!pattern) {
          this.empty = true;
          return;
        }
        this.parseNegate();
        let set = this.globSet = this.braceExpand();
        if (options29.debug)
          this.debug = (...args) => console.error(...args);
        this.debug(this.pattern, set);
        set = this.globParts = set.map((s) => s.split(slashSplit));
        this.debug(this.pattern, set);
        set = set.map((s, si2, set2) => s.map(this.parse, this));
        this.debug(this.pattern, set);
        set = set.filter((s) => s.indexOf(false) === -1);
        this.debug(this.pattern, set);
        this.set = set;
      }
      parseNegate() {
        if (this.options.nonegate)
          return;
        const pattern = this.pattern;
        let negate = false;
        let negateOffset = 0;
        for (let i = 0; i < pattern.length && pattern.charAt(i) === "!"; i++) {
          negate = !negate;
          negateOffset++;
        }
        if (negateOffset)
          this.pattern = pattern.substr(negateOffset);
        this.negate = negate;
      }
      // set partial to true to test if, for example,
      // "/a/b" matches the start of "/*/b/*/d"
      // Partial means, if you run out of file before you run
      // out of pattern, then that's fine, as long as all
      // the parts match.
      matchOne(file, pattern, partial) {
        var options29 = this.options;
        this.debug(
          "matchOne",
          { "this": this, file, pattern }
        );
        this.debug("matchOne", file.length, pattern.length);
        for (var fi = 0, pi = 0, fl = file.length, pl2 = pattern.length; fi < fl && pi < pl2; fi++, pi++) {
          this.debug("matchOne loop");
          var p2 = pattern[pi];
          var f = file[fi];
          this.debug(pattern, p2, f);
          if (p2 === false)
            return false;
          if (p2 === GLOBSTAR) {
            this.debug("GLOBSTAR", [pattern, p2, f]);
            var fr2 = fi;
            var pr = pi + 1;
            if (pr === pl2) {
              this.debug("** at the end");
              for (; fi < fl; fi++) {
                if (file[fi] === "." || file[fi] === ".." || !options29.dot && file[fi].charAt(0) === ".")
                  return false;
              }
              return true;
            }
            while (fr2 < fl) {
              var swallowee = file[fr2];
              this.debug("\nglobstar while", file, fr2, pattern, pr, swallowee);
              if (this.matchOne(file.slice(fr2), pattern.slice(pr), partial)) {
                this.debug("globstar found match!", fr2, fl, swallowee);
                return true;
              } else {
                if (swallowee === "." || swallowee === ".." || !options29.dot && swallowee.charAt(0) === ".") {
                  this.debug("dot detected!", file, fr2, pattern, pr);
                  break;
                }
                this.debug("globstar swallow a segment, and continue");
                fr2++;
              }
            }
            if (partial) {
              this.debug("\n>>> no match, partial?", file, fr2, pattern, pr);
              if (fr2 === fl)
                return true;
            }
            return false;
          }
          var hit;
          if (typeof p2 === "string") {
            hit = f === p2;
            this.debug("string match", p2, f, hit);
          } else {
            hit = f.match(p2);
            this.debug("pattern match", p2, f, hit);
          }
          if (!hit)
            return false;
        }
        if (fi === fl && pi === pl2) {
          return true;
        } else if (fi === fl) {
          return partial;
        } else if (pi === pl2) {
          return fi === fl - 1 && file[fi] === "";
        }
        throw new Error("wtf?");
      }
      braceExpand() {
        return braceExpand(this.pattern, this.options);
      }
      parse(pattern, isSub) {
        assertValidPattern(pattern);
        const options29 = this.options;
        if (pattern === "**") {
          if (!options29.noglobstar)
            return GLOBSTAR;
          else
            pattern = "*";
        }
        if (pattern === "")
          return "";
        let re = "";
        let hasMagic = !!options29.nocase;
        let escaping = false;
        const patternListStack = [];
        const negativeLists = [];
        let stateChar;
        let inClass = false;
        let reClassStart = -1;
        let classStart = -1;
        let cs2;
        let pl2;
        let sp;
        const patternStart = pattern.charAt(0) === "." ? "" : options29.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
        const clearStateChar = /* @__PURE__ */ __name(() => {
          if (stateChar) {
            switch (stateChar) {
              case "*":
                re += star;
                hasMagic = true;
                break;
              case "?":
                re += qmark;
                hasMagic = true;
                break;
              default:
                re += "\\" + stateChar;
                break;
            }
            this.debug("clearStateChar %j %j", stateChar, re);
            stateChar = false;
          }
        }, "clearStateChar");
        for (let i = 0, c2; i < pattern.length && (c2 = pattern.charAt(i)); i++) {
          this.debug("%s	%s %s %j", pattern, i, re, c2);
          if (escaping) {
            if (c2 === "/") {
              return false;
            }
            if (reSpecials[c2]) {
              re += "\\";
            }
            re += c2;
            escaping = false;
            continue;
          }
          switch (c2) {
            case "/": {
              return false;
            }
            case "\\":
              clearStateChar();
              escaping = true;
              continue;
            case "?":
            case "*":
            case "+":
            case "@":
            case "!":
              this.debug("%s	%s %s %j <-- stateChar", pattern, i, re, c2);
              if (inClass) {
                this.debug("  in class");
                if (c2 === "!" && i === classStart + 1)
                  c2 = "^";
                re += c2;
                continue;
              }
              this.debug("call clearStateChar %j", stateChar);
              clearStateChar();
              stateChar = c2;
              if (options29.noext)
                clearStateChar();
              continue;
            case "(":
              if (inClass) {
                re += "(";
                continue;
              }
              if (!stateChar) {
                re += "\\(";
                continue;
              }
              patternListStack.push({
                type: stateChar,
                start: i - 1,
                reStart: re.length,
                open: plTypes[stateChar].open,
                close: plTypes[stateChar].close
              });
              re += stateChar === "!" ? "(?:(?!(?:" : "(?:";
              this.debug("plType %j %j", stateChar, re);
              stateChar = false;
              continue;
            case ")":
              if (inClass || !patternListStack.length) {
                re += "\\)";
                continue;
              }
              clearStateChar();
              hasMagic = true;
              pl2 = patternListStack.pop();
              re += pl2.close;
              if (pl2.type === "!") {
                negativeLists.push(pl2);
              }
              pl2.reEnd = re.length;
              continue;
            case "|":
              if (inClass || !patternListStack.length) {
                re += "\\|";
                continue;
              }
              clearStateChar();
              re += "|";
              continue;
            case "[":
              clearStateChar();
              if (inClass) {
                re += "\\" + c2;
                continue;
              }
              inClass = true;
              classStart = i;
              reClassStart = re.length;
              re += c2;
              continue;
            case "]":
              if (i === classStart + 1 || !inClass) {
                re += "\\" + c2;
                continue;
              }
              cs2 = pattern.substring(classStart + 1, i);
              try {
                RegExp("[" + cs2 + "]");
              } catch (er) {
                sp = this.parse(cs2, SUBPARSE);
                re = re.substr(0, reClassStart) + "\\[" + sp[0] + "\\]";
                hasMagic = hasMagic || sp[1];
                inClass = false;
                continue;
              }
              hasMagic = true;
              inClass = false;
              re += c2;
              continue;
            default:
              clearStateChar();
              if (reSpecials[c2] && !(c2 === "^" && inClass)) {
                re += "\\";
              }
              re += c2;
              break;
          }
        }
        if (inClass) {
          cs2 = pattern.substr(classStart + 1);
          sp = this.parse(cs2, SUBPARSE);
          re = re.substr(0, reClassStart) + "\\[" + sp[0];
          hasMagic = hasMagic || sp[1];
        }
        for (pl2 = patternListStack.pop(); pl2; pl2 = patternListStack.pop()) {
          let tail;
          tail = re.slice(pl2.reStart + pl2.open.length);
          this.debug("setting tail", re, pl2);
          tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, (_3, $1, $22) => {
            if (!$22) {
              $22 = "\\";
            }
            return $1 + $1 + $22 + "|";
          });
          this.debug("tail=%j\n   %s", tail, tail, pl2, re);
          const t3 = pl2.type === "*" ? star : pl2.type === "?" ? qmark : "\\" + pl2.type;
          hasMagic = true;
          re = re.slice(0, pl2.reStart) + t3 + "\\(" + tail;
        }
        clearStateChar();
        if (escaping) {
          re += "\\\\";
        }
        const addPatternStart = addPatternStartSet[re.charAt(0)];
        for (let n2 = negativeLists.length - 1; n2 > -1; n2--) {
          const nl = negativeLists[n2];
          const nlBefore = re.slice(0, nl.reStart);
          const nlFirst = re.slice(nl.reStart, nl.reEnd - 8);
          let nlAfter = re.slice(nl.reEnd);
          const nlLast = re.slice(nl.reEnd - 8, nl.reEnd) + nlAfter;
          const openParensBefore = nlBefore.split("(").length - 1;
          let cleanAfter = nlAfter;
          for (let i = 0; i < openParensBefore; i++) {
            cleanAfter = cleanAfter.replace(/\)[+*?]?/, "");
          }
          nlAfter = cleanAfter;
          const dollar = nlAfter === "" && isSub !== SUBPARSE ? "$" : "";
          re = nlBefore + nlFirst + nlAfter + dollar + nlLast;
        }
        if (re !== "" && hasMagic) {
          re = "(?=.)" + re;
        }
        if (addPatternStart) {
          re = patternStart + re;
        }
        if (isSub === SUBPARSE) {
          return [re, hasMagic];
        }
        if (!hasMagic) {
          return globUnescape(pattern);
        }
        const flags = options29.nocase ? "i" : "";
        try {
          return Object.assign(new RegExp("^" + re + "$", flags), {
            _glob: pattern,
            _src: re
          });
        } catch (er) {
          return new RegExp("$.");
        }
      }
      makeRe() {
        if (this.regexp || this.regexp === false)
          return this.regexp;
        const set = this.set;
        if (!set.length) {
          this.regexp = false;
          return this.regexp;
        }
        const options29 = this.options;
        const twoStar = options29.noglobstar ? star : options29.dot ? twoStarDot : twoStarNoDot;
        const flags = options29.nocase ? "i" : "";
        let re = set.map((pattern) => {
          pattern = pattern.map(
            (p2) => typeof p2 === "string" ? regExpEscape(p2) : p2 === GLOBSTAR ? GLOBSTAR : p2._src
          ).reduce((set2, p2) => {
            if (!(set2[set2.length - 1] === GLOBSTAR && p2 === GLOBSTAR)) {
              set2.push(p2);
            }
            return set2;
          }, []);
          pattern.forEach((p2, i) => {
            if (p2 !== GLOBSTAR || pattern[i - 1] === GLOBSTAR) {
              return;
            }
            if (i === 0) {
              if (pattern.length > 1) {
                pattern[i + 1] = "(?:\\/|" + twoStar + "\\/)?" + pattern[i + 1];
              } else {
                pattern[i] = twoStar;
              }
            } else if (i === pattern.length - 1) {
              pattern[i - 1] += "(?:\\/|" + twoStar + ")?";
            } else {
              pattern[i - 1] += "(?:\\/|\\/" + twoStar + "\\/)" + pattern[i + 1];
              pattern[i + 1] = GLOBSTAR;
            }
          });
          return pattern.filter((p2) => p2 !== GLOBSTAR).join("/");
        }).join("|");
        re = "^(?:" + re + ")$";
        if (this.negate)
          re = "^(?!" + re + ").*$";
        try {
          this.regexp = new RegExp(re, flags);
        } catch (ex) {
          this.regexp = false;
        }
        return this.regexp;
      }
      match(f, partial = this.partial) {
        this.debug("match", f, this.pattern);
        if (this.comment)
          return false;
        if (this.empty)
          return f === "";
        if (f === "/" && partial)
          return true;
        const options29 = this.options;
        if (path67.sep !== "/") {
          f = f.split(path67.sep).join("/");
        }
        f = f.split(slashSplit);
        this.debug(this.pattern, "split", f);
        const set = this.set;
        this.debug(this.pattern, "set", set);
        let filename;
        for (let i = f.length - 1; i >= 0; i--) {
          filename = f[i];
          if (filename)
            break;
        }
        for (let i = 0; i < set.length; i++) {
          const pattern = set[i];
          let file = f;
          if (options29.matchBase && pattern.length === 1) {
            file = [filename];
          }
          const hit = this.matchOne(file, pattern, partial);
          if (hit) {
            if (options29.flipNegate)
              return true;
            return !this.negate;
          }
        }
        if (options29.flipNegate)
          return false;
        return this.negate;
      }
      static defaults(def) {
        return minimatch.defaults(def).Minimatch;
      }
    };
    __name(Minimatch2, "Minimatch");
    minimatch.Minimatch = Minimatch2;
  }
});

// ../../node_modules/.pnpm/ms@2.1.2/node_modules/ms/index.js
var require_ms3 = __commonJS({
  "../../node_modules/.pnpm/ms@2.1.2/node_modules/ms/index.js"(exports2, module3) {
    init_import_meta_url();
    var s = 1e3;
    var m2 = s * 60;
    var h2 = m2 * 60;
    var d2 = h2 * 24;
    var w2 = d2 * 7;
    var y2 = d2 * 365.25;
    module3.exports = function(val, options29) {
      options29 = options29 || {};
      var type = typeof val;
      if (type === "string" && val.length > 0) {
        return parse7(val);
      } else if (type === "number" && isFinite(val)) {
        return options29.long ? fmtLong(val) : fmtShort(val);
      }
      throw new Error(
        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
      );
    };
    function parse7(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 n2 = parseFloat(match[1]);
      var type = (match[2] || "ms").toLowerCase();
      switch (type) {
        case "years":
        case "year":
        case "yrs":
        case "yr":
        case "y":
          return n2 * y2;
        case "weeks":
        case "week":
        case "w":
          return n2 * w2;
        case "days":
        case "day":
        case "d":
          return n2 * d2;
        case "hours":
        case "hour":
        case "hrs":
        case "hr":
        case "h":
          return n2 * h2;
        case "minutes":
        case "minute":
        case "mins":
        case "min":
        case "m":
          return n2 * m2;
        case "seconds":
        case "second":
        case "secs":
        case "sec":
        case "s":
          return n2 * s;
        case "milliseconds":
        case "millisecond":
        case "msecs":
        case "msec":
        case "ms":
          return n2;
        default:
          return void 0;
      }
    }
    __name(parse7, "parse");
    function fmtShort(ms) {
      var msAbs = Math.abs(ms);
      if (msAbs >= d2) {
        return Math.round(ms / d2) + "d";
      }
      if (msAbs >= h2) {
        return Math.round(ms / h2) + "h";
      }
      if (msAbs >= m2) {
        return Math.round(ms / m2) + "m";
      }
      if (msAbs >= s) {
        return Math.round(ms / s) + "s";
      }
      return ms + "ms";
    }
    __name(fmtShort, "fmtShort");
    function fmtLong(ms) {
      var msAbs = Math.abs(ms);
      if (msAbs >= d2) {
        return plural2(ms, msAbs, d2, "day");
      }
      if (msAbs >= h2) {
        return plural2(ms, msAbs, h2, "hour");
      }
      if (msAbs >= m2) {
        return plural2(ms, msAbs, m2, "minute");
      }
      if (msAbs >= s) {
        return plural2(ms, msAbs, s, "second");
      }
      return ms + " ms";
    }
    __name(fmtLong, "fmtLong");
    function plural2(ms, msAbs, n2, name) {
      var isPlural = msAbs >= n2 * 1.5;
      return Math.round(ms / n2) + " " + name + (isPlural ? "s" : "");
    }
    __name(plural2, "plural");
  }
});

// ../../node_modules/.pnpm/debug@4.3.4_supports-color@9.2.2/node_modules/debug/src/common.js
var require_common = __commonJS({
  "../../node_modules/.pnpm/debug@4.3.4_supports-color@9.2.2/node_modules/debug/src/common.js"(exports2, module3) {
    init_import_meta_url();
    function setup(env5) {
      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(env5).forEach((key) => {
        createDebug[key] = env5[key];
      });
      createDebug.names = [];
      createDebug.skips = [];
      createDebug.formatters = {};
      function selectColor(namespace) {
        let hash = 0;
        for (let i = 0; i < namespace.length; i++) {
          hash = (hash << 5) - hash + namespace.charCodeAt(i);
          hash |= 0;
        }
        return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
      }
      __name(selectColor, "selectColor");
      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, format10) => {
            if (match === "%%") {
              return "%";
            }
            index++;
            const formatter = createDebug.formatters[format10];
            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);
        }
        __name(debug, "debug");
        debug.namespace = namespace;
        debug.useColors = createDebug.useColors();
        debug.color = createDebug.selectColor(namespace);
        debug.extend = extend;
        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: (v2) => {
            enableOverride = v2;
          }
        });
        if (typeof createDebug.init === "function") {
          createDebug.init(debug);
        }
        return debug;
      }
      __name(createDebug, "createDebug");
      function extend(namespace, delimiter) {
        const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
        newDebug.log = this.log;
        return newDebug;
      }
      __name(extend, "extend");
      function enable(namespaces) {
        createDebug.save(namespaces);
        createDebug.namespaces = namespaces;
        createDebug.names = [];
        createDebug.skips = [];
        let i;
        const split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
        const len = split.length;
        for (i = 0; i < len; i++) {
          if (!split[i]) {
            continue;
          }
          namespaces = split[i].replace(/\*/g, ".*?");
          if (namespaces[0] === "-") {
            createDebug.skips.push(new RegExp("^" + namespaces.slice(1) + "$"));
          } else {
            createDebug.names.push(new RegExp("^" + namespaces + "$"));
          }
        }
      }
      __name(enable, "enable");
      function disable() {
        const namespaces = [
          ...createDebug.names.map(toNamespace),
          ...createDebug.skips.map(toNamespace).map((namespace) => "-" + namespace)
        ].join(",");
        createDebug.enable("");
        return namespaces;
      }
      __name(disable, "disable");
      function enabled(name) {
        if (name[name.length - 1] === "*") {
          return true;
        }
        let i;
        let len;
        for (i = 0, len = createDebug.skips.length; i < len; i++) {
          if (createDebug.skips[i].test(name)) {
            return false;
          }
        }
        for (i = 0, len = createDebug.names.length; i < len; i++) {
          if (createDebug.names[i].test(name)) {
            return true;
          }
        }
        return false;
      }
      __name(enabled, "enabled");
      function toNamespace(regexp) {
        return regexp.toString().substring(2, regexp.toString().length - 2).replace(/\.\*\?$/, "*");
      }
      __name(toNamespace, "toNamespace");
      function coerce(val) {
        if (val instanceof Error) {
          return val.stack || val.message;
        }
        return val;
      }
      __name(coerce, "coerce");
      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`.");
      }
      __name(destroy, "destroy");
      createDebug.enable(createDebug.load());
      return createDebug;
    }
    __name(setup, "setup");
    module3.exports = setup;
  }
});

// ../../node_modules/.pnpm/debug@4.3.4_supports-color@9.2.2/node_modules/debug/src/browser.js
var require_browser2 = __commonJS({
  "../../node_modules/.pnpm/debug@4.3.4_supports-color@9.2.2/node_modules/debug/src/browser.js"(exports2, module3) {
    init_import_meta_url();
    exports2.formatArgs = formatArgs;
    exports2.save = save;
    exports2.load = load;
    exports2.useColors = useColors;
    exports2.storage = localstorage();
    exports2.destroy = (() => {
      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+)/);
    }
    __name(useColors, "useColors");
    function formatArgs(args) {
      args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module3.exports.humanize(this.diff);
      if (!this.useColors) {
        return;
      }
      const c2 = "color: " + this.color;
      args.splice(1, 0, c2, "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, c2);
    }
    __name(formatArgs, "formatArgs");
    exports2.log = console.debug || console.log || (() => {
    });
    function save(namespaces) {
      try {
        if (namespaces) {
          exports2.storage.setItem("debug", namespaces);
        } else {
          exports2.storage.removeItem("debug");
        }
      } catch (error2) {
      }
    }
    __name(save, "save");
    function load() {
      let r3;
      try {
        r3 = exports2.storage.getItem("debug");
      } catch (error2) {
      }
      if (!r3 && typeof process !== "undefined" && "env" in process) {
        r3 = process.env.DEBUG;
      }
      return r3;
    }
    __name(load, "load");
    function localstorage() {
      try {
        return localStorage;
      } catch (error2) {
      }
    }
    __name(localstorage, "localstorage");
    module3.exports = require_common()(exports2);
    var { formatters: formatters2 } = module3.exports;
    formatters2.j = function(v2) {
      try {
        return JSON.stringify(v2);
      } catch (error2) {
        return "[UnexpectedJSONParseError]: " + error2.message;
      }
    };
  }
});

// ../../node_modules/.pnpm/debug@4.3.4_supports-color@9.2.2/node_modules/debug/src/node.js
var require_node5 = __commonJS({
  "../../node_modules/.pnpm/debug@4.3.4_supports-color@9.2.2/node_modules/debug/src/node.js"(exports2, module3) {
    init_import_meta_url();
    var tty2 = require("tty");
    var util4 = require("util");
    exports2.init = init3;
    exports2.log = log2;
    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 supportsColor2 = (init_supports_color(), __toCommonJS(supports_color_exports));
      if (supportsColor2 && (supportsColor2.stderr || supportsColor2).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 (error2) {
    }
    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, (_3, k2) => {
        return k2.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) : tty2.isatty(process.stderr.fd);
    }
    __name(useColors, "useColors");
    function formatArgs(args) {
      const { namespace: name, useColors: useColors2 } = this;
      if (useColors2) {
        const c2 = this.color;
        const colorCode = "\x1B[3" + (c2 < 8 ? c2 : "8;5;" + c2);
        const prefix = `  ${colorCode};1m${name} \x1B[0m`;
        args[0] = prefix + args[0].split("\n").join("\n" + prefix);
        args.push(colorCode + "m+" + module3.exports.humanize(this.diff) + "\x1B[0m");
      } else {
        args[0] = getDate2() + name + " " + args[0];
      }
    }
    __name(formatArgs, "formatArgs");
    function getDate2() {
      if (exports2.inspectOpts.hideDate) {
        return "";
      }
      return (/* @__PURE__ */ new Date()).toISOString() + " ";
    }
    __name(getDate2, "getDate");
    function log2(...args) {
      return process.stderr.write(util4.format(...args) + "\n");
    }
    __name(log2, "log");
    function save(namespaces) {
      if (namespaces) {
        process.env.DEBUG = namespaces;
      } else {
        delete process.env.DEBUG;
      }
    }
    __name(save, "save");
    function load() {
      return process.env.DEBUG;
    }
    __name(load, "load");
    function init3(debug) {
      debug.inspectOpts = {};
      const keys = Object.keys(exports2.inspectOpts);
      for (let i = 0; i < keys.length; i++) {
        debug.inspectOpts[keys[i]] = exports2.inspectOpts[keys[i]];
      }
    }
    __name(init3, "init");
    module3.exports = require_common()(exports2);
    var { formatters: formatters2 } = module3.exports;
    formatters2.o = function(v2) {
      this.inspectOpts.colors = this.useColors;
      return util4.inspect(v2, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
    };
    formatters2.O = function(v2) {
      this.inspectOpts.colors = this.useColors;
      return util4.inspect(v2, this.inspectOpts);
    };
  }
});

// ../../node_modules/.pnpm/debug@4.3.4_supports-color@9.2.2/node_modules/debug/src/index.js
var require_src10 = __commonJS({
  "../../node_modules/.pnpm/debug@4.3.4_supports-color@9.2.2/node_modules/debug/src/index.js"(exports2, module3) {
    init_import_meta_url();
    if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
      module3.exports = require_browser2();
    } else {
      module3.exports = require_node5();
    }
  }
});

// ../../node_modules/.pnpm/agent-base@7.1.0_supports-color@9.2.2/node_modules/agent-base/dist/helpers.js
var require_helpers = __commonJS({
  "../../node_modules/.pnpm/agent-base@7.1.0_supports-color@9.2.2/node_modules/agent-base/dist/helpers.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o2, m2, k2, k22) {
      if (k22 === void 0)
        k22 = k2;
      var desc = Object.getOwnPropertyDescriptor(m2, k2);
      if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m2[k2];
        } };
      }
      Object.defineProperty(o2, k22, desc);
    } : function(o2, m2, k2, k22) {
      if (k22 === void 0)
        k22 = k2;
      o2[k22] = m2[k2];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o2, v2) {
      Object.defineProperty(o2, "default", { enumerable: true, value: v2 });
    } : function(o2, v2) {
      o2["default"] = v2;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule)
        return mod;
      var result = {};
      if (mod != null) {
        for (var k2 in mod)
          if (k2 !== "default" && Object.prototype.hasOwnProperty.call(mod, k2))
            __createBinding(result, mod, k2);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.req = exports2.json = exports2.toBuffer = void 0;
    var http4 = __importStar(require("http"));
    var https3 = __importStar(require("https"));
    async function toBuffer(stream2) {
      let length = 0;
      const chunks = [];
      for await (const chunk of stream2) {
        length += chunk.length;
        chunks.push(chunk);
      }
      return Buffer.concat(chunks, length);
    }
    __name(toBuffer, "toBuffer");
    exports2.toBuffer = toBuffer;
    async function json(stream2) {
      const buf = await toBuffer(stream2);
      const str = buf.toString("utf8");
      try {
        return JSON.parse(str);
      } catch (_err) {
        const err = _err;
        err.message += ` (input: ${str})`;
        throw err;
      }
    }
    __name(json, "json");
    exports2.json = json;
    function req(url4, opts = {}) {
      const href = typeof url4 === "string" ? url4 : url4.href;
      const req2 = (href.startsWith("https:") ? https3 : http4).request(url4, opts);
      const promise = new Promise((resolve19, reject) => {
        req2.once("response", resolve19).once("error", reject).end();
      });
      req2.then = promise.then.bind(promise);
      return req2;
    }
    __name(req, "req");
    exports2.req = req;
  }
});

// ../../node_modules/.pnpm/agent-base@7.1.0_supports-color@9.2.2/node_modules/agent-base/dist/index.js
var require_dist5 = __commonJS({
  "../../node_modules/.pnpm/agent-base@7.1.0_supports-color@9.2.2/node_modules/agent-base/dist/index.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o2, m2, k2, k22) {
      if (k22 === void 0)
        k22 = k2;
      var desc = Object.getOwnPropertyDescriptor(m2, k2);
      if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m2[k2];
        } };
      }
      Object.defineProperty(o2, k22, desc);
    } : function(o2, m2, k2, k22) {
      if (k22 === void 0)
        k22 = k2;
      o2[k22] = m2[k2];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o2, v2) {
      Object.defineProperty(o2, "default", { enumerable: true, value: v2 });
    } : function(o2, v2) {
      o2["default"] = v2;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule)
        return mod;
      var result = {};
      if (mod != null) {
        for (var k2 in mod)
          if (k2 !== "default" && Object.prototype.hasOwnProperty.call(mod, k2))
            __createBinding(result, mod, k2);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    var __exportStar = exports2 && exports2.__exportStar || function(m2, exports3) {
      for (var p2 in m2)
        if (p2 !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p2))
          __createBinding(exports3, m2, p2);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Agent = void 0;
    var http4 = __importStar(require("http"));
    __exportStar(require_helpers(), exports2);
    var INTERNAL = Symbol("AgentBaseInternalState");
    var Agent = class extends http4.Agent {
      constructor(opts) {
        super(opts);
        this[INTERNAL] = {};
      }
      /**
       * Determine whether this is an `http` or `https` request.
       */
      isSecureEndpoint(options29) {
        if (options29) {
          if (typeof options29.secureEndpoint === "boolean") {
            return options29.secureEndpoint;
          }
          if (typeof options29.protocol === "string") {
            return options29.protocol === "https:";
          }
        }
        const { stack } = new Error();
        if (typeof stack !== "string")
          return false;
        return stack.split("\n").some((l2) => l2.indexOf("(https.js:") !== -1 || l2.indexOf("node:https:") !== -1);
      }
      createSocket(req, options29, cb) {
        const connectOpts = {
          ...options29,
          secureEndpoint: this.isSecureEndpoint(options29)
        };
        Promise.resolve().then(() => this.connect(req, connectOpts)).then((socket) => {
          if (socket instanceof http4.Agent) {
            return socket.addRequest(req, connectOpts);
          }
          this[INTERNAL].currentSocket = socket;
          super.createSocket(req, options29, cb);
        }, cb);
      }
      createConnection() {
        const socket = this[INTERNAL].currentSocket;
        this[INTERNAL].currentSocket = void 0;
        if (!socket) {
          throw new Error("No socket was returned in the `connect()` function");
        }
        return socket;
      }
      get defaultPort() {
        return this[INTERNAL].defaultPort ?? (this.protocol === "https:" ? 443 : 80);
      }
      set defaultPort(v2) {
        if (this[INTERNAL]) {
          this[INTERNAL].defaultPort = v2;
        }
      }
      get protocol() {
        return this[INTERNAL].protocol ?? (this.isSecureEndpoint() ? "https:" : "http:");
      }
      set protocol(v2) {
        if (this[INTERNAL]) {
          this[INTERNAL].protocol = v2;
        }
      }
    };
    __name(Agent, "Agent");
    exports2.Agent = Agent;
  }
});

// ../../node_modules/.pnpm/https-proxy-agent@7.0.2_supports-color@9.2.2/node_modules/https-proxy-agent/dist/parse-proxy-response.js
var require_parse_proxy_response = __commonJS({
  "../../node_modules/.pnpm/https-proxy-agent@7.0.2_supports-color@9.2.2/node_modules/https-proxy-agent/dist/parse-proxy-response.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.parseProxyResponse = void 0;
    var debug_1 = __importDefault(require_src10());
    var debug = (0, debug_1.default)("https-proxy-agent:parse-proxy-response");
    function parseProxyResponse(socket) {
      return new Promise((resolve19, reject) => {
        let buffersLength = 0;
        const buffers = [];
        function read() {
          const b2 = socket.read();
          if (b2)
            ondata(b2);
          else
            socket.once("readable", read);
        }
        __name(read, "read");
        function cleanup() {
          socket.removeListener("end", onend);
          socket.removeListener("error", onerror);
          socket.removeListener("readable", read);
        }
        __name(cleanup, "cleanup");
        function onend() {
          cleanup();
          debug("onend");
          reject(new Error("Proxy connection ended before receiving CONNECT response"));
        }
        __name(onend, "onend");
        function onerror(err) {
          cleanup();
          debug("onerror %o", err);
          reject(err);
        }
        __name(onerror, "onerror");
        function ondata(b2) {
          buffers.push(b2);
          buffersLength += b2.length;
          const buffered = Buffer.concat(buffers, buffersLength);
          const endOfHeaders = buffered.indexOf("\r\n\r\n");
          if (endOfHeaders === -1) {
            debug("have not received end of HTTP headers yet...");
            read();
            return;
          }
          const headerParts = buffered.slice(0, endOfHeaders).toString("ascii").split("\r\n");
          const firstLine = headerParts.shift();
          if (!firstLine) {
            socket.destroy();
            return reject(new Error("No header received from proxy CONNECT response"));
          }
          const firstLineParts = firstLine.split(" ");
          const statusCode = +firstLineParts[1];
          const statusText = firstLineParts.slice(2).join(" ");
          const headers = {};
          for (const header of headerParts) {
            if (!header)
              continue;
            const firstColon = header.indexOf(":");
            if (firstColon === -1) {
              socket.destroy();
              return reject(new Error(`Invalid header from proxy CONNECT response: "${header}"`));
            }
            const key = header.slice(0, firstColon).toLowerCase();
            const value = header.slice(firstColon + 1).trimStart();
            const current = headers[key];
            if (typeof current === "string") {
              headers[key] = [current, value];
            } else if (Array.isArray(current)) {
              current.push(value);
            } else {
              headers[key] = value;
            }
          }
          debug("got proxy server response: %o %o", firstLine, headers);
          cleanup();
          resolve19({
            connect: {
              statusCode,
              statusText,
              headers
            },
            buffered
          });
        }
        __name(ondata, "ondata");
        socket.on("error", onerror);
        socket.on("end", onend);
        read();
      });
    }
    __name(parseProxyResponse, "parseProxyResponse");
    exports2.parseProxyResponse = parseProxyResponse;
  }
});

// ../../node_modules/.pnpm/https-proxy-agent@7.0.2_supports-color@9.2.2/node_modules/https-proxy-agent/dist/index.js
var require_dist6 = __commonJS({
  "../../node_modules/.pnpm/https-proxy-agent@7.0.2_supports-color@9.2.2/node_modules/https-proxy-agent/dist/index.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o2, m2, k2, k22) {
      if (k22 === void 0)
        k22 = k2;
      var desc = Object.getOwnPropertyDescriptor(m2, k2);
      if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m2[k2];
        } };
      }
      Object.defineProperty(o2, k22, desc);
    } : function(o2, m2, k2, k22) {
      if (k22 === void 0)
        k22 = k2;
      o2[k22] = m2[k2];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o2, v2) {
      Object.defineProperty(o2, "default", { enumerable: true, value: v2 });
    } : function(o2, v2) {
      o2["default"] = v2;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule)
        return mod;
      var result = {};
      if (mod != null) {
        for (var k2 in mod)
          if (k2 !== "default" && Object.prototype.hasOwnProperty.call(mod, k2))
            __createBinding(result, mod, k2);
      }
      __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.HttpsProxyAgent = void 0;
    var net3 = __importStar(require("net"));
    var tls = __importStar(require("tls"));
    var assert_1 = __importDefault(require("assert"));
    var debug_1 = __importDefault(require_src10());
    var agent_base_1 = require_dist5();
    var parse_proxy_response_1 = require_parse_proxy_response();
    var debug = (0, debug_1.default)("https-proxy-agent");
    var HttpsProxyAgent3 = class extends agent_base_1.Agent {
      constructor(proxy2, opts) {
        super(opts);
        this.options = { path: void 0 };
        this.proxy = typeof proxy2 === "string" ? new URL(proxy2) : proxy2;
        this.proxyHeaders = opts?.headers ?? {};
        debug("Creating new HttpsProxyAgent instance: %o", this.proxy.href);
        const host = (this.proxy.hostname || this.proxy.host).replace(/^\[|\]$/g, "");
        const port2 = this.proxy.port ? parseInt(this.proxy.port, 10) : this.proxy.protocol === "https:" ? 443 : 80;
        this.connectOpts = {
          // Attempt to negotiate http/1.1 for proxy servers that support http/2
          ALPNProtocols: ["http/1.1"],
          ...opts ? omit(opts, "headers") : null,
          host,
          port: port2
        };
      }
      /**
       * Called when the node-core HTTP client library is creating a
       * new HTTP request.
       */
      async connect(req, opts) {
        const { proxy: proxy2 } = this;
        if (!opts.host) {
          throw new TypeError('No "host" provided');
        }
        let socket;
        if (proxy2.protocol === "https:") {
          debug("Creating `tls.Socket`: %o", this.connectOpts);
          const servername = this.connectOpts.servername || this.connectOpts.host;
          socket = tls.connect({
            ...this.connectOpts,
            servername: servername && net3.isIP(servername) ? void 0 : servername
          });
        } else {
          debug("Creating `net.Socket`: %o", this.connectOpts);
          socket = net3.connect(this.connectOpts);
        }
        const headers = typeof this.proxyHeaders === "function" ? this.proxyHeaders() : { ...this.proxyHeaders };
        const host = net3.isIPv6(opts.host) ? `[${opts.host}]` : opts.host;
        let payload = `CONNECT ${host}:${opts.port} HTTP/1.1\r
`;
        if (proxy2.username || proxy2.password) {
          const auth = `${decodeURIComponent(proxy2.username)}:${decodeURIComponent(proxy2.password)}`;
          headers["Proxy-Authorization"] = `Basic ${Buffer.from(auth).toString("base64")}`;
        }
        headers.Host = `${host}:${opts.port}`;
        if (!headers["Proxy-Connection"]) {
          headers["Proxy-Connection"] = this.keepAlive ? "Keep-Alive" : "close";
        }
        for (const name of Object.keys(headers)) {
          payload += `${name}: ${headers[name]}\r
`;
        }
        const proxyResponsePromise = (0, parse_proxy_response_1.parseProxyResponse)(socket);
        socket.write(`${payload}\r
`);
        const { connect: connect2, buffered } = await proxyResponsePromise;
        req.emit("proxyConnect", connect2);
        this.emit("proxyConnect", connect2, req);
        if (connect2.statusCode === 200) {
          req.once("socket", resume);
          if (opts.secureEndpoint) {
            debug("Upgrading socket connection to TLS");
            const servername = opts.servername || opts.host;
            return tls.connect({
              ...omit(opts, "host", "path", "port"),
              socket,
              servername: net3.isIP(servername) ? void 0 : servername
            });
          }
          return socket;
        }
        socket.destroy();
        const fakeSocket = new net3.Socket({ writable: false });
        fakeSocket.readable = true;
        req.once("socket", (s) => {
          debug("Replaying proxy buffer for failed request");
          (0, assert_1.default)(s.listenerCount("data") > 0);
          s.push(buffered);
          s.push(null);
        });
        return fakeSocket;
      }
    };
    __name(HttpsProxyAgent3, "HttpsProxyAgent");
    HttpsProxyAgent3.protocols = ["http", "https"];
    exports2.HttpsProxyAgent = HttpsProxyAgent3;
    function resume(socket) {
      socket.resume();
    }
    __name(resume, "resume");
    function omit(obj, ...keys) {
      const ret = {};
      let key;
      for (key in obj) {
        if (!keys.includes(key)) {
          ret[key] = obj[key];
        }
      }
      return ret;
    }
    __name(omit, "omit");
  }
});

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

// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/constants.js
var require_constants13 = __commonJS({
  "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/constants.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    module3.exports = {
      BINARY_TYPES: ["nodebuffer", "arraybuffer", "fragments"],
      EMPTY_BUFFER: Buffer.alloc(0),
      GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
      kForOnEventAttribute: Symbol("kIsForOnEventAttribute"),
      kListener: Symbol("kListener"),
      kStatusCode: Symbol("status-code"),
      kWebSocket: Symbol("websocket"),
      NOOP: () => {
      }
    };
  }
});

// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/buffer-util.js
var require_buffer_util2 = __commonJS({
  "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/buffer-util.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { EMPTY_BUFFER } = require_constants13();
    function concat(list, totalLength) {
      if (list.length === 0)
        return EMPTY_BUFFER;
      if (list.length === 1)
        return list[0];
      const target = Buffer.allocUnsafe(totalLength);
      let offset = 0;
      for (let i = 0; i < list.length; i++) {
        const buf = list[i];
        target.set(buf, offset);
        offset += buf.length;
      }
      if (offset < totalLength)
        return target.slice(0, offset);
      return target;
    }
    __name(concat, "concat");
    function _mask(source, mask, output, offset, length) {
      for (let i = 0; i < length; i++) {
        output[offset + i] = source[i] ^ mask[i & 3];
      }
    }
    __name(_mask, "_mask");
    function _unmask(buffer, mask) {
      for (let i = 0; i < buffer.length; i++) {
        buffer[i] ^= mask[i & 3];
      }
    }
    __name(_unmask, "_unmask");
    function toArrayBuffer(buf) {
      if (buf.byteLength === buf.buffer.byteLength) {
        return buf.buffer;
      }
      return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
    }
    __name(toArrayBuffer, "toArrayBuffer");
    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;
    }
    __name(toBuffer, "toBuffer");
    module3.exports = {
      concat,
      mask: _mask,
      toArrayBuffer,
      toBuffer,
      unmask: _unmask
    };
    if (!process.env.WS_NO_BUFFER_UTIL) {
      try {
        const bufferUtil = require("bufferutil");
        module3.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);
        };
        module3.exports.unmask = function(buffer, mask) {
          if (buffer.length < 32)
            _unmask(buffer, mask);
          else
            bufferUtil.unmask(buffer, mask);
        };
      } catch (e3) {
      }
    }
  }
});

// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/limiter.js
var require_limiter2 = __commonJS({
  "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/limiter.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var kDone = Symbol("kDone");
    var kRun = 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]);
        }
      }
    };
    __name(Limiter, "Limiter");
    module3.exports = Limiter;
  }
});

// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/permessage-deflate.js
var require_permessage_deflate2 = __commonJS({
  "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/permessage-deflate.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var zlib = require("zlib");
    var bufferUtil = require_buffer_util2();
    var Limiter = require_limiter2();
    var { kStatusCode } = require_constants13();
    var TRAILER = Buffer.from([0, 0, 255, 255]);
    var kPerMessageDeflate = Symbol("permessage-deflate");
    var kTotalLength = Symbol("total-length");
    var kCallback = Symbol("callback");
    var kBuffers = Symbol("buffers");
    var kError = 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(options29, isServer, maxPayload) {
        this._maxPayload = maxPayload | 0;
        this._options = options29 || {};
        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 endpoint = this._isServer ? "client" : "server";
        if (!this._inflate) {
          const key = `${endpoint}_max_window_bits`;
          const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key];
          this._inflate = zlib.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[`${endpoint}_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 endpoint = this._isServer ? "server" : "client";
        if (!this._deflate) {
          const key = `${endpoint}_max_window_bits`;
          const windowBits = typeof this.params[key] !== "number" ? zlib.Z_DEFAULT_WINDOWBITS : this.params[key];
          this._deflate = zlib.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(zlib.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[`${endpoint}_no_context_takeover`]) {
            this._deflate.reset();
          }
          callback(null, data2);
        });
      }
    };
    __name(PerMessageDeflate, "PerMessageDeflate");
    module3.exports = PerMessageDeflate;
    function deflateOnData(chunk) {
      this[kBuffers].push(chunk);
      this[kTotalLength] += chunk.length;
    }
    __name(deflateOnData, "deflateOnData");
    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();
    }
    __name(inflateOnData, "inflateOnData");
    function inflateOnError(err) {
      this[kPerMessageDeflate]._inflate = null;
      err[kStatusCode] = 1007;
      this[kCallback](err);
    }
    __name(inflateOnError, "inflateOnError");
  }
});

// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/validation.js
var require_validation2 = __commonJS({
  "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/validation.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    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;
    }
    __name(isValidStatusCode, "isValidStatusCode");
    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;
    }
    __name(_isValidUTF8, "_isValidUTF8");
    module3.exports = {
      isValidStatusCode,
      isValidUTF8: _isValidUTF8,
      tokenChars
    };
    if (!process.env.WS_NO_UTF_8_VALIDATE) {
      try {
        const isValidUTF8 = require("utf-8-validate");
        module3.exports.isValidUTF8 = function(buf) {
          return buf.length < 150 ? _isValidUTF8(buf) : isValidUTF8(buf);
        };
      } catch (e3) {
      }
    }
  }
});

// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/receiver.js
var require_receiver4 = __commonJS({
  "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/receiver.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { Writable } = require("stream");
    var PerMessageDeflate = require_permessage_deflate2();
    var {
      BINARY_TYPES,
      EMPTY_BUFFER,
      kStatusCode,
      kWebSocket
    } = require_constants13();
    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 Receiver2 = class extends Writable {
      /**
       * Creates a Receiver instance.
       *
       * @param {Object} [options] Options object
       * @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(options29 = {}) {
        super();
        this._binaryType = options29.binaryType || BINARY_TYPES[0];
        this._extensions = options29.extensions || {};
        this._isServer = !!options29.isServer;
        this._maxPayload = options29.maxPayload | 0;
        this._skipUTF8Validation = !!options29.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._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(n2) {
        this._bufferedBytes -= n2;
        if (n2 === this._buffers[0].length)
          return this._buffers.shift();
        if (n2 < this._buffers[0].length) {
          const buf = this._buffers[0];
          this._buffers[0] = buf.slice(n2);
          return buf.slice(0, n2);
        }
        const dst = Buffer.allocUnsafe(n2);
        do {
          const buf = this._buffers[0];
          const offset = dst.length - n2;
          if (n2 >= buf.length) {
            dst.set(this._buffers.shift(), offset);
          } else {
            dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n2), offset);
            this._buffers[0] = buf.slice(n2);
          }
          n2 -= buf.length;
        } while (n2 > 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 error2(
            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 error2(
            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 error2(
              RangeError,
              "RSV1 must be clear",
              true,
              1002,
              "WS_ERR_UNEXPECTED_RSV_1"
            );
          }
          if (!this._fragmented) {
            this._loop = false;
            return error2(
              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 error2(
              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 error2(
              RangeError,
              "FIN must be set",
              true,
              1002,
              "WS_ERR_EXPECTED_FIN"
            );
          }
          if (compressed) {
            this._loop = false;
            return error2(
              RangeError,
              "RSV1 must be clear",
              true,
              1002,
              "WS_ERR_UNEXPECTED_RSV_1"
            );
          }
          if (this._payloadLength > 125) {
            this._loop = false;
            return error2(
              RangeError,
              `invalid payload length ${this._payloadLength}`,
              true,
              1002,
              "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH"
            );
          }
        } else {
          this._loop = false;
          return error2(
            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 error2(
              RangeError,
              "MASK must be set",
              true,
              1002,
              "WS_ERR_EXPECTED_MASK"
            );
          }
        } else if (this._masked) {
          this._loop = false;
          return error2(
            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 error2(
            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 error2(
              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 && (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0) {
            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(
                error2(
                  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, true);
          } else {
            const buf = concat(fragments, messageLength);
            if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
              this._loop = false;
              return error2(
                Error,
                "invalid UTF-8 sequence",
                true,
                1007,
                "WS_ERR_INVALID_UTF8"
              );
            }
            this.emit("message", buf, false);
          }
        }
        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, EMPTY_BUFFER);
            this.end();
          } else if (data.length === 1) {
            return error2(
              RangeError,
              "invalid payload length 1",
              true,
              1002,
              "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH"
            );
          } else {
            const code = data.readUInt16BE(0);
            if (!isValidStatusCode(code)) {
              return error2(
                RangeError,
                `invalid status code ${code}`,
                true,
                1002,
                "WS_ERR_INVALID_CLOSE_CODE"
              );
            }
            const buf = data.slice(2);
            if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
              return error2(
                Error,
                "invalid UTF-8 sequence",
                true,
                1007,
                "WS_ERR_INVALID_UTF8"
              );
            }
            this.emit("conclude", code, buf);
            this.end();
          }
        } else if (this._opcode === 9) {
          this.emit("ping", data);
        } else {
          this.emit("pong", data);
        }
        this._state = GET_INFO;
      }
    };
    __name(Receiver2, "Receiver");
    module3.exports = Receiver2;
    function error2(ErrorCtor, message, prefix, statusCode, errorCode) {
      const err = new ErrorCtor(
        prefix ? `Invalid WebSocket frame: ${message}` : message
      );
      Error.captureStackTrace(err, error2);
      err.code = errorCode;
      err[kStatusCode] = statusCode;
      return err;
    }
    __name(error2, "error");
  }
});

// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/sender.js
var require_sender2 = __commonJS({
  "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/sender.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var net3 = require("net");
    var tls = require("tls");
    var { randomFillSync } = require("crypto");
    var PerMessageDeflate = require_permessage_deflate2();
    var { EMPTY_BUFFER } = require_constants13();
    var { isValidStatusCode } = require_validation2();
    var { mask: applyMask, toBuffer } = require_buffer_util2();
    var kByteLength = Symbol("kByteLength");
    var maskBuffer = Buffer.alloc(4);
    var Sender2 = class {
      /**
       * Creates a Sender instance.
       *
       * @param {(net.Socket|tls.Socket)} 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._deflating = false;
        this._queue = [];
      }
      /**
       * 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, options29) {
        let mask;
        let merge = false;
        let offset = 2;
        let skipMasking = false;
        if (options29.mask) {
          mask = options29.maskBuffer || maskBuffer;
          if (options29.generateMask) {
            options29.generateMask(mask);
          } else {
            randomFillSync(mask, 0, 4);
          }
          skipMasking = (mask[0] | mask[1] | mask[2] | mask[3]) === 0;
          offset = 6;
        }
        let dataLength;
        if (typeof data === "string") {
          if ((!options29.mask || skipMasking) && options29[kByteLength] !== void 0) {
            dataLength = options29[kByteLength];
          } else {
            data = Buffer.from(data);
            dataLength = data.length;
          }
        } else {
          dataLength = data.length;
          merge = options29.mask && options29.readOnly && !skipMasking;
        }
        let payloadLength = dataLength;
        if (dataLength >= 65536) {
          offset += 8;
          payloadLength = 127;
        } else if (dataLength > 125) {
          offset += 2;
          payloadLength = 126;
        }
        const target = Buffer.allocUnsafe(merge ? dataLength + offset : offset);
        target[0] = options29.fin ? options29.opcode | 128 : options29.opcode;
        if (options29.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 (!options29.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 (merge) {
          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 options29 = {
          [kByteLength]: buf.length,
          fin: true,
          generateMask: this._generateMask,
          mask,
          maskBuffer: this._maskBuffer,
          opcode: 8,
          readOnly: false,
          rsv1: false
        };
        if (this._deflating) {
          this.enqueue([this.dispatch, buf, false, options29, cb]);
        } else {
          this.sendFrame(Sender2.frame(buf, options29), 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 {
          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 options29 = {
          [kByteLength]: byteLength,
          fin: true,
          generateMask: this._generateMask,
          mask,
          maskBuffer: this._maskBuffer,
          opcode: 9,
          readOnly,
          rsv1: false
        };
        if (this._deflating) {
          this.enqueue([this.dispatch, data, false, options29, cb]);
        } else {
          this.sendFrame(Sender2.frame(data, options29), 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 {
          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 options29 = {
          [kByteLength]: byteLength,
          fin: true,
          generateMask: this._generateMask,
          mask,
          maskBuffer: this._maskBuffer,
          opcode: 10,
          readOnly,
          rsv1: false
        };
        if (this._deflating) {
          this.enqueue([this.dispatch, data, false, options29, cb]);
        } else {
          this.sendFrame(Sender2.frame(data, options29), 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, options29, cb) {
        const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
        let opcode = options29.binary ? 2 : 1;
        let rsv1 = options29.compress;
        let byteLength;
        let readOnly;
        if (typeof data === "string") {
          byteLength = Buffer.byteLength(data);
          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 (options29.fin)
          this._firstFragment = true;
        if (perMessageDeflate) {
          const opts = {
            [kByteLength]: byteLength,
            fin: options29.fin,
            generateMask: this._generateMask,
            mask: options29.mask,
            maskBuffer: this._maskBuffer,
            opcode,
            readOnly,
            rsv1
          };
          if (this._deflating) {
            this.enqueue([this.dispatch, data, this._compress, opts, cb]);
          } else {
            this.dispatch(data, this._compress, opts, cb);
          }
        } else {
          this.sendFrame(
            Sender2.frame(data, {
              [kByteLength]: byteLength,
              fin: options29.fin,
              generateMask: this._generateMask,
              mask: options29.mask,
              maskBuffer: this._maskBuffer,
              opcode,
              readOnly,
              rsv1: false
            }),
            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, options29, cb) {
        if (!compress) {
          this.sendFrame(Sender2.frame(data, options29), cb);
          return;
        }
        const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
        this._bufferedBytes += options29[kByteLength];
        this._deflating = true;
        perMessageDeflate.compress(data, options29.fin, (_3, 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 params = this._queue[i];
              const callback = params[params.length - 1];
              if (typeof callback === "function")
                callback(err);
            }
            return;
          }
          this._bufferedBytes -= options29[kByteLength];
          this._deflating = false;
          options29.readOnly = false;
          this.sendFrame(Sender2.frame(buf, options29), cb);
          this.dequeue();
        });
      }
      /**
       * Executes queued send operations.
       *
       * @private
       */
      dequeue() {
        while (!this._deflating && 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[]} list The frame to send
       * @param {Function} [cb] Callback
       * @private
       */
      sendFrame(list, cb) {
        if (list.length === 2) {
          this._socket.cork();
          this._socket.write(list[0]);
          this._socket.write(list[1], cb);
          this._socket.uncork();
        } else {
          this._socket.write(list[0], cb);
        }
      }
    };
    __name(Sender2, "Sender");
    module3.exports = Sender2;
  }
});

// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/event-target.js
var require_event_target2 = __commonJS({
  "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/event-target.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { kForOnEventAttribute, kListener } = require_constants13();
    var kCode = Symbol("kCode");
    var kData = Symbol("kData");
    var kError = Symbol("kError");
    var kMessage = Symbol("kMessage");
    var kReason = Symbol("kReason");
    var kTarget = Symbol("kTarget");
    var kType = Symbol("kType");
    var kWasClean = Symbol("kWasClean");
    var Event2 = 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];
      }
    };
    __name(Event2, "Event");
    Object.defineProperty(Event2.prototype, "target", { enumerable: true });
    Object.defineProperty(Event2.prototype, "type", { enumerable: true });
    var CloseEvent = class extends Event2 {
      /**
       * 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, options29 = {}) {
        super(type);
        this[kCode] = options29.code === void 0 ? 0 : options29.code;
        this[kReason] = options29.reason === void 0 ? "" : options29.reason;
        this[kWasClean] = options29.wasClean === void 0 ? false : options29.wasClean;
      }
      /**
       * @type {Number}
       */
      get code() {
        return this[kCode];
      }
      /**
       * @type {String}
       */
      get reason() {
        return this[kReason];
      }
      /**
       * @type {Boolean}
       */
      get wasClean() {
        return this[kWasClean];
      }
    };
    __name(CloseEvent, "CloseEvent");
    Object.defineProperty(CloseEvent.prototype, "code", { enumerable: true });
    Object.defineProperty(CloseEvent.prototype, "reason", { enumerable: true });
    Object.defineProperty(CloseEvent.prototype, "wasClean", { enumerable: true });
    var ErrorEvent2 = class extends Event2 {
      /**
       * 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, options29 = {}) {
        super(type);
        this[kError] = options29.error === void 0 ? null : options29.error;
        this[kMessage] = options29.message === void 0 ? "" : options29.message;
      }
      /**
       * @type {*}
       */
      get error() {
        return this[kError];
      }
      /**
       * @type {String}
       */
      get message() {
        return this[kMessage];
      }
    };
    __name(ErrorEvent2, "ErrorEvent");
    Object.defineProperty(ErrorEvent2.prototype, "error", { enumerable: true });
    Object.defineProperty(ErrorEvent2.prototype, "message", { enumerable: true });
    var MessageEvent = class extends Event2 {
      /**
       * 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, options29 = {}) {
        super(type);
        this[kData] = options29.data === void 0 ? null : options29.data;
      }
      /**
       * @type {*}
       */
      get data() {
        return this[kData];
      }
    };
    __name(MessageEvent, "MessageEvent");
    Object.defineProperty(MessageEvent.prototype, "data", { enumerable: true });
    var EventTarget2 = {
      /**
       * 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, handler30, options29 = {}) {
        for (const listener of this.listeners(type)) {
          if (!options29[kForOnEventAttribute] && listener[kListener] === handler30 && !listener[kForOnEventAttribute]) {
            return;
          }
        }
        let wrapper;
        if (type === "message") {
          wrapper = /* @__PURE__ */ __name(function onMessage(data, isBinary) {
            const event = new MessageEvent("message", {
              data: isBinary ? data : data.toString()
            });
            event[kTarget] = this;
            callListener(handler30, this, event);
          }, "onMessage");
        } else if (type === "close") {
          wrapper = /* @__PURE__ */ __name(function onClose(code, message) {
            const event = new CloseEvent("close", {
              code,
              reason: message.toString(),
              wasClean: this._closeFrameReceived && this._closeFrameSent
            });
            event[kTarget] = this;
            callListener(handler30, this, event);
          }, "onClose");
        } else if (type === "error") {
          wrapper = /* @__PURE__ */ __name(function onError(error2) {
            const event = new ErrorEvent2("error", {
              error: error2,
              message: error2.message
            });
            event[kTarget] = this;
            callListener(handler30, this, event);
          }, "onError");
        } else if (type === "open") {
          wrapper = /* @__PURE__ */ __name(function onOpen() {
            const event = new Event2("open");
            event[kTarget] = this;
            callListener(handler30, this, event);
          }, "onOpen");
        } else {
          return;
        }
        wrapper[kForOnEventAttribute] = !!options29[kForOnEventAttribute];
        wrapper[kListener] = handler30;
        if (options29.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, handler30) {
        for (const listener of this.listeners(type)) {
          if (listener[kListener] === handler30 && !listener[kForOnEventAttribute]) {
            this.removeListener(type, listener);
            break;
          }
        }
      }
    };
    module3.exports = {
      CloseEvent,
      ErrorEvent: ErrorEvent2,
      Event: Event2,
      EventTarget: EventTarget2,
      MessageEvent
    };
    function callListener(listener, thisArg, event) {
      if (typeof listener === "object" && listener.handleEvent) {
        listener.handleEvent.call(listener, event);
      } else {
        listener.call(thisArg, event);
      }
    }
    __name(callListener, "callListener");
  }
});

// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/extension.js
var require_extension2 = __commonJS({
  "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/extension.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { tokenChars } = require_validation2();
    function push(dest, name, elem) {
      if (dest[name] === void 0)
        dest[name] = [elem];
      else
        dest[name].push(elem);
    }
    __name(push, "push");
    function parse7(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 name = header.slice(start, end);
            if (code === 44) {
              push(offers, name, params);
              params = /* @__PURE__ */ Object.create(null);
            } else {
              extensionName = name;
            }
            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;
    }
    __name(parse7, "parse");
    function format10(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((k2) => {
              let values = params[k2];
              if (!Array.isArray(values))
                values = [values];
              return values.map((v2) => v2 === true ? k2 : `${k2}=${v2}`).join("; ");
            })
          ).join("; ");
        }).join(", ");
      }).join(", ");
    }
    __name(format10, "format");
    module3.exports = { format: format10, parse: parse7 };
  }
});

// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/websocket.js
var require_websocket4 = __commonJS({
  "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/websocket.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var EventEmitter7 = require("events");
    var https3 = require("https");
    var http4 = require("http");
    var net3 = require("net");
    var tls = require("tls");
    var { randomBytes, createHash: createHash3 } = require("crypto");
    var { Readable: Readable2 } = require("stream");
    var { URL: URL7 } = require("url");
    var PerMessageDeflate = require_permessage_deflate2();
    var Receiver2 = require_receiver4();
    var Sender2 = require_sender2();
    var {
      BINARY_TYPES,
      EMPTY_BUFFER,
      GUID,
      kForOnEventAttribute,
      kListener,
      kStatusCode,
      kWebSocket,
      NOOP
    } = require_constants13();
    var {
      EventTarget: { addEventListener, removeEventListener }
    } = require_event_target2();
    var { format: format10, parse: parse7 } = require_extension2();
    var { toBuffer } = require_buffer_util2();
    var closeTimeout = 30 * 1e3;
    var kAborted = Symbol("kAborted");
    var protocolVersions = [8, 13];
    var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
    var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
    var WebSocket3 = class extends EventEmitter7 {
      /**
       * 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, options29) {
        super();
        this._binaryType = BINARY_TYPES[0];
        this._closeCode = 1006;
        this._closeFrameReceived = false;
        this._closeFrameSent = false;
        this._closeMessage = EMPTY_BUFFER;
        this._closeTimer = null;
        this._extensions = {};
        this._paused = false;
        this._protocol = "";
        this._readyState = WebSocket3.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) {
              options29 = protocols;
              protocols = [];
            } else {
              protocols = [protocols];
            }
          }
          initAsClient(this, address, protocols, options29);
        } 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 {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 {(net.Socket|tls.Socket)} 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 {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, options29) {
        const receiver = new Receiver2({
          binaryType: this.binaryType,
          extensions: this._extensions,
          isServer: this._isServer,
          maxPayload: options29.maxPayload,
          skipUTF8Validation: options29.skipUTF8Validation
        });
        this._sender = new Sender2(socket, this._extensions, options29.generateMask);
        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 = WebSocket3.OPEN;
        this.emit("open");
      }
      /**
       * Emit the `'close'` event.
       *
       * @private
       */
      emitClose() {
        if (!this._socket) {
          this._readyState = WebSocket3.CLOSED;
          this.emit("close", this._closeCode, this._closeMessage);
          return;
        }
        if (this._extensions[PerMessageDeflate.extensionName]) {
          this._extensions[PerMessageDeflate.extensionName].cleanup();
        }
        this._receiver.removeAllListeners();
        this._readyState = WebSocket3.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 === WebSocket3.CLOSED)
          return;
        if (this.readyState === WebSocket3.CONNECTING) {
          const msg = "WebSocket was closed before the connection was established";
          return abortHandshake(this, this._req, msg);
        }
        if (this.readyState === WebSocket3.CLOSING) {
          if (this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted)) {
            this._socket.end();
          }
          return;
        }
        this._readyState = WebSocket3.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
        );
      }
      /**
       * Pause the socket.
       *
       * @public
       */
      pause() {
        if (this.readyState === WebSocket3.CONNECTING || this.readyState === WebSocket3.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 === WebSocket3.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 !== WebSocket3.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 === WebSocket3.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 !== WebSocket3.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 === WebSocket3.CONNECTING || this.readyState === WebSocket3.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, options29, cb) {
        if (this.readyState === WebSocket3.CONNECTING) {
          throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
        }
        if (typeof options29 === "function") {
          cb = options29;
          options29 = {};
        }
        if (typeof data === "number")
          data = data.toString();
        if (this.readyState !== WebSocket3.OPEN) {
          sendAfterClose(this, data, cb);
          return;
        }
        const opts = {
          binary: typeof data !== "string",
          mask: !this._isServer,
          compress: true,
          fin: true,
          ...options29
        };
        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 === WebSocket3.CLOSED)
          return;
        if (this.readyState === WebSocket3.CONNECTING) {
          const msg = "WebSocket was closed before the connection was established";
          return abortHandshake(this, this._req, msg);
        }
        if (this._socket) {
          this._readyState = WebSocket3.CLOSING;
          this._socket.destroy();
        }
      }
    };
    __name(WebSocket3, "WebSocket");
    Object.defineProperty(WebSocket3, "CONNECTING", {
      enumerable: true,
      value: readyStates.indexOf("CONNECTING")
    });
    Object.defineProperty(WebSocket3.prototype, "CONNECTING", {
      enumerable: true,
      value: readyStates.indexOf("CONNECTING")
    });
    Object.defineProperty(WebSocket3, "OPEN", {
      enumerable: true,
      value: readyStates.indexOf("OPEN")
    });
    Object.defineProperty(WebSocket3.prototype, "OPEN", {
      enumerable: true,
      value: readyStates.indexOf("OPEN")
    });
    Object.defineProperty(WebSocket3, "CLOSING", {
      enumerable: true,
      value: readyStates.indexOf("CLOSING")
    });
    Object.defineProperty(WebSocket3.prototype, "CLOSING", {
      enumerable: true,
      value: readyStates.indexOf("CLOSING")
    });
    Object.defineProperty(WebSocket3, "CLOSED", {
      enumerable: true,
      value: readyStates.indexOf("CLOSED")
    });
    Object.defineProperty(WebSocket3.prototype, "CLOSED", {
      enumerable: true,
      value: readyStates.indexOf("CLOSED")
    });
    [
      "binaryType",
      "bufferedAmount",
      "extensions",
      "isPaused",
      "protocol",
      "readyState",
      "url"
    ].forEach((property) => {
      Object.defineProperty(WebSocket3.prototype, property, { enumerable: true });
    });
    ["open", "error", "close", "message"].forEach((method) => {
      Object.defineProperty(WebSocket3.prototype, `on${method}`, {
        enumerable: true,
        get() {
          for (const listener of this.listeners(method)) {
            if (listener[kForOnEventAttribute])
              return listener[kListener];
          }
          return null;
        },
        set(handler30) {
          for (const listener of this.listeners(method)) {
            if (listener[kForOnEventAttribute]) {
              this.removeListener(method, listener);
              break;
            }
          }
          if (typeof handler30 !== "function")
            return;
          this.addEventListener(method, handler30, {
            [kForOnEventAttribute]: true
          });
        }
      });
    });
    WebSocket3.prototype.addEventListener = addEventListener;
    WebSocket3.prototype.removeEventListener = removeEventListener;
    module3.exports = WebSocket3;
    function initAsClient(websocket, address, protocols, options29) {
      const opts = {
        protocolVersion: protocolVersions[1],
        maxPayload: 100 * 1024 * 1024,
        skipUTF8Validation: false,
        perMessageDeflate: true,
        followRedirects: false,
        maxRedirects: 10,
        ...options29,
        createConnection: void 0,
        socketPath: void 0,
        hostname: void 0,
        protocol: void 0,
        timeout: void 0,
        method: "GET",
        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 URL7) {
        parsedUrl = address;
        websocket._url = address.href;
      } else {
        try {
          parsedUrl = new URL7(address);
        } catch (e3) {
          throw new SyntaxError(`Invalid URL: ${address}`);
        }
        websocket._url = address;
      }
      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:", 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 request3 = isSecure ? https3.request : http4.request;
      const protocolSet = /* @__PURE__ */ new Set();
      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 = {
        ...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"] = format10({
          [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 = options29 && options29.headers;
          options29 = { ...options29, headers: {} };
          if (headers) {
            for (const [key2, value] of Object.entries(headers)) {
              options29.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 && !options29.headers.authorization) {
          options29.headers.authorization = "Basic " + Buffer.from(opts.auth).toString("base64");
        }
        req = websocket._req = request3(opts);
        if (websocket._redirects) {
          websocket.emit("redirect", websocket.url, req);
        }
      } else {
        req = websocket._req = request3(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 URL7(location, address);
          } catch (e3) {
            const err = new SyntaxError(`Invalid URL: ${location}`);
            emitErrorAndClose(websocket, err);
            return;
          }
          initAsClient(websocket, addr, protocols, options29);
        } 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 !== WebSocket3.CONNECTING)
          return;
        req = websocket._req = null;
        if (res.headers.upgrade.toLowerCase() !== "websocket") {
          abortHandshake(websocket, socket, "Invalid Upgrade header");
          return;
        }
        const digest = createHash3("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 = parse7(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, {
          generateMask: opts.generateMask,
          maxPayload: opts.maxPayload,
          skipUTF8Validation: opts.skipUTF8Validation
        });
      });
      req.end();
    }
    __name(initAsClient, "initAsClient");
    function emitErrorAndClose(websocket, err) {
      websocket._readyState = WebSocket3.CLOSING;
      websocket.emit("error", err);
      websocket.emitClose();
    }
    __name(emitErrorAndClose, "emitErrorAndClose");
    function netConnect(options29) {
      options29.path = options29.socketPath;
      return net3.connect(options29);
    }
    __name(netConnect, "netConnect");
    function tlsConnect(options29) {
      options29.path = void 0;
      if (!options29.servername && options29.servername !== "") {
        options29.servername = net3.isIP(options29.host) ? "" : options29.host;
      }
      return tls.connect(options29);
    }
    __name(tlsConnect, "tlsConnect");
    function abortHandshake(websocket, stream2, message) {
      websocket._readyState = WebSocket3.CLOSING;
      const err = new Error(message);
      Error.captureStackTrace(err, abortHandshake);
      if (stream2.setHeader) {
        stream2[kAborted] = true;
        stream2.abort();
        if (stream2.socket && !stream2.socket.destroyed) {
          stream2.socket.destroy();
        }
        process.nextTick(emitErrorAndClose, websocket, err);
      } else {
        stream2.destroy(err);
        stream2.once("error", websocket.emit.bind(websocket, "error"));
        stream2.once("close", websocket.emitClose.bind(websocket));
      }
    }
    __name(abortHandshake, "abortHandshake");
    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);
      }
    }
    __name(sendAfterClose, "sendAfterClose");
    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);
    }
    __name(receiverOnConclude, "receiverOnConclude");
    function receiverOnDrain() {
      const websocket = this[kWebSocket];
      if (!websocket.isPaused)
        websocket._socket.resume();
    }
    __name(receiverOnDrain, "receiverOnDrain");
    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);
    }
    __name(receiverOnError, "receiverOnError");
    function receiverOnFinish() {
      this[kWebSocket].emitClose();
    }
    __name(receiverOnFinish, "receiverOnFinish");
    function receiverOnMessage(data, isBinary) {
      this[kWebSocket].emit("message", data, isBinary);
    }
    __name(receiverOnMessage, "receiverOnMessage");
    function receiverOnPing(data) {
      const websocket = this[kWebSocket];
      websocket.pong(data, !websocket._isServer, NOOP);
      websocket.emit("ping", data);
    }
    __name(receiverOnPing, "receiverOnPing");
    function receiverOnPong(data) {
      this[kWebSocket].emit("pong", data);
    }
    __name(receiverOnPong, "receiverOnPong");
    function resume(stream2) {
      stream2.resume();
    }
    __name(resume, "resume");
    function socketOnClose() {
      const websocket = this[kWebSocket];
      this.removeListener("close", socketOnClose);
      this.removeListener("data", socketOnData);
      this.removeListener("end", socketOnEnd);
      websocket._readyState = WebSocket3.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);
      }
    }
    __name(socketOnClose, "socketOnClose");
    function socketOnData(chunk) {
      if (!this[kWebSocket]._receiver.write(chunk)) {
        this.pause();
      }
    }
    __name(socketOnData, "socketOnData");
    function socketOnEnd() {
      const websocket = this[kWebSocket];
      websocket._readyState = WebSocket3.CLOSING;
      websocket._receiver.end();
      this.end();
    }
    __name(socketOnEnd, "socketOnEnd");
    function socketOnError() {
      const websocket = this[kWebSocket];
      this.removeListener("error", socketOnError);
      this.on("error", NOOP);
      if (websocket) {
        websocket._readyState = WebSocket3.CLOSING;
        this.destroy();
      }
    }
    __name(socketOnError, "socketOnError");
  }
});

// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/subprotocol.js
var require_subprotocol = __commonJS({
  "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/subprotocol.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var { tokenChars } = require_validation2();
    function parse7(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;
    }
    __name(parse7, "parse");
    module3.exports = { parse: parse7 };
  }
});

// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/websocket-server.js
var require_websocket_server2 = __commonJS({
  "../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/lib/websocket-server.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var EventEmitter7 = require("events");
    var http4 = require("http");
    var https3 = require("https");
    var net3 = require("net");
    var tls = require("tls");
    var { createHash: createHash3 } = require("crypto");
    var extension = require_extension2();
    var PerMessageDeflate = require_permessage_deflate2();
    var subprotocol = require_subprotocol();
    var WebSocket3 = require_websocket4();
    var { GUID, kWebSocket } = require_constants13();
    var keyRegex = /^[+/0-9A-Za-z]{22}==$/;
    var RUNNING = 0;
    var CLOSING = 1;
    var CLOSED = 2;
    var WebSocketServer2 = class extends EventEmitter7 {
      /**
       * 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 {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(options29, callback) {
        super();
        options29 = {
          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: WebSocket3,
          ...options29
        };
        if (options29.port == null && !options29.server && !options29.noServer || options29.port != null && (options29.server || options29.noServer) || options29.server && options29.noServer) {
          throw new TypeError(
            'One and only one of the "port", "server", or "noServer" options must be specified'
          );
        }
        if (options29.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(
            options29.port,
            options29.host,
            options29.backlog,
            callback
          );
        } else if (options29.server) {
          this._server = options29.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 (options29.perMessageDeflate === true)
          options29.perMessageDeflate = {};
        if (options29.clientTracking) {
          this.clients = /* @__PURE__ */ new Set();
          this._shouldEmitClose = false;
        }
        this.options = options29;
        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 server = this._server;
          this._removeListeners();
          this._removeListeners = this._server = null;
          server.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 {(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"];
        const version3 = +req.headers["sec-websocket-version"];
        if (req.method !== "GET") {
          const message = "Invalid HTTP method";
          abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
          return;
        }
        if (req.headers.upgrade.toLowerCase() !== "websocket") {
          const message = "Invalid Upgrade header";
          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
          return;
        }
        if (!key || !keyRegex.test(key)) {
          const message = "Missing or invalid Sec-WebSocket-Key header";
          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
          return;
        }
        if (version3 !== 8 && version3 !== 13) {
          const message = "Missing or invalid Sec-WebSocket-Version header";
          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
          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 {(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(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 = createHash3("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);
        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, {
          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);
      }
    };
    __name(WebSocketServer2, "WebSocketServer");
    module3.exports = WebSocketServer2;
    function addListeners(server, map) {
      for (const event of Object.keys(map))
        server.on(event, map[event]);
      return /* @__PURE__ */ __name(function removeListeners() {
        for (const event of Object.keys(map)) {
          server.removeListener(event, map[event]);
        }
      }, "removeListeners");
    }
    __name(addListeners, "addListeners");
    function emitClose(server) {
      server._state = CLOSED;
      server.emit("close");
    }
    __name(emitClose, "emitClose");
    function socketOnError() {
      this.destroy();
    }
    __name(socketOnError, "socketOnError");
    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((h2) => `${h2}: ${headers[h2]}`).join("\r\n") + "\r\n\r\n" + message
      );
    }
    __name(abortHandshake, "abortHandshake");
    function abortHandshakeOrEmitwsClientError(server, req, socket, code, message) {
      if (server.listenerCount("wsClientError")) {
        const err = new Error(message);
        Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
        server.emit("wsClientError", err, socket, req);
      } else {
        abortHandshake(socket, code, message);
      }
    }
    __name(abortHandshakeOrEmitwsClientError, "abortHandshakeOrEmitwsClientError");
  }
});

// ../../node_modules/.pnpm/agent-base@6.0.2_supports-color@9.2.2/node_modules/agent-base/dist/src/promisify.js
var require_promisify = __commonJS({
  "../../node_modules/.pnpm/agent-base@6.0.2_supports-color@9.2.2/node_modules/agent-base/dist/src/promisify.js"(exports2) {
    "use strict";
    init_import_meta_url();
    Object.defineProperty(exports2, "__esModule", { value: true });
    function promisify2(fn2) {
      return function(req, opts) {
        return new Promise((resolve19, reject) => {
          fn2.call(this, req, opts, (err, rtn) => {
            if (err) {
              reject(err);
            } else {
              resolve19(rtn);
            }
          });
        });
      };
    }
    __name(promisify2, "promisify");
    exports2.default = promisify2;
  }
});

// ../../node_modules/.pnpm/agent-base@6.0.2_supports-color@9.2.2/node_modules/agent-base/dist/src/index.js
var require_src11 = __commonJS({
  "../../node_modules/.pnpm/agent-base@6.0.2_supports-color@9.2.2/node_modules/agent-base/dist/src/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    var events_1 = require("events");
    var debug_1 = __importDefault(require_src10());
    var promisify_1 = __importDefault(require_promisify());
    var debug = debug_1.default("agent-base");
    function isAgent(v2) {
      return Boolean(v2) && typeof v2.addRequest === "function";
    }
    __name(isAgent, "isAgent");
    function isSecureEndpoint() {
      const { stack } = new Error();
      if (typeof stack !== "string")
        return false;
      return stack.split("\n").some((l2) => l2.indexOf("(https.js:") !== -1 || l2.indexOf("node:https:") !== -1);
    }
    __name(isSecureEndpoint, "isSecureEndpoint");
    function createAgent(callback, opts) {
      return new createAgent.Agent(callback, opts);
    }
    __name(createAgent, "createAgent");
    (function(createAgent2) {
      class Agent extends events_1.EventEmitter {
        constructor(callback, _opts) {
          super();
          let opts = _opts;
          if (typeof callback === "function") {
            this.callback = callback;
          } else if (callback) {
            opts = callback;
          }
          this.timeout = null;
          if (opts && typeof opts.timeout === "number") {
            this.timeout = opts.timeout;
          }
          this.maxFreeSockets = 1;
          this.maxSockets = 1;
          this.maxTotalSockets = Infinity;
          this.sockets = {};
          this.freeSockets = {};
          this.requests = {};
          this.options = {};
        }
        get defaultPort() {
          if (typeof this.explicitDefaultPort === "number") {
            return this.explicitDefaultPort;
          }
          return isSecureEndpoint() ? 443 : 80;
        }
        set defaultPort(v2) {
          this.explicitDefaultPort = v2;
        }
        get protocol() {
          if (typeof this.explicitProtocol === "string") {
            return this.explicitProtocol;
          }
          return isSecureEndpoint() ? "https:" : "http:";
        }
        set protocol(v2) {
          this.explicitProtocol = v2;
        }
        callback(req, opts, fn2) {
          throw new Error('"agent-base" has no default implementation, you must subclass and override `callback()`');
        }
        /**
         * Called by node-core's "_http_client.js" module when creating
         * a new HTTP request with this Agent instance.
         *
         * @api public
         */
        addRequest(req, _opts) {
          const opts = Object.assign({}, _opts);
          if (typeof opts.secureEndpoint !== "boolean") {
            opts.secureEndpoint = isSecureEndpoint();
          }
          if (opts.host == null) {
            opts.host = "localhost";
          }
          if (opts.port == null) {
            opts.port = opts.secureEndpoint ? 443 : 80;
          }
          if (opts.protocol == null) {
            opts.protocol = opts.secureEndpoint ? "https:" : "http:";
          }
          if (opts.host && opts.path) {
            delete opts.path;
          }
          delete opts.agent;
          delete opts.hostname;
          delete opts._defaultAgent;
          delete opts.defaultPort;
          delete opts.createConnection;
          req._last = true;
          req.shouldKeepAlive = false;
          let timedOut = false;
          let timeoutId = null;
          const timeoutMs = opts.timeout || this.timeout;
          const onerror = /* @__PURE__ */ __name((err) => {
            if (req._hadError)
              return;
            req.emit("error", err);
            req._hadError = true;
          }, "onerror");
          const ontimeout = /* @__PURE__ */ __name(() => {
            timeoutId = null;
            timedOut = true;
            const err = new Error(`A "socket" was not created for HTTP request before ${timeoutMs}ms`);
            err.code = "ETIMEOUT";
            onerror(err);
          }, "ontimeout");
          const callbackError = /* @__PURE__ */ __name((err) => {
            if (timedOut)
              return;
            if (timeoutId !== null) {
              clearTimeout(timeoutId);
              timeoutId = null;
            }
            onerror(err);
          }, "callbackError");
          const onsocket = /* @__PURE__ */ __name((socket) => {
            if (timedOut)
              return;
            if (timeoutId != null) {
              clearTimeout(timeoutId);
              timeoutId = null;
            }
            if (isAgent(socket)) {
              debug("Callback returned another Agent instance %o", socket.constructor.name);
              socket.addRequest(req, opts);
              return;
            }
            if (socket) {
              socket.once("free", () => {
                this.freeSocket(socket, opts);
              });
              req.onSocket(socket);
              return;
            }
            const err = new Error(`no Duplex stream was returned to agent-base for \`${req.method} ${req.path}\``);
            onerror(err);
          }, "onsocket");
          if (typeof this.callback !== "function") {
            onerror(new Error("`callback` is not defined"));
            return;
          }
          if (!this.promisifiedCallback) {
            if (this.callback.length >= 3) {
              debug("Converting legacy callback function to promise");
              this.promisifiedCallback = promisify_1.default(this.callback);
            } else {
              this.promisifiedCallback = this.callback;
            }
          }
          if (typeof timeoutMs === "number" && timeoutMs > 0) {
            timeoutId = setTimeout(ontimeout, timeoutMs);
          }
          if ("port" in opts && typeof opts.port !== "number") {
            opts.port = Number(opts.port);
          }
          try {
            debug("Resolving socket for %o request: %o", opts.protocol, `${req.method} ${req.path}`);
            Promise.resolve(this.promisifiedCallback(req, opts)).then(onsocket, callbackError);
          } catch (err) {
            Promise.reject(err).catch(callbackError);
          }
        }
        freeSocket(socket, opts) {
          debug("Freeing socket %o %o", socket.constructor.name, opts);
          socket.destroy();
        }
        destroy() {
          debug("Destroying agent %o", this.constructor.name);
        }
      }
      __name(Agent, "Agent");
      createAgent2.Agent = Agent;
      createAgent2.prototype = createAgent2.Agent.prototype;
    })(createAgent || (createAgent = {}));
    module3.exports = createAgent;
  }
});

// ../../node_modules/.pnpm/https-proxy-agent@5.0.1_supports-color@9.2.2/node_modules/https-proxy-agent/dist/parse-proxy-response.js
var require_parse_proxy_response2 = __commonJS({
  "../../node_modules/.pnpm/https-proxy-agent@5.0.1_supports-color@9.2.2/node_modules/https-proxy-agent/dist/parse-proxy-response.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var debug_1 = __importDefault(require_src10());
    var debug = debug_1.default("https-proxy-agent:parse-proxy-response");
    function parseProxyResponse(socket) {
      return new Promise((resolve19, reject) => {
        let buffersLength = 0;
        const buffers = [];
        function read() {
          const b2 = socket.read();
          if (b2)
            ondata(b2);
          else
            socket.once("readable", read);
        }
        __name(read, "read");
        function cleanup() {
          socket.removeListener("end", onend);
          socket.removeListener("error", onerror);
          socket.removeListener("close", onclose);
          socket.removeListener("readable", read);
        }
        __name(cleanup, "cleanup");
        function onclose(err) {
          debug("onclose had error %o", err);
        }
        __name(onclose, "onclose");
        function onend() {
          debug("onend");
        }
        __name(onend, "onend");
        function onerror(err) {
          cleanup();
          debug("onerror %o", err);
          reject(err);
        }
        __name(onerror, "onerror");
        function ondata(b2) {
          buffers.push(b2);
          buffersLength += b2.length;
          const buffered = Buffer.concat(buffers, buffersLength);
          const endOfHeaders = buffered.indexOf("\r\n\r\n");
          if (endOfHeaders === -1) {
            debug("have not received end of HTTP headers yet...");
            read();
            return;
          }
          const firstLine = buffered.toString("ascii", 0, buffered.indexOf("\r\n"));
          const statusCode = +firstLine.split(" ")[1];
          debug("got proxy server response: %o", firstLine);
          resolve19({
            statusCode,
            buffered
          });
        }
        __name(ondata, "ondata");
        socket.on("error", onerror);
        socket.on("close", onclose);
        socket.on("end", onend);
        read();
      });
    }
    __name(parseProxyResponse, "parseProxyResponse");
    exports2.default = parseProxyResponse;
  }
});

// ../../node_modules/.pnpm/https-proxy-agent@5.0.1_supports-color@9.2.2/node_modules/https-proxy-agent/dist/agent.js
var require_agent3 = __commonJS({
  "../../node_modules/.pnpm/https-proxy-agent@5.0.1_supports-color@9.2.2/node_modules/https-proxy-agent/dist/agent.js"(exports2) {
    "use strict";
    init_import_meta_url();
    var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P2, generator) {
      function adopt(value) {
        return value instanceof P2 ? value : new P2(function(resolve19) {
          resolve19(value);
        });
      }
      __name(adopt, "adopt");
      return new (P2 || (P2 = Promise))(function(resolve19, reject) {
        function fulfilled(value) {
          try {
            step(generator.next(value));
          } catch (e3) {
            reject(e3);
          }
        }
        __name(fulfilled, "fulfilled");
        function rejected(value) {
          try {
            step(generator["throw"](value));
          } catch (e3) {
            reject(e3);
          }
        }
        __name(rejected, "rejected");
        function step(result) {
          result.done ? resolve19(result.value) : adopt(result.value).then(fulfilled, rejected);
        }
        __name(step, "step");
        step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
    };
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    var net_1 = __importDefault(require("net"));
    var tls_1 = __importDefault(require("tls"));
    var url_1 = __importDefault(require("url"));
    var assert_1 = __importDefault(require("assert"));
    var debug_1 = __importDefault(require_src10());
    var agent_base_1 = require_src11();
    var parse_proxy_response_1 = __importDefault(require_parse_proxy_response2());
    var debug = debug_1.default("https-proxy-agent:agent");
    var HttpsProxyAgent3 = class extends agent_base_1.Agent {
      constructor(_opts) {
        let opts;
        if (typeof _opts === "string") {
          opts = url_1.default.parse(_opts);
        } else {
          opts = _opts;
        }
        if (!opts) {
          throw new Error("an HTTP(S) proxy server `host` and `port` must be specified!");
        }
        debug("creating new HttpsProxyAgent instance: %o", opts);
        super(opts);
        const proxy2 = Object.assign({}, opts);
        this.secureProxy = opts.secureProxy || isHTTPS(proxy2.protocol);
        proxy2.host = proxy2.hostname || proxy2.host;
        if (typeof proxy2.port === "string") {
          proxy2.port = parseInt(proxy2.port, 10);
        }
        if (!proxy2.port && proxy2.host) {
          proxy2.port = this.secureProxy ? 443 : 80;
        }
        if (this.secureProxy && !("ALPNProtocols" in proxy2)) {
          proxy2.ALPNProtocols = ["http 1.1"];
        }
        if (proxy2.host && proxy2.path) {
          delete proxy2.path;
          delete proxy2.pathname;
        }
        this.proxy = proxy2;
      }
      /**
       * Called when the node-core HTTP client library is creating a
       * new HTTP request.
       *
       * @api protected
       */
      callback(req, opts) {
        return __awaiter(this, void 0, void 0, function* () {
          const { proxy: proxy2, secureProxy } = this;
          let socket;
          if (secureProxy) {
            debug("Creating `tls.Socket`: %o", proxy2);
            socket = tls_1.default.connect(proxy2);
          } else {
            debug("Creating `net.Socket`: %o", proxy2);
            socket = net_1.default.connect(proxy2);
          }
          const headers = Object.assign({}, proxy2.headers);
          const hostname2 = `${opts.host}:${opts.port}`;
          let payload = `CONNECT ${hostname2} HTTP/1.1\r
`;
          if (proxy2.auth) {
            headers["Proxy-Authorization"] = `Basic ${Buffer.from(proxy2.auth).toString("base64")}`;
          }
          let { host, port: port2, secureEndpoint } = opts;
          if (!isDefaultPort(port2, secureEndpoint)) {
            host += `:${port2}`;
          }
          headers.Host = host;
          headers.Connection = "close";
          for (const name of Object.keys(headers)) {
            payload += `${name}: ${headers[name]}\r
`;
          }
          const proxyResponsePromise = parse_proxy_response_1.default(socket);
          socket.write(`${payload}\r
`);
          const { statusCode, buffered } = yield proxyResponsePromise;
          if (statusCode === 200) {
            req.once("socket", resume);
            if (opts.secureEndpoint) {
              debug("Upgrading socket connection to TLS");
              const servername = opts.servername || opts.host;
              return tls_1.default.connect(Object.assign(Object.assign({}, omit(opts, "host", "hostname", "path", "port")), {
                socket,
                servername
              }));
            }
            return socket;
          }
          socket.destroy();
          const fakeSocket = new net_1.default.Socket({ writable: false });
          fakeSocket.readable = true;
          req.once("socket", (s) => {
            debug("replaying proxy buffer for failed request");
            assert_1.default(s.listenerCount("data") > 0);
            s.push(buffered);
            s.push(null);
          });
          return fakeSocket;
        });
      }
    };
    __name(HttpsProxyAgent3, "HttpsProxyAgent");
    exports2.default = HttpsProxyAgent3;
    function resume(socket) {
      socket.resume();
    }
    __name(resume, "resume");
    function isDefaultPort(port2, secure) {
      return Boolean(!secure && port2 === 80 || secure && port2 === 443);
    }
    __name(isDefaultPort, "isDefaultPort");
    function isHTTPS(protocol) {
      return typeof protocol === "string" ? /^https:?$/i.test(protocol) : false;
    }
    __name(isHTTPS, "isHTTPS");
    function omit(obj, ...keys) {
      const ret = {};
      let key;
      for (key in obj) {
        if (!keys.includes(key)) {
          ret[key] = obj[key];
        }
      }
      return ret;
    }
    __name(omit, "omit");
  }
});

// ../../node_modules/.pnpm/https-proxy-agent@5.0.1_supports-color@9.2.2/node_modules/https-proxy-agent/dist/index.js
var require_dist7 = __commonJS({
  "../../node_modules/.pnpm/https-proxy-agent@5.0.1_supports-color@9.2.2/node_modules/https-proxy-agent/dist/index.js"(exports2, module3) {
    "use strict";
    init_import_meta_url();
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    var agent_1 = __importDefault(require_agent3());
    function createHttpsProxyAgent(opts) {
      return new agent_1.default(opts);
    }
    __name(createHttpsProxyAgent, "createHttpsProxyAgent");
    (function(createHttpsProxyAgent2) {
      createHttpsProxyAgent2.HttpsProxyAgent = agent_1.default;
      createHttpsProxyAgent2.prototype = agent_1.default.prototype;
    })(createHttpsProxyAgent || (createHttpsProxyAgent = {}));
    module3.exports = createHttpsProxyAgent;
  }
});

// src/cli.ts
var cli_exports2 = {};
__export(cli_exports2, {
  getBindingsProxy: () => getBindingsProxy,
  getPlatformProxy: () => getPlatformProxy,
  unstable_DevEnv: () => DevEnv,
  unstable_dev: () => unstable_dev,
  unstable_getMiniflareWorkerOptions: () => unstable_getMiniflareWorkerOptions,
  unstable_pages: () => unstable_pages,
  unstable_splitSqlQuery: () => splitSqlQuery,
  unstable_startWorkerRegistryServer: () => startWorkerRegistryServer
});
module.exports = __toCommonJS(cli_exports2);
init_import_meta_url();
var import_process6 = __toESM(require("process"));

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/helpers/helpers.mjs
init_import_meta_url();

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/utils/apply-extends.js
init_import_meta_url();

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/yerror.js
init_import_meta_url();
var YError = class extends Error {
  constructor(msg) {
    super(msg || "yargs error");
    this.name = "YError";
    if (Error.captureStackTrace) {
      Error.captureStackTrace(this, YError);
    }
  }
};
__name(YError, "YError");

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/utils/apply-extends.js
var previouslyVisitedConfigs = [];
var shim;
function applyExtends(config, cwd2, mergeExtends, _shim) {
  shim = _shim;
  let defaultConfig = {};
  if (Object.prototype.hasOwnProperty.call(config, "extends")) {
    if (typeof config.extends !== "string")
      return defaultConfig;
    const isPath = /\.json|\..*rc$/.test(config.extends);
    let pathToDefault = null;
    if (!isPath) {
      try {
        pathToDefault = require.resolve(config.extends);
      } catch (_err) {
        return config;
      }
    } else {
      pathToDefault = getPathToDefaultConfig(cwd2, config.extends);
    }
    checkForCircularExtends(pathToDefault);
    previouslyVisitedConfigs.push(pathToDefault);
    defaultConfig = isPath ? JSON.parse(shim.readFileSync(pathToDefault, "utf8")) : require(config.extends);
    delete config.extends;
    defaultConfig = applyExtends(defaultConfig, shim.path.dirname(pathToDefault), mergeExtends, shim);
  }
  previouslyVisitedConfigs = [];
  return mergeExtends ? mergeDeep(defaultConfig, config) : Object.assign({}, defaultConfig, config);
}
__name(applyExtends, "applyExtends");
function checkForCircularExtends(cfgPath) {
  if (previouslyVisitedConfigs.indexOf(cfgPath) > -1) {
    throw new YError(`Circular extended configurations: '${cfgPath}'.`);
  }
}
__name(checkForCircularExtends, "checkForCircularExtends");
function getPathToDefaultConfig(cwd2, pathToExtend) {
  return shim.path.resolve(cwd2, pathToExtend);
}
__name(getPathToDefaultConfig, "getPathToDefaultConfig");
function mergeDeep(config1, config2) {
  const target = {};
  function isObject2(obj) {
    return obj && typeof obj === "object" && !Array.isArray(obj);
  }
  __name(isObject2, "isObject");
  Object.assign(target, config1);
  for (const key of Object.keys(config2)) {
    if (isObject2(config2[key]) && isObject2(target[key])) {
      target[key] = mergeDeep(config1[key], config2[key]);
    } else {
      target[key] = config2[key];
    }
  }
  return target;
}
__name(mergeDeep, "mergeDeep");

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/utils/process-argv.js
init_import_meta_url();
function getProcessArgvBinIndex() {
  if (isBundledElectronApp())
    return 0;
  return 1;
}
__name(getProcessArgvBinIndex, "getProcessArgvBinIndex");
function isBundledElectronApp() {
  return isElectronApp() && !process.defaultApp;
}
__name(isBundledElectronApp, "isBundledElectronApp");
function isElectronApp() {
  return !!process.versions.electron;
}
__name(isElectronApp, "isElectronApp");
function hideBin(argv) {
  return argv.slice(getProcessArgvBinIndex() + 1);
}
__name(hideBin, "hideBin");
function getProcessArgvBin() {
  return process.argv[getProcessArgvBinIndex()];
}
__name(getProcessArgvBin, "getProcessArgvBin");

// ../../node_modules/.pnpm/yargs-parser@21.1.1/node_modules/yargs-parser/build/lib/index.js
init_import_meta_url();
var import_util = require("util");
var import_path = require("path");

// ../../node_modules/.pnpm/yargs-parser@21.1.1/node_modules/yargs-parser/build/lib/string-utils.js
init_import_meta_url();
function camelCase(str) {
  const isCamelCase = str !== str.toLowerCase() && str !== str.toUpperCase();
  if (!isCamelCase) {
    str = str.toLowerCase();
  }
  if (str.indexOf("-") === -1 && str.indexOf("_") === -1) {
    return str;
  } else {
    let camelcase = "";
    let nextChrUpper = false;
    const leadingHyphens = str.match(/^-+/);
    for (let i = leadingHyphens ? leadingHyphens[0].length : 0; i < str.length; i++) {
      let chr = str.charAt(i);
      if (nextChrUpper) {
        nextChrUpper = false;
        chr = chr.toUpperCase();
      }
      if (i !== 0 && (chr === "-" || chr === "_")) {
        nextChrUpper = true;
      } else if (chr !== "-" && chr !== "_") {
        camelcase += chr;
      }
    }
    return camelcase;
  }
}
__name(camelCase, "camelCase");
function decamelize(str, joinString) {
  const lowercase = str.toLowerCase();
  joinString = joinString || "-";
  let notCamelcase = "";
  for (let i = 0; i < str.length; i++) {
    const chrLower = lowercase.charAt(i);
    const chrString = str.charAt(i);
    if (chrLower !== chrString && i > 0) {
      notCamelcase += `${joinString}${lowercase.charAt(i)}`;
    } else {
      notCamelcase += chrString;
    }
  }
  return notCamelcase;
}
__name(decamelize, "decamelize");
function looksLikeNumber(x2) {
  if (x2 === null || x2 === void 0)
    return false;
  if (typeof x2 === "number")
    return true;
  if (/^0x[0-9a-f]+$/i.test(x2))
    return true;
  if (/^0[^.]/.test(x2))
    return false;
  return /^[-]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x2);
}
__name(looksLikeNumber, "looksLikeNumber");

// ../../node_modules/.pnpm/yargs-parser@21.1.1/node_modules/yargs-parser/build/lib/yargs-parser.js
init_import_meta_url();

// ../../node_modules/.pnpm/yargs-parser@21.1.1/node_modules/yargs-parser/build/lib/tokenize-arg-string.js
init_import_meta_url();
function tokenizeArgString(argString) {
  if (Array.isArray(argString)) {
    return argString.map((e3) => typeof e3 !== "string" ? e3 + "" : e3);
  }
  argString = argString.trim();
  let i = 0;
  let prevC = null;
  let c2 = null;
  let opening = null;
  const args = [];
  for (let ii = 0; ii < argString.length; ii++) {
    prevC = c2;
    c2 = argString.charAt(ii);
    if (c2 === " " && !opening) {
      if (!(prevC === " ")) {
        i++;
      }
      continue;
    }
    if (c2 === opening) {
      opening = null;
    } else if ((c2 === "'" || c2 === '"') && !opening) {
      opening = c2;
    }
    if (!args[i])
      args[i] = "";
    args[i] += c2;
  }
  return args;
}
__name(tokenizeArgString, "tokenizeArgString");

// ../../node_modules/.pnpm/yargs-parser@21.1.1/node_modules/yargs-parser/build/lib/yargs-parser-types.js
init_import_meta_url();
var DefaultValuesForTypeKey;
(function(DefaultValuesForTypeKey2) {
  DefaultValuesForTypeKey2["BOOLEAN"] = "boolean";
  DefaultValuesForTypeKey2["STRING"] = "string";
  DefaultValuesForTypeKey2["NUMBER"] = "number";
  DefaultValuesForTypeKey2["ARRAY"] = "array";
})(DefaultValuesForTypeKey || (DefaultValuesForTypeKey = {}));

// ../../node_modules/.pnpm/yargs-parser@21.1.1/node_modules/yargs-parser/build/lib/yargs-parser.js
var mixin;
var YargsParser = class {
  constructor(_mixin) {
    mixin = _mixin;
  }
  parse(argsInput, options29) {
    const opts = Object.assign({
      alias: void 0,
      array: void 0,
      boolean: void 0,
      config: void 0,
      configObjects: void 0,
      configuration: void 0,
      coerce: void 0,
      count: void 0,
      default: void 0,
      envPrefix: void 0,
      narg: void 0,
      normalize: void 0,
      string: void 0,
      number: void 0,
      __: void 0,
      key: void 0
    }, options29);
    const args = tokenizeArgString(argsInput);
    const inputIsString = typeof argsInput === "string";
    const aliases2 = combineAliases(Object.assign(/* @__PURE__ */ Object.create(null), opts.alias));
    const configuration = Object.assign({
      "boolean-negation": true,
      "camel-case-expansion": true,
      "combine-arrays": false,
      "dot-notation": true,
      "duplicate-arguments-array": true,
      "flatten-duplicate-arrays": true,
      "greedy-arrays": true,
      "halt-at-non-option": false,
      "nargs-eats-options": false,
      "negation-prefix": "no-",
      "parse-numbers": true,
      "parse-positional-numbers": true,
      "populate--": false,
      "set-placeholder-key": false,
      "short-option-groups": true,
      "strip-aliased": false,
      "strip-dashed": false,
      "unknown-options-as-args": false
    }, opts.configuration);
    const defaults = Object.assign(/* @__PURE__ */ Object.create(null), opts.default);
    const configObjects = opts.configObjects || [];
    const envPrefix = opts.envPrefix;
    const notFlagsOption = configuration["populate--"];
    const notFlagsArgv = notFlagsOption ? "--" : "_";
    const newAliases = /* @__PURE__ */ Object.create(null);
    const defaulted = /* @__PURE__ */ Object.create(null);
    const __ = opts.__ || mixin.format;
    const flags = {
      aliases: /* @__PURE__ */ Object.create(null),
      arrays: /* @__PURE__ */ Object.create(null),
      bools: /* @__PURE__ */ Object.create(null),
      strings: /* @__PURE__ */ Object.create(null),
      numbers: /* @__PURE__ */ Object.create(null),
      counts: /* @__PURE__ */ Object.create(null),
      normalize: /* @__PURE__ */ Object.create(null),
      configs: /* @__PURE__ */ Object.create(null),
      nargs: /* @__PURE__ */ Object.create(null),
      coercions: /* @__PURE__ */ Object.create(null),
      keys: []
    };
    const negative = /^-([0-9]+(\.[0-9]+)?|\.[0-9]+)$/;
    const negatedBoolean = new RegExp("^--" + configuration["negation-prefix"] + "(.+)");
    [].concat(opts.array || []).filter(Boolean).forEach(function(opt) {
      const key = typeof opt === "object" ? opt.key : opt;
      const assignment = Object.keys(opt).map(function(key2) {
        const arrayFlagKeys = {
          boolean: "bools",
          string: "strings",
          number: "numbers"
        };
        return arrayFlagKeys[key2];
      }).filter(Boolean).pop();
      if (assignment) {
        flags[assignment][key] = true;
      }
      flags.arrays[key] = true;
      flags.keys.push(key);
    });
    [].concat(opts.boolean || []).filter(Boolean).forEach(function(key) {
      flags.bools[key] = true;
      flags.keys.push(key);
    });
    [].concat(opts.string || []).filter(Boolean).forEach(function(key) {
      flags.strings[key] = true;
      flags.keys.push(key);
    });
    [].concat(opts.number || []).filter(Boolean).forEach(function(key) {
      flags.numbers[key] = true;
      flags.keys.push(key);
    });
    [].concat(opts.count || []).filter(Boolean).forEach(function(key) {
      flags.counts[key] = true;
      flags.keys.push(key);
    });
    [].concat(opts.normalize || []).filter(Boolean).forEach(function(key) {
      flags.normalize[key] = true;
      flags.keys.push(key);
    });
    if (typeof opts.narg === "object") {
      Object.entries(opts.narg).forEach(([key, value]) => {
        if (typeof value === "number") {
          flags.nargs[key] = value;
          flags.keys.push(key);
        }
      });
    }
    if (typeof opts.coerce === "object") {
      Object.entries(opts.coerce).forEach(([key, value]) => {
        if (typeof value === "function") {
          flags.coercions[key] = value;
          flags.keys.push(key);
        }
      });
    }
    if (typeof opts.config !== "undefined") {
      if (Array.isArray(opts.config) || typeof opts.config === "string") {
        ;
        [].concat(opts.config).filter(Boolean).forEach(function(key) {
          flags.configs[key] = true;
        });
      } else if (typeof opts.config === "object") {
        Object.entries(opts.config).forEach(([key, value]) => {
          if (typeof value === "boolean" || typeof value === "function") {
            flags.configs[key] = value;
          }
        });
      }
    }
    extendAliases(opts.key, aliases2, opts.default, flags.arrays);
    Object.keys(defaults).forEach(function(key) {
      (flags.aliases[key] || []).forEach(function(alias) {
        defaults[alias] = defaults[key];
      });
    });
    let error2 = null;
    checkConfiguration();
    let notFlags = [];
    const argv = Object.assign(/* @__PURE__ */ Object.create(null), { _: [] });
    const argvReturn = {};
    for (let i = 0; i < args.length; i++) {
      const arg = args[i];
      const truncatedArg = arg.replace(/^-{3,}/, "---");
      let broken;
      let key;
      let letters;
      let m2;
      let next;
      let value;
      if (arg !== "--" && /^-/.test(arg) && isUnknownOptionAsArg(arg)) {
        pushPositional(arg);
      } else if (truncatedArg.match(/^---+(=|$)/)) {
        pushPositional(arg);
        continue;
      } else if (arg.match(/^--.+=/) || !configuration["short-option-groups"] && arg.match(/^-.+=/)) {
        m2 = arg.match(/^--?([^=]+)=([\s\S]*)$/);
        if (m2 !== null && Array.isArray(m2) && m2.length >= 3) {
          if (checkAllAliases(m2[1], flags.arrays)) {
            i = eatArray(i, m2[1], args, m2[2]);
          } else if (checkAllAliases(m2[1], flags.nargs) !== false) {
            i = eatNargs(i, m2[1], args, m2[2]);
          } else {
            setArg(m2[1], m2[2], true);
          }
        }
      } else if (arg.match(negatedBoolean) && configuration["boolean-negation"]) {
        m2 = arg.match(negatedBoolean);
        if (m2 !== null && Array.isArray(m2) && m2.length >= 2) {
          key = m2[1];
          setArg(key, checkAllAliases(key, flags.arrays) ? [false] : false);
        }
      } else if (arg.match(/^--.+/) || !configuration["short-option-groups"] && arg.match(/^-[^-]+/)) {
        m2 = arg.match(/^--?(.+)/);
        if (m2 !== null && Array.isArray(m2) && m2.length >= 2) {
          key = m2[1];
          if (checkAllAliases(key, flags.arrays)) {
            i = eatArray(i, key, args);
          } else if (checkAllAliases(key, flags.nargs) !== false) {
            i = eatNargs(i, key, args);
          } else {
            next = args[i + 1];
            if (next !== void 0 && (!next.match(/^-/) || next.match(negative)) && !checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts)) {
              setArg(key, next);
              i++;
            } else if (/^(true|false)$/.test(next)) {
              setArg(key, next);
              i++;
            } else {
              setArg(key, defaultValue(key));
            }
          }
        }
      } else if (arg.match(/^-.\..+=/)) {
        m2 = arg.match(/^-([^=]+)=([\s\S]*)$/);
        if (m2 !== null && Array.isArray(m2) && m2.length >= 3) {
          setArg(m2[1], m2[2]);
        }
      } else if (arg.match(/^-.\..+/) && !arg.match(negative)) {
        next = args[i + 1];
        m2 = arg.match(/^-(.\..+)/);
        if (m2 !== null && Array.isArray(m2) && m2.length >= 2) {
          key = m2[1];
          if (next !== void 0 && !next.match(/^-/) && !checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts)) {
            setArg(key, next);
            i++;
          } else {
            setArg(key, defaultValue(key));
          }
        }
      } else if (arg.match(/^-[^-]+/) && !arg.match(negative)) {
        letters = arg.slice(1, -1).split("");
        broken = false;
        for (let j2 = 0; j2 < letters.length; j2++) {
          next = arg.slice(j2 + 2);
          if (letters[j2 + 1] && letters[j2 + 1] === "=") {
            value = arg.slice(j2 + 3);
            key = letters[j2];
            if (checkAllAliases(key, flags.arrays)) {
              i = eatArray(i, key, args, value);
            } else if (checkAllAliases(key, flags.nargs) !== false) {
              i = eatNargs(i, key, args, value);
            } else {
              setArg(key, value);
            }
            broken = true;
            break;
          }
          if (next === "-") {
            setArg(letters[j2], next);
            continue;
          }
          if (/[A-Za-z]/.test(letters[j2]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next) && checkAllAliases(next, flags.bools) === false) {
            setArg(letters[j2], next);
            broken = true;
            break;
          }
          if (letters[j2 + 1] && letters[j2 + 1].match(/\W/)) {
            setArg(letters[j2], next);
            broken = true;
            break;
          } else {
            setArg(letters[j2], defaultValue(letters[j2]));
          }
        }
        key = arg.slice(-1)[0];
        if (!broken && key !== "-") {
          if (checkAllAliases(key, flags.arrays)) {
            i = eatArray(i, key, args);
          } else if (checkAllAliases(key, flags.nargs) !== false) {
            i = eatNargs(i, key, args);
          } else {
            next = args[i + 1];
            if (next !== void 0 && (!/^(-|--)[^-]/.test(next) || next.match(negative)) && !checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts)) {
              setArg(key, next);
              i++;
            } else if (/^(true|false)$/.test(next)) {
              setArg(key, next);
              i++;
            } else {
              setArg(key, defaultValue(key));
            }
          }
        }
      } else if (arg.match(/^-[0-9]$/) && arg.match(negative) && checkAllAliases(arg.slice(1), flags.bools)) {
        key = arg.slice(1);
        setArg(key, defaultValue(key));
      } else if (arg === "--") {
        notFlags = args.slice(i + 1);
        break;
      } else if (configuration["halt-at-non-option"]) {
        notFlags = args.slice(i);
        break;
      } else {
        pushPositional(arg);
      }
    }
    applyEnvVars(argv, true);
    applyEnvVars(argv, false);
    setConfig(argv);
    setConfigObjects();
    applyDefaultsAndAliases(argv, flags.aliases, defaults, true);
    applyCoercions(argv);
    if (configuration["set-placeholder-key"])
      setPlaceholderKeys(argv);
    Object.keys(flags.counts).forEach(function(key) {
      if (!hasKey2(argv, key.split(".")))
        setArg(key, 0);
    });
    if (notFlagsOption && notFlags.length)
      argv[notFlagsArgv] = [];
    notFlags.forEach(function(key) {
      argv[notFlagsArgv].push(key);
    });
    if (configuration["camel-case-expansion"] && configuration["strip-dashed"]) {
      Object.keys(argv).filter((key) => key !== "--" && key.includes("-")).forEach((key) => {
        delete argv[key];
      });
    }
    if (configuration["strip-aliased"]) {
      ;
      [].concat(...Object.keys(aliases2).map((k2) => aliases2[k2])).forEach((alias) => {
        if (configuration["camel-case-expansion"] && alias.includes("-")) {
          delete argv[alias.split(".").map((prop) => camelCase(prop)).join(".")];
        }
        delete argv[alias];
      });
    }
    function pushPositional(arg) {
      const maybeCoercedNumber = maybeCoerceNumber("_", arg);
      if (typeof maybeCoercedNumber === "string" || typeof maybeCoercedNumber === "number") {
        argv._.push(maybeCoercedNumber);
      }
    }
    __name(pushPositional, "pushPositional");
    function eatNargs(i, key, args2, argAfterEqualSign) {
      let ii;
      let toEat = checkAllAliases(key, flags.nargs);
      toEat = typeof toEat !== "number" || isNaN(toEat) ? 1 : toEat;
      if (toEat === 0) {
        if (!isUndefined(argAfterEqualSign)) {
          error2 = Error(__("Argument unexpected for: %s", key));
        }
        setArg(key, defaultValue(key));
        return i;
      }
      let available = isUndefined(argAfterEqualSign) ? 0 : 1;
      if (configuration["nargs-eats-options"]) {
        if (args2.length - (i + 1) + available < toEat) {
          error2 = Error(__("Not enough arguments following: %s", key));
        }
        available = toEat;
      } else {
        for (ii = i + 1; ii < args2.length; ii++) {
          if (!args2[ii].match(/^-[^0-9]/) || args2[ii].match(negative) || isUnknownOptionAsArg(args2[ii]))
            available++;
          else
            break;
        }
        if (available < toEat)
          error2 = Error(__("Not enough arguments following: %s", key));
      }
      let consumed = Math.min(available, toEat);
      if (!isUndefined(argAfterEqualSign) && consumed > 0) {
        setArg(key, argAfterEqualSign);
        consumed--;
      }
      for (ii = i + 1; ii < consumed + i + 1; ii++) {
        setArg(key, args2[ii]);
      }
      return i + consumed;
    }
    __name(eatNargs, "eatNargs");
    function eatArray(i, key, args2, argAfterEqualSign) {
      let argsToSet = [];
      let next = argAfterEqualSign || args2[i + 1];
      const nargsCount = checkAllAliases(key, flags.nargs);
      if (checkAllAliases(key, flags.bools) && !/^(true|false)$/.test(next)) {
        argsToSet.push(true);
      } else if (isUndefined(next) || isUndefined(argAfterEqualSign) && /^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next)) {
        if (defaults[key] !== void 0) {
          const defVal = defaults[key];
          argsToSet = Array.isArray(defVal) ? defVal : [defVal];
        }
      } else {
        if (!isUndefined(argAfterEqualSign)) {
          argsToSet.push(processValue(key, argAfterEqualSign, true));
        }
        for (let ii = i + 1; ii < args2.length; ii++) {
          if (!configuration["greedy-arrays"] && argsToSet.length > 0 || nargsCount && typeof nargsCount === "number" && argsToSet.length >= nargsCount)
            break;
          next = args2[ii];
          if (/^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next))
            break;
          i = ii;
          argsToSet.push(processValue(key, next, inputIsString));
        }
      }
      if (typeof nargsCount === "number" && (nargsCount && argsToSet.length < nargsCount || isNaN(nargsCount) && argsToSet.length === 0)) {
        error2 = Error(__("Not enough arguments following: %s", key));
      }
      setArg(key, argsToSet);
      return i;
    }
    __name(eatArray, "eatArray");
    function setArg(key, val, shouldStripQuotes = inputIsString) {
      if (/-/.test(key) && configuration["camel-case-expansion"]) {
        const alias = key.split(".").map(function(prop) {
          return camelCase(prop);
        }).join(".");
        addNewAlias(key, alias);
      }
      const value = processValue(key, val, shouldStripQuotes);
      const splitKey = key.split(".");
      setKey(argv, splitKey, value);
      if (flags.aliases[key]) {
        flags.aliases[key].forEach(function(x2) {
          const keyProperties = x2.split(".");
          setKey(argv, keyProperties, value);
        });
      }
      if (splitKey.length > 1 && configuration["dot-notation"]) {
        ;
        (flags.aliases[splitKey[0]] || []).forEach(function(x2) {
          let keyProperties = x2.split(".");
          const a = [].concat(splitKey);
          a.shift();
          keyProperties = keyProperties.concat(a);
          if (!(flags.aliases[key] || []).includes(keyProperties.join("."))) {
            setKey(argv, keyProperties, value);
          }
        });
      }
      if (checkAllAliases(key, flags.normalize) && !checkAllAliases(key, flags.arrays)) {
        const keys = [key].concat(flags.aliases[key] || []);
        keys.forEach(function(key2) {
          Object.defineProperty(argvReturn, key2, {
            enumerable: true,
            get() {
              return val;
            },
            set(value2) {
              val = typeof value2 === "string" ? mixin.normalize(value2) : value2;
            }
          });
        });
      }
    }
    __name(setArg, "setArg");
    function addNewAlias(key, alias) {
      if (!(flags.aliases[key] && flags.aliases[key].length)) {
        flags.aliases[key] = [alias];
        newAliases[alias] = true;
      }
      if (!(flags.aliases[alias] && flags.aliases[alias].length)) {
        addNewAlias(alias, key);
      }
    }
    __name(addNewAlias, "addNewAlias");
    function processValue(key, val, shouldStripQuotes) {
      if (shouldStripQuotes) {
        val = stripQuotes(val);
      }
      if (checkAllAliases(key, flags.bools) || checkAllAliases(key, flags.counts)) {
        if (typeof val === "string")
          val = val === "true";
      }
      let value = Array.isArray(val) ? val.map(function(v2) {
        return maybeCoerceNumber(key, v2);
      }) : maybeCoerceNumber(key, val);
      if (checkAllAliases(key, flags.counts) && (isUndefined(value) || typeof value === "boolean")) {
        value = increment();
      }
      if (checkAllAliases(key, flags.normalize) && checkAllAliases(key, flags.arrays)) {
        if (Array.isArray(val))
          value = val.map((val2) => {
            return mixin.normalize(val2);
          });
        else
          value = mixin.normalize(val);
      }
      return value;
    }
    __name(processValue, "processValue");
    function maybeCoerceNumber(key, value) {
      if (!configuration["parse-positional-numbers"] && key === "_")
        return value;
      if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.bools) && !Array.isArray(value)) {
        const shouldCoerceNumber = looksLikeNumber(value) && configuration["parse-numbers"] && Number.isSafeInteger(Math.floor(parseFloat(`${value}`)));
        if (shouldCoerceNumber || !isUndefined(value) && checkAllAliases(key, flags.numbers)) {
          value = Number(value);
        }
      }
      return value;
    }
    __name(maybeCoerceNumber, "maybeCoerceNumber");
    function setConfig(argv2) {
      const configLookup = /* @__PURE__ */ Object.create(null);
      applyDefaultsAndAliases(configLookup, flags.aliases, defaults);
      Object.keys(flags.configs).forEach(function(configKey) {
        const configPath = argv2[configKey] || configLookup[configKey];
        if (configPath) {
          try {
            let config = null;
            const resolvedConfigPath = mixin.resolve(mixin.cwd(), configPath);
            const resolveConfig = flags.configs[configKey];
            if (typeof resolveConfig === "function") {
              try {
                config = resolveConfig(resolvedConfigPath);
              } catch (e3) {
                config = e3;
              }
              if (config instanceof Error) {
                error2 = config;
                return;
              }
            } else {
              config = mixin.require(resolvedConfigPath);
            }
            setConfigObject(config);
          } catch (ex) {
            if (ex.name === "PermissionDenied")
              error2 = ex;
            else if (argv2[configKey])
              error2 = Error(__("Invalid JSON config file: %s", configPath));
          }
        }
      });
    }
    __name(setConfig, "setConfig");
    function setConfigObject(config, prev) {
      Object.keys(config).forEach(function(key) {
        const value = config[key];
        const fullKey = prev ? prev + "." + key : key;
        if (typeof value === "object" && value !== null && !Array.isArray(value) && configuration["dot-notation"]) {
          setConfigObject(value, fullKey);
        } else {
          if (!hasKey2(argv, fullKey.split(".")) || checkAllAliases(fullKey, flags.arrays) && configuration["combine-arrays"]) {
            setArg(fullKey, value);
          }
        }
      });
    }
    __name(setConfigObject, "setConfigObject");
    function setConfigObjects() {
      if (typeof configObjects !== "undefined") {
        configObjects.forEach(function(configObject) {
          setConfigObject(configObject);
        });
      }
    }
    __name(setConfigObjects, "setConfigObjects");
    function applyEnvVars(argv2, configOnly) {
      if (typeof envPrefix === "undefined")
        return;
      const prefix = typeof envPrefix === "string" ? envPrefix : "";
      const env5 = mixin.env();
      Object.keys(env5).forEach(function(envVar) {
        if (prefix === "" || envVar.lastIndexOf(prefix, 0) === 0) {
          const keys = envVar.split("__").map(function(key, i) {
            if (i === 0) {
              key = key.substring(prefix.length);
            }
            return camelCase(key);
          });
          if ((configOnly && flags.configs[keys.join(".")] || !configOnly) && !hasKey2(argv2, keys)) {
            setArg(keys.join("."), env5[envVar]);
          }
        }
      });
    }
    __name(applyEnvVars, "applyEnvVars");
    function applyCoercions(argv2) {
      let coerce;
      const applied = /* @__PURE__ */ new Set();
      Object.keys(argv2).forEach(function(key) {
        if (!applied.has(key)) {
          coerce = checkAllAliases(key, flags.coercions);
          if (typeof coerce === "function") {
            try {
              const value = maybeCoerceNumber(key, coerce(argv2[key]));
              [].concat(flags.aliases[key] || [], key).forEach((ali) => {
                applied.add(ali);
                argv2[ali] = value;
              });
            } catch (err) {
              error2 = err;
            }
          }
        }
      });
    }
    __name(applyCoercions, "applyCoercions");
    function setPlaceholderKeys(argv2) {
      flags.keys.forEach((key) => {
        if (~key.indexOf("."))
          return;
        if (typeof argv2[key] === "undefined")
          argv2[key] = void 0;
      });
      return argv2;
    }
    __name(setPlaceholderKeys, "setPlaceholderKeys");
    function applyDefaultsAndAliases(obj, aliases3, defaults2, canLog = false) {
      Object.keys(defaults2).forEach(function(key) {
        if (!hasKey2(obj, key.split("."))) {
          setKey(obj, key.split("."), defaults2[key]);
          if (canLog)
            defaulted[key] = true;
          (aliases3[key] || []).forEach(function(x2) {
            if (hasKey2(obj, x2.split(".")))
              return;
            setKey(obj, x2.split("."), defaults2[key]);
          });
        }
      });
    }
    __name(applyDefaultsAndAliases, "applyDefaultsAndAliases");
    function hasKey2(obj, keys) {
      let o2 = obj;
      if (!configuration["dot-notation"])
        keys = [keys.join(".")];
      keys.slice(0, -1).forEach(function(key2) {
        o2 = o2[key2] || {};
      });
      const key = keys[keys.length - 1];
      if (typeof o2 !== "object")
        return false;
      else
        return key in o2;
    }
    __name(hasKey2, "hasKey");
    function setKey(obj, keys, value) {
      let o2 = obj;
      if (!configuration["dot-notation"])
        keys = [keys.join(".")];
      keys.slice(0, -1).forEach(function(key2) {
        key2 = sanitizeKey(key2);
        if (typeof o2 === "object" && o2[key2] === void 0) {
          o2[key2] = {};
        }
        if (typeof o2[key2] !== "object" || Array.isArray(o2[key2])) {
          if (Array.isArray(o2[key2])) {
            o2[key2].push({});
          } else {
            o2[key2] = [o2[key2], {}];
          }
          o2 = o2[key2][o2[key2].length - 1];
        } else {
          o2 = o2[key2];
        }
      });
      const key = sanitizeKey(keys[keys.length - 1]);
      const isTypeArray = checkAllAliases(keys.join("."), flags.arrays);
      const isValueArray = Array.isArray(value);
      let duplicate = configuration["duplicate-arguments-array"];
      if (!duplicate && checkAllAliases(key, flags.nargs)) {
        duplicate = true;
        if (!isUndefined(o2[key]) && flags.nargs[key] === 1 || Array.isArray(o2[key]) && o2[key].length === flags.nargs[key]) {
          o2[key] = void 0;
        }
      }
      if (value === increment()) {
        o2[key] = increment(o2[key]);
      } else if (Array.isArray(o2[key])) {
        if (duplicate && isTypeArray && isValueArray) {
          o2[key] = configuration["flatten-duplicate-arrays"] ? o2[key].concat(value) : (Array.isArray(o2[key][0]) ? o2[key] : [o2[key]]).concat([value]);
        } else if (!duplicate && Boolean(isTypeArray) === Boolean(isValueArray)) {
          o2[key] = value;
        } else {
          o2[key] = o2[key].concat([value]);
        }
      } else if (o2[key] === void 0 && isTypeArray) {
        o2[key] = isValueArray ? value : [value];
      } else if (duplicate && !(o2[key] === void 0 || checkAllAliases(key, flags.counts) || checkAllAliases(key, flags.bools))) {
        o2[key] = [o2[key], value];
      } else {
        o2[key] = value;
      }
    }
    __name(setKey, "setKey");
    function extendAliases(...args2) {
      args2.forEach(function(obj) {
        Object.keys(obj || {}).forEach(function(key) {
          if (flags.aliases[key])
            return;
          flags.aliases[key] = [].concat(aliases2[key] || []);
          flags.aliases[key].concat(key).forEach(function(x2) {
            if (/-/.test(x2) && configuration["camel-case-expansion"]) {
              const c2 = camelCase(x2);
              if (c2 !== key && flags.aliases[key].indexOf(c2) === -1) {
                flags.aliases[key].push(c2);
                newAliases[c2] = true;
              }
            }
          });
          flags.aliases[key].concat(key).forEach(function(x2) {
            if (x2.length > 1 && /[A-Z]/.test(x2) && configuration["camel-case-expansion"]) {
              const c2 = decamelize(x2, "-");
              if (c2 !== key && flags.aliases[key].indexOf(c2) === -1) {
                flags.aliases[key].push(c2);
                newAliases[c2] = true;
              }
            }
          });
          flags.aliases[key].forEach(function(x2) {
            flags.aliases[x2] = [key].concat(flags.aliases[key].filter(function(y2) {
              return x2 !== y2;
            }));
          });
        });
      });
    }
    __name(extendAliases, "extendAliases");
    function checkAllAliases(key, flag) {
      const toCheck = [].concat(flags.aliases[key] || [], key);
      const keys = Object.keys(flag);
      const setAlias = toCheck.find((key2) => keys.includes(key2));
      return setAlias ? flag[setAlias] : false;
    }
    __name(checkAllAliases, "checkAllAliases");
    function hasAnyFlag(key) {
      const flagsKeys = Object.keys(flags);
      const toCheck = [].concat(flagsKeys.map((k2) => flags[k2]));
      return toCheck.some(function(flag) {
        return Array.isArray(flag) ? flag.includes(key) : flag[key];
      });
    }
    __name(hasAnyFlag, "hasAnyFlag");
    function hasFlagsMatching(arg, ...patterns) {
      const toCheck = [].concat(...patterns);
      return toCheck.some(function(pattern) {
        const match = arg.match(pattern);
        return match && hasAnyFlag(match[1]);
      });
    }
    __name(hasFlagsMatching, "hasFlagsMatching");
    function hasAllShortFlags(arg) {
      if (arg.match(negative) || !arg.match(/^-[^-]+/)) {
        return false;
      }
      let hasAllFlags = true;
      let next;
      const letters = arg.slice(1).split("");
      for (let j2 = 0; j2 < letters.length; j2++) {
        next = arg.slice(j2 + 2);
        if (!hasAnyFlag(letters[j2])) {
          hasAllFlags = false;
          break;
        }
        if (letters[j2 + 1] && letters[j2 + 1] === "=" || next === "-" || /[A-Za-z]/.test(letters[j2]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next) || letters[j2 + 1] && letters[j2 + 1].match(/\W/)) {
          break;
        }
      }
      return hasAllFlags;
    }
    __name(hasAllShortFlags, "hasAllShortFlags");
    function isUnknownOptionAsArg(arg) {
      return configuration["unknown-options-as-args"] && isUnknownOption(arg);
    }
    __name(isUnknownOptionAsArg, "isUnknownOptionAsArg");
    function isUnknownOption(arg) {
      arg = arg.replace(/^-{3,}/, "--");
      if (arg.match(negative)) {
        return false;
      }
      if (hasAllShortFlags(arg)) {
        return false;
      }
      const flagWithEquals = /^-+([^=]+?)=[\s\S]*$/;
      const normalFlag = /^-+([^=]+?)$/;
      const flagEndingInHyphen = /^-+([^=]+?)-$/;
      const flagEndingInDigits = /^-+([^=]+?\d+)$/;
      const flagEndingInNonWordCharacters = /^-+([^=]+?)\W+.*$/;
      return !hasFlagsMatching(arg, flagWithEquals, negatedBoolean, normalFlag, flagEndingInHyphen, flagEndingInDigits, flagEndingInNonWordCharacters);
    }
    __name(isUnknownOption, "isUnknownOption");
    function defaultValue(key) {
      if (!checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts) && `${key}` in defaults) {
        return defaults[key];
      } else {
        return defaultForType(guessType2(key));
      }
    }
    __name(defaultValue, "defaultValue");
    function defaultForType(type) {
      const def = {
        [DefaultValuesForTypeKey.BOOLEAN]: true,
        [DefaultValuesForTypeKey.STRING]: "",
        [DefaultValuesForTypeKey.NUMBER]: void 0,
        [DefaultValuesForTypeKey.ARRAY]: []
      };
      return def[type];
    }
    __name(defaultForType, "defaultForType");
    function guessType2(key) {
      let type = DefaultValuesForTypeKey.BOOLEAN;
      if (checkAllAliases(key, flags.strings))
        type = DefaultValuesForTypeKey.STRING;
      else if (checkAllAliases(key, flags.numbers))
        type = DefaultValuesForTypeKey.NUMBER;
      else if (checkAllAliases(key, flags.bools))
        type = DefaultValuesForTypeKey.BOOLEAN;
      else if (checkAllAliases(key, flags.arrays))
        type = DefaultValuesForTypeKey.ARRAY;
      return type;
    }
    __name(guessType2, "guessType");
    function isUndefined(num) {
      return num === void 0;
    }
    __name(isUndefined, "isUndefined");
    function checkConfiguration() {
      Object.keys(flags.counts).find((key) => {
        if (checkAllAliases(key, flags.arrays)) {
          error2 = Error(__("Invalid configuration: %s, opts.count excludes opts.array.", key));
          return true;
        } else if (checkAllAliases(key, flags.nargs)) {
          error2 = Error(__("Invalid configuration: %s, opts.count excludes opts.narg.", key));
          return true;
        }
        return false;
      });
    }
    __name(checkConfiguration, "checkConfiguration");
    return {
      aliases: Object.assign({}, flags.aliases),
      argv: Object.assign(argvReturn, argv),
      configuration,
      defaulted: Object.assign({}, defaulted),
      error: error2,
      newAliases: Object.assign({}, newAliases)
    };
  }
};
__name(YargsParser, "YargsParser");
function combineAliases(aliases2) {
  const aliasArrays = [];
  const combined = /* @__PURE__ */ Object.create(null);
  let change = true;
  Object.keys(aliases2).forEach(function(key) {
    aliasArrays.push([].concat(aliases2[key], key));
  });
  while (change) {
    change = false;
    for (let i = 0; i < aliasArrays.length; i++) {
      for (let ii = i + 1; ii < aliasArrays.length; ii++) {
        const intersect = aliasArrays[i].filter(function(v2) {
          return aliasArrays[ii].indexOf(v2) !== -1;
        });
        if (intersect.length) {
          aliasArrays[i] = aliasArrays[i].concat(aliasArrays[ii]);
          aliasArrays.splice(ii, 1);
          change = true;
          break;
        }
      }
    }
  }
  aliasArrays.forEach(function(aliasArray) {
    aliasArray = aliasArray.filter(function(v2, i, self2) {
      return self2.indexOf(v2) === i;
    });
    const lastAlias = aliasArray.pop();
    if (lastAlias !== void 0 && typeof lastAlias === "string") {
      combined[lastAlias] = aliasArray;
    }
  });
  return combined;
}
__name(combineAliases, "combineAliases");
function increment(orig) {
  return orig !== void 0 ? orig + 1 : 1;
}
__name(increment, "increment");
function sanitizeKey(key) {
  if (key === "__proto__")
    return "___proto___";
  return key;
}
__name(sanitizeKey, "sanitizeKey");
function stripQuotes(val) {
  return typeof val === "string" && (val[0] === "'" || val[0] === '"') && val[val.length - 1] === val[0] ? val.substring(1, val.length - 1) : val;
}
__name(stripQuotes, "stripQuotes");

// ../../node_modules/.pnpm/yargs-parser@21.1.1/node_modules/yargs-parser/build/lib/index.js
var import_fs = require("fs");
var _a;
var _b;
var _c;
var minNodeVersion = process && process.env && process.env.YARGS_MIN_NODE_VERSION ? Number(process.env.YARGS_MIN_NODE_VERSION) : 12;
var nodeVersion = (_b = (_a = process === null || process === void 0 ? void 0 : process.versions) === null || _a === void 0 ? void 0 : _a.node) !== null && _b !== void 0 ? _b : (_c = process === null || process === void 0 ? void 0 : process.version) === null || _c === void 0 ? void 0 : _c.slice(1);
if (nodeVersion) {
  const major = Number(nodeVersion.match(/^([^.]+)/)[1]);
  if (major < minNodeVersion) {
    throw Error(`yargs parser supports a minimum Node.js version of ${minNodeVersion}. Read our version support policy: https://github.com/yargs/yargs-parser#supported-nodejs-versions`);
  }
}
var env = process ? process.env : {};
var parser = new YargsParser({
  cwd: process.cwd,
  env: () => {
    return env;
  },
  format: import_util.format,
  normalize: import_path.normalize,
  resolve: import_path.resolve,
  // TODO: figure  out a  way to combine ESM and CJS coverage, such  that
  // we can exercise all the lines below:
  require: (path67) => {
    if (typeof require !== "undefined") {
      return require(path67);
    } else if (path67.match(/\.json$/)) {
      return JSON.parse((0, import_fs.readFileSync)(path67, "utf8"));
    } else {
      throw Error("only .json config files are supported in ESM");
    }
  }
});
var yargsParser = /* @__PURE__ */ __name(function Parser(args, opts) {
  const result = parser.parse(args.slice(), opts);
  return result.argv;
}, "Parser");
yargsParser.detailed = function(args, opts) {
  return parser.parse(args.slice(), opts);
};
yargsParser.camelCase = camelCase;
yargsParser.decamelize = decamelize;
yargsParser.looksLikeNumber = looksLikeNumber;
var lib_default = yargsParser;

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/lib/platform-shims/esm.mjs
init_import_meta_url();
var import_assert = require("assert");

// ../../node_modules/.pnpm/cliui@8.0.1/node_modules/cliui/index.mjs
init_import_meta_url();

// ../../node_modules/.pnpm/cliui@8.0.1/node_modules/cliui/build/lib/index.js
init_import_meta_url();
var align = {
  right: alignRight,
  center: alignCenter
};
var top = 0;
var right = 1;
var bottom = 2;
var left = 3;
var UI = class {
  constructor(opts) {
    var _a2;
    this.width = opts.width;
    this.wrap = (_a2 = opts.wrap) !== null && _a2 !== void 0 ? _a2 : true;
    this.rows = [];
  }
  span(...args) {
    const cols = this.div(...args);
    cols.span = true;
  }
  resetOutput() {
    this.rows = [];
  }
  div(...args) {
    if (args.length === 0) {
      this.div("");
    }
    if (this.wrap && this.shouldApplyLayoutDSL(...args) && typeof args[0] === "string") {
      return this.applyLayoutDSL(args[0]);
    }
    const cols = args.map((arg) => {
      if (typeof arg === "string") {
        return this.colFromString(arg);
      }
      return arg;
    });
    this.rows.push(cols);
    return cols;
  }
  shouldApplyLayoutDSL(...args) {
    return args.length === 1 && typeof args[0] === "string" && /[\t\n]/.test(args[0]);
  }
  applyLayoutDSL(str) {
    const rows = str.split("\n").map((row) => row.split("	"));
    let leftColumnWidth = 0;
    rows.forEach((columns) => {
      if (columns.length > 1 && mixin2.stringWidth(columns[0]) > leftColumnWidth) {
        leftColumnWidth = Math.min(Math.floor(this.width * 0.5), mixin2.stringWidth(columns[0]));
      }
    });
    rows.forEach((columns) => {
      this.div(...columns.map((r3, i) => {
        return {
          text: r3.trim(),
          padding: this.measurePadding(r3),
          width: i === 0 && columns.length > 1 ? leftColumnWidth : void 0
        };
      }));
    });
    return this.rows[this.rows.length - 1];
  }
  colFromString(text) {
    return {
      text,
      padding: this.measurePadding(text)
    };
  }
  measurePadding(str) {
    const noAnsi = mixin2.stripAnsi(str);
    return [0, noAnsi.match(/\s*$/)[0].length, 0, noAnsi.match(/^\s*/)[0].length];
  }
  toString() {
    const lines = [];
    this.rows.forEach((row) => {
      this.rowToString(row, lines);
    });
    return lines.filter((line) => !line.hidden).map((line) => line.text).join("\n");
  }
  rowToString(row, lines) {
    this.rasterize(row).forEach((rrow, r3) => {
      let str = "";
      rrow.forEach((col, c2) => {
        const { width } = row[c2];
        const wrapWidth = this.negatePadding(row[c2]);
        let ts = col;
        if (wrapWidth > mixin2.stringWidth(col)) {
          ts += " ".repeat(wrapWidth - mixin2.stringWidth(col));
        }
        if (row[c2].align && row[c2].align !== "left" && this.wrap) {
          const fn2 = align[row[c2].align];
          ts = fn2(ts, wrapWidth);
          if (mixin2.stringWidth(ts) < wrapWidth) {
            ts += " ".repeat((width || 0) - mixin2.stringWidth(ts) - 1);
          }
        }
        const padding = row[c2].padding || [0, 0, 0, 0];
        if (padding[left]) {
          str += " ".repeat(padding[left]);
        }
        str += addBorder(row[c2], ts, "| ");
        str += ts;
        str += addBorder(row[c2], ts, " |");
        if (padding[right]) {
          str += " ".repeat(padding[right]);
        }
        if (r3 === 0 && lines.length > 0) {
          str = this.renderInline(str, lines[lines.length - 1]);
        }
      });
      lines.push({
        text: str.replace(/ +$/, ""),
        span: row.span
      });
    });
    return lines;
  }
  // if the full 'source' can render in
  // the target line, do so.
  renderInline(source, previousLine) {
    const match = source.match(/^ */);
    const leadingWhitespace = match ? match[0].length : 0;
    const target = previousLine.text;
    const targetTextWidth = mixin2.stringWidth(target.trimRight());
    if (!previousLine.span) {
      return source;
    }
    if (!this.wrap) {
      previousLine.hidden = true;
      return target + source;
    }
    if (leadingWhitespace < targetTextWidth) {
      return source;
    }
    previousLine.hidden = true;
    return target.trimRight() + " ".repeat(leadingWhitespace - targetTextWidth) + source.trimLeft();
  }
  rasterize(row) {
    const rrows = [];
    const widths = this.columnWidths(row);
    let wrapped;
    row.forEach((col, c2) => {
      col.width = widths[c2];
      if (this.wrap) {
        wrapped = mixin2.wrap(col.text, this.negatePadding(col), { hard: true }).split("\n");
      } else {
        wrapped = col.text.split("\n");
      }
      if (col.border) {
        wrapped.unshift("." + "-".repeat(this.negatePadding(col) + 2) + ".");
        wrapped.push("'" + "-".repeat(this.negatePadding(col) + 2) + "'");
      }
      if (col.padding) {
        wrapped.unshift(...new Array(col.padding[top] || 0).fill(""));
        wrapped.push(...new Array(col.padding[bottom] || 0).fill(""));
      }
      wrapped.forEach((str, r3) => {
        if (!rrows[r3]) {
          rrows.push([]);
        }
        const rrow = rrows[r3];
        for (let i = 0; i < c2; i++) {
          if (rrow[i] === void 0) {
            rrow.push("");
          }
        }
        rrow.push(str);
      });
    });
    return rrows;
  }
  negatePadding(col) {
    let wrapWidth = col.width || 0;
    if (col.padding) {
      wrapWidth -= (col.padding[left] || 0) + (col.padding[right] || 0);
    }
    if (col.border) {
      wrapWidth -= 4;
    }
    return wrapWidth;
  }
  columnWidths(row) {
    if (!this.wrap) {
      return row.map((col) => {
        return col.width || mixin2.stringWidth(col.text);
      });
    }
    let unset = row.length;
    let remainingWidth = this.width;
    const widths = row.map((col) => {
      if (col.width) {
        unset--;
        remainingWidth -= col.width;
        return col.width;
      }
      return void 0;
    });
    const unsetWidth = unset ? Math.floor(remainingWidth / unset) : 0;
    return widths.map((w2, i) => {
      if (w2 === void 0) {
        return Math.max(unsetWidth, _minWidth(row[i]));
      }
      return w2;
    });
  }
};
__name(UI, "UI");
function addBorder(col, ts, style) {
  if (col.border) {
    if (/[.']-+[.']/.test(ts)) {
      return "";
    }
    if (ts.trim().length !== 0) {
      return style;
    }
    return "  ";
  }
  return "";
}
__name(addBorder, "addBorder");
function _minWidth(col) {
  const padding = col.padding || [];
  const minWidth = 1 + (padding[left] || 0) + (padding[right] || 0);
  if (col.border) {
    return minWidth + 4;
  }
  return minWidth;
}
__name(_minWidth, "_minWidth");
function getWindowWidth() {
  if (typeof process === "object" && process.stdout && process.stdout.columns) {
    return process.stdout.columns;
  }
  return 80;
}
__name(getWindowWidth, "getWindowWidth");
function alignRight(str, width) {
  str = str.trim();
  const strWidth = mixin2.stringWidth(str);
  if (strWidth < width) {
    return " ".repeat(width - strWidth) + str;
  }
  return str;
}
__name(alignRight, "alignRight");
function alignCenter(str, width) {
  str = str.trim();
  const strWidth = mixin2.stringWidth(str);
  if (strWidth >= width) {
    return str;
  }
  return " ".repeat(width - strWidth >> 1) + str;
}
__name(alignCenter, "alignCenter");
var mixin2;
function cliui(opts, _mixin) {
  mixin2 = _mixin;
  return new UI({
    width: (opts === null || opts === void 0 ? void 0 : opts.width) || getWindowWidth(),
    wrap: opts === null || opts === void 0 ? void 0 : opts.wrap
  });
}
__name(cliui, "cliui");

// ../../node_modules/.pnpm/cliui@8.0.1/node_modules/cliui/build/lib/string-utils.js
init_import_meta_url();
var ansi = new RegExp("\x1B(?:\\[(?:\\d+[ABCDEFGJKSTm]|\\d+;\\d+[Hfm]|\\d+;\\d+;\\d+m|6n|s|u|\\?25[lh])|\\w)", "g");
function stripAnsi(str) {
  return str.replace(ansi, "");
}
__name(stripAnsi, "stripAnsi");
function wrap(str, width) {
  const [start, end] = str.match(ansi) || ["", ""];
  str = stripAnsi(str);
  let wrapped = "";
  for (let i = 0; i < str.length; i++) {
    if (i !== 0 && i % width === 0) {
      wrapped += "\n";
    }
    wrapped += str.charAt(i);
  }
  if (start && end) {
    wrapped = `${start}${wrapped}${end}`;
  }
  return wrapped;
}
__name(wrap, "wrap");

// ../../node_modules/.pnpm/cliui@8.0.1/node_modules/cliui/index.mjs
function ui(opts) {
  return cliui(opts, {
    stringWidth: (str) => {
      return [...str].length;
    },
    stripAnsi,
    wrap
  });
}
__name(ui, "ui");

// ../../node_modules/.pnpm/escalade@3.1.1/node_modules/escalade/sync/index.mjs
init_import_meta_url();
var import_path2 = require("path");
var import_fs2 = require("fs");
function sync_default(start, callback) {
  let dir = (0, import_path2.resolve)(".", start);
  let tmp, stats = (0, import_fs2.statSync)(dir);
  if (!stats.isDirectory()) {
    dir = (0, import_path2.dirname)(dir);
  }
  while (true) {
    tmp = callback(dir, (0, import_fs2.readdirSync)(dir));
    if (tmp)
      return (0, import_path2.resolve)(dir, tmp);
    dir = (0, import_path2.dirname)(tmp = dir);
    if (tmp === dir)
      break;
  }
}
__name(sync_default, "default");

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/lib/platform-shims/esm.mjs
var import_util3 = require("util");
var import_fs4 = require("fs");
var import_url = require("url");
var import_path4 = require("path");

// ../../node_modules/.pnpm/y18n@5.0.8/node_modules/y18n/index.mjs
init_import_meta_url();

// ../../node_modules/.pnpm/y18n@5.0.8/node_modules/y18n/build/lib/platform-shims/node.js
init_import_meta_url();
var import_fs3 = require("fs");
var import_util2 = require("util");
var import_path3 = require("path");
var node_default = {
  fs: {
    readFileSync: import_fs3.readFileSync,
    writeFile: import_fs3.writeFile
  },
  format: import_util2.format,
  resolve: import_path3.resolve,
  exists: (file) => {
    try {
      return (0, import_fs3.statSync)(file).isFile();
    } catch (err) {
      return false;
    }
  }
};

// ../../node_modules/.pnpm/y18n@5.0.8/node_modules/y18n/build/lib/index.js
init_import_meta_url();
var shim2;
var Y18N = class {
  constructor(opts) {
    opts = opts || {};
    this.directory = opts.directory || "./locales";
    this.updateFiles = typeof opts.updateFiles === "boolean" ? opts.updateFiles : true;
    this.locale = opts.locale || "en";
    this.fallbackToLanguage = typeof opts.fallbackToLanguage === "boolean" ? opts.fallbackToLanguage : true;
    this.cache = /* @__PURE__ */ Object.create(null);
    this.writeQueue = [];
  }
  __(...args) {
    if (typeof arguments[0] !== "string") {
      return this._taggedLiteral(arguments[0], ...arguments);
    }
    const str = args.shift();
    let cb = /* @__PURE__ */ __name(function() {
    }, "cb");
    if (typeof args[args.length - 1] === "function")
      cb = args.pop();
    cb = cb || function() {
    };
    if (!this.cache[this.locale])
      this._readLocaleFile();
    if (!this.cache[this.locale][str] && this.updateFiles) {
      this.cache[this.locale][str] = str;
      this._enqueueWrite({
        directory: this.directory,
        locale: this.locale,
        cb
      });
    } else {
      cb();
    }
    return shim2.format.apply(shim2.format, [this.cache[this.locale][str] || str].concat(args));
  }
  __n() {
    const args = Array.prototype.slice.call(arguments);
    const singular = args.shift();
    const plural2 = args.shift();
    const quantity = args.shift();
    let cb = /* @__PURE__ */ __name(function() {
    }, "cb");
    if (typeof args[args.length - 1] === "function")
      cb = args.pop();
    if (!this.cache[this.locale])
      this._readLocaleFile();
    let str = quantity === 1 ? singular : plural2;
    if (this.cache[this.locale][singular]) {
      const entry = this.cache[this.locale][singular];
      str = entry[quantity === 1 ? "one" : "other"];
    }
    if (!this.cache[this.locale][singular] && this.updateFiles) {
      this.cache[this.locale][singular] = {
        one: singular,
        other: plural2
      };
      this._enqueueWrite({
        directory: this.directory,
        locale: this.locale,
        cb
      });
    } else {
      cb();
    }
    const values = [str];
    if (~str.indexOf("%d"))
      values.push(quantity);
    return shim2.format.apply(shim2.format, values.concat(args));
  }
  setLocale(locale) {
    this.locale = locale;
  }
  getLocale() {
    return this.locale;
  }
  updateLocale(obj) {
    if (!this.cache[this.locale])
      this._readLocaleFile();
    for (const key in obj) {
      if (Object.prototype.hasOwnProperty.call(obj, key)) {
        this.cache[this.locale][key] = obj[key];
      }
    }
  }
  _taggedLiteral(parts, ...args) {
    let str = "";
    parts.forEach(function(part, i) {
      const arg = args[i + 1];
      str += part;
      if (typeof arg !== "undefined") {
        str += "%s";
      }
    });
    return this.__.apply(this, [str].concat([].slice.call(args, 1)));
  }
  _enqueueWrite(work) {
    this.writeQueue.push(work);
    if (this.writeQueue.length === 1)
      this._processWriteQueue();
  }
  _processWriteQueue() {
    const _this = this;
    const work = this.writeQueue[0];
    const directory = work.directory;
    const locale = work.locale;
    const cb = work.cb;
    const languageFile = this._resolveLocaleFile(directory, locale);
    const serializedLocale = JSON.stringify(this.cache[locale], null, 2);
    shim2.fs.writeFile(languageFile, serializedLocale, "utf-8", function(err) {
      _this.writeQueue.shift();
      if (_this.writeQueue.length > 0)
        _this._processWriteQueue();
      cb(err);
    });
  }
  _readLocaleFile() {
    let localeLookup = {};
    const languageFile = this._resolveLocaleFile(this.directory, this.locale);
    try {
      if (shim2.fs.readFileSync) {
        localeLookup = JSON.parse(shim2.fs.readFileSync(languageFile, "utf-8"));
      }
    } catch (err) {
      if (err instanceof SyntaxError) {
        err.message = "syntax error in " + languageFile;
      }
      if (err.code === "ENOENT")
        localeLookup = {};
      else
        throw err;
    }
    this.cache[this.locale] = localeLookup;
  }
  _resolveLocaleFile(directory, locale) {
    let file = shim2.resolve(directory, "./", locale + ".json");
    if (this.fallbackToLanguage && !this._fileExistsSync(file) && ~locale.lastIndexOf("_")) {
      const languageFile = shim2.resolve(directory, "./", locale.split("_")[0] + ".json");
      if (this._fileExistsSync(languageFile))
        file = languageFile;
    }
    return file;
  }
  _fileExistsSync(file) {
    return shim2.exists(file);
  }
};
__name(Y18N, "Y18N");
function y18n(opts, _shim) {
  shim2 = _shim;
  const y18n3 = new Y18N(opts);
  return {
    __: y18n3.__.bind(y18n3),
    __n: y18n3.__n.bind(y18n3),
    setLocale: y18n3.setLocale.bind(y18n3),
    getLocale: y18n3.getLocale.bind(y18n3),
    updateLocale: y18n3.updateLocale.bind(y18n3),
    locale: y18n3.locale
  };
}
__name(y18n, "y18n");

// ../../node_modules/.pnpm/y18n@5.0.8/node_modules/y18n/index.mjs
var y18n2 = /* @__PURE__ */ __name((opts) => {
  return y18n(opts, node_default);
}, "y18n");
var y18n_default = y18n2;

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/lib/platform-shims/esm.mjs
var REQUIRE_ERROR = "require is not supported by ESM";
var REQUIRE_DIRECTORY_ERROR = "loading a directory of commands is not supported yet for ESM";
var __dirname2;
try {
  __dirname2 = (0, import_url.fileURLToPath)(import_meta_url);
} catch (e3) {
  __dirname2 = process.cwd();
}
var mainFilename = __dirname2.substring(0, __dirname2.lastIndexOf("node_modules"));
var esm_default = {
  assert: {
    notStrictEqual: import_assert.notStrictEqual,
    strictEqual: import_assert.strictEqual
  },
  cliui: ui,
  findUp: sync_default,
  getEnv: (key) => {
    return process.env[key];
  },
  inspect: import_util3.inspect,
  getCallerFile: () => {
    throw new YError(REQUIRE_DIRECTORY_ERROR);
  },
  getProcessArgvBin,
  mainFilename: mainFilename || process.cwd(),
  Parser: lib_default,
  path: {
    basename: import_path4.basename,
    dirname: import_path4.dirname,
    extname: import_path4.extname,
    relative: import_path4.relative,
    resolve: import_path4.resolve
  },
  process: {
    argv: () => process.argv,
    cwd: process.cwd,
    emitWarning: (warning, type) => process.emitWarning(warning, type),
    execPath: () => process.execPath,
    exit: process.exit,
    nextTick: process.nextTick,
    stdColumns: typeof process.stdout.columns !== "undefined" ? process.stdout.columns : null
  },
  readFileSync: import_fs4.readFileSync,
  require: () => {
    throw new YError(REQUIRE_ERROR);
  },
  requireDirectory: () => {
    throw new YError(REQUIRE_DIRECTORY_ERROR);
  },
  stringWidth: (str) => {
    return [...str].length;
  },
  y18n: y18n_default({
    directory: (0, import_path4.resolve)(__dirname2, "../../../locales"),
    updateFiles: false
  })
};

// src/api/index.ts
init_import_meta_url();

// src/api/dev.ts
init_import_meta_url();
var import_undici25 = __toESM(require_undici());

// src/dev.tsx
init_import_meta_url();
var import_node_path56 = __toESM(require("node:path"));
var import_env2 = __toESM(require_dist());
var import_chokidar5 = require("chokidar");

// ../../node_modules/.pnpm/get-port@6.1.2/node_modules/get-port/index.js
init_import_meta_url();
var import_node_net = __toESM(require("node:net"), 1);
var import_node_os = __toESM(require("node:os"), 1);
var Locked = class extends Error {
  constructor(port2) {
    super(`${port2} is locked`);
  }
};
__name(Locked, "Locked");
var lockedPorts = {
  old: /* @__PURE__ */ new Set(),
  young: /* @__PURE__ */ new Set()
};
var releaseOldLockedPortsIntervalMs = 1e3 * 15;
var interval;
var getLocalHosts = /* @__PURE__ */ __name(() => {
  const interfaces = import_node_os.default.networkInterfaces();
  const results = /* @__PURE__ */ new Set([void 0, "0.0.0.0"]);
  for (const _interface of Object.values(interfaces)) {
    for (const config of _interface) {
      results.add(config.address);
    }
  }
  return results;
}, "getLocalHosts");
var checkAvailablePort = /* @__PURE__ */ __name((options29) => new Promise((resolve19, reject) => {
  const server = import_node_net.default.createServer();
  server.unref();
  server.on("error", reject);
  server.listen(options29, () => {
    const { port: port2 } = server.address();
    server.close(() => {
      resolve19(port2);
    });
  });
}), "checkAvailablePort");
var getAvailablePort = /* @__PURE__ */ __name(async (options29, hosts) => {
  if (options29.host || options29.port === 0) {
    return checkAvailablePort(options29);
  }
  for (const host of hosts) {
    try {
      await checkAvailablePort({ port: options29.port, host });
    } catch (error2) {
      if (!["EADDRNOTAVAIL", "EINVAL"].includes(error2.code)) {
        throw error2;
      }
    }
  }
  return options29.port;
}, "getAvailablePort");
var portCheckSequence = /* @__PURE__ */ __name(function* (ports) {
  if (ports) {
    yield* ports;
  }
  yield 0;
}, "portCheckSequence");
async function getPorts(options29) {
  let ports;
  let exclude = /* @__PURE__ */ new Set();
  if (options29) {
    if (options29.port) {
      ports = typeof options29.port === "number" ? [options29.port] : options29.port;
    }
    if (options29.exclude) {
      const excludeIterable = options29.exclude;
      if (typeof excludeIterable[Symbol.iterator] !== "function") {
        throw new TypeError("The `exclude` option must be an iterable.");
      }
      for (const element of excludeIterable) {
        if (typeof element !== "number") {
          throw new TypeError("Each item in the `exclude` option must be a number corresponding to the port you want excluded.");
        }
        if (!Number.isSafeInteger(element)) {
          throw new TypeError(`Number ${element} in the exclude option is not a safe integer and can't be used`);
        }
      }
      exclude = new Set(excludeIterable);
    }
  }
  if (interval === void 0) {
    interval = setInterval(() => {
      lockedPorts.old = lockedPorts.young;
      lockedPorts.young = /* @__PURE__ */ new Set();
    }, releaseOldLockedPortsIntervalMs);
    if (interval.unref) {
      interval.unref();
    }
  }
  const hosts = getLocalHosts();
  for (const port2 of portCheckSequence(ports)) {
    try {
      if (exclude.has(port2)) {
        continue;
      }
      let availablePort = await getAvailablePort({ ...options29, port: port2 }, hosts);
      while (lockedPorts.old.has(availablePort) || lockedPorts.young.has(availablePort)) {
        if (port2 !== 0) {
          throw new Locked(port2);
        }
        availablePort = await getAvailablePort({ ...options29, port: port2 }, hosts);
      }
      lockedPorts.young.add(availablePort);
      return availablePort;
    } catch (error2) {
      if (!["EADDRINUSE", "EACCES"].includes(error2.code) && !(error2 instanceof Locked)) {
        throw error2;
      }
    }
  }
  throw new Error("No available ports found");
}
__name(getPorts, "getPorts");

// src/dev.tsx
var import_ink14 = __toESM(require_build2());
var import_react20 = __toESM(require_react());

// src/config/index.ts
init_import_meta_url();
var import_node_fs4 = __toESM(require("node:fs"));
var import_dotenv = __toESM(require_main2());

// ../../node_modules/.pnpm/find-up@6.3.0/node_modules/find-up/index.js
init_import_meta_url();
var import_node_path2 = __toESM(require("node:path"), 1);
var import_node_url2 = require("node:url");

// ../../node_modules/.pnpm/locate-path@7.1.0/node_modules/locate-path/index.js
init_import_meta_url();
var import_node_process = __toESM(require("node:process"), 1);
var import_node_path = __toESM(require("node:path"), 1);
var import_node_fs = __toESM(require("node:fs"), 1);
var import_node_url = require("node:url");

// ../../node_modules/.pnpm/p-locate@6.0.0/node_modules/p-locate/index.js
init_import_meta_url();

// ../../node_modules/.pnpm/p-limit@4.0.0/node_modules/p-limit/index.js
init_import_meta_url();

// ../../node_modules/.pnpm/yocto-queue@1.0.0/node_modules/yocto-queue/index.js
init_import_meta_url();
var Node2 = class {
  value;
  next;
  constructor(value) {
    this.value = value;
  }
};
__name(Node2, "Node");
var Queue = class {
  #head;
  #tail;
  #size;
  constructor() {
    this.clear();
  }
  enqueue(value) {
    const node2 = new Node2(value);
    if (this.#head) {
      this.#tail.next = node2;
      this.#tail = node2;
    } else {
      this.#head = node2;
      this.#tail = node2;
    }
    this.#size++;
  }
  dequeue() {
    const current = this.#head;
    if (!current) {
      return;
    }
    this.#head = this.#head.next;
    this.#size--;
    return current.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;
    }
  }
};
__name(Queue, "Queue");

// ../../node_modules/.pnpm/p-limit@4.0.0/node_modules/p-limit/index.js
function pLimit(concurrency) {
  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
  }
  const queue = new Queue();
  let activeCount = 0;
  const next = /* @__PURE__ */ __name(() => {
    activeCount--;
    if (queue.size > 0) {
      queue.dequeue()();
    }
  }, "next");
  const run = /* @__PURE__ */ __name(async (fn2, resolve19, args) => {
    activeCount++;
    const result = (async () => fn2(...args))();
    resolve19(result);
    try {
      await result;
    } catch {
    }
    next();
  }, "run");
  const enqueue = /* @__PURE__ */ __name((fn2, resolve19, args) => {
    queue.enqueue(run.bind(void 0, fn2, resolve19, args));
    (async () => {
      await Promise.resolve();
      if (activeCount < concurrency && queue.size > 0) {
        queue.dequeue()();
      }
    })();
  }, "enqueue");
  const generator = /* @__PURE__ */ __name((fn2, ...args) => new Promise((resolve19) => {
    enqueue(fn2, resolve19, args);
  }), "generator");
  Object.defineProperties(generator, {
    activeCount: {
      get: () => activeCount
    },
    pendingCount: {
      get: () => queue.size
    },
    clearQueue: {
      value: () => {
        queue.clear();
      }
    }
  });
  return generator;
}
__name(pLimit, "pLimit");

// ../../node_modules/.pnpm/p-locate@6.0.0/node_modules/p-locate/index.js
var EndError = class extends Error {
  constructor(value) {
    super();
    this.value = value;
  }
};
__name(EndError, "EndError");
var testElement = /* @__PURE__ */ __name(async (element, tester) => tester(await element), "testElement");
var finder = /* @__PURE__ */ __name(async (element) => {
  const values = await Promise.all(element);
  if (values[1] === true) {
    throw new EndError(values[0]);
  }
  return false;
}, "finder");
async function pLocate(iterable, tester, {
  concurrency = Number.POSITIVE_INFINITY,
  preserveOrder = true
} = {}) {
  const limit = pLimit(concurrency);
  const items = [...iterable].map((element) => [element, limit(testElement, element, tester)]);
  const checkLimit = pLimit(preserveOrder ? 1 : Number.POSITIVE_INFINITY);
  try {
    await Promise.all(items.map((element) => checkLimit(finder, element)));
  } catch (error2) {
    if (error2 instanceof EndError) {
      return error2.value;
    }
    throw error2;
  }
}
__name(pLocate, "pLocate");

// ../../node_modules/.pnpm/locate-path@7.1.0/node_modules/locate-path/index.js
var typeMappings = {
  directory: "isDirectory",
  file: "isFile"
};
function checkType(type) {
  if (type in typeMappings) {
    return;
  }
  throw new Error(`Invalid type specified: ${type}`);
}
__name(checkType, "checkType");
var matchType = /* @__PURE__ */ __name((type, stat4) => type === void 0 || stat4[typeMappings[type]](), "matchType");
var toPath = /* @__PURE__ */ __name((urlOrPath) => urlOrPath instanceof URL ? (0, import_node_url.fileURLToPath)(urlOrPath) : urlOrPath, "toPath");
async function locatePath(paths, {
  cwd: cwd2 = import_node_process.default.cwd(),
  type = "file",
  allowSymlinks = true,
  concurrency,
  preserveOrder
} = {}) {
  checkType(type);
  cwd2 = toPath(cwd2);
  const statFunction = allowSymlinks ? import_node_fs.promises.stat : import_node_fs.promises.lstat;
  return pLocate(paths, async (path_) => {
    try {
      const stat4 = await statFunction(import_node_path.default.resolve(cwd2, path_));
      return matchType(type, stat4);
    } catch {
      return false;
    }
  }, { concurrency, preserveOrder });
}
__name(locatePath, "locatePath");
function locatePathSync(paths, {
  cwd: cwd2 = import_node_process.default.cwd(),
  type = "file",
  allowSymlinks = true
} = {}) {
  checkType(type);
  cwd2 = toPath(cwd2);
  const statFunction = allowSymlinks ? import_node_fs.default.statSync : import_node_fs.default.lstatSync;
  for (const path_ of paths) {
    try {
      const stat4 = statFunction(import_node_path.default.resolve(cwd2, path_));
      if (matchType(type, stat4)) {
        return path_;
      }
    } catch {
    }
  }
}
__name(locatePathSync, "locatePathSync");

// ../../node_modules/.pnpm/path-exists@5.0.0/node_modules/path-exists/index.js
init_import_meta_url();

// ../../node_modules/.pnpm/find-up@6.3.0/node_modules/find-up/index.js
var toPath2 = /* @__PURE__ */ __name((urlOrPath) => urlOrPath instanceof URL ? (0, import_node_url2.fileURLToPath)(urlOrPath) : urlOrPath, "toPath");
var findUpStop = Symbol("findUpStop");
async function findUpMultiple(name, options29 = {}) {
  let directory = import_node_path2.default.resolve(toPath2(options29.cwd) || "");
  const { root } = import_node_path2.default.parse(directory);
  const stopAt = import_node_path2.default.resolve(directory, options29.stopAt || root);
  const limit = options29.limit || Number.POSITIVE_INFINITY;
  const paths = [name].flat();
  const runMatcher = /* @__PURE__ */ __name(async (locateOptions) => {
    if (typeof name !== "function") {
      return locatePath(paths, locateOptions);
    }
    const foundPath = await name(locateOptions.cwd);
    if (typeof foundPath === "string") {
      return locatePath([foundPath], locateOptions);
    }
    return foundPath;
  }, "runMatcher");
  const matches = [];
  while (true) {
    const foundPath = await runMatcher({ ...options29, cwd: directory });
    if (foundPath === findUpStop) {
      break;
    }
    if (foundPath) {
      matches.push(import_node_path2.default.resolve(directory, foundPath));
    }
    if (directory === stopAt || matches.length >= limit) {
      break;
    }
    directory = import_node_path2.default.dirname(directory);
  }
  return matches;
}
__name(findUpMultiple, "findUpMultiple");
function findUpMultipleSync(name, options29 = {}) {
  let directory = import_node_path2.default.resolve(toPath2(options29.cwd) || "");
  const { root } = import_node_path2.default.parse(directory);
  const stopAt = options29.stopAt || root;
  const limit = options29.limit || Number.POSITIVE_INFINITY;
  const paths = [name].flat();
  const runMatcher = /* @__PURE__ */ __name((locateOptions) => {
    if (typeof name !== "function") {
      return locatePathSync(paths, locateOptions);
    }
    const foundPath = name(locateOptions.cwd);
    if (typeof foundPath === "string") {
      return locatePathSync([foundPath], locateOptions);
    }
    return foundPath;
  }, "runMatcher");
  const matches = [];
  while (true) {
    const foundPath = runMatcher({ ...options29, cwd: directory });
    if (foundPath === findUpStop) {
      break;
    }
    if (foundPath) {
      matches.push(import_node_path2.default.resolve(directory, foundPath));
    }
    if (directory === stopAt || matches.length >= limit) {
      break;
    }
    directory = import_node_path2.default.dirname(directory);
  }
  return matches;
}
__name(findUpMultipleSync, "findUpMultipleSync");
async function findUp(name, options29 = {}) {
  const matches = await findUpMultiple(name, { ...options29, limit: 1 });
  return matches[0];
}
__name(findUp, "findUp");
function findUpSync(name, options29 = {}) {
  const matches = findUpMultipleSync(name, { ...options29, limit: 1 });
  return matches[0];
}
__name(findUpSync, "findUpSync");

// src/errors.ts
init_import_meta_url();
var UserError = class extends Error {
  constructor(...args) {
    super(...args);
    Object.setPrototypeOf(this, new.target.prototype);
  }
};
__name(UserError, "UserError");
var DeprecationError = class extends UserError {
  constructor(message) {
    super(`Deprecation:
${message}`);
  }
};
__name(DeprecationError, "DeprecationError");
var FatalError = class extends UserError {
  constructor(message, code) {
    super(message);
    this.code = code;
  }
};
__name(FatalError, "FatalError");
var JsonFriendlyFatalError = class extends FatalError {
  constructor(message, code) {
    super(message);
    this.code = code;
  }
};
__name(JsonFriendlyFatalError, "JsonFriendlyFatalError");
function createFatalError(message, isJson, code) {
  if (isJson) {
    return new JsonFriendlyFatalError(JSON.stringify(message), code);
  } else {
    return new FatalError(`${message}`, code);
  }
}
__name(createFatalError, "createFatalError");

// src/logger.ts
init_import_meta_url();
var import_node_util = require("node:util");
var import_chalk = __toESM(require_chalk());
var import_cli_table3 = __toESM(require_cli_table3());
var import_esbuild = require("esbuild");

// src/environment-variables/factory.ts
init_import_meta_url();
function getEnvironmentVariableFactory({
  variableName,
  deprecatedName,
  defaultValue
}) {
  let hasWarned = false;
  return () => {
    if (process.env[variableName]) {
      return process.env[variableName];
    } else if (deprecatedName && process.env[deprecatedName]) {
      if (!hasWarned) {
        hasWarned = true;
        logger.warn(
          `Using "${deprecatedName}" environment variable. This is deprecated. Please use "${variableName}", instead.`
        );
      }
      return process.env[deprecatedName];
    } else {
      return defaultValue?.();
    }
  };
}
__name(getEnvironmentVariableFactory, "getEnvironmentVariableFactory");

// src/environment-variables/misc-variables.ts
init_import_meta_url();
var getC3CommandFromEnv = getEnvironmentVariableFactory({
  variableName: "WRANGLER_C3_COMMAND",
  defaultValue: () => "create cloudflare@2.5.0"
});
var getWranglerSendMetricsFromEnv = getEnvironmentVariableFactory({
  variableName: "WRANGLER_SEND_METRICS"
});
var getCloudflareApiEnvironmentFromEnv = getEnvironmentVariableFactory(
  {
    variableName: "WRANGLER_API_ENVIRONMENT",
    defaultValue: () => "production"
  }
);
var getCloudflareApiBaseUrl = getEnvironmentVariableFactory({
  variableName: "CLOUDFLARE_API_BASE_URL",
  deprecatedName: "CF_API_BASE_URL",
  defaultValue: () => getCloudflareApiEnvironmentFromEnv() === "staging" ? "https://api.staging.cloudflare.com/client/v4" : "https://api.cloudflare.com/client/v4"
});
var getSanitizeLogs = getEnvironmentVariableFactory({
  variableName: "WRANGLER_LOG_SANITIZE",
  defaultValue() {
    return "true";
  }
});

// src/utils/log-file.ts
init_import_meta_url();
var import_promises = require("node:fs/promises");
var import_node_path4 = __toESM(require("node:path"));
var import_miniflare = require("miniflare");
var import_signal_exit = __toESM(require_signal_exit());

// src/global-wrangler-config-path.ts
init_import_meta_url();
var import_node_fs2 = __toESM(require("node:fs"));
var import_node_os2 = __toESM(require("node:os"));
var import_node_path3 = __toESM(require("node:path"));

// ../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/esm-wrapper/mod.esm.js
var mod_esm_exports = {};
__export(mod_esm_exports, {
  default: () => mod_esm_default
});
init_import_meta_url();
var import_mod_cjs = __toESM(require_mod_cjs3(), 1);
__reExport(mod_esm_exports, __toESM(require_mod_cjs3(), 1));
var mod_esm_default = import_mod_cjs.default;

// src/global-wrangler-config-path.ts
function isDirectory(configPath) {
  try {
    return import_node_fs2.default.statSync(configPath).isDirectory();
  } catch (error2) {
    return false;
  }
}
__name(isDirectory, "isDirectory");
function getGlobalWranglerConfigPath() {
  const configDir = mod_esm_default(".wrangler").config();
  const legacyConfigDir = import_node_path3.default.join(import_node_os2.default.homedir(), ".wrangler");
  if (isDirectory(legacyConfigDir)) {
    return legacyConfigDir;
  } else {
    return configDir;
  }
}
__name(getGlobalWranglerConfigPath, "getGlobalWranglerConfigPath");

// src/utils/log-file.ts
var getDebugFileDir = getEnvironmentVariableFactory({
  variableName: "WRANGLER_LOG_PATH",
  defaultValue() {
    const gobalWranglerConfigDir = getGlobalWranglerConfigPath();
    return import_node_path4.default.join(gobalWranglerConfigDir, "logs");
  }
});
function getDebugFilepath() {
  const dir = getDebugFileDir();
  const date = (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-").replace(".", "_").replace("T", "_").replace("Z", "");
  const filepath = dir.endsWith(".log") ? dir : import_node_path4.default.join(dir, `wrangler-${date}.log`);
  return import_node_path4.default.resolve(filepath);
}
__name(getDebugFilepath, "getDebugFilepath");
async function ensureDirectoryExists(filepath) {
  const dirpath = import_node_path4.default.dirname(filepath);
  await (0, import_promises.mkdir)(dirpath, { recursive: true });
}
__name(ensureDirectoryExists, "ensureDirectoryExists");
var debugLogFilepath = getDebugFilepath();
var mutex = new import_miniflare.Mutex();
var hasLoggedLocation = false;
var hasLoggedError = false;
var hasSeenErrorMessage = false;
async function appendToDebugLogFile(messageLevel, message) {
  const entry = `
--- ${(/* @__PURE__ */ new Date()).toISOString()} ${messageLevel}
${message}
---
`;
  if (!hasLoggedLocation) {
    hasLoggedLocation = true;
    logger.debug(`\u{1FAB5}  Writing logs to "${debugLogFilepath}"`);
    (0, import_signal_exit.default)(() => {
      if (hasSeenErrorMessage) {
        console.warn(`\u{1FAB5}  Logs were written to "${debugLogFilepath}"`);
      }
    });
  }
  if (!hasSeenErrorMessage) {
    hasSeenErrorMessage = messageLevel === "error";
  }
  await mutex.runWith(async () => {
    try {
      await ensureDirectoryExists(debugLogFilepath);
      await (0, import_promises.appendFile)(debugLogFilepath, entry);
    } catch (err) {
      if (!hasLoggedError) {
        hasLoggedError = true;
        logger.error(`Failed to write to log file`, err);
        logger.error(`Would have written:`, entry);
      }
    }
  });
}
__name(appendToDebugLogFile, "appendToDebugLogFile");

// src/logger.ts
var LOGGER_LEVELS = {
  none: -1,
  error: 0,
  warn: 1,
  info: 2,
  log: 3,
  debug: 4
};
var LOGGER_LEVEL_FORMAT_TYPE_MAP = {
  error: "error",
  warn: "warning",
  info: void 0,
  log: void 0,
  debug: void 0
};
var getLogLevelFromEnv = getEnvironmentVariableFactory({
  variableName: "WRANGLER_LOG"
});
function getLoggerLevel() {
  const fromEnv = getLogLevelFromEnv()?.toLowerCase();
  if (fromEnv !== void 0) {
    if (fromEnv in LOGGER_LEVELS)
      return fromEnv;
    const expected = Object.keys(LOGGER_LEVELS).map((level) => `"${level}"`).join(" | ");
    console.warn(
      `Unrecognised WRANGLER_LOG value ${JSON.stringify(
        fromEnv
      )}, expected ${expected}, defaulting to "log"...`
    );
  }
  return "log";
}
__name(getLoggerLevel, "getLoggerLevel");
var Logger = class {
  constructor() {
  }
  loggerLevel = getLoggerLevel();
  columns = process.stdout.columns;
  debug = (...args) => this.doLog("debug", args);
  debugWithSanitization = (label, ...args) => {
    if (getSanitizeLogs() === "false") {
      this.doLog("debug", [label, ...args]);
    } else {
      this.doLog("debug", [
        label,
        "omitted; set WRANGLER_LOG_SANITIZE=false to include sanitized data"
      ]);
    }
  };
  info = (...args) => this.doLog("info", args);
  log = (...args) => this.doLog("log", args);
  warn = (...args) => this.doLog("warn", args);
  error = (...args) => this.doLog("error", args);
  table(data) {
    const keys = data.length === 0 ? [] : Object.keys(data[0]);
    const t3 = new import_cli_table3.default({
      head: keys,
      style: {
        head: import_chalk.default.level ? ["blue"] : [],
        border: import_chalk.default.level ? ["gray"] : []
      }
    });
    t3.push(...data.map((row) => keys.map((k2) => row[k2])));
    return this.doLog("log", [t3.toString()]);
  }
  doLog(messageLevel, args) {
    const message = this.formatMessage(messageLevel, (0, import_node_util.format)(...args));
    const inUnitTests = typeof jest !== "undefined";
    if (!inUnitTests) {
      void appendToDebugLogFile(messageLevel, message);
    }
    if (LOGGER_LEVELS[this.loggerLevel] >= LOGGER_LEVELS[messageLevel]) {
      console[messageLevel](message);
    }
  }
  formatMessage(level, message) {
    const kind = LOGGER_LEVEL_FORMAT_TYPE_MAP[level];
    if (kind) {
      const [firstLine, ...otherLines] = message.split("\n");
      const notes = otherLines.length > 0 ? otherLines.map((text) => ({ text })) : void 0;
      return (0, import_esbuild.formatMessagesSync)([{ text: firstLine, notes }], {
        color: true,
        kind,
        terminalWidth: this.columns
      })[0];
    } else {
      return message;
    }
  }
};
__name(Logger, "Logger");
var logger = new Logger();
function logBuildWarnings(warnings) {
  const logs = (0, import_esbuild.formatMessagesSync)(warnings, { kind: "warning", color: true });
  for (const log2 of logs)
    console.warn(log2);
}
__name(logBuildWarnings, "logBuildWarnings");
function logBuildFailure(errors, warnings) {
  const logs = (0, import_esbuild.formatMessagesSync)(errors, { kind: "error", color: true });
  for (const log2 of logs)
    console.error(log2);
  logBuildWarnings(warnings);
}
__name(logBuildFailure, "logBuildFailure");

// src/pages/errors.ts
init_import_meta_url();

// src/pages/constants.ts
init_import_meta_url();

// package.json
var version = "3.55.0";
var package_default = {
  name: "wrangler",
  version,
  description: "Command-line interface for all things Cloudflare Workers",
  keywords: [
    "wrangler",
    "cloudflare",
    "workers",
    "cloudflare workers",
    "edge",
    "compute",
    "serverless",
    "serverless application",
    "serverless module",
    "wasm",
    "web",
    "assembly",
    "webassembly",
    "rust",
    "emscripten",
    "typescript",
    "graphql",
    "router",
    "http",
    "cli"
  ],
  homepage: "https://github.com/cloudflare/workers-sdk#readme",
  bugs: {
    url: "https://github.com/cloudflare/workers-sdk/issues"
  },
  repository: {
    type: "git",
    url: "https://github.com/cloudflare/workers-sdk.git",
    directory: "packages/wrangler"
  },
  license: "MIT OR Apache-2.0",
  author: "wrangler@cloudflare.com",
  main: "wrangler-dist/cli.js",
  types: "wrangler-dist/cli.d.ts",
  bin: {
    wrangler: "./bin/wrangler.js",
    wrangler2: "./bin/wrangler.js"
  },
  files: [
    "bin",
    "miniflare-dist",
    "wrangler-dist",
    "templates",
    "kv-asset-handler.js",
    "Cloudflare_CA.pem",
    "config-schema.json"
  ],
  scripts: {
    "assert-git-version": "node -r esbuild-register scripts/assert-git-version.ts",
    build: "pnpm run clean && pnpm run bundle && pnpm run emit-types && pnpm run generate-json-schema",
    bundle: "node -r esbuild-register scripts/bundle.ts",
    "check:lint": "eslint .",
    "check:type": "tsc",
    clean: "rimraf wrangler-dist miniflare-dist emitted-types",
    dev: 'pnpm run clean && concurrently -c black,blue --kill-others-on-fail false "pnpm run bundle --watch" "pnpm run check:type --watch --preserveWatchOutput"',
    "emit-types": "tsc -p tsconfig.emit.json && node -r esbuild-register scripts/emit-types.ts",
    "generate-json-schema": "pnpm exec ts-json-schema-generator --no-type-check --path src/config/config.ts --type RawConfig --out config-schema.json",
    prepublishOnly: "SOURCEMAPS=false pnpm run -w build",
    start: "pnpm run bundle && cross-env NODE_OPTIONS=--enable-source-maps ./bin/wrangler.js",
    test: "pnpm run assert-git-version && jest",
    "test:ci": "pnpm run test",
    "test:debug": "pnpm run test --silent=false --verbose=true",
    "test:e2e": "vitest -c ./e2e/vitest.config.ts",
    "test:watch": "pnpm run test --testTimeout=50000 --watch",
    "type:tests": "tsc -p ./src/__tests__/tsconfig.json && tsc -p ./e2e/tsconfig.json"
  },
  jest: {
    moduleNameMapper: {
      clipboardy: "<rootDir>/src/__tests__/helpers/clipboardy-mock.js",
      "miniflare/cli": "<rootDir>/../../node_modules/miniflare/dist/src/cli.js"
    },
    restoreMocks: true,
    setupFilesAfterEnv: [
      "<rootDir>/src/__tests__/jest.setup.ts"
    ],
    testRegex: "src/__tests__/.*\\.(test|spec)\\.[jt]sx?$",
    testTimeout: 5e4,
    transform: {
      "^.+\\.c?(t|j)sx?$": [
        "esbuild-jest",
        {
          sourcemap: true
        }
      ]
    },
    transformIgnorePatterns: [
      "node_modules/.pnpm/(?!find-up|locate-path|p-locate|p-limit|p-timeout|p-queue|yocto-queue|path-exists|execa|strip-final-newline|npm-run-path|path-key|onetime|mimic-fn|human-signals|is-stream|get-port|supports-color|pretty-bytes|strip-ansi|ansi-regex)"
    ],
    snapshotFormat: {
      escapeString: true,
      printBasicPrototype: true
    }
  },
  dependencies: {
    "@cloudflare/kv-asset-handler": "workspace:*",
    "@esbuild-plugins/node-globals-polyfill": "^0.2.3",
    "@esbuild-plugins/node-modules-polyfill": "^0.2.2",
    "blake3-wasm": "^2.1.5",
    chokidar: "^3.5.3",
    esbuild: "0.17.19",
    miniflare: "workspace:*",
    nanoid: "^3.3.3",
    "path-to-regexp": "^6.2.0",
    resolve: "^1.22.8",
    "resolve.exports": "^2.0.2",
    selfsigned: "^2.0.1",
    "source-map": "0.6.1",
    "xxhash-wasm": "^1.0.1"
  },
  devDependencies: {
    "@cloudflare/cli": "workspace:*",
    "@cloudflare/eslint-config-worker": "*",
    "@cloudflare/pages-shared": "workspace:^",
    "@cloudflare/types": "^6.18.4",
    "@cloudflare/workers-tsconfig": "workspace:*",
    "@cloudflare/workers-types": "^4.20240419.0",
    "@cspotcode/source-map-support": "0.8.1",
    "@iarna/toml": "^3.0.0",
    "@microsoft/api-extractor": "^7.28.3",
    "@sentry/node": "^7.86.0",
    "@sentry/types": "^7.86.0",
    "@sentry/utils": "^7.86.0",
    "@types/body-parser": "^1.19.2",
    "@types/command-exists": "^1.2.0",
    "@types/express": "^4.17.13",
    "@types/glob-to-regexp": "0.4.1",
    "@types/is-ci": "^3.0.0",
    "@types/javascript-time-ago": "^2.0.3",
    "@types/jest": "^29.5.5",
    "@types/mime": "^2.0.3",
    "@types/minimatch": "^5.1.2",
    "@types/prompts": "^2.0.14",
    "@types/react": "^17.0.37",
    "@types/resolve": "^1.20.6",
    "@types/serve-static": "^1.13.10",
    "@types/shell-quote": "^1.7.2",
    "@types/signal-exit": "^3.0.1",
    "@types/supports-color": "^8.1.1",
    "@types/ws": "^8.5.3",
    "@types/yargs": "^17.0.10",
    "@webcontainer/env": "^1.1.0",
    "body-parser": "^1.20.0",
    chalk: "^2.4.2",
    "cli-table3": "^0.6.3",
    clipboardy: "^3.0.0",
    "cmd-shim": "^4.1.0",
    "command-exists": "^1.2.9",
    concurrently: "^7.2.2",
    "devtools-protocol": "^0.0.955664",
    dotenv: "^16.0.0",
    "es-module-lexer": "^1.3.0",
    "esbuild-jest": "0.5.0",
    execa: "^6.1.0",
    express: "^4.18.1",
    "find-up": "^6.3.0",
    "get-port": "^6.1.2",
    "glob-to-regexp": "0.4.1",
    "http-terminator": "^3.2.0",
    "https-proxy-agent": "7.0.2",
    ignore: "^5.2.0",
    ink: "^3.2.0",
    "ink-select-input": "^4.2.1",
    "ink-spinner": "^4.0.3",
    "ink-table": "^3.0.0",
    "is-ci": "^3.0.1",
    "javascript-time-ago": "^2.5.4",
    jest: "^29.7.0",
    "jest-fetch-mock": "^3.0.3",
    "jest-websocket-mock": "^2.5.0",
    mime: "^3.0.0",
    minimatch: "^5.1.0",
    msw: "^0.49.1",
    open: "^8.4.0",
    "p-queue": "^7.2.0",
    "patch-console": "^1.0.0",
    "pretty-bytes": "^6.0.0",
    prompts: "^2.4.2",
    react: "^17.0.2",
    "react-error-boundary": "^3.1.4",
    semiver: "^1.1.0",
    "serve-static": "^1.15.0",
    "shell-quote": "^1.8.1",
    shellac: "^0.8.0",
    "signal-exit": "^3.0.7",
    "strip-ansi": "^7.0.1",
    "supports-color": "^9.2.2",
    "timeago.js": "^4.0.2",
    "ts-dedent": "^2.2.0",
    "ts-json-schema-generator": "^1.5.0",
    undici: "5.28.3",
    "update-check": "^1.5.4",
    ws: "^8.5.0",
    "xdg-app-paths": "^8.3.0",
    yargs: "^17.7.2",
    "yoga-layout": "file:../../vendor/yoga-layout-2.0.0-beta.1.tgz"
  },
  optionalDependencies: {
    fsevents: "~2.3.2"
  },
  peerDependencies: {
    "@cloudflare/workers-types": "^4.20240419.0"
  },
  peerDependenciesMeta: {
    "@cloudflare/workers-types": {
      optional: true
    }
  },
  engines: {
    node: ">=16.17.0"
  },
  "workers-sdk": {
    prerelease: true
  }
};

// src/pages/constants.ts
var MAX_ASSET_COUNT = 2e4;
var MAX_ASSET_SIZE = 25 * 1024 * 1024;
var PAGES_CONFIG_CACHE_FILENAME = "pages.json";
var MAX_BUCKET_SIZE = 50 * 1024 * 1024;
var MAX_BUCKET_FILE_COUNT = 5e3;
var BULK_UPLOAD_CONCURRENCY = 3;
var MAX_UPLOAD_ATTEMPTS = 5;
var MAX_DEPLOYMENT_ATTEMPTS = 3;
var MAX_CHECK_MISSING_ATTEMPTS = 5;
var SECONDS_TO_WAIT_FOR_PROXY = 5;
var isInPagesCI = !!process.env.CF_PAGES;
var MAX_FUNCTIONS_ROUTES_RULES = 100;
var MAX_FUNCTIONS_ROUTES_RULE_LENGTH = 100;
var ROUTES_SPEC_VERSION = 1;
var ROUTES_SPEC_DESCRIPTION = `Generated by wrangler@${version}`;

// src/pages/functions/routes-validation.ts
init_import_meta_url();
function isRoutesJSONSpec(data) {
  return typeof data === "object" && data && "version" in data && typeof data.version === "number" && data.version === ROUTES_SPEC_VERSION && Array.isArray(data.include) && Array.isArray(data.exclude) || false;
}
__name(isRoutesJSONSpec, "isRoutesJSONSpec");
function validateRoutes(routesJSON, routesPath) {
  if (!isRoutesJSONSpec(routesJSON)) {
    throw new FatalError(
      getRoutesValidationErrorMessage(
        0 /* INVALID_JSON_SPEC */,
        routesPath
      ),
      1
    );
  }
  if (!hasIncludeRules(routesJSON)) {
    throw new FatalError(
      getRoutesValidationErrorMessage(
        1 /* NO_INCLUDE_RULES */,
        routesPath
      ),
      1
    );
  }
  if (!hasValidRulesCount(routesJSON)) {
    throw new FatalError(
      getRoutesValidationErrorMessage(
        3 /* TOO_MANY_RULES */,
        routesPath
      ),
      1
    );
  }
  if (!hasValidRuleCharCount(routesJSON)) {
    throw new FatalError(
      getRoutesValidationErrorMessage(
        4 /* RULE_TOO_LONG */,
        routesPath
      ),
      1
    );
  }
  if (!hasValidRules(routesJSON)) {
    throw new FatalError(
      getRoutesValidationErrorMessage(
        2 /* INVALID_RULES */,
        routesPath
      ),
      1
    );
  }
  if (hasOverlappingRules(routesJSON.include) || hasOverlappingRules(routesJSON.exclude)) {
    throw new FatalError(
      getRoutesValidationErrorMessage(
        5 /* OVERLAPPING_RULES */,
        routesPath
      ),
      1
    );
  }
}
__name(validateRoutes, "validateRoutes");
function hasIncludeRules(routesJSON) {
  if (!routesJSON || !routesJSON.include) {
    throw new Error(
      "Function `hasIncludeRules` was called out of context. Attempting to validate include rules for routes that are undefined or an invalid RoutesJSONSpec"
    );
  }
  return routesJSON?.include?.length > 0;
}
__name(hasIncludeRules, "hasIncludeRules");
function hasValidRulesCount(routesJSON) {
  if (!routesJSON || !routesJSON.include || !routesJSON.exclude) {
    throw new Error(
      "Function `hasValidRulesCount` was called out of context. Attempting to validate maximum rules count for routes that are undefined or an invalid RoutesJSONSpec"
    );
  }
  return routesJSON.include.length + routesJSON.exclude.length <= MAX_FUNCTIONS_ROUTES_RULES;
}
__name(hasValidRulesCount, "hasValidRulesCount");
function hasValidRuleCharCount(routesJSON) {
  if (!routesJSON || !routesJSON.include || !routesJSON.exclude) {
    throw new Error(
      "Function `hasValidRuleCharCount` was called out of context. Attempting to validate rules maximum character count for routes that are undefined or an invalid RoutesJSONSpec"
    );
  }
  const rules = [...routesJSON.include, ...routesJSON.exclude];
  return rules.filter((rule) => rule.length > MAX_FUNCTIONS_ROUTES_RULE_LENGTH).length === 0;
}
__name(hasValidRuleCharCount, "hasValidRuleCharCount");
function hasValidRules(routesJSON) {
  if (!routesJSON || !routesJSON.include || !routesJSON.exclude) {
    throw new Error(
      "Function `hasValidRules` was called out of context. Attempting to validate rules for routes that are undefined or an invalid RoutesJSONSpec"
    );
  }
  const rules = [...routesJSON.include, ...routesJSON.exclude];
  return rules.filter((rule) => !rule.match(/^\//)).length === 0;
}
__name(hasValidRules, "hasValidRules");
function hasOverlappingRules(routes) {
  if (!routes) {
    throw new Error(
      "Function `hasverlappingRules` was called out of context. Attempting to validate rules for routes that are undefined"
    );
  }
  const endingSplatRoutes = routes.filter((route2) => route2.endsWith("/*"));
  for (let i = 0; i < endingSplatRoutes.length; i++) {
    const crrRoute = endingSplatRoutes[i];
    const crrRouteTrimmed = crrRoute.substring(0, crrRoute.length - 1);
    for (let j2 = 0; j2 < routes.length; j2++) {
      const nextRoute = routes[j2];
      if (nextRoute !== crrRoute && nextRoute.startsWith(crrRouteTrimmed)) {
        return true;
      }
    }
  }
  return false;
}
__name(hasOverlappingRules, "hasOverlappingRules");

// src/pages/errors.ts
var EXIT_CODE_FUNCTIONS_NO_ROUTES_ERROR = 156;
var EXIT_CODE_FUNCTIONS_NOTHING_TO_BUILD_ERROR = 157;
var EXIT_CODE_NO_CONFIG_FOUND = 158;
var EXIT_CODE_INVALID_PAGES_CONFIG = 159;
var FunctionsBuildError = class extends UserError {
  constructor(message) {
    super(message);
  }
};
__name(FunctionsBuildError, "FunctionsBuildError");
function getFunctionsBuildWarning(functionsDirectory, suffix) {
  return `Unexpected error building Functions directory: ${functionsDirectory}${suffix ? " - " + suffix : ""}`;
}
__name(getFunctionsBuildWarning, "getFunctionsBuildWarning");
var FunctionsNoRoutesError = class extends UserError {
  constructor(message) {
    super(message);
  }
};
__name(FunctionsNoRoutesError, "FunctionsNoRoutesError");
function getFunctionsNoRoutesWarning(functionsDirectory, suffix) {
  return `No routes found when building Functions directory: ${functionsDirectory}${suffix ? " - " + suffix : ""}`;
}
__name(getFunctionsNoRoutesWarning, "getFunctionsNoRoutesWarning");
function getRoutesValidationErrorMessage(errorCode, routesPath) {
  switch (errorCode) {
    case 1 /* NO_INCLUDE_RULES */:
      return `Invalid _routes.json file found at: ${routesPath}
Routes must have at least 1 include rule, but no include rules were detected.`;
    case 3 /* TOO_MANY_RULES */:
      return `Invalid _routes.json file found at: ${routesPath}
Detected rules that are over the ${MAX_FUNCTIONS_ROUTES_RULES} rule limit. Please make sure you have a total of ${MAX_FUNCTIONS_ROUTES_RULES} include and exclude rules combined.`;
    case 4 /* RULE_TOO_LONG */:
      return `Invalid _routes.json file found at: ${routesPath}
Detected rules the are over the ${MAX_FUNCTIONS_ROUTES_RULE_LENGTH} character limit. Please make sure that each include and exclude routing rule is at most ${MAX_FUNCTIONS_ROUTES_RULE_LENGTH} characters long.`;
    case 2 /* INVALID_RULES */:
      return `Invalid _routes.json file found at: ${routesPath}
All rules must start with '/'.`;
    case 5 /* OVERLAPPING_RULES */:
      return `Invalid _routes.json file found at: ${routesPath}
Overlapping rules found. Please make sure that rules ending with a splat (eg. "/api/*") don't overlap any other rules (eg. "/api/foo"). This applies to both include and exclude rules individually.`;
    case 0 /* INVALID_JSON_SPEC */:
    default:
      return `Invalid _routes.json file found at: ${routesPath}
Please make sure the JSON object has the following format:
{
	version: ${ROUTES_SPEC_VERSION};
	include: string[];
	exclude: string[];
}
and that at least one include rule is provided.
			`;
  }
}
__name(getRoutesValidationErrorMessage, "getRoutesValidationErrorMessage");

// src/parse.ts
init_import_meta_url();
var fs3 = __toESM(require("node:fs"));
var import_node_path5 = require("node:path");
var import_toml = __toESM(require_toml());
var import_esbuild2 = require("esbuild");

// ../../node_modules/.pnpm/jsonc-parser@3.2.0/node_modules/jsonc-parser/lib/esm/main.js
init_import_meta_url();

// ../../node_modules/.pnpm/jsonc-parser@3.2.0/node_modules/jsonc-parser/lib/esm/impl/format.js
init_import_meta_url();

// ../../node_modules/.pnpm/jsonc-parser@3.2.0/node_modules/jsonc-parser/lib/esm/impl/scanner.js
init_import_meta_url();
function createScanner(text, ignoreTrivia = false) {
  const len = text.length;
  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
  function scanHexDigits(count, exact) {
    let digits = 0;
    let value2 = 0;
    while (digits < count || !exact) {
      let ch = text.charCodeAt(pos);
      if (ch >= 48 && ch <= 57) {
        value2 = value2 * 16 + ch - 48;
      } else if (ch >= 65 && ch <= 70) {
        value2 = value2 * 16 + ch - 65 + 10;
      } else if (ch >= 97 && ch <= 102) {
        value2 = value2 * 16 + ch - 97 + 10;
      } else {
        break;
      }
      pos++;
      digits++;
    }
    if (digits < count) {
      value2 = -1;
    }
    return value2;
  }
  __name(scanHexDigits, "scanHexDigits");
  function setPosition(newPosition) {
    pos = newPosition;
    value = "";
    tokenOffset = 0;
    token = 16;
    scanError = 0;
  }
  __name(setPosition, "setPosition");
  function scanNumber() {
    let start = pos;
    if (text.charCodeAt(pos) === 48) {
      pos++;
    } else {
      pos++;
      while (pos < text.length && isDigit2(text.charCodeAt(pos))) {
        pos++;
      }
    }
    if (pos < text.length && text.charCodeAt(pos) === 46) {
      pos++;
      if (pos < text.length && isDigit2(text.charCodeAt(pos))) {
        pos++;
        while (pos < text.length && isDigit2(text.charCodeAt(pos))) {
          pos++;
        }
      } else {
        scanError = 3;
        return text.substring(start, pos);
      }
    }
    let end = pos;
    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
      pos++;
      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
        pos++;
      }
      if (pos < text.length && isDigit2(text.charCodeAt(pos))) {
        pos++;
        while (pos < text.length && isDigit2(text.charCodeAt(pos))) {
          pos++;
        }
        end = pos;
      } else {
        scanError = 3;
      }
    }
    return text.substring(start, end);
  }
  __name(scanNumber, "scanNumber");
  function scanString() {
    let result = "", start = pos;
    while (true) {
      if (pos >= len) {
        result += text.substring(start, pos);
        scanError = 2;
        break;
      }
      const ch = text.charCodeAt(pos);
      if (ch === 34) {
        result += text.substring(start, pos);
        pos++;
        break;
      }
      if (ch === 92) {
        result += text.substring(start, pos);
        pos++;
        if (pos >= len) {
          scanError = 2;
          break;
        }
        const ch2 = text.charCodeAt(pos++);
        switch (ch2) {
          case 34:
            result += '"';
            break;
          case 92:
            result += "\\";
            break;
          case 47:
            result += "/";
            break;
          case 98:
            result += "\b";
            break;
          case 102:
            result += "\f";
            break;
          case 110:
            result += "\n";
            break;
          case 114:
            result += "\r";
            break;
          case 116:
            result += "	";
            break;
          case 117:
            const ch3 = scanHexDigits(4, true);
            if (ch3 >= 0) {
              result += String.fromCharCode(ch3);
            } else {
              scanError = 4;
            }
            break;
          default:
            scanError = 5;
        }
        start = pos;
        continue;
      }
      if (ch >= 0 && ch <= 31) {
        if (isLineBreak(ch)) {
          result += text.substring(start, pos);
          scanError = 2;
          break;
        } else {
          scanError = 6;
        }
      }
      pos++;
    }
    return result;
  }
  __name(scanString, "scanString");
  function scanNext() {
    value = "";
    scanError = 0;
    tokenOffset = pos;
    lineStartOffset = lineNumber;
    prevTokenLineStartOffset = tokenLineStartOffset;
    if (pos >= len) {
      tokenOffset = len;
      return token = 17;
    }
    let code = text.charCodeAt(pos);
    if (isWhiteSpace(code)) {
      do {
        pos++;
        value += String.fromCharCode(code);
        code = text.charCodeAt(pos);
      } while (isWhiteSpace(code));
      return token = 15;
    }
    if (isLineBreak(code)) {
      pos++;
      value += String.fromCharCode(code);
      if (code === 13 && text.charCodeAt(pos) === 10) {
        pos++;
        value += "\n";
      }
      lineNumber++;
      tokenLineStartOffset = pos;
      return token = 14;
    }
    switch (code) {
      case 123:
        pos++;
        return token = 1;
      case 125:
        pos++;
        return token = 2;
      case 91:
        pos++;
        return token = 3;
      case 93:
        pos++;
        return token = 4;
      case 58:
        pos++;
        return token = 6;
      case 44:
        pos++;
        return token = 5;
      case 34:
        pos++;
        value = scanString();
        return token = 10;
      case 47:
        const start = pos - 1;
        if (text.charCodeAt(pos + 1) === 47) {
          pos += 2;
          while (pos < len) {
            if (isLineBreak(text.charCodeAt(pos))) {
              break;
            }
            pos++;
          }
          value = text.substring(start, pos);
          return token = 12;
        }
        if (text.charCodeAt(pos + 1) === 42) {
          pos += 2;
          const safeLength = len - 1;
          let commentClosed = false;
          while (pos < safeLength) {
            const ch = text.charCodeAt(pos);
            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
              pos += 2;
              commentClosed = true;
              break;
            }
            pos++;
            if (isLineBreak(ch)) {
              if (ch === 13 && text.charCodeAt(pos) === 10) {
                pos++;
              }
              lineNumber++;
              tokenLineStartOffset = pos;
            }
          }
          if (!commentClosed) {
            pos++;
            scanError = 1;
          }
          value = text.substring(start, pos);
          return token = 13;
        }
        value += String.fromCharCode(code);
        pos++;
        return token = 16;
      case 45:
        value += String.fromCharCode(code);
        pos++;
        if (pos === len || !isDigit2(text.charCodeAt(pos))) {
          return token = 16;
        }
      case 48:
      case 49:
      case 50:
      case 51:
      case 52:
      case 53:
      case 54:
      case 55:
      case 56:
      case 57:
        value += scanNumber();
        return token = 11;
      default:
        while (pos < len && isUnknownContentCharacter(code)) {
          pos++;
          code = text.charCodeAt(pos);
        }
        if (tokenOffset !== pos) {
          value = text.substring(tokenOffset, pos);
          switch (value) {
            case "true":
              return token = 8;
            case "false":
              return token = 9;
            case "null":
              return token = 7;
          }
          return token = 16;
        }
        value += String.fromCharCode(code);
        pos++;
        return token = 16;
    }
  }
  __name(scanNext, "scanNext");
  function isUnknownContentCharacter(code) {
    if (isWhiteSpace(code) || isLineBreak(code)) {
      return false;
    }
    switch (code) {
      case 125:
      case 93:
      case 123:
      case 91:
      case 34:
      case 58:
      case 44:
      case 47:
        return false;
    }
    return true;
  }
  __name(isUnknownContentCharacter, "isUnknownContentCharacter");
  function scanNextNonTrivia() {
    let result;
    do {
      result = scanNext();
    } while (result >= 12 && result <= 15);
    return result;
  }
  __name(scanNextNonTrivia, "scanNextNonTrivia");
  return {
    setPosition,
    getPosition: () => pos,
    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
    getToken: () => token,
    getTokenValue: () => value,
    getTokenOffset: () => tokenOffset,
    getTokenLength: () => pos - tokenOffset,
    getTokenStartLine: () => lineStartOffset,
    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
    getTokenError: () => scanError
  };
}
__name(createScanner, "createScanner");
function isWhiteSpace(ch) {
  return ch === 32 || ch === 9;
}
__name(isWhiteSpace, "isWhiteSpace");
function isLineBreak(ch) {
  return ch === 10 || ch === 13;
}
__name(isLineBreak, "isLineBreak");
function isDigit2(ch) {
  return ch >= 48 && ch <= 57;
}
__name(isDigit2, "isDigit");
var CharacterCodes;
(function(CharacterCodes2) {
  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
})(CharacterCodes || (CharacterCodes = {}));

// ../../node_modules/.pnpm/jsonc-parser@3.2.0/node_modules/jsonc-parser/lib/esm/impl/edit.js
init_import_meta_url();

// ../../node_modules/.pnpm/jsonc-parser@3.2.0/node_modules/jsonc-parser/lib/esm/impl/parser.js
init_import_meta_url();
var ParseOptions;
(function(ParseOptions2) {
  ParseOptions2.DEFAULT = {
    allowTrailingComma: false
  };
})(ParseOptions || (ParseOptions = {}));
function parse(text, errors = [], options29 = ParseOptions.DEFAULT) {
  let currentProperty = null;
  let currentParent = [];
  const previousParents = [];
  function onValue(value) {
    if (Array.isArray(currentParent)) {
      currentParent.push(value);
    } else if (currentProperty !== null) {
      currentParent[currentProperty] = value;
    }
  }
  __name(onValue, "onValue");
  const visitor = {
    onObjectBegin: () => {
      const object = {};
      onValue(object);
      previousParents.push(currentParent);
      currentParent = object;
      currentProperty = null;
    },
    onObjectProperty: (name) => {
      currentProperty = name;
    },
    onObjectEnd: () => {
      currentParent = previousParents.pop();
    },
    onArrayBegin: () => {
      const array = [];
      onValue(array);
      previousParents.push(currentParent);
      currentParent = array;
      currentProperty = null;
    },
    onArrayEnd: () => {
      currentParent = previousParents.pop();
    },
    onLiteralValue: onValue,
    onError: (error2, offset, length) => {
      errors.push({ error: error2, offset, length });
    }
  };
  visit(text, visitor, options29);
  return currentParent[0];
}
__name(parse, "parse");
function visit(text, visitor, options29 = ParseOptions.DEFAULT) {
  const _scanner = createScanner(text, false);
  const _jsonPath = [];
  function toNoArgVisit(visitFunction) {
    return visitFunction ? () => visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
  }
  __name(toNoArgVisit, "toNoArgVisit");
  function toNoArgVisitWithPath(visitFunction) {
    return visitFunction ? () => visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
  }
  __name(toNoArgVisitWithPath, "toNoArgVisitWithPath");
  function toOneArgVisit(visitFunction) {
    return visitFunction ? (arg) => visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
  }
  __name(toOneArgVisit, "toOneArgVisit");
  function toOneArgVisitWithPath(visitFunction) {
    return visitFunction ? (arg) => visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
  }
  __name(toOneArgVisitWithPath, "toOneArgVisitWithPath");
  const onObjectBegin = toNoArgVisitWithPath(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toNoArgVisit(visitor.onObjectEnd), onArrayBegin = toNoArgVisitWithPath(visitor.onArrayBegin), onArrayEnd = toNoArgVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
  const disallowComments = options29 && options29.disallowComments;
  const allowTrailingComma = options29 && options29.allowTrailingComma;
  function scanNext() {
    while (true) {
      const token = _scanner.scan();
      switch (_scanner.getTokenError()) {
        case 4:
          handleError(
            14
            /* ParseErrorCode.InvalidUnicode */
          );
          break;
        case 5:
          handleError(
            15
            /* ParseErrorCode.InvalidEscapeCharacter */
          );
          break;
        case 3:
          handleError(
            13
            /* ParseErrorCode.UnexpectedEndOfNumber */
          );
          break;
        case 1:
          if (!disallowComments) {
            handleError(
              11
              /* ParseErrorCode.UnexpectedEndOfComment */
            );
          }
          break;
        case 2:
          handleError(
            12
            /* ParseErrorCode.UnexpectedEndOfString */
          );
          break;
        case 6:
          handleError(
            16
            /* ParseErrorCode.InvalidCharacter */
          );
          break;
      }
      switch (token) {
        case 12:
        case 13:
          if (disallowComments) {
            handleError(
              10
              /* ParseErrorCode.InvalidCommentToken */
            );
          } else {
            onComment();
          }
          break;
        case 16:
          handleError(
            1
            /* ParseErrorCode.InvalidSymbol */
          );
          break;
        case 15:
        case 14:
          break;
        default:
          return token;
      }
    }
  }
  __name(scanNext, "scanNext");
  function handleError(error2, skipUntilAfter = [], skipUntil = []) {
    onError(error2);
    if (skipUntilAfter.length + skipUntil.length > 0) {
      let token = _scanner.getToken();
      while (token !== 17) {
        if (skipUntilAfter.indexOf(token) !== -1) {
          scanNext();
          break;
        } else if (skipUntil.indexOf(token) !== -1) {
          break;
        }
        token = scanNext();
      }
    }
  }
  __name(handleError, "handleError");
  function parseString(isValue) {
    const value = _scanner.getTokenValue();
    if (isValue) {
      onLiteralValue(value);
    } else {
      onObjectProperty(value);
      _jsonPath.push(value);
    }
    scanNext();
    return true;
  }
  __name(parseString, "parseString");
  function parseLiteral() {
    switch (_scanner.getToken()) {
      case 11:
        const tokenValue = _scanner.getTokenValue();
        let value = Number(tokenValue);
        if (isNaN(value)) {
          handleError(
            2
            /* ParseErrorCode.InvalidNumberFormat */
          );
          value = 0;
        }
        onLiteralValue(value);
        break;
      case 7:
        onLiteralValue(null);
        break;
      case 8:
        onLiteralValue(true);
        break;
      case 9:
        onLiteralValue(false);
        break;
      default:
        return false;
    }
    scanNext();
    return true;
  }
  __name(parseLiteral, "parseLiteral");
  function parseProperty() {
    if (_scanner.getToken() !== 10) {
      handleError(3, [], [
        2,
        5
        /* SyntaxKind.CommaToken */
      ]);
      return false;
    }
    parseString(false);
    if (_scanner.getToken() === 6) {
      onSeparator(":");
      scanNext();
      if (!parseValue()) {
        handleError(4, [], [
          2,
          5
          /* SyntaxKind.CommaToken */
        ]);
      }
    } else {
      handleError(5, [], [
        2,
        5
        /* SyntaxKind.CommaToken */
      ]);
    }
    _jsonPath.pop();
    return true;
  }
  __name(parseProperty, "parseProperty");
  function parseObject() {
    onObjectBegin();
    scanNext();
    let needsComma = false;
    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
      if (_scanner.getToken() === 5) {
        if (!needsComma) {
          handleError(4, [], []);
        }
        onSeparator(",");
        scanNext();
        if (_scanner.getToken() === 2 && allowTrailingComma) {
          break;
        }
      } else if (needsComma) {
        handleError(6, [], []);
      }
      if (!parseProperty()) {
        handleError(4, [], [
          2,
          5
          /* SyntaxKind.CommaToken */
        ]);
      }
      needsComma = true;
    }
    onObjectEnd();
    if (_scanner.getToken() !== 2) {
      handleError(7, [
        2
        /* SyntaxKind.CloseBraceToken */
      ], []);
    } else {
      scanNext();
    }
    return true;
  }
  __name(parseObject, "parseObject");
  function parseArray() {
    onArrayBegin();
    scanNext();
    let isFirstElement = true;
    let needsComma = false;
    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
      if (_scanner.getToken() === 5) {
        if (!needsComma) {
          handleError(4, [], []);
        }
        onSeparator(",");
        scanNext();
        if (_scanner.getToken() === 4 && allowTrailingComma) {
          break;
        }
      } else if (needsComma) {
        handleError(6, [], []);
      }
      if (isFirstElement) {
        _jsonPath.push(0);
        isFirstElement = false;
      } else {
        _jsonPath[_jsonPath.length - 1]++;
      }
      if (!parseValue()) {
        handleError(4, [], [
          4,
          5
          /* SyntaxKind.CommaToken */
        ]);
      }
      needsComma = true;
    }
    onArrayEnd();
    if (!isFirstElement) {
      _jsonPath.pop();
    }
    if (_scanner.getToken() !== 4) {
      handleError(8, [
        4
        /* SyntaxKind.CloseBracketToken */
      ], []);
    } else {
      scanNext();
    }
    return true;
  }
  __name(parseArray, "parseArray");
  function parseValue() {
    switch (_scanner.getToken()) {
      case 3:
        return parseArray();
      case 1:
        return parseObject();
      case 10:
        return parseString(true);
      default:
        return parseLiteral();
    }
  }
  __name(parseValue, "parseValue");
  scanNext();
  if (_scanner.getToken() === 17) {
    if (options29.allowEmptyContent) {
      return true;
    }
    handleError(4, [], []);
    return false;
  }
  if (!parseValue()) {
    handleError(4, [], []);
    return false;
  }
  if (_scanner.getToken() !== 17) {
    handleError(9, [], []);
  }
  return true;
}
__name(visit, "visit");

// ../../node_modules/.pnpm/jsonc-parser@3.2.0/node_modules/jsonc-parser/lib/esm/main.js
var ScanError;
(function(ScanError2) {
  ScanError2[ScanError2["None"] = 0] = "None";
  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
})(ScanError || (ScanError = {}));
var SyntaxKind;
(function(SyntaxKind2) {
  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
})(SyntaxKind || (SyntaxKind = {}));
var parse2 = parse;
var ParseErrorCode;
(function(ParseErrorCode2) {
  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
})(ParseErrorCode || (ParseErrorCode = {}));
function printParseErrorCode(code) {
  switch (code) {
    case 1:
      return "InvalidSymbol";
    case 2:
      return "InvalidNumberFormat";
    case 3:
      return "PropertyNameExpected";
    case 4:
      return "ValueExpected";
    case 5:
      return "ColonExpected";
    case 6:
      return "CommaExpected";
    case 7:
      return "CloseBraceExpected";
    case 8:
      return "CloseBracketExpected";
    case 9:
      return "EndOfFileExpected";
    case 10:
      return "InvalidCommentToken";
    case 11:
      return "UnexpectedEndOfComment";
    case 12:
      return "UnexpectedEndOfString";
    case 13:
      return "UnexpectedEndOfNumber";
    case 14:
      return "InvalidUnicode";
    case 15:
      return "InvalidEscapeCharacter";
    case 16:
      return "InvalidCharacter";
  }
  return "<unknown ParseErrorCode>";
}
__name(printParseErrorCode, "printParseErrorCode");

// src/parse.ts
function formatMessage({ text, notes, location, kind = "error" }, color = true) {
  const input = { text, notes, location };
  delete input.location?.fileText;
  for (const note of notes ?? []) {
    delete note.location?.fileText;
  }
  const lines = (0, import_esbuild2.formatMessagesSync)([input], {
    color,
    kind,
    terminalWidth: logger.columns
  });
  return lines.join("\n");
}
__name(formatMessage, "formatMessage");
var ParseError = class extends UserError {
  text;
  notes;
  location;
  kind;
  constructor({ text, notes, location, kind }) {
    super(text);
    this.name = this.constructor.name;
    this.text = text;
    this.notes = notes ?? [];
    this.location = location;
    this.kind = kind ?? "error";
  }
};
__name(ParseError, "ParseError");
var APIError = class extends ParseError {
  // Allow `APIError`s to be marked as handled.
  #reportable = true;
  get reportable() {
    return this.#reportable;
  }
  preventReport() {
    this.#reportable = false;
  }
};
__name(APIError, "APIError");
var TOML_ERROR_NAME = "TomlError";
var TOML_ERROR_SUFFIX = " at row ";
function parseTOML(input, file) {
  try {
    const normalizedInput = input.replace(/\r\n/g, "\n");
    return import_toml.default.parse(normalizedInput);
  } catch (err) {
    const { name, message, line, col } = err;
    if (name !== TOML_ERROR_NAME) {
      throw err;
    }
    const text = message.substring(0, message.lastIndexOf(TOML_ERROR_SUFFIX));
    const lineText = input.split("\n")[line];
    const location = {
      lineText,
      line: line + 1,
      column: col - 1,
      file,
      fileText: input
    };
    throw new ParseError({ text, location });
  }
}
__name(parseTOML, "parseTOML");
var JSON_ERROR_SUFFIX = " in JSON at position ";
function parsePackageJSON(input, file) {
  return parseJSON(input, file);
}
__name(parsePackageJSON, "parsePackageJSON");
function parseJSON(input, file) {
  try {
    return JSON.parse(input);
  } catch (err) {
    const { message } = err;
    const index = message.lastIndexOf(JSON_ERROR_SUFFIX);
    if (index < 0) {
      throw err;
    }
    const text = message.substring(0, index);
    const position = parseInt(
      message.substring(index + JSON_ERROR_SUFFIX.length)
    );
    const location = indexLocation({ file, fileText: input }, position);
    throw new ParseError({ text, location });
  }
}
__name(parseJSON, "parseJSON");
function parseJSONC(input, file) {
  const errors = [];
  const data = parse2(input, errors);
  if (errors.length) {
    throw new ParseError({
      text: printParseErrorCode(errors[0].error),
      location: {
        ...indexLocation({ file, fileText: input }, errors[0].offset + 1),
        length: errors[0].length
      }
    });
  }
  return data;
}
__name(parseJSONC, "parseJSONC");
function readFileSyncToBuffer(file) {
  try {
    return fs3.readFileSync(file);
  } catch (err) {
    const { message } = err;
    throw new ParseError({
      text: `Could not read file: ${file}`,
      notes: [
        {
          text: message.replace(file, (0, import_node_path5.resolve)(file))
        }
      ]
    });
  }
}
__name(readFileSyncToBuffer, "readFileSyncToBuffer");
function readFileSync5(file) {
  try {
    return fs3.readFileSync(file, { encoding: "utf-8" });
  } catch (err) {
    const { message } = err;
    throw new ParseError({
      text: `Could not read file: ${file}`,
      notes: [
        {
          text: message.replace(file, (0, import_node_path5.resolve)(file))
        }
      ]
    });
  }
}
__name(readFileSync5, "readFileSync");
function indexLocation(file, index) {
  let lineText, line = 0, column = 0, cursor = 0;
  const { fileText = "" } = file;
  for (const row of fileText.split("\n")) {
    line++;
    cursor += row.length + 1;
    if (cursor >= index) {
      lineText = row;
      column = row.length - (cursor - index);
      break;
    }
  }
  return { lineText, line, column, ...file };
}
__name(indexLocation, "indexLocation");
var units = {
  nanoseconds: 1e-9,
  nanosecond: 1e-9,
  microseconds: 1e-6,
  microsecond: 1e-6,
  milliseconds: 1e-3,
  millisecond: 1e-3,
  seconds: 1,
  second: 1,
  minutes: 60,
  minute: 60,
  hours: 3600,
  hour: 3600,
  days: 86400,
  day: 86400,
  weeks: 604800,
  week: 604800,
  month: 18144e3,
  year: 220752e3,
  nsecs: 1e-9,
  nsec: 1e-9,
  usecs: 1e-6,
  usec: 1e-6,
  msecs: 1e-3,
  msec: 1e-3,
  secs: 1,
  sec: 1,
  mins: 60,
  min: 60,
  ns: 1e-9,
  us: 1e-6,
  ms: 1e-3,
  mo: 18144e3,
  yr: 220752e3,
  s: 1,
  m: 60,
  h: 3600,
  d: 86400,
  w: 604800,
  y: 220752e3
};
function parseHumanDuration(s) {
  const unitsMap = new Map(Object.entries(units));
  s = s.trim().toLowerCase();
  let base = 1;
  for (const [name, _3] of unitsMap) {
    if (s.endsWith(name)) {
      s = s.substring(0, s.length - name.length);
      base = unitsMap.get(name) || 1;
      break;
    }
  }
  return Number(s) * base;
}
__name(parseHumanDuration, "parseHumanDuration");

// src/config/validation.ts
init_import_meta_url();
var import_node_assert3 = __toESM(require("node:assert"));
var import_node_path7 = __toESM(require("node:path"));
var import_toml3 = __toESM(require_toml());

// src/constellation/utils.ts
init_import_meta_url();

// src/cfetch/index.ts
init_import_meta_url();
var import_node_url4 = require("node:url");

// src/cfetch/errors.ts
init_import_meta_url();
function buildDetailedError(message, ...extra) {
  return new ParseError({
    text: message,
    notes: extra.map((text) => ({ text }))
  });
}
__name(buildDetailedError, "buildDetailedError");
function maybeThrowFriendlyError(error2) {
  if (error2.message === "workers.api.error.email_verification_required") {
    throw buildDetailedError(
      "Please verify your account's email address and try again.",
      "Check your email for a verification link, or login to https://dash.cloudflare.com and request a new one."
    );
  }
}
__name(maybeThrowFriendlyError, "maybeThrowFriendlyError");

// src/cfetch/internal.ts
init_import_meta_url();
var import_node_assert2 = __toESM(require("node:assert"));
var import_undici3 = __toESM(require_undici());

// src/user/index.ts
init_import_meta_url();

// src/user/user.ts
init_import_meta_url();
var import_node_assert = __toESM(require("node:assert"));
var import_node_crypto2 = require("node:crypto");
var import_node_fs3 = require("node:fs");
var import_node_http = __toESM(require("node:http"));
var import_node_path6 = __toESM(require("node:path"));
var import_node_url3 = __toESM(require("node:url"));
var import_node_util2 = require("node:util");
var import_toml2 = __toESM(require_toml());
var import_undici2 = __toESM(require_undici());

// src/config-cache.ts
init_import_meta_url();
var import_fs5 = require("fs");
var path5 = __toESM(require("path"));

// src/is-ci.ts
init_import_meta_url();
var import_is_ci = __toESM(require_is_ci2());
var CI = {
  /** Is Wrangler currently running in a CI? */
  isCI() {
    return import_is_ci.default;
  }
};

// src/is-interactive.ts
init_import_meta_url();
function isInteractive() {
  if (process.env.CF_PAGES === "1") {
    return false;
  }
  try {
    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
  } catch {
    return false;
  }
}
__name(isInteractive, "isInteractive");

// src/config-cache.ts
var cacheMessageShown = false;
var __cacheFolder;
function getCacheFolder() {
  if (__cacheFolder || __cacheFolder === null)
    return __cacheFolder;
  const closestNodeModulesDirectory = findUpSync("node_modules", {
    type: "directory"
  });
  __cacheFolder = closestNodeModulesDirectory ? path5.join(closestNodeModulesDirectory, ".cache/wrangler") : null;
  if (!__cacheFolder) {
    logger.debug("No folder available to cache configuration");
  }
  return __cacheFolder;
}
__name(getCacheFolder, "getCacheFolder");
var arrayFormatter = new Intl.ListFormat("en-US", {
  style: "long",
  type: "conjunction"
});
function showCacheMessage(fields, folder) {
  if (!cacheMessageShown && isInteractive() && !CI.isCI()) {
    if (fields.length > 0) {
      logger.debug(
        `Retrieving cached values for ${arrayFormatter.format(
          fields
        )} from ${path5.relative(process.cwd(), folder)}`
      );
      cacheMessageShown = true;
    }
  }
}
__name(showCacheMessage, "showCacheMessage");
function getConfigCache(fileName) {
  try {
    const cacheFolder = getCacheFolder();
    if (cacheFolder) {
      const configCacheLocation = path5.join(cacheFolder, fileName);
      const configCache = JSON.parse(
        (0, import_fs5.readFileSync)(configCacheLocation, "utf-8")
      );
      showCacheMessage(Object.keys(configCache), cacheFolder);
      return configCache;
    } else
      return {};
  } catch (err) {
    return {};
  }
}
__name(getConfigCache, "getConfigCache");
function saveToConfigCache(fileName, newValues) {
  const cacheFolder = getCacheFolder();
  if (cacheFolder) {
    logger.debug(`Saving to cache: ${JSON.stringify(newValues)}`);
    const configCacheLocation = path5.join(cacheFolder, fileName);
    const existingValues = getConfigCache(fileName);
    (0, import_fs5.mkdirSync)(path5.dirname(configCacheLocation), { recursive: true });
    (0, import_fs5.writeFileSync)(
      configCacheLocation,
      JSON.stringify({ ...existingValues, ...newValues }, null, 2)
    );
  }
}
__name(saveToConfigCache, "saveToConfigCache");
function purgeConfigCaches() {
  const cacheFolder = getCacheFolder();
  if (cacheFolder) {
    (0, import_fs5.rmSync)(cacheFolder, { recursive: true, force: true });
  }
  __cacheFolder = void 0;
}
__name(purgeConfigCaches, "purgeConfigCaches");

// src/dialogs.ts
init_import_meta_url();
var import_chalk2 = __toESM(require_chalk());
var import_prompts = __toESM(require_prompts3());
function isNonInteractiveOrCI() {
  return !isInteractive() || CI.isCI();
}
__name(isNonInteractiveOrCI, "isNonInteractiveOrCI");
var NoDefaultValueProvided = class extends UserError {
  constructor() {
    super("This command cannot be run in a non-interactive context");
    Object.setPrototypeOf(this, new.target.prototype);
  }
};
__name(NoDefaultValueProvided, "NoDefaultValueProvided");
async function confirm(text, { defaultValue = true, fallbackValue = true } = {}) {
  if (isNonInteractiveOrCI()) {
    logger.log(`? ${text}`);
    logger.log(
      `\u{1F916} ${import_chalk2.default.dim(
        "Using fallback value in non-interactive context:"
      )} ${import_chalk2.default.white.bold(fallbackValue ? "yes" : "no")}`
    );
    return fallbackValue;
  }
  const { value } = await (0, import_prompts.default)({
    type: "confirm",
    name: "value",
    message: text,
    initial: defaultValue,
    onState: (state) => {
      if (state.aborted) {
        process.nextTick(() => {
          process.exit(1);
        });
      }
    }
  });
  return value;
}
__name(confirm, "confirm");
async function prompt(text, options29 = {}) {
  if (isNonInteractiveOrCI()) {
    if (options29?.defaultValue === void 0) {
      throw new NoDefaultValueProvided();
    }
    logger.log(`? ${text}`);
    logger.log(
      `\u{1F916} ${import_chalk2.default.dim(
        "Using default value in non-interactive context:"
      )} ${import_chalk2.default.white.bold(options29.defaultValue)}`
    );
    return options29.defaultValue;
  }
  const { value } = await (0, import_prompts.default)({
    type: "text",
    name: "value",
    message: text,
    initial: options29?.defaultValue,
    style: options29?.isSecret ? "password" : "default",
    onState: (state) => {
      if (state.aborted) {
        process.nextTick(() => {
          process.exit(1);
        });
      }
    }
  });
  return value;
}
__name(prompt, "prompt");
async function select(text, options29) {
  if (isNonInteractiveOrCI()) {
    if (options29?.defaultOption === void 0) {
      throw new NoDefaultValueProvided();
    }
    logger.log(`? ${text}`);
    logger.log(
      `\u{1F916} ${import_chalk2.default.dim(
        "Using default value in non-interactive context:"
      )} ${import_chalk2.default.white.bold(options29.choices[options29.defaultOption].title)}`
    );
    return options29.choices[options29.defaultOption].value;
  }
  const { value } = await (0, import_prompts.default)({
    type: "select",
    name: "value",
    message: text,
    choices: options29.choices,
    initial: options29.defaultOption,
    onState: (state) => {
      if (state.aborted) {
        process.nextTick(() => {
          process.exit(1);
        });
      }
    }
  });
  return value;
}
__name(select, "select");

// src/open-in-browser.ts
init_import_meta_url();
var import_open = __toESM(require_open());
async function openInBrowser(url4) {
  const childProcess2 = await (0, import_open.default)(url4);
  childProcess2.on("error", () => {
    logger.warn("Failed to open");
  });
}
__name(openInBrowser, "openInBrowser");

// src/user/access.ts
init_import_meta_url();
var import_child_process = require("child_process");
var import_undici = __toESM(require_undici());
var cache = {};
var usesAccessCache = /* @__PURE__ */ new Map();
async function domainUsesAccess(domain2) {
  logger.debug("Checking if domain has Access enabled:", domain2);
  if (usesAccessCache.has(domain2)) {
    logger.debug(
      "Using cached Access switch for:",
      domain2,
      usesAccessCache.get(domain2)
    );
    return usesAccessCache.get(domain2);
  }
  logger.debug("Access switch not cached for:", domain2);
  try {
    const controller = new AbortController();
    const cancel3 = setTimeout(() => {
      controller.abort();
    }, 1e3);
    const output = await (0, import_undici.fetch)(`https://${domain2}`, {
      redirect: "manual",
      signal: controller.signal
    });
    clearTimeout(cancel3);
    const usesAccess = !!(output.status === 302 && output.headers.get("location")?.includes("cloudflareaccess.com"));
    logger.debug("Caching access switch for:", domain2);
    usesAccessCache.set(domain2, usesAccess);
    return usesAccess;
  } catch (e3) {
    usesAccessCache.set(domain2, false);
    return false;
  }
}
__name(domainUsesAccess, "domainUsesAccess");
async function getAccessToken(domain2) {
  if (!await domainUsesAccess(domain2)) {
    return void 0;
  }
  if (cache[domain2]) {
    return cache[domain2];
  }
  const output = (0, import_child_process.spawnSync)("cloudflared", ["access", "login", domain2]);
  if (output.error) {
    throw new UserError(
      "To use Wrangler with Cloudflare Access, please install `cloudflared` from https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/install-and-setup/installation"
    );
  }
  const stringOutput = output.stdout.toString();
  const matches = stringOutput.match(/fetched your token:\n\n(.*)/m);
  if (matches && matches.length >= 2) {
    cache[domain2] = matches[1];
    return matches[1];
  }
  throw new Error("Failed to authenticate with Cloudflare Access");
}
__name(getAccessToken, "getAccessToken");

// src/user/auth-variables.ts
init_import_meta_url();
var getCloudflareAccountIdFromEnv = getEnvironmentVariableFactory({
  variableName: "CLOUDFLARE_ACCOUNT_ID",
  deprecatedName: "CF_ACCOUNT_ID"
});
var getCloudflareAPITokenFromEnv = getEnvironmentVariableFactory({
  variableName: "CLOUDFLARE_API_TOKEN",
  deprecatedName: "CF_API_TOKEN"
});
var getCloudflareGlobalAuthKeyFromEnv = getEnvironmentVariableFactory({
  variableName: "CLOUDFLARE_API_KEY",
  deprecatedName: "CF_API_KEY"
});
var getCloudflareGlobalAuthEmailFromEnv = getEnvironmentVariableFactory({
  variableName: "CLOUDFLARE_EMAIL",
  deprecatedName: "CF_EMAIL"
});
var getClientIdFromEnv = getEnvironmentVariableFactory({
  variableName: "WRANGLER_CLIENT_ID",
  defaultValue: () => getCloudflareApiEnvironmentFromEnv() === "staging" ? "4b2ea6cc-9421-4761-874b-ce550e0e3def" : "54d11594-84e4-41aa-b438-e81b8fa78ee7"
});
var getAuthDomainFromEnv = getEnvironmentVariableFactory({
  variableName: "WRANGLER_AUTH_DOMAIN",
  defaultValue: () => getCloudflareApiEnvironmentFromEnv() === "staging" ? "dash.staging.cloudflare.com" : "dash.cloudflare.com"
});
var getAuthUrlFromEnv = getEnvironmentVariableFactory({
  variableName: "WRANGLER_AUTH_URL",
  defaultValue: () => `https://${getAuthDomainFromEnv()}/oauth2/auth`
});
var getTokenUrlFromEnv = getEnvironmentVariableFactory({
  variableName: "WRANGLER_TOKEN_URL",
  defaultValue: () => `https://${getAuthDomainFromEnv()}/oauth2/token`
});
var getRevokeUrlFromEnv = getEnvironmentVariableFactory({
  variableName: "WRANGLER_REVOKE_URL",
  defaultValue: () => `https://${getAuthDomainFromEnv()}/oauth2/revoke`
});
var getCloudflareAccessToken = /* @__PURE__ */ __name(async () => {
  const env5 = getEnvironmentVariableFactory({
    variableName: "WRANGLER_CF_AUTHORIZATION_TOKEN"
  })();
  if (env5 !== void 0) {
    return env5;
  }
  return getAccessToken(getAuthDomainFromEnv());
}, "getCloudflareAccessToken");

// src/user/choose-account.tsx
init_import_meta_url();
async function getAccountChoices() {
  const accountIdFromEnv = getCloudflareAccountIdFromEnv();
  if (accountIdFromEnv) {
    return [{ id: accountIdFromEnv, name: "" }];
  } else {
    try {
      const response = await fetchPagedListResult(`/memberships`);
      const accounts = response.map((r3) => r3.account);
      if (accounts.length === 0) {
        throw new UserError(
          "Failed to automatically retrieve account IDs for the logged in user.\nIn a non-interactive environment, it is mandatory to specify an account ID, either by assigning its value to CLOUDFLARE_ACCOUNT_ID, or as `account_id` in your `wrangler.toml` file."
        );
      } else {
        return accounts;
      }
    } catch (err) {
      if (err.code === 9109) {
        throw new UserError(
          `Failed to automatically retrieve account IDs for the logged in user.
You may have incorrect permissions on your API token. You can skip this account check by adding an \`account_id\` in your \`wrangler.toml\`, or by setting the value of CLOUDFLARE_ACCOUNT_ID"`
        );
      } else
        throw err;
    }
  }
}
__name(getAccountChoices, "getAccountChoices");

// src/user/generate-auth-url.ts
init_import_meta_url();
var generateAuthUrl = /* @__PURE__ */ __name(({
  authUrl,
  clientId,
  callbackUrl,
  scopes,
  stateQueryParam,
  codeChallenge
}) => {
  return authUrl + `?response_type=code&client_id=${encodeURIComponent(clientId)}&redirect_uri=${encodeURIComponent(callbackUrl)}&scope=${encodeURIComponent([...scopes, "offline_access"].join(" "))}&state=${stateQueryParam}&code_challenge=${encodeURIComponent(codeChallenge)}&code_challenge_method=S256`;
}, "generateAuthUrl");

// src/user/generate-random-state.ts
init_import_meta_url();
var import_node_crypto = require("node:crypto");
function generateRandomState(lengthOfState) {
  const output = new Uint32Array(lengthOfState);
  import_node_crypto.webcrypto.getRandomValues(output);
  return Array.from(output).map((num) => PKCE_CHARSET[num % PKCE_CHARSET.length]).join("");
}
__name(generateRandomState, "generateRandomState");

// src/user/user.ts
function getAuthFromEnv() {
  const globalApiKey = getCloudflareGlobalAuthKeyFromEnv();
  const globalApiEmail = getCloudflareGlobalAuthEmailFromEnv();
  const apiToken = getCloudflareAPITokenFromEnv();
  if (globalApiKey && globalApiEmail) {
    return { authKey: globalApiKey, authEmail: globalApiEmail };
  } else if (apiToken) {
    return { apiToken };
  }
}
__name(getAuthFromEnv, "getAuthFromEnv");
var USER_AUTH_CONFIG_FILE = "config/default.toml";
var DefaultScopes = {
  "account:read": "See your account info such as account details, analytics, and memberships.",
  "user:read": "See your user info such as name, email address, and account memberships.",
  "workers:write": "See and change Cloudflare Workers data such as zones, KV storage, namespaces, scripts, and routes.",
  "workers_kv:write": "See and change Cloudflare Workers KV Storage data such as keys and namespaces.",
  "workers_routes:write": "See and change Cloudflare Workers data such as filters and routes.",
  "workers_scripts:write": "See and change Cloudflare Workers scripts, durable objects, subdomains, triggers, and tail data.",
  "workers_tail:read": "See Cloudflare Workers tail and script data.",
  "d1:write": "See and change D1 Databases.",
  "pages:write": "See and change Cloudflare Pages projects, settings and deployments.",
  "zone:read": "Grants read level access to account zone.",
  "ssl_certs:write": "See and manage mTLS certificates for your account",
  "constellation:write": "Manage Constellation projects/models",
  "ai:write": "See and change Workers AI catalog and assets",
  "queues:write": "See and change Cloudflare Queues settings and data"
};
var OptionalScopes = {
  "cloudchamber:write": "Manage Cloudchamber"
};
var AllScopes = {
  ...DefaultScopes,
  ...OptionalScopes
};
var DefaultScopeKeys = Object.keys(DefaultScopes);
function setLoginScopeKeys(scopes) {
  DefaultScopeKeys = scopes;
}
__name(setLoginScopeKeys, "setLoginScopeKeys");
function validateScopeKeys(scopes) {
  return scopes.every((scope) => scope in DefaultScopes);
}
__name(validateScopeKeys, "validateScopeKeys");
var CALLBACK_URL = "http://localhost:8976/oauth/callback";
var LocalState = {
  ...getAuthTokens()
};
function getAuthTokens(config) {
  try {
    if (getAuthFromEnv())
      return;
    const { oauth_token, refresh_token, expiration_time, scopes, api_token } = config || readAuthConfigFile();
    if (oauth_token) {
      return {
        accessToken: {
          value: oauth_token,
          // If there is no `expiration_time` field then set it to an old date, to cause it to expire immediately.
          expiry: expiration_time ?? "2000-01-01:00:00:00+00:00"
        },
        refreshToken: { value: refresh_token ?? "" },
        scopes
      };
    } else if (api_token) {
      logger.warn(
        "It looks like you have used Wrangler v1's `config` command to login with an API token.\nThis is no longer supported in the current version of Wrangler.\nIf you wish to authenticate via an API token then please set the `CLOUDFLARE_API_TOKEN` environment variable."
      );
      return { apiToken: api_token };
    }
  } catch {
    return void 0;
  }
}
__name(getAuthTokens, "getAuthTokens");
function reinitialiseAuthTokens(config) {
  LocalState = {
    ...getAuthTokens(config)
  };
}
__name(reinitialiseAuthTokens, "reinitialiseAuthTokens");
function getAPIToken() {
  if (LocalState.apiToken) {
    return { apiToken: LocalState.apiToken };
  }
  const localAPIToken = getAuthFromEnv();
  if (localAPIToken)
    return localAPIToken;
  const storedAccessToken = LocalState.accessToken?.value;
  if (storedAccessToken)
    return { apiToken: storedAccessToken };
  return void 0;
}
__name(getAPIToken, "getAPIToken");
var ErrorOAuth2 = class extends UserError {
  toString() {
    return "ErrorOAuth2";
  }
};
__name(ErrorOAuth2, "ErrorOAuth2");
var ErrorUnknown = class extends Error {
  toString() {
    return "ErrorUnknown";
  }
};
__name(ErrorUnknown, "ErrorUnknown");
var ErrorNoAuthCode = class extends ErrorOAuth2 {
  toString() {
    return "ErrorNoAuthCode";
  }
};
__name(ErrorNoAuthCode, "ErrorNoAuthCode");
var ErrorInvalidReturnedStateParam = class extends ErrorOAuth2 {
  toString() {
    return "ErrorInvalidReturnedStateParam";
  }
};
__name(ErrorInvalidReturnedStateParam, "ErrorInvalidReturnedStateParam");
var ErrorInvalidJson = class extends ErrorOAuth2 {
  toString() {
    return "ErrorInvalidJson";
  }
};
__name(ErrorInvalidJson, "ErrorInvalidJson");
var ErrorInvalidScope = class extends ErrorOAuth2 {
  toString() {
    return "ErrorInvalidScope";
  }
};
__name(ErrorInvalidScope, "ErrorInvalidScope");
var ErrorInvalidRequest = class extends ErrorOAuth2 {
  toString() {
    return "ErrorInvalidRequest";
  }
};
__name(ErrorInvalidRequest, "ErrorInvalidRequest");
var ErrorInvalidToken = class extends ErrorOAuth2 {
  toString() {
    return "ErrorInvalidToken";
  }
};
__name(ErrorInvalidToken, "ErrorInvalidToken");
var ErrorAuthenticationGrant = class extends ErrorOAuth2 {
  toString() {
    return "ErrorAuthenticationGrant";
  }
};
__name(ErrorAuthenticationGrant, "ErrorAuthenticationGrant");
var ErrorUnauthorizedClient = class extends ErrorAuthenticationGrant {
  toString() {
    return "ErrorUnauthorizedClient";
  }
};
__name(ErrorUnauthorizedClient, "ErrorUnauthorizedClient");
var ErrorAccessDenied = class extends ErrorAuthenticationGrant {
  toString() {
    return "ErrorAccessDenied";
  }
};
__name(ErrorAccessDenied, "ErrorAccessDenied");
var ErrorUnsupportedResponseType = class extends ErrorAuthenticationGrant {
  toString() {
    return "ErrorUnsupportedResponseType";
  }
};
__name(ErrorUnsupportedResponseType, "ErrorUnsupportedResponseType");
var ErrorServerError = class extends ErrorAuthenticationGrant {
  toString() {
    return "ErrorServerError";
  }
};
__name(ErrorServerError, "ErrorServerError");
var ErrorTemporarilyUnavailable = class extends ErrorAuthenticationGrant {
  toString() {
    return "ErrorTemporarilyUnavailable";
  }
};
__name(ErrorTemporarilyUnavailable, "ErrorTemporarilyUnavailable");
var ErrorAccessTokenResponse = class extends ErrorOAuth2 {
  toString() {
    return "ErrorAccessTokenResponse";
  }
};
__name(ErrorAccessTokenResponse, "ErrorAccessTokenResponse");
var ErrorInvalidClient = class extends ErrorAccessTokenResponse {
  toString() {
    return "ErrorInvalidClient";
  }
};
__name(ErrorInvalidClient, "ErrorInvalidClient");
var ErrorInvalidGrant = class extends ErrorAccessTokenResponse {
  toString() {
    return "ErrorInvalidGrant";
  }
};
__name(ErrorInvalidGrant, "ErrorInvalidGrant");
var ErrorUnsupportedGrantType = class extends ErrorAccessTokenResponse {
  toString() {
    return "ErrorUnsupportedGrantType";
  }
};
__name(ErrorUnsupportedGrantType, "ErrorUnsupportedGrantType");
var RawErrorToErrorClassMap = {
  invalid_request: ErrorInvalidRequest,
  invalid_grant: ErrorInvalidGrant,
  unauthorized_client: ErrorUnauthorizedClient,
  access_denied: ErrorAccessDenied,
  unsupported_response_type: ErrorUnsupportedResponseType,
  invalid_scope: ErrorInvalidScope,
  server_error: ErrorServerError,
  temporarily_unavailable: ErrorTemporarilyUnavailable,
  invalid_client: ErrorInvalidClient,
  unsupported_grant_type: ErrorUnsupportedGrantType,
  invalid_json: ErrorInvalidJson,
  invalid_token: ErrorInvalidToken
};
function toErrorClass(rawError) {
  return new (RawErrorToErrorClassMap[rawError] || ErrorUnknown)();
}
__name(toErrorClass, "toErrorClass");
var RECOMMENDED_CODE_VERIFIER_LENGTH = 96;
var RECOMMENDED_STATE_LENGTH = 32;
var PKCE_CHARSET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~";
function isReturningFromAuthServer(query) {
  if (query.error) {
    if (Array.isArray(query.error)) {
      throw toErrorClass(query.error[0]);
    }
    throw toErrorClass(query.error);
  }
  const code = query.code;
  if (!code) {
    return false;
  }
  const state = LocalState;
  const stateQueryParam = query.state;
  if (stateQueryParam !== state.stateQueryParam) {
    logger.warn(
      "Received query string parameter doesn't match the one sent! Possible malicious activity somewhere."
    );
    throw new ErrorInvalidReturnedStateParam();
  }
  (0, import_node_assert.default)(!Array.isArray(code));
  state.authorizationCode = code;
  state.hasAuthCodeBeenExchangedForAccessToken = false;
  return true;
}
__name(isReturningFromAuthServer, "isReturningFromAuthServer");
async function getAuthURL(scopes = DefaultScopeKeys) {
  const { codeChallenge, codeVerifier } = await generatePKCECodes();
  const stateQueryParam = generateRandomState(RECOMMENDED_STATE_LENGTH);
  Object.assign(LocalState, {
    codeChallenge,
    codeVerifier,
    stateQueryParam
  });
  return generateAuthUrl({
    authUrl: getAuthUrlFromEnv(),
    clientId: getClientIdFromEnv(),
    callbackUrl: CALLBACK_URL,
    scopes,
    stateQueryParam,
    codeChallenge
  });
}
__name(getAuthURL, "getAuthURL");
async function exchangeRefreshTokenForAccessToken() {
  if (!LocalState.refreshToken) {
    logger.warn("No refresh token is present.");
  }
  const params = new URLSearchParams({
    grant_type: "refresh_token",
    refresh_token: LocalState.refreshToken?.value ?? "",
    client_id: getClientIdFromEnv()
  });
  const response = await fetchAuthToken(params);
  if (response.status >= 400) {
    let tokenExchangeResErr = void 0;
    try {
      tokenExchangeResErr = await response.text();
      tokenExchangeResErr = JSON.parse(tokenExchangeResErr);
    } catch (e3) {
    }
    if (tokenExchangeResErr !== void 0) {
      throw typeof tokenExchangeResErr === "string" ? new Error(tokenExchangeResErr) : tokenExchangeResErr;
    } else {
      throw new ErrorUnknown(
        "Failed to parse Error from exchangeRefreshTokenForAccessToken"
      );
    }
  } else {
    try {
      const json = await response.json();
      if ("error" in json) {
        throw json.error;
      }
      const { access_token, expires_in, refresh_token, scope } = json;
      let scopes = [];
      const accessToken = {
        value: access_token,
        expiry: new Date(Date.now() + expires_in * 1e3).toISOString()
      };
      LocalState.accessToken = accessToken;
      if (refresh_token) {
        LocalState.refreshToken = {
          value: refresh_token
        };
      }
      if (scope) {
        scopes = scope.split(" ");
        LocalState.scopes = scopes;
      }
      const accessContext = {
        token: accessToken,
        scopes,
        refreshToken: LocalState.refreshToken
      };
      return accessContext;
    } catch (error2) {
      if (typeof error2 === "string") {
        throw toErrorClass(error2);
      } else {
        throw error2;
      }
    }
  }
}
__name(exchangeRefreshTokenForAccessToken, "exchangeRefreshTokenForAccessToken");
async function exchangeAuthCodeForAccessToken() {
  const { authorizationCode, codeVerifier = "" } = LocalState;
  if (!codeVerifier) {
    logger.warn("No code verifier is being sent.");
  } else if (!authorizationCode) {
    logger.warn("No authorization grant code is being passed.");
  }
  const params = new URLSearchParams({
    grant_type: `authorization_code`,
    code: authorizationCode ?? "",
    redirect_uri: CALLBACK_URL,
    client_id: getClientIdFromEnv(),
    code_verifier: codeVerifier
  });
  const response = await fetchAuthToken(params);
  if (!response.ok) {
    const { error: error2 } = await response.json();
    if (error2 === "invalid_grant") {
      logger.log("Expired! Auth code or refresh token needs to be renewed.");
    }
    throw toErrorClass(error2);
  }
  const json = await response.json();
  if ("error" in json) {
    throw new Error(json.error);
  }
  const { access_token, expires_in, refresh_token, scope } = json;
  let scopes = [];
  LocalState.hasAuthCodeBeenExchangedForAccessToken = true;
  const expiryDate = new Date(Date.now() + expires_in * 1e3);
  const accessToken = {
    value: access_token,
    expiry: expiryDate.toISOString()
  };
  LocalState.accessToken = accessToken;
  if (refresh_token) {
    LocalState.refreshToken = {
      value: refresh_token
    };
  }
  if (scope) {
    scopes = scope.split(" ");
    LocalState.scopes = scopes;
  }
  const accessContext = {
    token: accessToken,
    scopes,
    refreshToken: LocalState.refreshToken
  };
  return accessContext;
}
__name(exchangeAuthCodeForAccessToken, "exchangeAuthCodeForAccessToken");
function base64urlEncode(value) {
  let base642 = btoa(value);
  base642 = base642.replace(/\+/g, "-");
  base642 = base642.replace(/\//g, "_");
  base642 = base642.replace(/=/g, "");
  return base642;
}
__name(base64urlEncode, "base64urlEncode");
async function generatePKCECodes() {
  const output = new Uint32Array(RECOMMENDED_CODE_VERIFIER_LENGTH);
  import_node_crypto2.webcrypto.getRandomValues(output);
  const codeVerifier = base64urlEncode(
    Array.from(output).map((num) => PKCE_CHARSET[num % PKCE_CHARSET.length]).join("")
  );
  const buffer = await import_node_crypto2.webcrypto.subtle.digest(
    "SHA-256",
    new import_node_util2.TextEncoder().encode(codeVerifier)
  );
  const hash = new Uint8Array(buffer);
  let binary = "";
  const hashLength = hash.byteLength;
  for (let i = 0; i < hashLength; i++) {
    binary += String.fromCharCode(hash[i]);
  }
  const codeChallenge = base64urlEncode(binary);
  return { codeChallenge, codeVerifier };
}
__name(generatePKCECodes, "generatePKCECodes");
function writeAuthConfigFile(config) {
  const authConfigFilePath = import_node_path6.default.join(
    getGlobalWranglerConfigPath(),
    USER_AUTH_CONFIG_FILE
  );
  (0, import_node_fs3.mkdirSync)(import_node_path6.default.dirname(authConfigFilePath), {
    recursive: true
  });
  (0, import_node_fs3.writeFileSync)(
    import_node_path6.default.join(authConfigFilePath),
    import_toml2.default.stringify(config),
    { encoding: "utf-8" }
  );
  reinitialiseAuthTokens();
}
__name(writeAuthConfigFile, "writeAuthConfigFile");
function readAuthConfigFile() {
  const authConfigFilePath = import_node_path6.default.join(
    getGlobalWranglerConfigPath(),
    USER_AUTH_CONFIG_FILE
  );
  const toml = parseTOML(readFileSync5(authConfigFilePath));
  return toml;
}
__name(readAuthConfigFile, "readAuthConfigFile");
async function loginOrRefreshIfRequired(props) {
  const { isCI: isCI2 } = CI;
  if (!getAPIToken()) {
    return isInteractive() && !isCI2() && await login(props);
  } else if (isAccessTokenExpired()) {
    const didRefresh = await refreshToken();
    if (didRefresh) {
      return true;
    } else {
      return isInteractive() && !isCI2() && await login(props);
    }
  } else {
    return true;
  }
}
__name(loginOrRefreshIfRequired, "loginOrRefreshIfRequired");
async function login(props = { browser: true }) {
  logger.log("Attempting to login via OAuth...");
  const urlToOpen = await getAuthURL(props?.scopes);
  let server;
  let loginTimeoutHandle;
  const timerPromise = new Promise((resolve19) => {
    loginTimeoutHandle = setTimeout(() => {
      logger.error(
        "Timed out waiting for authorization code, please try again."
      );
      server.close();
      clearTimeout(loginTimeoutHandle);
      resolve19(false);
    }, 12e4);
  });
  const loginPromise = new Promise((resolve19, reject) => {
    server = import_node_http.default.createServer(async (req, res) => {
      function finish(status2, error2) {
        clearTimeout(loginTimeoutHandle);
        server.close((closeErr) => {
          if (error2 || closeErr) {
            reject(error2 || closeErr);
          } else
            resolve19(status2);
        });
      }
      __name(finish, "finish");
      (0, import_node_assert.default)(req.url, "This request doesn't have a URL");
      const { pathname, query } = import_node_url3.default.parse(req.url, true);
      if (req.method !== "GET")
        return res.end("OK");
      switch (pathname) {
        case "/oauth/callback": {
          let hasAuthCode = false;
          try {
            hasAuthCode = isReturningFromAuthServer(query);
          } catch (err) {
            if (err instanceof ErrorAccessDenied) {
              res.writeHead(307, {
                Location: "https://welcome.developers.workers.dev/wrangler-oauth-consent-denied"
              });
              res.end(() => {
                finish(false);
              });
              logger.error(
                "Error: Consent denied. You must grant consent to Wrangler in order to login.\nIf you don't want to do this consider passing an API token via the `CLOUDFLARE_API_TOKEN` environment variable"
              );
              return;
            } else {
              finish(false, err);
              return;
            }
          }
          if (!hasAuthCode) {
            finish(false, new ErrorNoAuthCode());
            return;
          } else {
            const exchange = await exchangeAuthCodeForAccessToken();
            writeAuthConfigFile({
              oauth_token: exchange.token?.value ?? "",
              expiration_time: exchange.token?.expiry,
              refresh_token: exchange.refreshToken?.value,
              scopes: exchange.scopes
            });
            res.writeHead(307, {
              Location: "https://welcome.developers.workers.dev/wrangler-oauth-consent-granted"
            });
            res.end(() => {
              finish(true);
            });
            logger.log(`Successfully logged in.`);
            purgeConfigCaches();
            return;
          }
        }
      }
    });
    server.listen(8976, "localhost");
  });
  if (props?.browser) {
    logger.log(`Opening a link in your default browser: ${urlToOpen}`);
    await openInBrowser(urlToOpen);
  } else {
    logger.log(`Visit this link to authenticate: ${urlToOpen}`);
  }
  return Promise.race([timerPromise, loginPromise]);
}
__name(login, "login");
function isAccessTokenExpired() {
  const { accessToken } = LocalState;
  return Boolean(accessToken && /* @__PURE__ */ new Date() >= new Date(accessToken.expiry));
}
__name(isAccessTokenExpired, "isAccessTokenExpired");
async function refreshToken() {
  try {
    const {
      token: { value: oauth_token, expiry: expiration_time } = {
        value: "",
        expiry: ""
      },
      refreshToken: { value: refresh_token } = {},
      scopes
    } = await exchangeRefreshTokenForAccessToken();
    writeAuthConfigFile({
      oauth_token,
      expiration_time,
      refresh_token,
      scopes
    });
    return true;
  } catch (err) {
    return false;
  }
}
__name(refreshToken, "refreshToken");
async function logout() {
  if (!LocalState.accessToken) {
    if (!LocalState.refreshToken) {
      logger.log("Not logged in, exiting...");
      return;
    }
    const body2 = `client_id=${encodeURIComponent(getClientIdFromEnv())}&token_type_hint=refresh_token&token=${encodeURIComponent(LocalState.refreshToken?.value || "")}`;
    const response2 = await (0, import_undici2.fetch)(getRevokeUrlFromEnv(), {
      method: "POST",
      body: body2,
      headers: {
        "Content-Type": "application/x-www-form-urlencoded"
      }
    });
    await response2.text();
    logger.log(
      "\u{1F481}  Wrangler is configured with an OAuth token. The token has been successfully revoked"
    );
  }
  const body = `client_id=${encodeURIComponent(getClientIdFromEnv())}&token_type_hint=refresh_token&token=${encodeURIComponent(LocalState.refreshToken?.value || "")}`;
  const response = await (0, import_undici2.fetch)(getRevokeUrlFromEnv(), {
    method: "POST",
    body,
    headers: {
      "Content-Type": "application/x-www-form-urlencoded"
    }
  });
  await response.text();
  (0, import_node_fs3.rmSync)(import_node_path6.default.join(getGlobalWranglerConfigPath(), USER_AUTH_CONFIG_FILE));
  logger.log(`Successfully logged out.`);
}
__name(logout, "logout");
function listScopes(message = "\u{1F481} Available scopes:") {
  logger.log(message);
  const data = DefaultScopeKeys.map((scope) => ({
    Scope: scope,
    Description: AllScopes[scope]
  }));
  logger.table(data);
}
__name(listScopes, "listScopes");
async function getAccountId() {
  const apiToken = getAPIToken();
  if (!apiToken)
    return;
  const cachedAccount2 = getAccountFromCache();
  if (cachedAccount2 && !getCloudflareAccountIdFromEnv()) {
    return cachedAccount2.id;
  }
  const accounts = await getAccountChoices();
  if (accounts.length === 1) {
    saveAccountToCache({ id: accounts[0].id, name: accounts[0].name });
    return accounts[0].id;
  }
  try {
    const accountID = await select("Select an account", {
      choices: accounts.map((account2) => ({
        title: account2.name,
        value: account2.id
      }))
    });
    const account = accounts.find(
      (a) => a.id === accountID
    );
    saveAccountToCache({ id: account.id, name: account.name });
    return accountID;
  } catch (e3) {
    if (e3 instanceof NoDefaultValueProvided) {
      throw new UserError(
        `More than one account available but unable to select one in non-interactive mode.
Please set the appropriate \`account_id\` in your \`wrangler.toml\` file.
Available accounts are (\`<name>\`: \`<account_id>\`):
${accounts.map((account) => `  \`${account.name}\`: \`${account.id}\``).join("\n")}`
      );
    }
    throw e3;
  }
}
__name(getAccountId, "getAccountId");
async function requireAuth(config) {
  const loggedIn = await loginOrRefreshIfRequired();
  if (!loggedIn) {
    if (!isInteractive() || CI.isCI()) {
      throw new UserError(
        "In a non-interactive environment, it's necessary to set a CLOUDFLARE_API_TOKEN environment variable for wrangler to work. Please go to https://developers.cloudflare.com/fundamentals/api/get-started/create-token/ for instructions on how to create an api token, and assign its value to CLOUDFLARE_API_TOKEN."
      );
    } else {
      throw new UserError("Did not login, quitting...");
    }
  }
  const accountId = config.account_id || await getAccountId();
  if (!accountId) {
    throw new UserError("No account id found, quitting...");
  }
  return accountId;
}
__name(requireAuth, "requireAuth");
function requireApiToken() {
  const credentials = getAPIToken();
  if (!credentials) {
    throw new UserError("No API token found.");
  }
  return credentials;
}
__name(requireApiToken, "requireApiToken");
function saveAccountToCache(account) {
  saveToConfigCache(
    "wrangler-account.json",
    { account }
  );
}
__name(saveAccountToCache, "saveAccountToCache");
function getAccountFromCache() {
  return getConfigCache(
    "wrangler-account.json"
  ).account;
}
__name(getAccountFromCache, "getAccountFromCache");
function getScopes() {
  return LocalState.scopes;
}
__name(getScopes, "getScopes");
async function fetchAuthToken(body) {
  const headers = {
    "Content-Type": "application/x-www-form-urlencoded"
  };
  if (await domainUsesAccess(getAuthDomainFromEnv())) {
    headers["Cookie"] = `CF_Authorization=${await getCloudflareAccessToken()}`;
  }
  return await (0, import_undici2.fetch)(getTokenUrlFromEnv(), {
    method: "POST",
    body: body.toString(),
    headers
  });
}
__name(fetchAuthToken, "fetchAuthToken");

// src/cfetch/internal.ts
async function performApiFetch(resource, init3 = {}, queryParams, abortSignal) {
  const method = init3.method ?? "GET";
  (0, import_node_assert2.default)(
    resource.startsWith("/"),
    `CF API fetch - resource path must start with a "/" but got "${resource}"`
  );
  await requireLoggedIn();
  const apiToken = requireApiToken();
  const headers = cloneHeaders(init3.headers);
  addAuthorizationHeaderIfUnspecified(headers, apiToken);
  addUserAgent(headers);
  const queryString = queryParams ? `?${queryParams.toString()}` : "";
  logger.debug(
    `-- START CF API REQUEST: ${method} ${getCloudflareApiBaseUrl()}${resource}${queryString}`
  );
  const logHeaders = cloneHeaders(headers);
  delete logHeaders["Authorization"];
  logger.debugWithSanitization("HEADERS:", JSON.stringify(logHeaders, null, 2));
  logger.debugWithSanitization("INIT:", JSON.stringify({ ...init3 }, null, 2));
  logger.debug("-- END CF API REQUEST");
  return await (0, import_undici3.fetch)(`${getCloudflareApiBaseUrl()}${resource}${queryString}`, {
    method,
    ...init3,
    headers,
    signal: abortSignal
  });
}
__name(performApiFetch, "performApiFetch");
async function fetchInternal(resource, init3 = {}, queryParams, abortSignal) {
  const method = init3.method ?? "GET";
  const response = await performApiFetch(
    resource,
    init3,
    queryParams,
    abortSignal
  );
  const jsonText = await response.text();
  logger.debug(
    "-- START CF API RESPONSE:",
    response.statusText,
    response.status
  );
  const logHeaders = cloneHeaders(response.headers);
  delete logHeaders["Authorization"];
  logger.debugWithSanitization("HEADERS:", JSON.stringify(logHeaders, null, 2));
  logger.debugWithSanitization("RESPONSE:", jsonText);
  logger.debug("-- END CF API RESPONSE");
  if (!jsonText && (response.status === 204 || response.status === 205)) {
    const emptyBody = `{"result": {}, "success": true, "errors": [], "messages": []}`;
    return parseJSON(emptyBody);
  }
  try {
    return parseJSON(jsonText);
  } catch (err) {
    throw new APIError({
      text: "Received a malformed response from the API",
      notes: [
        {
          text: truncate(jsonText, 100)
        },
        {
          text: `${method} ${resource} -> ${response.status} ${response.statusText}`
        }
      ]
    });
  }
}
__name(fetchInternal, "fetchInternal");
function truncate(text, maxLength) {
  const { length } = text;
  if (length <= maxLength) {
    return text;
  }
  return `${text.substring(0, maxLength)}... (length = ${length})`;
}
__name(truncate, "truncate");
function cloneHeaders(headers) {
  return headers instanceof import_undici3.Headers ? Object.fromEntries(headers.entries()) : Array.isArray(headers) ? Object.fromEntries(headers) : { ...headers };
}
__name(cloneHeaders, "cloneHeaders");
async function requireLoggedIn() {
  const loggedIn = await loginOrRefreshIfRequired();
  if (!loggedIn) {
    throw new UserError("Not logged in.");
  }
}
__name(requireLoggedIn, "requireLoggedIn");
function addAuthorizationHeaderIfUnspecified(headers, auth) {
  if (!("Authorization" in headers)) {
    if ("apiToken" in auth) {
      headers["Authorization"] = `Bearer ${auth.apiToken}`;
    } else {
      headers["X-Auth-Key"] = auth.authKey;
      headers["X-Auth-Email"] = auth.authEmail;
    }
  }
}
__name(addAuthorizationHeaderIfUnspecified, "addAuthorizationHeaderIfUnspecified");
function addUserAgent(headers) {
  headers["User-Agent"] = `wrangler/${version}`;
}
__name(addUserAgent, "addUserAgent");
async function fetchKVGetValue(accountId, namespaceId, key) {
  await requireLoggedIn();
  const auth = requireApiToken();
  const headers = {};
  addAuthorizationHeaderIfUnspecified(headers, auth);
  const resource = `${getCloudflareApiBaseUrl()}/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${key}`;
  const response = await (0, import_undici3.fetch)(resource, {
    method: "GET",
    headers
  });
  if (response.ok) {
    return await response.arrayBuffer();
  } else {
    throw new Error(
      `Failed to fetch ${resource} - ${response.status}: ${response.statusText});`
    );
  }
}
__name(fetchKVGetValue, "fetchKVGetValue");
async function fetchR2Objects(resource, bodyInit = {}) {
  await requireLoggedIn();
  const auth = requireApiToken();
  const headers = cloneHeaders(bodyInit.headers);
  addAuthorizationHeaderIfUnspecified(headers, auth);
  addUserAgent(headers);
  const response = await (0, import_undici3.fetch)(`${getCloudflareApiBaseUrl()}${resource}`, {
    ...bodyInit,
    headers
  });
  if (response.ok && response.body) {
    return response;
  } else if (response.status === 404) {
    return null;
  } else {
    throw new Error(
      `Failed to fetch ${resource} - ${response.status}: ${response.statusText});`
    );
  }
}
__name(fetchR2Objects, "fetchR2Objects");
async function fetchWorker(resource, bodyInit = {}) {
  await requireLoggedIn();
  const auth = requireApiToken();
  const headers = cloneHeaders(bodyInit.headers);
  addAuthorizationHeaderIfUnspecified(headers, auth);
  addUserAgent(headers);
  let response = await (0, import_undici3.fetch)(`${getCloudflareApiBaseUrl()}${resource}`, {
    ...bodyInit,
    headers
  });
  if (!response.ok || !response.body) {
    console.error(response.ok, response.body);
    throw new Error(
      `Failed to fetch ${resource} - ${response.status}: ${response.statusText});`
    );
  }
  const usesModules = response.headers.get("content-type")?.startsWith("multipart");
  if (usesModules) {
    if (!response.formData) {
      response = new import_undici3.Response(await response.text(), response);
    }
    const form = await response.formData();
    const files = Array.from(form.entries()).map(
      ([filename, contents]) => contents instanceof import_undici3.File ? contents : new import_undici3.File([contents], filename)
    );
    return {
      entrypoint: response.headers.get("cf-entrypoint") ?? "src/index.js",
      modules: files
    };
  } else {
    const contents = await response.text();
    const file = new import_undici3.File([contents], "index.js", { type: "text" });
    return {
      entrypoint: "index.js",
      modules: [file]
    };
  }
}
__name(fetchWorker, "fetchWorker");

// src/cfetch/index.ts
async function fetchResult(resource, init3 = {}, queryParams, abortSignal) {
  const json = await fetchInternal(
    resource,
    init3,
    queryParams,
    abortSignal
  );
  if (json.success) {
    return json.result;
  } else {
    throwFetchError(resource, json);
  }
}
__name(fetchResult, "fetchResult");
async function fetchGraphqlResult(init3 = {}, abortSignal) {
  const json = await fetchInternal(
    "/graphql",
    { ...init3, method: "POST" },
    //Cloudflare API v4 doesn't allow GETs to /graphql
    void 0,
    abortSignal
  );
  if (json) {
    return json;
  } else {
    throw new Error("A request to the Cloudflare API (/graphql) failed.");
  }
}
__name(fetchGraphqlResult, "fetchGraphqlResult");
async function fetchListResult(resource, init3 = {}, queryParams) {
  const results = [];
  let getMoreResults = true;
  let cursor;
  while (getMoreResults) {
    if (cursor) {
      queryParams = new import_node_url4.URLSearchParams(queryParams);
      queryParams.set("cursor", cursor);
    }
    const json = await fetchInternal(
      resource,
      init3,
      queryParams
    );
    if (json.success) {
      results.push(...json.result);
      if (hasCursor(json.result_info)) {
        cursor = json.result_info?.cursor;
      } else {
        getMoreResults = false;
      }
    } else {
      throwFetchError(resource, json);
    }
  }
  return results;
}
__name(fetchListResult, "fetchListResult");
async function fetchPagedListResult(resource, init3 = {}, queryParams) {
  const results = [];
  let getMoreResults = true;
  let page = 1;
  while (getMoreResults) {
    queryParams = new import_node_url4.URLSearchParams(queryParams);
    queryParams.set("page", String(page));
    const json = await fetchInternal(
      resource,
      init3,
      queryParams
    );
    if (json.success) {
      results.push(...json.result);
      if (hasMorePages(json.result_info)) {
        page = page + 1;
      } else {
        getMoreResults = false;
      }
    } else {
      throwFetchError(resource, json);
    }
  }
  return results;
}
__name(fetchPagedListResult, "fetchPagedListResult");
function hasMorePages(result_info) {
  const page = result_info?.page;
  const per_page = result_info?.per_page;
  const total = result_info?.total_count;
  return page !== void 0 && per_page !== void 0 && total !== void 0 && page * per_page < total;
}
__name(hasMorePages, "hasMorePages");
function throwFetchError(resource, response) {
  for (const error3 of response.errors)
    maybeThrowFriendlyError(error3);
  const error2 = new APIError({
    text: `A request to the Cloudflare API (${resource}) failed.`,
    notes: [
      ...response.errors.map((err) => ({ text: renderError(err) })),
      ...response.messages?.map((text) => ({ text })) ?? []
    ]
  });
  const code = response.errors[0]?.code;
  if (code) {
    error2.code = code;
  }
  throw error2;
}
__name(throwFetchError, "throwFetchError");
function hasCursor(result_info) {
  const cursor = result_info?.cursor;
  return cursor !== void 0 && cursor !== null && cursor !== "";
}
__name(hasCursor, "hasCursor");
function renderError(err, level = 0) {
  const chainedMessages = err.error_chain?.map(
    (chainedError) => `
${"  ".repeat(level)}- ${renderError(chainedError, level + 1)}`
  ).join("\n") ?? "";
  return (err.code ? `${err.message} [code: ${err.code}]` : err.message) + chainedMessages;
}
__name(renderError, "renderError");
async function fetchScriptContent(resource, init3 = {}, queryParams, abortSignal) {
  const response = await performApiFetch(
    resource,
    init3,
    queryParams,
    abortSignal
  );
  logger.debug(
    "-- START CF API RESPONSE:",
    response.statusText,
    response.status
  );
  logger.debug("HEADERS:", { ...response.headers });
  logger.debug("-- END CF API RESPONSE");
  const contentType = response.headers.get("content-type");
  const usesModules = contentType?.startsWith("multipart");
  if (usesModules && contentType) {
    const form = await response.formData();
    const entries = Array.from(form.entries());
    return entries.map((e3) => e3[1]).join("\n");
  } else {
    return await response.text();
  }
}
__name(fetchScriptContent, "fetchScriptContent");

// src/constellation/utils.ts
var getConstellationWarningFromEnv = getEnvironmentVariableFactory({
  variableName: "NO_CONSTELLATION_WARNING"
});
var constellationBetaWarning = getConstellationWarningFromEnv() !== void 0 ? "" : "--------------------\n\u{1F6A7} Constellation is currently in open alpha and is not recommended for production data and traffic\n\u{1F6A7} Please report any bugs to https://github.com/cloudflare/workers-sdk/issues/new/choose\n\u{1F6A7} To give feedback, visit https://discord.cloudflare.com\n--------------------\n";
var getProjectByName = /* @__PURE__ */ __name(async (config, accountId, name) => {
  const allProjects = await listProjects(accountId);
  const matchingProj = allProjects.find((proj) => proj.name === name);
  if (!matchingProj) {
    throw new UserError(`Couldn't find Project with name '${name}'`);
  }
  return matchingProj;
}, "getProjectByName");
var getProjectModelByName = /* @__PURE__ */ __name(async (config, accountId, proj, modelName) => {
  const allModels = await listModels(accountId, proj);
  const matchingModel = allModels.find((model) => model.name === modelName);
  if (!matchingModel) {
    throw new UserError(`Couldn't find Model with name '${modelName}'`);
  }
  return matchingModel;
}, "getProjectModelByName");
async function constellationList(accountId, partialUrl) {
  const pageSize = 50;
  let page = 1;
  const results = [];
  while (results.length % pageSize === 0) {
    const json = await fetchResult(
      `/accounts/${accountId}/constellation/${partialUrl}`,
      {},
      new URLSearchParams({
        per_page: pageSize.toString(),
        page: page.toString()
      })
    );
    page++;
    results.push(...json);
    if (json.length < pageSize) {
      break;
    }
  }
  return results;
}
__name(constellationList, "constellationList");
var listCatalogEntries = /* @__PURE__ */ __name(async (accountId) => {
  return await constellationList(accountId, "catalog");
}, "listCatalogEntries");
var listModels = /* @__PURE__ */ __name(async (accountId, proj) => {
  return constellationList(accountId, `project/${proj.id}/model`);
}, "listModels");
var listProjects = /* @__PURE__ */ __name(async (accountId) => {
  return await constellationList(accountId, "project");
}, "listProjects");
var listRuntimes = /* @__PURE__ */ __name(async (accountId) => {
  return await constellationList(accountId, "runtime");
}, "listRuntimes");

// src/config/diagnostics.ts
init_import_meta_url();
var Diagnostics = class {
  /**
   * Create a new Diagnostics object.
   * @param description A general description of this collection of messages.
   */
  constructor(description) {
    this.description = description;
  }
  errors = [];
  warnings = [];
  children = [];
  /**
   * Merge the given `diagnostics` into this as a child.
   */
  addChild(diagnostics) {
    if (diagnostics.hasErrors() || diagnostics.hasWarnings()) {
      this.children.push(diagnostics);
    }
  }
  /** Does this or any of its children have errors. */
  hasErrors() {
    if (this.errors.length > 0) {
      return true;
    } else {
      return this.children.some((child) => child.hasErrors());
    }
  }
  /** Render the errors of this and all its children. */
  renderErrors() {
    return this.render("errors");
  }
  /** Does this or any of its children have warnings. */
  hasWarnings() {
    if (this.warnings.length > 0) {
      return true;
    } else {
      return this.children.some((child) => child.hasWarnings());
    }
  }
  /** Render the warnings of this and all its children. */
  renderWarnings() {
    return this.render("warnings");
  }
  render(field) {
    const hasMethod = field === "errors" ? "hasErrors" : "hasWarnings";
    return indentText(
      `${this.description}
` + // Output all the fields (errors or warnings) at this level
      this[field].map((message) => `- ${indentText(message)}`).join("\n") + // Output all the child diagnostics at the next level
      this.children.map(
        (child) => child[hasMethod]() ? "\n- " + child.render(field) : ""
      ).filter((output) => output !== "").join("\n")
    );
  }
};
__name(Diagnostics, "Diagnostics");
function indentText(str) {
  return str.split("\n").map(
    (line, index) => (index === 0 ? line : `  ${line}`).replace(/^\s*$/, "")
  ).join("\n");
}
__name(indentText, "indentText");

// src/config/validation-helpers.ts
init_import_meta_url();
function deprecated(diagnostics, config, fieldPath, message, remove, title = "Deprecation", type = "warning") {
  const BOLD = "\x1B[1m";
  const NORMAL = "\x1B[0m";
  const diagnosticMessage = `${BOLD}${title}${NORMAL}: "${fieldPath}":
${message}`;
  const result = unwindPropertyPath(config, fieldPath);
  if (result !== void 0 && result.field in result.container) {
    diagnostics[`${type}s`].push(diagnosticMessage);
    if (remove) {
      delete result.container[result.field];
    }
  }
}
__name(deprecated, "deprecated");
function experimental(diagnostics, config, fieldPath) {
  const result = unwindPropertyPath(config, fieldPath);
  if (result !== void 0 && result.field in result.container) {
    diagnostics.warnings.push(
      `"${fieldPath}" fields are experimental and may change or break at any time.`
    );
  }
}
__name(experimental, "experimental");
function inheritable(diagnostics, topLevelEnv, rawEnv, field, validate2, defaultValue, transformFn = (v2) => v2) {
  validate2(diagnostics, field, rawEnv[field], topLevelEnv);
  return rawEnv[field] ?? transformFn(topLevelEnv?.[field]) ?? defaultValue;
}
__name(inheritable, "inheritable");
function inheritableInLegacyEnvironments(diagnostics, isLegacyEnv2, topLevelEnv, rawEnv, field, validate2, transformFn = (v2) => v2, defaultValue) {
  return topLevelEnv === void 0 || isLegacyEnv2 === true ? inheritable(
    diagnostics,
    topLevelEnv,
    rawEnv,
    field,
    validate2,
    defaultValue,
    transformFn
  ) : notAllowedInNamedServiceEnvironment(
    diagnostics,
    topLevelEnv,
    rawEnv,
    field
  );
}
__name(inheritableInLegacyEnvironments, "inheritableInLegacyEnvironments");
var appendEnvName = /* @__PURE__ */ __name((envName) => (fieldValue) => fieldValue ? `${fieldValue}-${envName}` : void 0, "appendEnvName");
function notAllowedInNamedServiceEnvironment(diagnostics, topLevelEnv, rawEnv, field) {
  if (field in rawEnv) {
    diagnostics.errors.push(
      `The "${field}" field is not allowed in named service environments.
Please remove the field from this environment.`
    );
  }
  return topLevelEnv[field];
}
__name(notAllowedInNamedServiceEnvironment, "notAllowedInNamedServiceEnvironment");
function notInheritable(diagnostics, topLevelEnv, rawConfig, rawEnv, envName, field, validate2, defaultValue) {
  if (rawEnv[field] !== void 0) {
    validate2(diagnostics, field, rawEnv[field], topLevelEnv);
  } else {
    if (rawConfig?.[field] !== void 0) {
      diagnostics.warnings.push(
        `"${field}" exists at the top level, but not on "env.${envName}".
This is not what you probably want, since "${field}" is not inherited by environments.
Please add "${field}" to "env.${envName}".`
      );
    }
  }
  return rawEnv[field] ?? defaultValue;
}
__name(notInheritable, "notInheritable");
function unwindPropertyPath(root, path67) {
  let container = root;
  const parts = path67.split(".");
  for (let i = 0; i < parts.length - 1; i++) {
    if (!hasProperty(container, parts[i])) {
      return;
    }
    container = container[parts[i]];
  }
  return { container, field: parts[parts.length - 1] };
}
__name(unwindPropertyPath, "unwindPropertyPath");
var isString = /* @__PURE__ */ __name((diagnostics, field, value) => {
  if (value !== void 0 && typeof value !== "string") {
    diagnostics.errors.push(
      `Expected "${field}" to be of type string but got ${JSON.stringify(
        value
      )}.`
    );
    return false;
  }
  return true;
}, "isString");
var isValidName = /* @__PURE__ */ __name((diagnostics, field, value) => {
  if (typeof value === "string" && /^$|^[a-z0-9_ ][a-z0-9-_ ]*$/.test(value) || value === void 0) {
    return true;
  } else {
    diagnostics.errors.push(
      `Expected "${field}" to be of type string, alphanumeric and lowercase with dashes only but got ${JSON.stringify(
        value
      )}.`
    );
    return false;
  }
}, "isValidName");
var isStringArray = /* @__PURE__ */ __name((diagnostics, field, value) => {
  if (value !== void 0 && (!Array.isArray(value) || value.some((item) => typeof item !== "string"))) {
    diagnostics.errors.push(
      `Expected "${field}" to be of type string array but got ${JSON.stringify(
        value
      )}.`
    );
    return false;
  }
  return true;
}, "isStringArray");
var isObjectWith = /* @__PURE__ */ __name((...properties) => (diagnostics, field, value) => {
  if (value !== void 0 && (typeof value !== "object" || value === null || !properties.every((prop) => prop in value))) {
    diagnostics.errors.push(
      `Expected "${field}" to be of type object, containing only properties ${properties}, but got ${JSON.stringify(
        value
      )}.`
    );
    return false;
  }
  if (value !== void 0) {
    const restFields = Object.keys(value).filter(
      (key) => !properties.includes(key)
    );
    validateAdditionalProperties(diagnostics, field, restFields, []);
  }
  return true;
}, "isObjectWith");
var isOneOf = /* @__PURE__ */ __name((...choices) => (diagnostics, field, value) => {
  if (value !== void 0 && !choices.some((choice) => value === choice)) {
    diagnostics.errors.push(
      `Expected "${field}" field to be one of ${JSON.stringify(
        choices
      )} but got ${JSON.stringify(value)}.`
    );
    return false;
  }
  return true;
}, "isOneOf");
var all = /* @__PURE__ */ __name((...validations) => {
  return (diagnostics, field, value, config) => {
    let passedValidations = true;
    for (const validate2 of validations) {
      if (!validate2(diagnostics, field, value, config)) {
        passedValidations = false;
      }
    }
    return passedValidations;
  };
}, "all");
var isMutuallyExclusiveWith = /* @__PURE__ */ __name((container, ...fields) => {
  return (diagnostics, field, value) => {
    if (value === void 0) {
      return true;
    }
    for (const exclusiveWith of fields) {
      if (container[exclusiveWith] !== void 0) {
        diagnostics.errors.push(
          `Expected exactly one of the following fields ${JSON.stringify([
            field,
            ...fields
          ])}.`
        );
        return false;
      }
    }
    return true;
  };
}, "isMutuallyExclusiveWith");
var isBoolean = /* @__PURE__ */ __name((diagnostics, field, value) => {
  if (value !== void 0 && typeof value !== "boolean") {
    diagnostics.errors.push(
      `Expected "${field}" to be of type boolean but got ${JSON.stringify(
        value
      )}.`
    );
    return false;
  }
  return true;
}, "isBoolean");
var validateRequiredProperty = /* @__PURE__ */ __name((diagnostics, container, key, value, type, choices) => {
  if (container) {
    container += ".";
  }
  if (value === void 0) {
    diagnostics.errors.push(`"${container}${key}" is a required field.`);
    return false;
  } else if (typeof value !== type) {
    diagnostics.errors.push(
      `Expected "${container}${key}" to be of type ${type} but got ${JSON.stringify(
        value
      )}.`
    );
    return false;
  } else if (choices) {
    if (!isOneOf(...choices)(diagnostics, `${container}${key}`, value, void 0)) {
      return false;
    }
  }
  return true;
}, "validateRequiredProperty");
var validateOptionalProperty = /* @__PURE__ */ __name((diagnostics, container, key, value, type, choices) => {
  if (value !== void 0) {
    return validateRequiredProperty(
      diagnostics,
      container,
      key,
      value,
      type,
      choices
    );
  }
  return true;
}, "validateOptionalProperty");
var validateTypedArray = /* @__PURE__ */ __name((diagnostics, container, value, type) => {
  let isValid = true;
  if (!Array.isArray(value)) {
    diagnostics.errors.push(
      `Expected "${container}" to be an array of ${type}s but got ${JSON.stringify(
        value
      )}`
    );
    isValid = false;
  } else {
    for (let i = 0; i < value.length; i++) {
      isValid = validateRequiredProperty(
        diagnostics,
        container,
        `[${i}]`,
        value[i],
        type
      ) && isValid;
    }
  }
  return isValid;
}, "validateTypedArray");
var validateOptionalTypedArray = /* @__PURE__ */ __name((diagnostics, container, value, type) => {
  if (value !== void 0) {
    return validateTypedArray(diagnostics, container, value, type);
  }
  return true;
}, "validateOptionalTypedArray");
var isRequiredProperty = /* @__PURE__ */ __name((obj, prop, type, choices) => hasProperty(obj, prop) && typeof obj[prop] === type && (choices === void 0 || choices.includes(obj[prop])), "isRequiredProperty");
var isOptionalProperty = /* @__PURE__ */ __name((obj, prop, type) => !hasProperty(obj, prop) || typeof obj[prop] === type, "isOptionalProperty");
var hasProperty = /* @__PURE__ */ __name((obj, property) => property in obj, "hasProperty");
var validateAdditionalProperties = /* @__PURE__ */ __name((diagnostics, fieldPath, restProps, knownProps) => {
  const restPropSet = new Set(restProps);
  for (const knownProp of knownProps) {
    restPropSet.delete(knownProp);
  }
  if (restPropSet.size > 0) {
    const fields = Array.from(restPropSet.keys()).map((field) => `"${field}"`);
    diagnostics.warnings.push(
      `Unexpected fields found in ${fieldPath} field: ${fields}`
    );
    return false;
  }
  return true;
}, "validateAdditionalProperties");
var getBindingNames = /* @__PURE__ */ __name((value) => {
  if (typeof value !== "object" || value === null) {
    return [];
  }
  if (isBindingList(value)) {
    return value.bindings.map(({ name }) => name);
  } else if (isNamespaceList(value)) {
    return value.map(({ binding }) => binding);
  } else if (isRecord(value)) {
    if (value["binding"] !== void 0) {
      return [value["binding"]];
    }
    return Object.keys(value).filter((k2) => value[k2] !== void 0);
  } else {
    return [];
  }
}, "getBindingNames");
var isBindingList = /* @__PURE__ */ __name((value) => isRecord(value) && "bindings" in value && Array.isArray(value.bindings) && value.bindings.every(
  (binding) => isRecord(binding) && "name" in binding && typeof binding.name === "string"
), "isBindingList");
var isNamespaceList = /* @__PURE__ */ __name((value) => Array.isArray(value) && value.every(
  (entry) => isRecord(entry) && "binding" in entry && typeof entry.binding === "string"
), "isNamespaceList");
var isRecord = /* @__PURE__ */ __name((value) => typeof value === "object" && value !== null && !Array.isArray(value), "isRecord");

// src/config/validation.ts
var ENGLISH = new Intl.ListFormat("en-US");
function isPagesConfig(rawConfig) {
  return rawConfig.pages_build_output_dir !== void 0;
}
__name(isPagesConfig, "isPagesConfig");
function normalizeAndValidateConfig(rawConfig, configPath, args) {
  const diagnostics = new Diagnostics(
    `Processing ${configPath ? import_node_path7.default.relative(process.cwd(), configPath) : "wrangler"} configuration:`
  );
  deprecated(
    diagnostics,
    rawConfig,
    "miniflare",
    "Wrangler does not use configuration in the `miniflare` section. Unless you are using Miniflare directly you can remove this section.",
    true,
    "\u{1F636} Ignored"
  );
  deprecated(
    diagnostics,
    rawConfig,
    "type",
    "Most common features now work out of the box with wrangler, including modules, jsx, typescript, etc. If you need anything more, use a custom build.",
    true,
    "\u{1F636} Ignored"
  );
  deprecated(
    diagnostics,
    rawConfig,
    "webpack_config",
    "Most common features now work out of the box with wrangler, including modules, jsx, typescript, etc. If you need anything more, use a custom build.",
    true,
    "\u{1F636} Ignored"
  );
  validateOptionalProperty(
    diagnostics,
    "",
    "legacy_env",
    rawConfig.legacy_env,
    "boolean"
  );
  validateOptionalProperty(
    diagnostics,
    "",
    "send_metrics",
    rawConfig.send_metrics,
    "boolean"
  );
  validateOptionalProperty(
    diagnostics,
    "",
    "keep_vars",
    rawConfig.keep_vars,
    "boolean"
  );
  validateOptionalProperty(
    diagnostics,
    "",
    "pages_build_output_dir",
    rawConfig.pages_build_output_dir,
    "string"
  );
  validateOptionalProperty(
    diagnostics,
    "",
    "$schema",
    rawConfig.$schema,
    "string"
  );
  const isLegacyEnv2 = typeof args["legacy-env"] === "boolean" ? args["legacy-env"] : rawConfig.legacy_env ?? true;
  if (!isLegacyEnv2) {
    diagnostics.warnings.push(
      "Experimental: Service environments are in beta, and their behaviour is guaranteed to change in the future. DO NOT USE IN PRODUCTION."
    );
  }
  const isDispatchNamespace = typeof args["dispatch-namespace"] === "string" && args["dispatch-namespace"].trim() !== "";
  const topLevelEnv = normalizeAndValidateEnvironment(
    diagnostics,
    configPath,
    rawConfig,
    isDispatchNamespace
  );
  const envName = args.env;
  (0, import_node_assert3.default)(envName === void 0 || typeof envName === "string");
  let activeEnv = topLevelEnv;
  if (envName !== void 0) {
    const envDiagnostics = new Diagnostics(
      `"env.${envName}" environment configuration`
    );
    const rawEnv = rawConfig.env?.[envName];
    if (rawEnv !== void 0) {
      activeEnv = normalizeAndValidateEnvironment(
        envDiagnostics,
        configPath,
        rawEnv,
        isDispatchNamespace,
        envName,
        topLevelEnv,
        isLegacyEnv2,
        rawConfig
      );
      diagnostics.addChild(envDiagnostics);
    } else if (!isPagesConfig(rawConfig)) {
      activeEnv = normalizeAndValidateEnvironment(
        envDiagnostics,
        configPath,
        {},
        isDispatchNamespace,
        envName,
        topLevelEnv,
        isLegacyEnv2,
        rawConfig
      );
      const envNames = rawConfig.env ? `The available configured environment names are: ${JSON.stringify(
        Object.keys(rawConfig.env)
      )}
` : "";
      const message = `No environment found in configuration with name "${envName}".
Before using \`--env=${envName}\` there should be an equivalent environment section in the configuration.
${envNames}
Consider adding an environment configuration section to the wrangler.toml file:
\`\`\`
[env.` + envName + "]\n```\n";
      if (envNames.length > 0) {
        diagnostics.errors.push(message);
      } else {
        diagnostics.warnings.push(message);
      }
    }
  }
  const config = {
    configPath,
    pages_build_output_dir: normalizeAndValidatePagesBuildOutputDir(
      configPath,
      rawConfig.pages_build_output_dir
    ),
    legacy_env: isLegacyEnv2,
    send_metrics: rawConfig.send_metrics,
    keep_vars: rawConfig.keep_vars,
    ...activeEnv,
    dev: normalizeAndValidateDev(diagnostics, rawConfig.dev ?? {}, args),
    migrations: normalizeAndValidateMigrations(
      diagnostics,
      rawConfig.migrations ?? [],
      activeEnv.durable_objects
    ),
    site: normalizeAndValidateSite(
      diagnostics,
      configPath,
      rawConfig,
      activeEnv.main
    ),
    assets: normalizeAndValidateAssets(diagnostics, configPath, rawConfig),
    wasm_modules: normalizeAndValidateModulePaths(
      diagnostics,
      configPath,
      "wasm_modules",
      rawConfig.wasm_modules
    ),
    text_blobs: normalizeAndValidateModulePaths(
      diagnostics,
      configPath,
      "text_blobs",
      rawConfig.text_blobs
    ),
    data_blobs: normalizeAndValidateModulePaths(
      diagnostics,
      configPath,
      "data_blobs",
      rawConfig.data_blobs
    )
  };
  validateBindingsHaveUniqueNames(diagnostics, config);
  validateAdditionalProperties(
    diagnostics,
    "top-level",
    Object.keys(rawConfig),
    [...Object.keys(config), "env", "$schema"]
  );
  experimental(diagnostics, rawConfig, "assets");
  return { config, diagnostics };
}
__name(normalizeAndValidateConfig, "normalizeAndValidateConfig");
function normalizeAndValidateBuild(diagnostics, rawEnv, rawBuild, configPath) {
  const { command: command2, cwd: cwd2, watch_dir = "./src", upload: upload2, ...rest } = rawBuild;
  const deprecatedUpload = { ...upload2 };
  validateAdditionalProperties(diagnostics, "build", Object.keys(rest), []);
  validateOptionalProperty(diagnostics, "build", "command", command2, "string");
  validateOptionalProperty(diagnostics, "build", "cwd", cwd2, "string");
  if (Array.isArray(watch_dir)) {
    validateTypedArray(diagnostics, "build.watch_dir", watch_dir, "string");
  } else {
    validateOptionalProperty(
      diagnostics,
      "build",
      "watch_dir",
      watch_dir,
      "string"
    );
  }
  deprecated(
    diagnostics,
    rawEnv,
    "build.upload.format",
    "The format is inferred automatically from the code.",
    true
  );
  if (rawEnv.main !== void 0 && rawBuild.upload?.main) {
    diagnostics.errors.push(
      `Don't define both the \`main\` and \`build.upload.main\` fields in your configuration.
They serve the same purpose: to point to the entry-point of your worker.
Delete the \`build.upload.main\` and \`build.upload.dir\` field from your config.`
    );
  } else {
    deprecated(
      diagnostics,
      rawEnv,
      "build.upload.main",
      `Delete the \`build.upload.main\` and \`build.upload.dir\` fields.
Then add the top level \`main\` field to your configuration file:
\`\`\`
main = "${import_node_path7.default.join(
        rawBuild.upload?.dir ?? "./dist",
        rawBuild.upload?.main ?? "."
      )}"
\`\`\``,
      true
    );
    deprecated(
      diagnostics,
      rawEnv,
      "build.upload.dir",
      `Use the top level "main" field or a command-line argument to specify the entry-point for the Worker.`,
      true
    );
  }
  return {
    command: command2,
    watch_dir: (
      // - `watch_dir` only matters when `command` is defined, so we apply
      // a default only when `command` is defined
      // - `configPath` will always be defined since `build` can only
      // be configured in `wrangler.toml`, but who knows, that may
      // change in the future, so we do a check anyway
      command2 && configPath ? Array.isArray(watch_dir) ? watch_dir.map(
        (dir) => import_node_path7.default.relative(
          process.cwd(),
          import_node_path7.default.join(import_node_path7.default.dirname(configPath), `${dir}`)
        )
      ) : import_node_path7.default.relative(
        process.cwd(),
        import_node_path7.default.join(import_node_path7.default.dirname(configPath), `${watch_dir}`)
      ) : watch_dir
    ),
    cwd: cwd2,
    deprecatedUpload
  };
}
__name(normalizeAndValidateBuild, "normalizeAndValidateBuild");
function normalizeAndValidateMainField(configPath, rawMain, deprecatedUpload) {
  const configDir = import_node_path7.default.dirname(configPath ?? "wrangler.toml");
  if (rawMain !== void 0) {
    if (typeof rawMain === "string") {
      const directory = import_node_path7.default.resolve(configDir);
      return import_node_path7.default.resolve(directory, rawMain);
    } else {
      return rawMain;
    }
  } else if (deprecatedUpload?.main !== void 0) {
    const directory = import_node_path7.default.resolve(
      configDir,
      deprecatedUpload?.dir || "./dist"
    );
    return import_node_path7.default.resolve(directory, deprecatedUpload.main);
  } else {
    return;
  }
}
__name(normalizeAndValidateMainField, "normalizeAndValidateMainField");
function normalizeAndValidateBaseDirField(configPath, rawDir) {
  const configDir = import_node_path7.default.dirname(configPath ?? "wrangler.toml");
  if (rawDir !== void 0) {
    if (typeof rawDir === "string") {
      const directory = import_node_path7.default.resolve(configDir);
      return import_node_path7.default.resolve(directory, rawDir);
    } else {
      return rawDir;
    }
  } else {
    return;
  }
}
__name(normalizeAndValidateBaseDirField, "normalizeAndValidateBaseDirField");
function normalizeAndValidatePagesBuildOutputDir(configPath, rawPagesDir) {
  const configDir = import_node_path7.default.dirname(configPath ?? "wrangler.toml");
  if (rawPagesDir !== void 0) {
    if (typeof rawPagesDir === "string") {
      const directory = import_node_path7.default.resolve(configDir);
      return import_node_path7.default.resolve(directory, rawPagesDir);
    } else {
      return rawPagesDir;
    }
  } else {
    return;
  }
}
__name(normalizeAndValidatePagesBuildOutputDir, "normalizeAndValidatePagesBuildOutputDir");
function normalizeAndValidateDev(diagnostics, rawDev, args) {
  (0, import_node_assert3.default)(typeof args === "object" && args !== null && !Array.isArray(args));
  const {
    localProtocol: localProtocolArg,
    upstreamProtocol: upstreamProtocolArg,
    remote: remoteArg
  } = args;
  (0, import_node_assert3.default)(
    localProtocolArg === void 0 || localProtocolArg === "http" || localProtocolArg === "https"
  );
  (0, import_node_assert3.default)(
    upstreamProtocolArg === void 0 || upstreamProtocolArg === "http" || upstreamProtocolArg === "https"
  );
  (0, import_node_assert3.default)(remoteArg === void 0 || typeof remoteArg === "boolean");
  const {
    // On Windows, when specifying `localhost` as the socket hostname, `workerd`
    // will only listen on the IPv4 loopback `127.0.0.1`, not the IPv6 `::1`:
    // https://github.com/cloudflare/workerd/issues/1408
    // On Node 17+, `fetch()` will only try to fetch the IPv6 address.
    // For now, on Windows, we default to listening on IPv4 only and using
    // `127.0.0.1` when sending control requests to `workerd` (e.g. with the
    // `ProxyController`).
    ip: ip2 = process.platform === "win32" ? "127.0.0.1" : "localhost",
    port: port2,
    inspector_port,
    local_protocol = localProtocolArg ?? "http",
    // In remote mode upstream_protocol must be https, otherwise it defaults to local_protocol.
    upstream_protocol = upstreamProtocolArg ?? remoteArg ? "https" : local_protocol,
    host,
    ...rest
  } = rawDev;
  validateAdditionalProperties(diagnostics, "dev", Object.keys(rest), []);
  validateOptionalProperty(diagnostics, "dev", "ip", ip2, "string");
  validateOptionalProperty(diagnostics, "dev", "port", port2, "number");
  validateOptionalProperty(
    diagnostics,
    "dev",
    "inspector_port",
    inspector_port,
    "number"
  );
  validateOptionalProperty(
    diagnostics,
    "dev",
    "local_protocol",
    local_protocol,
    "string",
    ["http", "https"]
  );
  validateOptionalProperty(
    diagnostics,
    "dev",
    "upstream_protocol",
    upstream_protocol,
    "string",
    ["http", "https"]
  );
  validateOptionalProperty(diagnostics, "dev", "host", host, "string");
  return { ip: ip2, port: port2, inspector_port, local_protocol, upstream_protocol, host };
}
__name(normalizeAndValidateDev, "normalizeAndValidateDev");
function normalizeAndValidateMigrations(diagnostics, rawMigrations, durableObjects) {
  if (!Array.isArray(rawMigrations)) {
    diagnostics.errors.push(
      `The optional "migrations" field should be an array, but got ${JSON.stringify(
        rawMigrations
      )}`
    );
    return [];
  } else {
    for (let i = 0; i < rawMigrations.length; i++) {
      const { tag, new_classes, renamed_classes, deleted_classes, ...rest } = rawMigrations[i];
      validateAdditionalProperties(
        diagnostics,
        "migrations",
        Object.keys(rest),
        []
      );
      validateRequiredProperty(
        diagnostics,
        `migrations[${i}]`,
        `tag`,
        tag,
        "string"
      );
      validateOptionalTypedArray(
        diagnostics,
        `migrations[${i}].new_classes`,
        new_classes,
        "string"
      );
      if (renamed_classes !== void 0) {
        if (!Array.isArray(renamed_classes)) {
          diagnostics.errors.push(
            `Expected "migrations[${i}].renamed_classes" to be an array of "{from: string, to: string}" objects but got ${JSON.stringify(
              renamed_classes
            )}.`
          );
        } else if (renamed_classes.some(
          (c2) => typeof c2 !== "object" || !isRequiredProperty(c2, "from", "string") || !isRequiredProperty(c2, "to", "string")
        )) {
          diagnostics.errors.push(
            `Expected "migrations[${i}].renamed_classes" to be an array of "{from: string, to: string}" objects but got ${JSON.stringify(
              renamed_classes
            )}.`
          );
        }
      }
      validateOptionalTypedArray(
        diagnostics,
        `migrations[${i}].deleted_classes`,
        deleted_classes,
        "string"
      );
    }
    if (Array.isArray(durableObjects?.bindings) && durableObjects.bindings.length > 0) {
      const exportedDurableObjects = (durableObjects.bindings || []).filter(
        (binding) => !binding.script_name
      );
      if (exportedDurableObjects.length > 0 && rawMigrations.length === 0) {
        if (!exportedDurableObjects.some(
          (exportedDurableObject) => typeof exportedDurableObject.class_name !== "string"
        )) {
          const durableObjectClassnames = exportedDurableObjects.map(
            (durable) => durable.class_name
          );
          diagnostics.warnings.push(
            `In wrangler.toml, you have configured [durable_objects] exported by this Worker (${durableObjectClassnames.join(
              ", "
            )}), but no [migrations] for them. This may not work as expected until you add a [migrations] section to your wrangler.toml. Add this configuration to your wrangler.toml:

  \`\`\`
  [[migrations]]
  tag = "v1" # Should be unique for each entry
  new_classes = [${durableObjectClassnames.map((name) => `"${name}"`).join(", ")}]
  \`\`\`

Refer to https://developers.cloudflare.com/durable-objects/reference/durable-objects-migrations/ for more details.`
          );
        }
      }
    }
    return rawMigrations;
  }
}
__name(normalizeAndValidateMigrations, "normalizeAndValidateMigrations");
function normalizeAndValidateSite(diagnostics, configPath, rawConfig, mainEntryPoint) {
  if (rawConfig?.site !== void 0) {
    const { bucket, include = [], exclude = [], ...rest } = rawConfig.site;
    validateAdditionalProperties(diagnostics, "site", Object.keys(rest), [
      "entry-point"
    ]);
    validateRequiredProperty(diagnostics, "site", "bucket", bucket, "string");
    validateTypedArray(diagnostics, "sites.include", include, "string");
    validateTypedArray(diagnostics, "sites.exclude", exclude, "string");
    validateOptionalProperty(
      diagnostics,
      "site",
      "entry-point",
      rawConfig.site["entry-point"],
      "string"
    );
    deprecated(
      diagnostics,
      rawConfig,
      `site.entry-point`,
      `Delete the \`site.entry-point\` field, then add the top level \`main\` field to your configuration file:
\`\`\`
main = "${import_node_path7.default.join(
        String(rawConfig.site["entry-point"]) || "workers-site",
        import_node_path7.default.extname(String(rawConfig.site["entry-point"]) || "workers-site") ? "" : "index.js"
      )}"
\`\`\``,
      false,
      void 0,
      "warning"
    );
    let siteEntryPoint = rawConfig.site["entry-point"];
    if (!mainEntryPoint && !siteEntryPoint) {
      diagnostics.warnings.push(
        `Because you've defined a [site] configuration, we're defaulting to "workers-site" for the deprecated \`site.entry-point\`field.
Add the top level \`main\` field to your configuration file:
\`\`\`
main = "workers-site/index.js"
\`\`\``
      );
      siteEntryPoint = "workers-site";
    } else if (mainEntryPoint && siteEntryPoint) {
      diagnostics.errors.push(
        `Don't define both the \`main\` and \`site.entry-point\` fields in your configuration.
They serve the same purpose: to point to the entry-point of your worker.
Delete the deprecated \`site.entry-point\` field from your config.`
      );
    }
    if (configPath && siteEntryPoint) {
      siteEntryPoint = import_node_path7.default.relative(
        process.cwd(),
        import_node_path7.default.join(import_node_path7.default.dirname(configPath), siteEntryPoint)
      );
    }
    return {
      bucket,
      "entry-point": siteEntryPoint,
      include,
      exclude
    };
  }
  return void 0;
}
__name(normalizeAndValidateSite, "normalizeAndValidateSite");
function normalizeAndValidateAssets(diagnostics, configPath, rawConfig) {
  if (typeof rawConfig?.assets === "string") {
    return {
      bucket: rawConfig.assets,
      include: [],
      exclude: [],
      browser_TTL: void 0,
      serve_single_page_app: false
    };
  }
  if (rawConfig?.assets === void 0) {
    return void 0;
  }
  if (typeof rawConfig.assets !== "object") {
    diagnostics.errors.push(
      `Expected the \`assets\` field to be a string or an object, but got ${typeof rawConfig.assets}.`
    );
    return void 0;
  }
  const {
    bucket,
    include = [],
    exclude = [],
    browser_TTL,
    serve_single_page_app,
    ...rest
  } = rawConfig.assets;
  validateAdditionalProperties(diagnostics, "assets", Object.keys(rest), []);
  validateRequiredProperty(diagnostics, "assets", "bucket", bucket, "string");
  validateTypedArray(diagnostics, "assets.include", include, "string");
  validateTypedArray(diagnostics, "assets.exclude", exclude, "string");
  validateOptionalProperty(
    diagnostics,
    "assets",
    "browser_TTL",
    browser_TTL,
    "number"
  );
  validateOptionalProperty(
    diagnostics,
    "assets",
    "serve_single_page_app",
    serve_single_page_app,
    "boolean"
  );
  return {
    bucket,
    include,
    exclude,
    browser_TTL,
    serve_single_page_app
  };
}
__name(normalizeAndValidateAssets, "normalizeAndValidateAssets");
function normalizeAndValidateModulePaths(diagnostics, configPath, field, rawMapping) {
  if (rawMapping === void 0) {
    return void 0;
  }
  const mapping = {};
  for (const [name, filePath] of Object.entries(rawMapping)) {
    if (isString(diagnostics, `${field}['${name}']`, filePath, void 0)) {
      if (configPath) {
        mapping[name] = configPath ? import_node_path7.default.relative(
          process.cwd(),
          import_node_path7.default.join(import_node_path7.default.dirname(configPath), filePath)
        ) : filePath;
      }
    }
  }
  return mapping;
}
__name(normalizeAndValidateModulePaths, "normalizeAndValidateModulePaths");
function isValidRouteValue(item) {
  if (!item) {
    return false;
  }
  if (typeof item === "string") {
    return true;
  }
  if (typeof item === "object") {
    if (!hasProperty(item, "pattern") || typeof item.pattern !== "string") {
      return false;
    }
    const otherKeys = Object.keys(item).length - 1;
    const hasZoneId = hasProperty(item, "zone_id") && typeof item.zone_id === "string";
    const hasZoneName = hasProperty(item, "zone_name") && typeof item.zone_name === "string";
    const hasCustomDomainFlag = hasProperty(item, "custom_domain") && typeof item.custom_domain === "boolean";
    if (otherKeys === 2 && hasCustomDomainFlag && (hasZoneId || hasZoneName)) {
      return true;
    } else if (otherKeys === 1 && (hasZoneId || hasZoneName || hasCustomDomainFlag)) {
      return true;
    }
  }
  return false;
}
__name(isValidRouteValue, "isValidRouteValue");
function mutateEmptyStringAccountIDValue(diagnostics, rawEnv) {
  if (rawEnv.account_id === "") {
    diagnostics.warnings.push(
      `The "account_id" field in your configuration is an empty string and will be ignored.
Please remove the "account_id" field from your configuration.`
    );
    rawEnv.account_id = void 0;
  }
  return rawEnv;
}
__name(mutateEmptyStringAccountIDValue, "mutateEmptyStringAccountIDValue");
function mutateEmptyStringRouteValue(diagnostics, rawEnv) {
  if (rawEnv["route"] === "") {
    diagnostics.warnings.push(
      `The "route" field in your configuration is an empty string and will be ignored.
Please remove the "route" field from your configuration.`
    );
    rawEnv["route"] = void 0;
  }
  return rawEnv;
}
__name(mutateEmptyStringRouteValue, "mutateEmptyStringRouteValue");
var isRoute = /* @__PURE__ */ __name((diagnostics, field, value) => {
  if (value !== void 0 && !isValidRouteValue(value)) {
    diagnostics.errors.push(
      `Expected "${field}" to be either a string, or an object with shape { pattern, custom_domain, zone_id | zone_name }, but got ${JSON.stringify(
        value
      )}.`
    );
    return false;
  }
  return true;
}, "isRoute");
var isRouteArray = /* @__PURE__ */ __name((diagnostics, field, value) => {
  if (value === void 0) {
    return true;
  }
  if (!Array.isArray(value)) {
    diagnostics.errors.push(
      `Expected "${field}" to be an array but got ${JSON.stringify(value)}.`
    );
    return false;
  }
  const invalidRoutes = [];
  for (const item of value) {
    if (!isValidRouteValue(item)) {
      invalidRoutes.push(item);
    }
  }
  if (invalidRoutes.length > 0) {
    diagnostics.errors.push(
      `Expected "${field}" to be an array of either strings or objects with the shape { pattern, custom_domain, zone_id | zone_name }, but these weren't valid: ${JSON.stringify(
        invalidRoutes,
        null,
        2
      )}.`
    );
  }
  return invalidRoutes.length === 0;
}, "isRouteArray");
function normalizeAndValidateRoute(diagnostics, topLevelEnv, rawEnv) {
  return inheritable(
    diagnostics,
    topLevelEnv,
    mutateEmptyStringRouteValue(diagnostics, rawEnv),
    "route",
    isRoute,
    void 0
  );
}
__name(normalizeAndValidateRoute, "normalizeAndValidateRoute");
function validateRoutes2(diagnostics, topLevelEnv, rawEnv) {
  return inheritable(
    diagnostics,
    topLevelEnv,
    rawEnv,
    "routes",
    all(isRouteArray, isMutuallyExclusiveWith(rawEnv, "route")),
    void 0
  );
}
__name(validateRoutes2, "validateRoutes");
function normalizeAndValidatePlacement(diagnostics, topLevelEnv, rawEnv) {
  if (rawEnv.placement) {
    validateRequiredProperty(
      diagnostics,
      "placement",
      "mode",
      rawEnv.placement.mode,
      "string",
      ["off", "smart"]
    );
  }
  return inheritable(
    diagnostics,
    topLevelEnv,
    rawEnv,
    "placement",
    () => true,
    void 0
  );
}
__name(normalizeAndValidatePlacement, "normalizeAndValidatePlacement");
function validateTailConsumer(diagnostics, field, value) {
  if (typeof value !== "object" || value === null) {
    diagnostics.errors.push(
      `"${field}" should be an object but got ${JSON.stringify(value)}.`
    );
    return false;
  }
  let isValid = true;
  isValid = isValid && validateRequiredProperty(
    diagnostics,
    field,
    "service",
    value.service,
    "string"
  );
  isValid = isValid && validateOptionalProperty(
    diagnostics,
    field,
    "environment",
    value.environment,
    "string"
  );
  return isValid;
}
__name(validateTailConsumer, "validateTailConsumer");
var validateTailConsumers = /* @__PURE__ */ __name((diagnostics, field, value) => {
  if (!value) {
    return true;
  }
  if (!Array.isArray(value)) {
    diagnostics.errors.push(
      `Expected "${field}" to be an array but got ${JSON.stringify(value)}.`
    );
    return false;
  }
  let isValid = true;
  for (let i = 0; i < value.length; i++) {
    isValid = validateTailConsumer(diagnostics, `${field}[${i}]`, value[i]) && isValid;
  }
  return isValid;
}, "validateTailConsumers");
function normalizeAndValidateEnvironment(diagnostics, configPath, rawEnv, isDispatchNamespace, envName = "top level", topLevelEnv, isLegacyEnv2, rawConfig) {
  deprecated(
    diagnostics,
    rawEnv,
    "kv-namespaces",
    `The "kv-namespaces" field is no longer supported, please rename to "kv_namespaces"`,
    true
  );
  deprecated(
    diagnostics,
    rawEnv,
    "zone_id",
    "This is unnecessary since we can deduce this from routes directly.",
    false
    // We need to leave this in-place for the moment since `route` commands might use it.
  );
  deprecated(
    diagnostics,
    rawEnv,
    "experimental_services",
    `The "experimental_services" field is no longer supported. Simply rename the [experimental_services] field to [services].`,
    true
  );
  experimental(diagnostics, rawEnv, "unsafe");
  const route2 = normalizeAndValidateRoute(diagnostics, topLevelEnv, rawEnv);
  const account_id = inheritableInLegacyEnvironments(
    diagnostics,
    isLegacyEnv2,
    topLevelEnv,
    mutateEmptyStringAccountIDValue(diagnostics, rawEnv),
    "account_id",
    isString,
    void 0,
    void 0
  );
  const routes = validateRoutes2(diagnostics, topLevelEnv, rawEnv);
  const workers_dev = inheritable(
    diagnostics,
    topLevelEnv,
    rawEnv,
    "workers_dev",
    isBoolean,
    void 0
  );
  const { deprecatedUpload, ...build5 } = normalizeAndValidateBuild(
    diagnostics,
    rawEnv,
    rawEnv.build ?? topLevelEnv?.build ?? {},
    configPath
  );
  const environment = {
    // Inherited fields
    account_id,
    compatibility_date: inheritable(
      diagnostics,
      topLevelEnv,
      rawEnv,
      "compatibility_date",
      isString,
      void 0
    ),
    compatibility_flags: inheritable(
      diagnostics,
      topLevelEnv,
      rawEnv,
      "compatibility_flags",
      isStringArray,
      []
    ),
    jsx_factory: inheritable(
      diagnostics,
      topLevelEnv,
      rawEnv,
      "jsx_factory",
      isString,
      "React.createElement"
    ),
    jsx_fragment: inheritable(
      diagnostics,
      topLevelEnv,
      rawEnv,
      "jsx_fragment",
      isString,
      "React.Fragment"
    ),
    tsconfig: validateAndNormalizeTsconfig(
      diagnostics,
      topLevelEnv,
      rawEnv,
      configPath
    ),
    rules: validateAndNormalizeRules(
      diagnostics,
      topLevelEnv,
      rawEnv,
      deprecatedUpload?.rules,
      envName
    ),
    name: inheritableInLegacyEnvironments(
      diagnostics,
      isLegacyEnv2,
      topLevelEnv,
      rawEnv,
      "name",
      isDispatchNamespace ? isString : isValidName,
      appendEnvName(envName),
      void 0
    ),
    main: normalizeAndValidateMainField(
      configPath,
      inheritable(
        diagnostics,
        topLevelEnv,
        rawEnv,
        "main",
        isString,
        void 0
      ),
      deprecatedUpload
    ),
    find_additional_modules: inheritable(
      diagnostics,
      topLevelEnv,
      rawEnv,
      "find_additional_modules",
      isBoolean,
      void 0
    ),
    preserve_file_names: inheritable(
      diagnostics,
      topLevelEnv,
      rawEnv,
      "preserve_file_names",
      isBoolean,
      void 0
    ),
    base_dir: normalizeAndValidateBaseDirField(
      configPath,
      inheritable(
        diagnostics,
        topLevelEnv,
        rawEnv,
        "base_dir",
        isString,
        void 0
      )
    ),
    route: route2,
    routes,
    triggers: inheritable(
      diagnostics,
      topLevelEnv,
      rawEnv,
      "triggers",
      isObjectWith("crons"),
      { crons: [] }
    ),
    usage_model: inheritable(
      diagnostics,
      topLevelEnv,
      rawEnv,
      "usage_model",
      isOneOf("bundled", "unbound"),
      void 0
    ),
    limits: normalizeAndValidateLimits(diagnostics, topLevelEnv, rawEnv),
    placement: normalizeAndValidatePlacement(diagnostics, topLevelEnv, rawEnv),
    build: build5,
    workers_dev,
    // Not inherited fields
    vars: notInheritable(
      diagnostics,
      topLevelEnv,
      rawConfig,
      rawEnv,
      envName,
      "vars",
      validateVars(envName),
      {}
    ),
    define: notInheritable(
      diagnostics,
      topLevelEnv,
      rawConfig,
      rawEnv,
      envName,
      "define",
      validateDefines(envName),
      {}
    ),
    durable_objects: notInheritable(
      diagnostics,
      topLevelEnv,
      rawConfig,
      rawEnv,
      envName,
      "durable_objects",
      validateBindingsProperty(envName, validateDurableObjectBinding),
      {
        bindings: []
      }
    ),
    kv_namespaces: notInheritable(
      diagnostics,
      topLevelEnv,
      rawConfig,
      rawEnv,
      envName,
      "kv_namespaces",
      validateBindingArray(envName, validateKVBinding),
      []
    ),
    cloudchamber: notInheritable(
      diagnostics,
      topLevelEnv,
      rawConfig,
      rawEnv,
      envName,
      "cloudchamber",
      validateCloudchamberConfig,
      {}
    ),
    send_email: notInheritable(
      diagnostics,
      topLevelEnv,
      rawConfig,
      rawEnv,
      envName,
      "send_email",
      validateBindingArray(envName, validateSendEmailBinding),
      []
    ),
    queues: notInheritable(
      diagnostics,
      topLevelEnv,
      rawConfig,
      rawEnv,
      envName,
      "queues",
      validateQueues(envName),
      { producers: [], consumers: [] }
    ),
    r2_buckets: notInheritable(
      diagnostics,
      topLevelEnv,
      rawConfig,
      rawEnv,
      envName,
      "r2_buckets",
      validateBindingArray(envName, validateR2Binding),
      []
    ),
    d1_databases: notInheritable(
      diagnostics,
      topLevelEnv,
      rawConfig,
      rawEnv,
      envName,
      "d1_databases",
      validateBindingArray(envName, validateD1Binding),
      []
    ),
    vectorize: notInheritable(
      diagnostics,
      topLevelEnv,
      rawConfig,
      rawEnv,
      envName,
      "vectorize",
      validateBindingArray(envName, validateVectorizeBinding),
      []
    ),
    constellation: notInheritable(
      diagnostics,
      topLevelEnv,
      rawConfig,
      rawEnv,
      envName,
      "constellation",
      validateBindingArray(envName, validateConstellationBinding),
      []
    ),
    hyperdrive: notInheritable(
      diagnostics,
      topLevelEnv,
      rawConfig,
      rawEnv,
      envName,
      "hyperdrive",
      validateBindingArray(envName, validateHyperdriveBinding),
      []
    ),
    services: notInheritable(
      diagnostics,
      topLevelEnv,
      rawConfig,
      rawEnv,
      envName,
      "services",
      validateBindingArray(envName, validateServiceBinding),
      []
    ),
    analytics_engine_datasets: notInheritable(
      diagnostics,
      topLevelEnv,
      rawConfig,
      rawEnv,
      envName,
      "analytics_engine_datasets",
      validateBindingArray(envName, validateAnalyticsEngineBinding),
      []
    ),
    dispatch_namespaces: notInheritable(
      diagnostics,
      topLevelEnv,
      rawConfig,
      rawEnv,
      envName,
      "dispatch_namespaces",
      validateBindingArray(envName, validateWorkerNamespaceBinding),
      []
    ),
    mtls_certificates: notInheritable(
      diagnostics,
      topLevelEnv,
      rawConfig,
      rawEnv,
      envName,
      "mtls_certificates",
      validateBindingArray(envName, validateMTlsCertificateBinding),
      []
    ),
    tail_consumers: notInheritable(
      diagnostics,
      topLevelEnv,
      rawConfig,
      rawEnv,
      envName,
      "tail_consumers",
      validateTailConsumers,
      void 0
    ),
    unsafe: notInheritable(
      diagnostics,
      topLevelEnv,
      rawConfig,
      rawEnv,
      envName,
      "unsafe",
      validateUnsafeSettings(envName),
      {}
    ),
    browser: notInheritable(
      diagnostics,
      topLevelEnv,
      rawConfig,
      rawEnv,
      envName,
      "browser",
      validateBrowserBinding(envName),
      void 0
    ),
    ai: notInheritable(
      diagnostics,
      topLevelEnv,
      rawConfig,
      rawEnv,
      envName,
      "ai",
      validateAIBinding(envName),
      void 0
    ),
    version_metadata: notInheritable(
      diagnostics,
      topLevelEnv,
      rawConfig,
      rawEnv,
      envName,
      "version_metadata",
      validateVersionMetadataBinding(envName),
      void 0
    ),
    zone_id: rawEnv.zone_id,
    logfwdr: inheritable(
      diagnostics,
      topLevelEnv,
      rawEnv,
      "logfwdr",
      validateCflogfwdrObject(envName),
      {
        bindings: []
      }
    ),
    no_bundle: inheritable(
      diagnostics,
      topLevelEnv,
      rawEnv,
      "no_bundle",
      isBoolean,
      void 0
    ),
    minify: inheritable(
      diagnostics,
      topLevelEnv,
      rawEnv,
      "minify",
      isBoolean,
      void 0
    ),
    node_compat: inheritable(
      diagnostics,
      topLevelEnv,
      rawEnv,
      "node_compat",
      isBoolean,
      void 0
    ),
    first_party_worker: inheritable(
      diagnostics,
      topLevelEnv,
      rawEnv,
      "first_party_worker",
      isBoolean,
      void 0
    ),
    logpush: inheritable(
      diagnostics,
      topLevelEnv,
      rawEnv,
      "logpush",
      isBoolean,
      void 0
    ),
    upload_source_maps: inheritable(
      diagnostics,
      topLevelEnv,
      rawEnv,
      "upload_source_maps",
      isBoolean,
      void 0
    )
  };
  return environment;
}
__name(normalizeAndValidateEnvironment, "normalizeAndValidateEnvironment");
function validateAndNormalizeTsconfig(diagnostics, topLevelEnv, rawEnv, configPath) {
  const tsconfig = inheritable(
    diagnostics,
    topLevelEnv,
    rawEnv,
    "tsconfig",
    isString,
    void 0
  );
  return configPath && tsconfig ? import_node_path7.default.relative(
    process.cwd(),
    import_node_path7.default.join(import_node_path7.default.dirname(configPath), tsconfig)
  ) : tsconfig;
}
__name(validateAndNormalizeTsconfig, "validateAndNormalizeTsconfig");
var validateAndNormalizeRules = /* @__PURE__ */ __name((diagnostics, topLevelEnv, rawEnv, deprecatedRules, envName) => {
  if (topLevelEnv === void 0) {
    if (rawEnv.rules && deprecatedRules) {
      diagnostics.errors.push(
        `You cannot configure both [rules] and [build.upload.rules] in your wrangler.toml. Delete the \`build.upload\` section.`
      );
    } else if (deprecatedRules) {
      diagnostics.warnings.push(
        `Deprecation: The \`build.upload.rules\` config field is no longer used, the rules should be specified via the \`rules\` config field. Delete the \`build.upload\` field from the configuration file, and add this:
\`\`\`
` + import_toml3.default.stringify({ rules: deprecatedRules }) + "```"
      );
    }
  }
  return inheritable(
    diagnostics,
    topLevelEnv,
    rawEnv,
    "rules",
    validateRules(envName),
    deprecatedRules ?? []
  );
}, "validateAndNormalizeRules");
var validateRules = /* @__PURE__ */ __name((envName) => (diagnostics, field, envValue, config) => {
  if (!envValue) {
    return true;
  }
  const fieldPath = config === void 0 ? `${field}` : `env.${envName}.${field}`;
  if (!Array.isArray(envValue)) {
    diagnostics.errors.push(
      `The field "${fieldPath}" should be an array but got ${JSON.stringify(
        envValue
      )}.`
    );
    return false;
  }
  let isValid = true;
  for (let i = 0; i < envValue.length; i++) {
    isValid = validateRule(diagnostics, `${fieldPath}[${i}]`, envValue[i], config) && isValid;
  }
  return isValid;
}, "validateRules");
var validateRule = /* @__PURE__ */ __name((diagnostics, field, value) => {
  if (typeof value !== "object" || value === null) {
    diagnostics.errors.push(
      `"${field}" should be an object but got ${JSON.stringify(value)}.`
    );
    return false;
  }
  let isValid = true;
  const rule = value;
  if (!isRequiredProperty(rule, "type", "string", [
    "ESModule",
    "CommonJS",
    "CompiledWasm",
    "Text",
    "Data"
  ])) {
    diagnostics.errors.push(
      `bindings should have a string "type" field, which contains one of "ESModule", "CommonJS", "CompiledWasm", "Text", or "Data".`
    );
    isValid = false;
  }
  isValid = validateTypedArray(diagnostics, `${field}.globs`, rule.globs, "string") && isValid;
  if (!isOptionalProperty(rule, "fallthrough", "boolean")) {
    diagnostics.errors.push(
      `the field "fallthrough", when present, should be a boolean.`
    );
    isValid = false;
  }
  return isValid;
}, "validateRule");
var validateDefines = /* @__PURE__ */ __name((envName) => (diagnostics, field, value, config) => {
  let isValid = true;
  const fieldPath = config === void 0 ? `${field}` : `env.${envName}.${field}`;
  if (typeof value === "object" && value !== null) {
    for (const varName in value) {
      if (typeof value[varName] !== "string") {
        diagnostics.errors.push(
          `The field "${fieldPath}.${varName}" should be a string but got ${JSON.stringify(
            value[varName]
          )}.`
        );
        isValid = false;
      }
    }
  } else {
    if (value !== void 0) {
      diagnostics.errors.push(
        `The field "${fieldPath}" should be an object but got ${JSON.stringify(
          value
        )}.
`
      );
      isValid = false;
    }
  }
  const configDefines = Object.keys(config?.define ?? {});
  if (configDefines.length > 0) {
    if (typeof value === "object" && value !== null) {
      const configEnvDefines = config === void 0 ? [] : Object.keys(value);
      for (const varName of configDefines) {
        if (!(varName in value)) {
          diagnostics.warnings.push(
            `"define.${varName}" exists at the top level, but not on "${fieldPath}".
This is not what you probably want, since "define" configuration is not inherited by environments.
Please add "define.${varName}" to "env.${envName}".`
          );
        }
      }
      for (const varName of configEnvDefines) {
        if (!configDefines.includes(varName)) {
          diagnostics.warnings.push(
            `"${varName}" exists on "env.${envName}", but not on the top level.
This is not what you probably want, since "define" configuration within environments can only override existing top level "define" configuration
Please remove "${fieldPath}.${varName}", or add "define.${varName}".`
          );
        }
      }
    }
  }
  return isValid;
}, "validateDefines");
var validateVars = /* @__PURE__ */ __name((envName) => (diagnostics, field, value, config) => {
  let isValid = true;
  const fieldPath = config === void 0 ? `${field}` : `env.${envName}.${field}`;
  const configVars = Object.keys(config?.vars ?? {});
  if (configVars.length > 0) {
    if (typeof value !== "object" || value === null) {
      diagnostics.errors.push(
        `The field "${fieldPath}" should be an object but got ${JSON.stringify(
          value
        )}.
`
      );
      isValid = false;
    } else {
      for (const varName of configVars) {
        if (!(varName in value)) {
          diagnostics.warnings.push(
            `"vars.${varName}" exists at the top level, but not on "${fieldPath}".
This is not what you probably want, since "vars" configuration is not inherited by environments.
Please add "vars.${varName}" to "env.${envName}".`
          );
        }
      }
    }
  }
  return isValid;
}, "validateVars");
var validateBindingsProperty = /* @__PURE__ */ __name((envName, validateBinding) => (diagnostics, field, value, config) => {
  let isValid = true;
  const fieldPath = config === void 0 ? `${field}` : `env.${envName}.${field}`;
  if (value !== void 0) {
    if (typeof value !== "object" || value === null || Array.isArray(value)) {
      diagnostics.errors.push(
        `The field "${fieldPath}" should be an object but got ${JSON.stringify(
          value
        )}.`
      );
      isValid = false;
    } else if (!hasProperty(value, "bindings")) {
      diagnostics.errors.push(
        `The field "${fieldPath}" is missing the required "bindings" property.`
      );
      isValid = false;
    } else if (!Array.isArray(value.bindings)) {
      diagnostics.errors.push(
        `The field "${fieldPath}.bindings" should be an array but got ${JSON.stringify(
          value.bindings
        )}.`
      );
      isValid = false;
    } else {
      for (let i = 0; i < value.bindings.length; i++) {
        const binding = value.bindings[i];
        const bindingDiagnostics = new Diagnostics(
          `"${fieldPath}.bindings[${i}]": ${JSON.stringify(binding)}`
        );
        isValid = validateBinding(
          bindingDiagnostics,
          `${fieldPath}.bindings[${i}]`,
          binding,
          config
        ) && isValid;
        diagnostics.addChild(bindingDiagnostics);
      }
    }
    const configBindingNames = getBindingNames(
      config?.[field]
    );
    if (isValid && configBindingNames.length > 0) {
      const envBindingNames = new Set(getBindingNames(value));
      const missingBindings = configBindingNames.filter(
        (name) => !envBindingNames.has(name)
      );
      if (missingBindings.length > 0) {
        diagnostics.warnings.push(
          `The following bindings are at the top level, but not on "env.${envName}".
This is not what you probably want, since "${field}" configuration is not inherited by environments.
Please add a binding for each to "${fieldPath}.bindings":
` + missingBindings.map((name) => `- ${name}`).join("\n")
        );
      }
    }
  }
  return isValid;
}, "validateBindingsProperty");
var validateUnsafeSettings = /* @__PURE__ */ __name((envName) => (diagnostics, field, value, config) => {
  const fieldPath = config === void 0 ? `${field}` : `env.${envName}.${field}`;
  if (typeof value !== "object" || value === null || Array.isArray(value)) {
    diagnostics.errors.push(
      `The field "${fieldPath}" should be an object but got ${JSON.stringify(
        value
      )}.`
    );
    return false;
  }
  if (!hasProperty(value, "bindings") && !hasProperty(value, "metadata") && !hasProperty(value, "capnp")) {
    diagnostics.errors.push(
      `The field "${fieldPath}" should contain at least one of "bindings", "metadata" or "capnp" properties but got ${JSON.stringify(
        value
      )}.`
    );
    return false;
  }
  if (hasProperty(value, "bindings") && value.bindings !== void 0) {
    const validateBindingsFn = validateBindingsProperty(
      envName,
      validateUnsafeBinding
    );
    const valid = validateBindingsFn(diagnostics, field, value, config);
    if (!valid) {
      return false;
    }
  }
  if (hasProperty(value, "metadata") && value.metadata !== void 0 && (typeof value.metadata !== "object" || value.metadata === null || Array.isArray(value.metadata))) {
    diagnostics.errors.push(
      `The field "${fieldPath}.metadata" should be an object but got ${JSON.stringify(
        value.metadata
      )}.`
    );
    return false;
  }
  if (hasProperty(value, "capnp") && value.capnp !== void 0) {
    if (typeof value.capnp !== "object" || value.capnp === null || Array.isArray(value.capnp)) {
      diagnostics.errors.push(
        `The field "${fieldPath}.capnp" should be an object but got ${JSON.stringify(
          value.capnp
        )}.`
      );
      return false;
    }
    if (hasProperty(value.capnp, "compiled_schema")) {
      if (hasProperty(value.capnp, "base_path") || hasProperty(value.capnp, "source_schemas")) {
        diagnostics.errors.push(
          `The field "${fieldPath}.capnp" cannot contain both "compiled_schema" and one of "base_path" or "source_schemas".`
        );
        return false;
      }
      if (typeof value.capnp.compiled_schema !== "string") {
        diagnostics.errors.push(
          `The field "${fieldPath}.capnp.compiled_schema", when present, should be a string but got ${JSON.stringify(
            value.capnp.compiled_schema
          )}.`
        );
        return false;
      }
    } else {
      if (!isRequiredProperty(value.capnp, "base_path", "string")) {
        diagnostics.errors.push(
          `The field "${fieldPath}.capnp.base_path", when present, should be a string but got ${JSON.stringify(
            value.capnp.base_path
          )}`
        );
      }
      if (!validateTypedArray(
        diagnostics,
        `${fieldPath}.capnp.source_schemas`,
        value.capnp.source_schemas,
        "string"
      )) {
        return false;
      }
    }
  }
  return true;
}, "validateUnsafeSettings");
var validateDurableObjectBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
  if (typeof value !== "object" || value === null) {
    diagnostics.errors.push(
      `Expected "${field}" to be an object but got ${JSON.stringify(value)}`
    );
    return false;
  }
  let isValid = true;
  if (!isRequiredProperty(value, "name", "string")) {
    diagnostics.errors.push(`binding should have a string "name" field.`);
    isValid = false;
  }
  if (!isRequiredProperty(value, "class_name", "string")) {
    diagnostics.errors.push(`binding should have a string "class_name" field.`);
    isValid = false;
  }
  if (!isOptionalProperty(value, "script_name", "string")) {
    diagnostics.errors.push(
      `the field "script_name", when present, should be a string.`
    );
    isValid = false;
  }
  if (!isOptionalProperty(value, "environment", "string")) {
    diagnostics.errors.push(
      `the field "environment", when present, should be a string.`
    );
    isValid = false;
  }
  if ("environment" in value && !("script_name" in value)) {
    diagnostics.errors.push(
      `binding should have a "script_name" field if "environment" is present.`
    );
    isValid = false;
  }
  validateAdditionalProperties(diagnostics, field, Object.keys(value), [
    "class_name",
    "environment",
    "name",
    "script_name"
  ]);
  return isValid;
}, "validateDurableObjectBinding");
var validateCflogfwdrObject = /* @__PURE__ */ __name((envName) => (diagnostics, field, value, topLevelEnv) => {
  const bindingsValidation = validateBindingsProperty(
    envName,
    validateCflogfwdrBinding
  );
  if (!bindingsValidation(diagnostics, field, value, topLevelEnv))
    return false;
  const v2 = value;
  if (v2?.schema !== void 0) {
    diagnostics.errors.push(
      `"${field}" binding "schema" property has been replaced with the "unsafe.capnp" object, which expects a "base_path" and an array of "source_schemas" to compile, or a "compiled_schema" property.`
    );
    return false;
  }
  return true;
}, "validateCflogfwdrObject");
var validateCflogfwdrBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
  if (typeof value !== "object" || value === null) {
    diagnostics.errors.push(
      `Expected "${field}" to be an object but got ${JSON.stringify(value)}`
    );
    return false;
  }
  let isValid = true;
  if (!isRequiredProperty(value, "name", "string")) {
    diagnostics.errors.push(`binding should have a string "name" field.`);
    isValid = false;
  }
  if (!isRequiredProperty(value, "destination", "string")) {
    diagnostics.errors.push(
      `binding should have a string "destination" field.`
    );
    isValid = false;
  }
  validateAdditionalProperties(diagnostics, field, Object.keys(value), [
    "destination",
    "name"
  ]);
  return isValid;
}, "validateCflogfwdrBinding");
var validateBrowserBinding = /* @__PURE__ */ __name((envName) => (diagnostics, field, value, config) => {
  const fieldPath = config === void 0 ? `${field}` : `env.${envName}.${field}`;
  if (typeof value !== "object" || value === null || Array.isArray(value)) {
    diagnostics.errors.push(
      `The field "${fieldPath}" should be an object but got ${JSON.stringify(
        value
      )}.`
    );
    return false;
  }
  let isValid = true;
  if (!isRequiredProperty(value, "binding", "string")) {
    diagnostics.errors.push(`binding should have a string "binding" field.`);
    isValid = false;
  }
  validateAdditionalProperties(diagnostics, field, Object.keys(value), [
    "binding"
  ]);
  return isValid;
}, "validateBrowserBinding");
var validateAIBinding = /* @__PURE__ */ __name((envName) => (diagnostics, field, value, config) => {
  const fieldPath = config === void 0 ? `${field}` : `env.${envName}.${field}`;
  if (typeof value !== "object" || value === null || Array.isArray(value)) {
    diagnostics.errors.push(
      `The field "${fieldPath}" should be an object but got ${JSON.stringify(
        value
      )}.`
    );
    return false;
  }
  let isValid = true;
  if (!isRequiredProperty(value, "binding", "string")) {
    diagnostics.errors.push(`binding should have a string "binding" field.`);
    isValid = false;
  }
  return isValid;
}, "validateAIBinding");
var validateVersionMetadataBinding = /* @__PURE__ */ __name((envName) => (diagnostics, field, value, config) => {
  const fieldPath = config === void 0 ? `${field}` : `env.${envName}.${field}`;
  if (typeof value !== "object" || value === null || Array.isArray(value)) {
    diagnostics.errors.push(
      `The field "${fieldPath}" should be an object but got ${JSON.stringify(
        value
      )}.`
    );
    return false;
  }
  let isValid = true;
  if (!isRequiredProperty(value, "binding", "string")) {
    diagnostics.errors.push(`binding should have a string "binding" field.`);
    isValid = false;
  }
  return isValid;
}, "validateVersionMetadataBinding");
var validateUnsafeBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
  if (typeof value !== "object" || value === null) {
    diagnostics.errors.push(
      `Expected ${field} to be an object but got ${JSON.stringify(value)}.`
    );
    return false;
  }
  let isValid = true;
  if (!isRequiredProperty(value, "name", "string")) {
    diagnostics.errors.push(`binding should have a string "name" field.`);
    isValid = false;
  }
  if (isRequiredProperty(value, "type", "string")) {
    const safeBindings = [
      "plain_text",
      "json",
      "wasm_module",
      "data_blob",
      "text_blob",
      "browser",
      "ai",
      "kv_namespace",
      "durable_object_namespace",
      "d1_database",
      "constellation",
      "r2_bucket",
      "service",
      "logfwdr",
      "mtls_certificate"
    ];
    if (safeBindings.includes(value.type)) {
      diagnostics.warnings.push(
        `The binding type "${value.type}" is directly supported by wrangler.
Consider migrating this unsafe binding to a format for '${value.type}' bindings that is supported by wrangler for optimal support.
For more details, see https://developers.cloudflare.com/workers/cli-wrangler/configuration`
      );
    }
  } else {
    diagnostics.errors.push(`binding should have a string "type" field.`);
    isValid = false;
  }
  return isValid;
}, "validateUnsafeBinding");
var validateBindingArray = /* @__PURE__ */ __name((envName, validateBinding) => (diagnostics, field, envValue, config) => {
  if (envValue === void 0) {
    return true;
  }
  const fieldPath = config === void 0 ? `${field}` : `env.${envName}.${field}`;
  if (!Array.isArray(envValue)) {
    diagnostics.errors.push(
      `The field "${fieldPath}" should be an array but got ${JSON.stringify(
        envValue
      )}.`
    );
    return false;
  }
  let isValid = true;
  for (let i = 0; i < envValue.length; i++) {
    isValid = validateBinding(
      diagnostics,
      `${fieldPath}[${i}]`,
      envValue[i],
      config
    ) && isValid;
  }
  const configValue = config?.[field];
  if (Array.isArray(configValue)) {
    const configBindingNames = configValue.map((value) => value.binding);
    if (configBindingNames.length > 0) {
      const envBindingNames = new Set(envValue.map((value) => value.binding));
      for (const configBindingName of configBindingNames) {
        if (!envBindingNames.has(configBindingName)) {
          diagnostics.warnings.push(
            `There is a ${field} binding with name "${configBindingName}" at the top level, but not on "env.${envName}".
This is not what you probably want, since "${field}" configuration is not inherited by environments.
Please add a binding for "${configBindingName}" to "env.${envName}.${field}.bindings".`
          );
        }
      }
    }
  }
  return isValid;
}, "validateBindingArray");
var validateCloudchamberConfig = /* @__PURE__ */ __name((diagnostics, field, value) => {
  if (typeof value !== "object" || value === null) {
    diagnostics.errors.push(
      `"cloudchamber" should be an object, but got ${JSON.stringify(value)}`
    );
    return false;
  }
  let isValid = true;
  const requiredKeys = [];
  requiredKeys.forEach((key) => {
    if (!isRequiredProperty(value, key, "string")) {
      diagnostics.errors.push(
        `"${field}" bindings should have a string "${key}" field but got ${JSON.stringify(
          value
        )}.`
      );
      isValid = false;
    }
  });
  return isValid;
}, "validateCloudchamberConfig");
var validateKVBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
  if (typeof value !== "object" || value === null) {
    diagnostics.errors.push(
      `"kv_namespaces" bindings should be objects, but got ${JSON.stringify(
        value
      )}`
    );
    return false;
  }
  let isValid = true;
  if (!isRequiredProperty(value, "binding", "string")) {
    diagnostics.errors.push(
      `"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  if (!isRequiredProperty(value, "id", "string") || value.id.length === 0) {
    diagnostics.errors.push(
      `"${field}" bindings should have a string "id" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  if (!isOptionalProperty(value, "preview_id", "string")) {
    diagnostics.errors.push(
      `"${field}" bindings should, optionally, have a string "preview_id" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  validateAdditionalProperties(diagnostics, field, Object.keys(value), [
    "binding",
    "id",
    "preview_id"
  ]);
  return isValid;
}, "validateKVBinding");
var validateSendEmailBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
  if (typeof value !== "object" || value === null) {
    diagnostics.errors.push(
      `"send_email" bindings should be objects, but got ${JSON.stringify(
        value
      )}`
    );
    return false;
  }
  let isValid = true;
  if (!isRequiredProperty(value, "name", "string")) {
    diagnostics.errors.push(
      `"${field}" bindings should have a string "name" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  if (!isOptionalProperty(value, "destination_address", "string")) {
    diagnostics.errors.push(
      `"${field}" bindings should, optionally, have a string "destination_address" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  if (!isOptionalProperty(value, "allowed_destination_addresses", "object")) {
    diagnostics.errors.push(
      `"${field}" bindings should, optionally, have a []string "allowed_destination_addresses" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  if ("destination_address" in value && "allowed_destination_addresses" in value) {
    diagnostics.errors.push(
      `"${field}" bindings should have either a "destination_address" or "allowed_destination_addresses" field, but not both.`
    );
    isValid = false;
  }
  validateAdditionalProperties(diagnostics, field, Object.keys(value), [
    "allowed_destination_addresses",
    "destination_address",
    "name",
    "binding"
  ]);
  return isValid;
}, "validateSendEmailBinding");
var validateQueueBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
  if (typeof value !== "object" || value === null) {
    diagnostics.errors.push(
      `"queue" bindings should be objects, but got ${JSON.stringify(value)}`
    );
    return false;
  }
  if (!validateAdditionalProperties(diagnostics, field, Object.keys(value), [
    "binding",
    "queue",
    "delivery_delay"
  ])) {
    return false;
  }
  let isValid = true;
  if (!isRequiredProperty(value, "binding", "string")) {
    diagnostics.errors.push(
      `"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  if (!isRequiredProperty(value, "queue", "string") || value.queue.length === 0) {
    diagnostics.errors.push(
      `"${field}" bindings should have a string "queue" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  const options29 = [{ key: "delivery_delay", type: "number" }];
  for (const optionalOpt of options29) {
    if (!isOptionalProperty(value, optionalOpt.key, optionalOpt.type)) {
      diagnostics.errors.push(
        `"${field}" should, optionally, have a ${optionalOpt.type} "${optionalOpt.key}" field but got ${JSON.stringify(value)}.`
      );
      isValid = false;
    }
  }
  return isValid;
}, "validateQueueBinding");
var validateR2Binding = /* @__PURE__ */ __name((diagnostics, field, value) => {
  if (typeof value !== "object" || value === null) {
    diagnostics.errors.push(
      `"r2_buckets" bindings should be objects, but got ${JSON.stringify(
        value
      )}`
    );
    return false;
  }
  let isValid = true;
  if (!isRequiredProperty(value, "binding", "string")) {
    diagnostics.errors.push(
      `"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  if (!isRequiredProperty(value, "bucket_name", "string") || value.bucket_name.length === 0) {
    diagnostics.errors.push(
      `"${field}" bindings should have a string "bucket_name" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  if (!isOptionalProperty(value, "preview_bucket_name", "string")) {
    diagnostics.errors.push(
      `"${field}" bindings should, optionally, have a string "preview_bucket_name" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  if (!isOptionalProperty(value, "jurisdiction", "string")) {
    diagnostics.errors.push(
      `"${field}" bindings should, optionally, have a string "jurisdiction" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  validateAdditionalProperties(diagnostics, field, Object.keys(value), [
    "binding",
    "bucket_name",
    "preview_bucket_name",
    "jurisdiction"
  ]);
  return isValid;
}, "validateR2Binding");
var validateD1Binding = /* @__PURE__ */ __name((diagnostics, field, value) => {
  if (typeof value !== "object" || value === null) {
    diagnostics.errors.push(
      `"d1_databases" bindings should be objects, but got ${JSON.stringify(
        value
      )}`
    );
    return false;
  }
  let isValid = true;
  if (!isRequiredProperty(value, "binding", "string")) {
    diagnostics.errors.push(
      `"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  if (
    // TODO: allow name only, where we look up the ID dynamically
    // !isOptionalProperty(value, "database_name", "string") &&
    !isRequiredProperty(value, "database_id", "string")
  ) {
    diagnostics.errors.push(
      `"${field}" bindings must have a "database_id" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  if (!isOptionalProperty(value, "preview_database_id", "string")) {
    diagnostics.errors.push(
      `"${field}" bindings should, optionally, have a string "preview_database_id" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  validateAdditionalProperties(diagnostics, field, Object.keys(value), [
    "binding",
    "database_id",
    "database_internal_env",
    "database_name",
    "migrations_dir",
    "migrations_table",
    "preview_database_id"
  ]);
  return isValid;
}, "validateD1Binding");
var validateVectorizeBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
  if (typeof value !== "object" || value === null) {
    diagnostics.errors.push(
      `"vectorize" bindings should be objects, but got ${JSON.stringify(value)}`
    );
    return false;
  }
  let isValid = true;
  if (!isRequiredProperty(value, "binding", "string")) {
    diagnostics.errors.push(
      `"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  if (!isRequiredProperty(value, "index_name", "string")) {
    diagnostics.errors.push(
      `"${field}" bindings must have an "index_name" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  validateAdditionalProperties(diagnostics, field, Object.keys(value), [
    "binding",
    "index_name"
  ]);
  return isValid;
}, "validateVectorizeBinding");
var validateConstellationBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
  if (typeof value !== "object" || value === null) {
    diagnostics.errors.push(
      `"constellation" bindings should be objects, but got ${JSON.stringify(
        value
      )}`
    );
    return false;
  }
  let isValid = true;
  if (!isRequiredProperty(value, "binding", "string")) {
    diagnostics.errors.push(
      `"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  if (!isRequiredProperty(value, "project_id", "string")) {
    diagnostics.errors.push(
      `"${field}" bindings must have a "project_id" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  if (isValid && getConstellationWarningFromEnv() === void 0) {
    diagnostics.warnings.push(
      "Constellation Bindings are currently in beta to allow the API to evolve before general availability.\nPlease report any issues to https://github.com/cloudflare/workers-sdk/issues/new/choose\nNote: Run this command with the environment variable NO_CONSTELLATION_WARNING=true to hide this message\n\nFor example: `export NO_CONSTELLATION_WARNING=true && wrangler <YOUR COMMAND HERE>`"
    );
  }
  validateAdditionalProperties(diagnostics, field, Object.keys(value), [
    "binding",
    "project_id"
  ]);
  return isValid;
}, "validateConstellationBinding");
var validateHyperdriveBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
  if (typeof value !== "object" || value === null) {
    diagnostics.errors.push(
      `"hyperdrive" bindings should be objects, but got ${JSON.stringify(
        value
      )}`
    );
    return false;
  }
  let isValid = true;
  if (!isRequiredProperty(value, "binding", "string")) {
    diagnostics.errors.push(
      `"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  if (!isRequiredProperty(value, "id", "string")) {
    diagnostics.errors.push(
      `"${field}" bindings must have a "id" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  validateAdditionalProperties(diagnostics, field, Object.keys(value), [
    "binding",
    "id",
    "localConnectionString"
  ]);
  return isValid;
}, "validateHyperdriveBinding");
var validateBindingsHaveUniqueNames = /* @__PURE__ */ __name((diagnostics, {
  durable_objects,
  kv_namespaces,
  r2_buckets,
  analytics_engine_datasets,
  text_blobs,
  browser,
  ai: ai2,
  unsafe,
  vars,
  define: define2,
  wasm_modules,
  data_blobs
}) => {
  let hasDuplicates = false;
  const bindingsGroupedByType = {
    "Durable Object": getBindingNames(durable_objects),
    "KV Namespace": getBindingNames(kv_namespaces),
    "R2 Bucket": getBindingNames(r2_buckets),
    "Analytics Engine Dataset": getBindingNames(analytics_engine_datasets),
    "Text Blob": getBindingNames(text_blobs),
    Browser: getBindingNames(browser),
    AI: getBindingNames(ai2),
    Unsafe: getBindingNames(unsafe),
    "Environment Variable": getBindingNames(vars),
    Definition: getBindingNames(define2),
    "WASM Module": getBindingNames(wasm_modules),
    "Data Blob": getBindingNames(data_blobs)
  };
  const bindingsGroupedByName = {};
  for (const bindingType in bindingsGroupedByType) {
    const bindingNames = bindingsGroupedByType[bindingType];
    for (const bindingName of bindingNames) {
      if (!(bindingName in bindingsGroupedByName)) {
        bindingsGroupedByName[bindingName] = [];
      }
      bindingsGroupedByName[bindingName].push(bindingType);
    }
  }
  for (const bindingName in bindingsGroupedByName) {
    const bindingTypes = bindingsGroupedByName[bindingName];
    if (bindingTypes.length < 2) {
      continue;
    }
    hasDuplicates = true;
    const sameType = bindingTypes.filter((type, i) => bindingTypes.indexOf(type) !== i).filter(
      (type, i, duplicateBindingTypes) => duplicateBindingTypes.indexOf(type) === i
    );
    const differentTypes = bindingTypes.filter(
      (type, i) => bindingTypes.indexOf(type) === i
    );
    if (differentTypes.length > 1) {
      diagnostics.errors.push(
        `${bindingName} assigned to ${ENGLISH.format(differentTypes)} bindings.`
      );
    }
    sameType.forEach((bindingType) => {
      diagnostics.errors.push(
        `${bindingName} assigned to multiple ${bindingType} bindings.`
      );
    });
  }
  if (hasDuplicates) {
    const problem = "Bindings must have unique names, so that they can all be referenced in the worker.";
    const resolution = "Please change your bindings to have unique names.";
    diagnostics.errors.push(`${problem}
${resolution}`);
  }
  return !hasDuplicates;
}, "validateBindingsHaveUniqueNames");
var validateServiceBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
  if (typeof value !== "object" || value === null) {
    diagnostics.errors.push(
      `"services" bindings should be objects, but got ${JSON.stringify(value)}`
    );
    return false;
  }
  let isValid = true;
  if (!isRequiredProperty(value, "binding", "string")) {
    diagnostics.errors.push(
      `"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  if (!isRequiredProperty(value, "service", "string")) {
    diagnostics.errors.push(
      `"${field}" bindings should have a string "service" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  if (!isOptionalProperty(value, "environment", "string")) {
    diagnostics.errors.push(
      `"${field}" bindings should have a string "environment" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  if (!isOptionalProperty(value, "entrypoint", "string")) {
    diagnostics.errors.push(
      `"${field}" bindings should have a string "entrypoint" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  return isValid;
}, "validateServiceBinding");
var validateAnalyticsEngineBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
  if (typeof value !== "object" || value === null) {
    diagnostics.errors.push(
      `"analytics_engine" bindings should be objects, but got ${JSON.stringify(
        value
      )}`
    );
    return false;
  }
  let isValid = true;
  if (!isRequiredProperty(value, "binding", "string")) {
    diagnostics.errors.push(
      `"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  if (!isOptionalProperty(value, "dataset", "string") || value.dataset?.length === 0) {
    diagnostics.errors.push(
      `"${field}" bindings should, optionally, have a string "dataset" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  validateAdditionalProperties(diagnostics, field, Object.keys(value), [
    "binding",
    "dataset"
  ]);
  return isValid;
}, "validateAnalyticsEngineBinding");
var validateWorkerNamespaceBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
  if (typeof value !== "object" || value === null) {
    diagnostics.errors.push(
      `"${field}" binding should be objects, but got ${JSON.stringify(value)}`
    );
    return false;
  }
  let isValid = true;
  if (!isRequiredProperty(value, "binding", "string")) {
    diagnostics.errors.push(
      `"${field}" should have a string "binding" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  if (!isRequiredProperty(value, "namespace", "string")) {
    diagnostics.errors.push(
      `"${field}" should have a string "namespace" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  if (hasProperty(value, "outbound")) {
    if (!validateWorkerNamespaceOutbound(
      diagnostics,
      `${field}.outbound`,
      value.outbound ?? {}
    )) {
      diagnostics.errors.push(`"${field}" has an invalid outbound definition.`);
      isValid = false;
    }
  }
  return isValid;
}, "validateWorkerNamespaceBinding");
function validateWorkerNamespaceOutbound(diagnostics, field, value) {
  if (typeof value !== "object" || value === null) {
    diagnostics.errors.push(
      `"${field}" should be an object, but got ${JSON.stringify(value)}`
    );
    return false;
  }
  let isValid = true;
  isValid = isValid && validateRequiredProperty(
    diagnostics,
    field,
    "service",
    value.service,
    "string"
  );
  isValid = isValid && validateOptionalProperty(
    diagnostics,
    field,
    "environment",
    value.environment,
    "string"
  );
  isValid = isValid && validateOptionalTypedArray(
    diagnostics,
    `${field}.parameters`,
    value.parameters,
    "string"
  );
  return isValid;
}
__name(validateWorkerNamespaceOutbound, "validateWorkerNamespaceOutbound");
var validateMTlsCertificateBinding = /* @__PURE__ */ __name((diagnostics, field, value) => {
  if (typeof value !== "object" || value === null) {
    diagnostics.errors.push(
      `"mtls_certificates" bindings should be objects, but got ${JSON.stringify(
        value
      )}`
    );
    return false;
  }
  let isValid = true;
  if (!isRequiredProperty(value, "binding", "string")) {
    diagnostics.errors.push(
      `"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  if (!isRequiredProperty(value, "certificate_id", "string") || value.certificate_id.length === 0) {
    diagnostics.errors.push(
      `"${field}" bindings should have a string "certificate_id" field but got ${JSON.stringify(
        value
      )}.`
    );
    isValid = false;
  }
  validateAdditionalProperties(diagnostics, field, Object.keys(value), [
    "binding",
    "certificate_id"
  ]);
  return isValid;
}, "validateMTlsCertificateBinding");
function validateQueues(envName) {
  return (diagnostics, field, value, config) => {
    const fieldPath = config === void 0 ? `${field}` : `env.${envName}.${field}`;
    if (typeof value !== "object" || Array.isArray(value) || value === null) {
      diagnostics.errors.push(
        `The field "${fieldPath}" should be an object but got ${JSON.stringify(
          value
        )}.`
      );
      return false;
    }
    let isValid = true;
    if (!validateAdditionalProperties(
      diagnostics,
      fieldPath,
      Object.keys(value),
      ["consumers", "producers"]
    )) {
      isValid = false;
    }
    if (hasProperty(value, "consumers")) {
      const consumers2 = value.consumers;
      if (!Array.isArray(consumers2)) {
        diagnostics.errors.push(
          `The field "${fieldPath}.consumers" should be an array but got ${JSON.stringify(
            consumers2
          )}.`
        );
        isValid = false;
      }
      for (let i = 0; i < consumers2.length; i++) {
        const consumer = consumers2[i];
        const consumerPath = `${fieldPath}.consumers[${i}]`;
        if (!validateConsumer(diagnostics, consumerPath, consumer, config)) {
          isValid = false;
        }
      }
    }
    if (hasProperty(value, "producers")) {
      if (!validateBindingArray(envName, validateQueueBinding)(
        diagnostics,
        `${field}.producers`,
        value.producers,
        config
      )) {
        isValid = false;
      }
    }
    return isValid;
  };
}
__name(validateQueues, "validateQueues");
var validateConsumer = /* @__PURE__ */ __name((diagnostics, field, value, _config) => {
  if (typeof value !== "object" || value === null) {
    diagnostics.errors.push(
      `"${field}" should be a objects, but got ${JSON.stringify(value)}`
    );
    return false;
  }
  let isValid = true;
  if (!validateAdditionalProperties(diagnostics, field, Object.keys(value), [
    "queue",
    "type",
    "max_batch_size",
    "max_batch_timeout",
    "max_retries",
    "dead_letter_queue",
    "max_concurrency",
    "visibility_timeout_ms",
    "retry_delay"
  ])) {
    isValid = false;
  }
  if (!isRequiredProperty(value, "queue", "string")) {
    diagnostics.errors.push(
      `"${field}" should have a string "queue" field but got ${JSON.stringify(
        value
      )}.`
    );
  }
  const options29 = [
    { key: "type", type: "string" },
    { key: "max_batch_size", type: "number" },
    { key: "max_batch_timeout", type: "number" },
    { key: "max_retries", type: "number" },
    { key: "dead_letter_queue", type: "string" },
    { key: "max_concurrency", type: "number" },
    { key: "visibility_timeout_ms", type: "number" },
    { key: "retry_delay", type: "number" }
  ];
  for (const optionalOpt of options29) {
    if (!isOptionalProperty(value, optionalOpt.key, optionalOpt.type)) {
      diagnostics.errors.push(
        `"${field}" should, optionally, have a ${optionalOpt.type} "${optionalOpt.key}" field but got ${JSON.stringify(value)}.`
      );
      isValid = false;
    }
  }
  return isValid;
}, "validateConsumer");
function normalizeAndValidateLimits(diagnostics, topLevelEnv, rawEnv) {
  if (rawEnv.limits) {
    validateRequiredProperty(
      diagnostics,
      "limits",
      "cpu_ms",
      rawEnv.limits.cpu_ms,
      "number"
    );
  }
  return inheritable(
    diagnostics,
    topLevelEnv,
    rawEnv,
    "limits",
    () => true,
    void 0
  );
}
__name(normalizeAndValidateLimits, "normalizeAndValidateLimits");

// src/config/validation-pages.ts
init_import_meta_url();

// src/config/config.ts
init_import_meta_url();
var defaultWranglerConfig = {
  /*====================================================*/
  /*      Fields supported by both Workers & Pages      */
  /*====================================================*/
  /* TOP-LEVEL ONLY FIELDS */
  pages_build_output_dir: void 0,
  send_metrics: void 0,
  dev: {
    ip: process.platform === "win32" ? "127.0.0.1" : "localhost",
    port: void 0,
    // the default of 8787 is set at runtime
    inspector_port: void 0,
    // the default of 9229 is set at runtime
    local_protocol: "http",
    upstream_protocol: "http",
    host: void 0
  },
  /** INHERITABLE ENVIRONMENT FIELDS **/
  name: void 0,
  compatibility_date: void 0,
  compatibility_flags: [],
  limits: void 0,
  placement: void 0,
  /** NON-INHERITABLE ENVIRONMENT FIELDS **/
  vars: {},
  durable_objects: { bindings: [] },
  kv_namespaces: [],
  queues: {
    producers: [],
    consumers: []
    // WORKERS SUPPORT ONLY!!
  },
  r2_buckets: [],
  d1_databases: [],
  vectorize: [],
  hyperdrive: [],
  services: [],
  analytics_engine_datasets: [],
  ai: void 0,
  version_metadata: void 0,
  /*====================================================*/
  /*           Fields supported by Workers only         */
  /*====================================================*/
  /* TOP-LEVEL ONLY FIELDS */
  configPath: void 0,
  legacy_env: true,
  migrations: [],
  site: void 0,
  assets: void 0,
  wasm_modules: void 0,
  text_blobs: void 0,
  data_blobs: void 0,
  keep_vars: void 0,
  /** INHERITABLE ENVIRONMENT FIELDS **/
  account_id: void 0,
  main: void 0,
  find_additional_modules: void 0,
  preserve_file_names: void 0,
  base_dir: void 0,
  workers_dev: void 0,
  route: void 0,
  routes: void 0,
  tsconfig: void 0,
  jsx_factory: "React.createElement",
  jsx_fragment: "React.Fragment",
  triggers: {
    crons: []
  },
  usage_model: void 0,
  rules: [],
  build: { command: void 0, watch_dir: "./src", cwd: void 0 },
  no_bundle: void 0,
  minify: void 0,
  node_compat: void 0,
  dispatch_namespaces: [],
  first_party_worker: void 0,
  zone_id: void 0,
  logfwdr: { bindings: [] },
  logpush: void 0,
  upload_source_maps: void 0,
  /** NON-INHERITABLE ENVIRONMENT FIELDS **/
  define: {},
  cloudchamber: {},
  send_email: [],
  constellation: [],
  browser: void 0,
  unsafe: {
    bindings: void 0,
    metadata: void 0
  },
  mtls_certificates: [],
  tail_consumers: void 0
};

// src/config/validation-pages.ts
var supportedPagesConfigFields = [
  "pages_build_output_dir",
  "name",
  "compatibility_date",
  "compatibility_flags",
  "send_metrics",
  "limits",
  "placement",
  "vars",
  "durable_objects",
  "kv_namespaces",
  "queues",
  // `producers` ONLY
  "r2_buckets",
  "d1_databases",
  "vectorize",
  "hyperdrive",
  "services",
  "analytics_engine_datasets",
  "ai",
  "version_metadata",
  "dev",
  // normalizeAndValidateConfig() sets this value
  "configPath"
];
function validatePagesConfig(config, envNames, projectName) {
  if (!config.pages_build_output_dir) {
    throw new FatalError(`Attempting to validate Pages configuration file, but "pages_build_output_dir" field was not found.
		"pages_build_output_dir" is required for Pages projects.`);
  }
  const diagnostics = new Diagnostics(
    `Running configuration file validation for Pages:`
  );
  validateMainField(config, diagnostics);
  validateProjectName(projectName, diagnostics);
  validatePagesEnvironmentNames(envNames, diagnostics);
  validateUnsupportedFields(config, diagnostics);
  validateDurableObjectBinding2(config, diagnostics);
  return diagnostics;
}
__name(validatePagesConfig, "validatePagesConfig");
function validateMainField(config, diagnostics) {
  if (config.main !== void 0) {
    diagnostics.errors.push(
      `Configuration file cannot contain both both "main" and "pages_build_output_dir" configuration keys.
Please use "main" if you are deploying a Worker, or "pages_build_output_dir" if you are deploying a Pages project.`
    );
  }
}
__name(validateMainField, "validateMainField");
function validateProjectName(name, diagnostics) {
  if (name === void 0 || name.trim() === "") {
    diagnostics.errors.push(
      `Missing top-level field "name" in configuration file.
Pages requires the name of your project to be configured at the top-level of your \`wrangler.toml\` file. This is because, in Pages, environments target the same project.`
    );
  }
}
__name(validateProjectName, "validateProjectName");
function validatePagesEnvironmentNames(envNames, diagnostics) {
  if (!envNames?.length)
    return;
  const unsupportedPagesEnvNames = envNames.filter(
    (name) => name !== "preview" && name !== "production"
  );
  if (unsupportedPagesEnvNames.length > 0) {
    diagnostics.errors.push(
      `Configuration file contains the following environment names that are not supported by Pages projects:
${unsupportedPagesEnvNames.map((name) => `"${name}"`).join()}.
The supported named-environments for Pages are "preview" and "production".`
    );
  }
}
__name(validatePagesEnvironmentNames, "validatePagesEnvironmentNames");
function validateUnsupportedFields(config, diagnostics) {
  const unsupportedFields = new Set(Object.keys(config));
  for (const field of supportedPagesConfigFields) {
    if (field === "queues" && config.queues?.consumers?.length) {
      continue;
    }
    unsupportedFields.delete(field);
  }
  for (const field of unsupportedFields) {
    if (config[field] === void 0 || JSON.stringify(config[field]) === JSON.stringify(defaultWranglerConfig[field])) {
      unsupportedFields.delete(field);
    }
  }
  if (unsupportedFields.size > 0) {
    const fields = Array.from(unsupportedFields.keys());
    fields.forEach((field) => {
      if (field === "queues" && config.queues?.consumers?.length) {
        diagnostics.errors.push(
          `Configuration file for Pages projects does not support "queues.consumers"`
        );
      } else {
        diagnostics.errors.push(
          `Configuration file for Pages projects does not support "${field}"`
        );
      }
    });
  }
}
__name(validateUnsupportedFields, "validateUnsupportedFields");
function validateDurableObjectBinding2(config, diagnostics) {
  if (config.durable_objects.bindings.length > 0) {
    const invalidBindings = config.durable_objects.bindings.filter(
      (binding) => !isRequiredProperty(binding, "script_name", "string")
    );
    if (invalidBindings.length > 0) {
      diagnostics.errors.push(
        `Durable Objects bindings should specify a "script_name".
Pages requires Durable Object bindings to specify the name of the Worker where the Durable Object is defined.`
      );
    }
  }
}
__name(validateDurableObjectBinding2, "validateDurableObjectBinding");

// src/config/index.ts
function readConfig(configPath, args, requirePagesConfig) {
  let rawConfig = {};
  if (!configPath) {
    configPath = findWranglerToml(process.cwd(), args.experimentalJsonConfig);
  }
  try {
    if (configPath?.endsWith("toml")) {
      rawConfig = parseTOML(readFileSync5(configPath), configPath);
    } else if (configPath?.endsWith("json")) {
      rawConfig = parseJSONC(readFileSync5(configPath), configPath);
    }
  } catch (e3) {
    if (requirePagesConfig) {
      logger.error(e3);
      throw new FatalError(
        "Your wrangler.toml is not a valid Pages config file",
        EXIT_CODE_INVALID_PAGES_CONFIG
      );
    } else {
      throw e3;
    }
  }
  const isPagesConfigFile = isPagesConfig(rawConfig);
  if (!isPagesConfigFile && requirePagesConfig) {
    throw new FatalError(
      "Your wrangler.toml is not a valid Pages config file",
      EXIT_CODE_INVALID_PAGES_CONFIG
    );
  }
  if (isPagesConfigFile && (configPath?.endsWith("json") || args.experimentalJsonConfig)) {
    throw new UserError(
      `Pages doesn't currently support JSON formatted config \`${configPath ?? "wrangler.json"}\`. Please use wrangler.toml instead.`
    );
  }
  const { config, diagnostics } = normalizeAndValidateConfig(
    rawConfig,
    configPath,
    args
  );
  if (diagnostics.hasWarnings()) {
    logger.warn(diagnostics.renderWarnings());
  }
  if (diagnostics.hasErrors()) {
    throw new UserError(diagnostics.renderErrors());
  }
  if (isPagesConfigFile) {
    logger.debug(
      `Configuration file belonging to \u26A1\uFE0F Pages \u26A1\uFE0F project detected.`
    );
    const envNames = rawConfig.env ? Object.keys(rawConfig.env) : [];
    const projectName = rawConfig?.name;
    const pagesDiagnostics = validatePagesConfig(config, envNames, projectName);
    if (pagesDiagnostics.hasWarnings()) {
      logger.warn(pagesDiagnostics.renderWarnings());
    }
    if (pagesDiagnostics.hasErrors()) {
      throw new UserError(pagesDiagnostics.renderErrors());
    }
  }
  const mainModule = "script" in args ? args.script : config.main;
  if (typeof mainModule === "string" && mainModule.endsWith(".py")) {
    config.no_bundle = true;
    if (!config.rules.some((rule) => rule.type === "PythonModule")) {
      config.rules.push({ type: "PythonModule", globs: ["**/*.py"] });
    }
  }
  return config;
}
__name(readConfig, "readConfig");
function findWranglerToml(referencePath = process.cwd(), preferJson = false) {
  if (preferJson) {
    return findUpSync(`wrangler.json`, { cwd: referencePath }) ?? findUpSync(`wrangler.toml`, { cwd: referencePath });
  }
  return findUpSync(`wrangler.toml`, { cwd: referencePath });
}
__name(findWranglerToml, "findWranglerToml");
function printBindings(bindings) {
  const truncate4 = /* @__PURE__ */ __name((item) => {
    const s = typeof item === "string" ? item : JSON.stringify(item);
    const maxLength = 40;
    if (s.length < maxLength) {
      return s;
    }
    return `${s.substring(0, maxLength - 3)}...`;
  }, "truncate");
  const output = [];
  const {
    data_blobs,
    durable_objects,
    kv_namespaces,
    send_email,
    queues: queues2,
    d1_databases,
    vectorize: vectorize2,
    constellation: constellation2,
    hyperdrive: hyperdrive2,
    r2_buckets,
    logfwdr,
    services,
    analytics_engine_datasets,
    text_blobs,
    browser,
    ai: ai2,
    version_metadata,
    unsafe,
    vars,
    wasm_modules,
    dispatch_namespaces,
    mtls_certificates
  } = bindings;
  if (data_blobs !== void 0 && Object.keys(data_blobs).length > 0) {
    output.push({
      type: "Data Blobs",
      entries: Object.entries(data_blobs).map(([key, value]) => ({
        key,
        value: truncate4(value)
      }))
    });
  }
  if (durable_objects !== void 0 && durable_objects.bindings.length > 0) {
    output.push({
      type: "Durable Objects",
      entries: durable_objects.bindings.map(
        ({ name, class_name, script_name, environment }) => {
          let value = class_name;
          if (script_name) {
            value += ` (defined in ${script_name})`;
          }
          if (environment) {
            value += ` - ${environment}`;
          }
          return {
            key: name,
            value
          };
        }
      )
    });
  }
  if (kv_namespaces !== void 0 && kv_namespaces.length > 0) {
    output.push({
      type: "KV Namespaces",
      entries: kv_namespaces.map(({ binding, id }) => {
        return {
          key: binding,
          value: id
        };
      })
    });
  }
  if (send_email !== void 0 && send_email.length > 0) {
    output.push({
      type: "Send Email",
      entries: send_email.map(
        ({ name, destination_address, allowed_destination_addresses }) => {
          return {
            key: name,
            value: destination_address || allowed_destination_addresses?.join(", ") || "unrestricted"
          };
        }
      )
    });
  }
  if (queues2 !== void 0 && queues2.length > 0) {
    output.push({
      type: "Queues",
      entries: queues2.map(({ binding, queue_name }) => {
        return {
          key: binding,
          value: queue_name
        };
      })
    });
  }
  if (d1_databases !== void 0 && d1_databases.length > 0) {
    output.push({
      type: "D1 Databases",
      entries: d1_databases.map(
        ({ binding, database_name, database_id, preview_database_id }) => {
          let databaseValue = `${database_id}`;
          if (database_name) {
            databaseValue = `${database_name} (${database_id})`;
          }
          if (preview_database_id && database_id !== "local") {
            databaseValue += `, Preview: (${preview_database_id})`;
          }
          return {
            key: binding,
            value: databaseValue
          };
        }
      )
    });
  }
  if (vectorize2 !== void 0 && vectorize2.length > 0) {
    output.push({
      type: "Vectorize Indexes",
      entries: vectorize2.map(({ binding, index_name }) => {
        return {
          key: binding,
          value: index_name
        };
      })
    });
  }
  if (constellation2 !== void 0 && constellation2.length > 0) {
    output.push({
      type: "Constellation Projects",
      entries: constellation2.map(({ binding, project_id }) => {
        return {
          key: binding,
          value: project_id
        };
      })
    });
  }
  if (hyperdrive2 !== void 0 && hyperdrive2.length > 0) {
    output.push({
      type: "Hyperdrive Configs",
      entries: hyperdrive2.map(({ binding, id }) => {
        return {
          key: binding,
          value: id
        };
      })
    });
  }
  if (r2_buckets !== void 0 && r2_buckets.length > 0) {
    output.push({
      type: "R2 Buckets",
      entries: r2_buckets.map(({ binding, bucket_name, jurisdiction }) => {
        if (jurisdiction !== void 0) {
          bucket_name += ` (${jurisdiction})`;
        }
        return {
          key: binding,
          value: bucket_name
        };
      })
    });
  }
  if (logfwdr !== void 0 && logfwdr.bindings.length > 0) {
    output.push({
      type: "logfwdr",
      entries: logfwdr.bindings.map((binding) => {
        return {
          key: binding.name,
          value: binding.destination
        };
      })
    });
  }
  if (services !== void 0 && services.length > 0) {
    output.push({
      type: "Services",
      entries: services.map(({ binding, service, environment, entrypoint }) => {
        let value = service;
        if (environment) {
          value += ` - ${environment}${entrypoint ? ` (#${entrypoint})` : ""}`;
        }
        return {
          key: binding,
          value
        };
      })
    });
  }
  if (analytics_engine_datasets !== void 0 && analytics_engine_datasets.length > 0) {
    output.push({
      type: "Analytics Engine Datasets",
      entries: analytics_engine_datasets.map(({ binding, dataset }) => {
        return {
          key: binding,
          value: dataset ?? binding
        };
      })
    });
  }
  if (text_blobs !== void 0 && Object.keys(text_blobs).length > 0) {
    output.push({
      type: "Text Blobs",
      entries: Object.entries(text_blobs).map(([key, value]) => ({
        key,
        value: truncate4(value)
      }))
    });
  }
  if (browser !== void 0) {
    output.push({
      type: "Browser",
      entries: [{ key: "Name", value: browser.binding }]
    });
  }
  if (ai2 !== void 0) {
    const entries = [
      { key: "Name", value: ai2.binding }
    ];
    if (ai2.staging)
      entries.push({ key: "Staging", value: ai2.staging });
    output.push({
      type: "AI",
      entries
    });
  }
  if (version_metadata !== void 0) {
    output.push({
      type: "Worker Version Metadata",
      entries: [{ key: "Name", value: version_metadata.binding }]
    });
  }
  if (unsafe?.bindings !== void 0 && unsafe.bindings.length > 0) {
    output.push({
      type: "Unsafe",
      entries: unsafe.bindings.map(({ name, type }) => ({
        key: type,
        value: name
      }))
    });
  }
  if (vars !== void 0 && Object.keys(vars).length > 0) {
    output.push({
      type: "Vars",
      entries: Object.entries(vars).map(([key, value]) => {
        let parsedValue;
        if (typeof value === "string") {
          parsedValue = `"${truncate4(value)}"`;
        } else if (typeof value === "object") {
          parsedValue = JSON.stringify(value, null, 1);
        } else {
          parsedValue = `${truncate4(`${value}`)}`;
        }
        return {
          key,
          value: parsedValue
        };
      })
    });
  }
  if (wasm_modules !== void 0 && Object.keys(wasm_modules).length > 0) {
    output.push({
      type: "Wasm Modules",
      entries: Object.entries(wasm_modules).map(([key, value]) => ({
        key,
        value: truncate4(value)
      }))
    });
  }
  if (dispatch_namespaces !== void 0 && dispatch_namespaces.length > 0) {
    output.push({
      type: "dispatch namespaces",
      entries: dispatch_namespaces.map(({ binding, namespace, outbound }) => {
        return {
          key: binding,
          value: outbound ? `${namespace} (outbound -> ${outbound.service})` : namespace
        };
      })
    });
  }
  if (mtls_certificates !== void 0 && mtls_certificates.length > 0) {
    output.push({
      type: "mTLS Certificates",
      entries: mtls_certificates.map(({ binding, certificate_id }) => {
        return {
          key: binding,
          value: certificate_id
        };
      })
    });
  }
  if (unsafe?.metadata !== void 0) {
    output.push({
      type: "Unsafe Metadata",
      entries: Object.entries(unsafe.metadata).map(([key, value]) => ({
        key,
        value: JSON.stringify(value)
      }))
    });
  }
  if (output.length === 0) {
    return;
  }
  const message = [
    `Your worker has access to the following bindings:`,
    ...output.map((bindingGroup) => {
      return [
        `- ${bindingGroup.type}:`,
        bindingGroup.entries.map(({ key, value }) => `  - ${key}: ${value}`)
      ];
    }).flat(2)
  ].join("\n");
  logger.log(message);
}
__name(printBindings, "printBindings");
function withConfig(handler30) {
  return (t3) => {
    return handler30({ ...t3, config: readConfig(t3.config, t3) });
  };
}
__name(withConfig, "withConfig");
function tryLoadDotEnv(path67) {
  try {
    const parsed = import_dotenv.default.parse(import_node_fs4.default.readFileSync(path67));
    return { path: path67, parsed };
  } catch (e3) {
    logger.debug(`Failed to load .env file "${path67}":`, e3);
  }
}
__name(tryLoadDotEnv, "tryLoadDotEnv");
function loadDotEnv(path67, env5) {
  if (env5 === void 0) {
    return tryLoadDotEnv(path67);
  } else {
    return tryLoadDotEnv(`${path67}.${env5}`) ?? tryLoadDotEnv(path67);
  }
}
__name(loadDotEnv, "loadDotEnv");

// src/deployment-bundle/entry.ts
init_import_meta_url();
var import_node_path15 = __toESM(require("node:path"));

// src/paths.ts
init_import_meta_url();
var import_node_console = require("node:console");
var import_node_fs5 = __toESM(require("node:fs"));
var import_node_path8 = __toESM(require("node:path"));
var import_signal_exit2 = __toESM(require_signal_exit());
function toUrlPath(filePath) {
  (0, import_node_console.assert)(
    !/^[a-z]:/i.test(filePath),
    "Tried to convert a Windows file path with a drive to a URL path."
  );
  return filePath.replace(/\\/g, "/");
}
__name(toUrlPath, "toUrlPath");
function readableRelative(to) {
  const relativePath = import_node_path8.default.relative(process.cwd(), to);
  if (
    // No directory nesting, return as-is
    import_node_path8.default.basename(relativePath) === relativePath || // Outside current directory
    relativePath.startsWith(".")
  ) {
    return relativePath;
  } else {
    return "./" + relativePath;
  }
}
__name(readableRelative, "readableRelative");
function getBasePath() {
  return import_node_path8.default.resolve(__dirname, "..");
}
__name(getBasePath, "getBasePath");
function getWranglerTmpDir(projectRoot, prefix) {
  projectRoot ??= process.cwd();
  const tmpRoot = import_node_path8.default.join(projectRoot, ".wrangler", "tmp");
  import_node_fs5.default.mkdirSync(tmpRoot, { recursive: true });
  const tmpPrefix = import_node_path8.default.join(tmpRoot, `${prefix}-`);
  const tmpDir = import_node_fs5.default.realpathSync(import_node_fs5.default.mkdtempSync(tmpPrefix));
  const removeDir = /* @__PURE__ */ __name(() => import_node_fs5.default.rmSync(tmpDir, { recursive: true, force: true }), "removeDir");
  const removeExitListener = (0, import_signal_exit2.default)(removeDir);
  return {
    path: tmpDir,
    remove() {
      removeExitListener();
      removeDir();
    }
  };
}
__name(getWranglerTmpDir, "getWranglerTmpDir");

// src/deployment-bundle/guess-worker-format.ts
init_import_meta_url();
var import_node_path11 = __toESM(require("node:path"));
var esbuild2 = __toESM(require("esbuild"));

// src/deployment-bundle/bundle.ts
init_import_meta_url();
var fs7 = __toESM(require("node:fs"));
var path12 = __toESM(require("node:path"));
var import_node_globals_polyfill = __toESM(require("@esbuild-plugins/node-globals-polyfill"));
var import_node_modules_polyfill = __toESM(require("@esbuild-plugins/node-modules-polyfill"));
var esbuild = __toESM(require("esbuild"));

// src/deployment-bundle/apply-middleware.ts
init_import_meta_url();
var fs6 = __toESM(require("node:fs"));
var path9 = __toESM(require("node:path"));

// src/utils/dedent.ts
init_import_meta_url();
var import_node_assert4 = __toESM(require("node:assert"));
function dedent(strings, ...values) {
  const raw = String.raw({ raw: strings }, ...values);
  let lines = raw.split("\n");
  (0, import_node_assert4.default)(lines.length > 0);
  if (lines[lines.length - 1].trim() === "") {
    lines = lines.slice(0, lines.length - 1);
  }
  let minIndent = "";
  let minIndentLength = Infinity;
  for (const line of lines.slice(1)) {
    const indent = line.match(/^[ \t]*/)?.[0];
    if (indent != null && indent.length < minIndentLength) {
      minIndent = indent;
      minIndentLength = indent.length;
    }
  }
  if (lines.length > 0 && lines[0].trim() === "")
    lines = lines.slice(1);
  lines = lines.map(
    (line) => line.startsWith(minIndent) ? line.substring(minIndent.length) : line
  );
  return lines.join("\n");
}
__name(dedent, "dedent");

// src/deployment-bundle/apply-middleware.ts
async function applyMiddlewareLoaderFacade(entry, tmpDirPath, middleware) {
  tmpDirPath = fs6.realpathSync(tmpDirPath);
  const middlewareIdentifiers = middleware.map((m2, index) => [
    `__MIDDLEWARE_${index}__`,
    path9.resolve(getBasePath(), m2.path)
  ]);
  const dynamicFacadePath = path9.join(
    tmpDirPath,
    "middleware-insertion-facade.js"
  );
  const imports = middlewareIdentifiers.map(
    ([id, middlewarePath]) => (
      /*javascript*/
      `import * as ${id} from "${prepareFilePath(
        middlewarePath
      )}";`
    )
  ).join("\n");
  const middlewareFns = middlewareIdentifiers.map(([m2]) => `${m2}.default`);
  if (entry.format === "modules") {
    await fs6.promises.writeFile(
      dynamicFacadePath,
      dedent`
				import worker, * as OTHER_EXPORTS from "${prepareFilePath(entry.file)}";
				${imports}
				
				worker.middleware = [
					${middlewareFns.join(",")},
					...(worker.middleware ?? []),
				].filter(Boolean);
				
				export * from "${prepareFilePath(entry.file)}";
				export default worker;
			`
    );
    const targetPathLoader = path9.join(
      tmpDirPath,
      "middleware-loader.entry.ts"
    );
    const loaderPath = path9.resolve(
      getBasePath(),
      "templates/middleware/loader-modules.ts"
    );
    const baseLoader = await fs6.promises.readFile(loaderPath, "utf-8");
    const transformedLoader = baseLoader.replaceAll("__ENTRY_POINT__", prepareFilePath(dynamicFacadePath)).replace(
      "./common",
      prepareFilePath(
        path9.resolve(getBasePath(), "templates/middleware/common.ts")
      )
    );
    await fs6.promises.writeFile(targetPathLoader, transformedLoader);
    return {
      entry: {
        ...entry,
        file: targetPathLoader
      }
    };
  } else {
    const loaderSwPath = path9.resolve(
      getBasePath(),
      "templates/middleware/loader-sw.ts"
    );
    await fs6.promises.writeFile(
      dynamicFacadePath,
      dedent`
				import { __facade_registerInternal__ } from "${prepareFilePath(loaderSwPath)}";
				${imports}
				__facade_registerInternal__([${middlewareFns}])
			`
    );
    return {
      entry,
      inject: [dynamicFacadePath]
    };
  }
}
__name(applyMiddlewareLoaderFacade, "applyMiddlewareLoaderFacade");
function prepareFilePath(filePath) {
  return JSON.stringify(filePath).slice(1, -1);
}
__name(prepareFilePath, "prepareFilePath");

// src/deployment-bundle/build-failures.ts
init_import_meta_url();
var import_node_module = require("node:module");
var nodeBuiltinResolveErrorText = new RegExp(
  '^Could not resolve "(' + import_node_module.builtinModules.join("|") + "|" + import_node_module.builtinModules.map((module3) => "node:" + module3).join("|") + ')"$'
);
function rewriteNodeCompatBuildFailure(errors, forPages = false) {
  for (const error2 of errors) {
    const match = nodeBuiltinResolveErrorText.exec(error2.text);
    if (match !== null) {
      const issue = `The package "${match[1]}" wasn't found on the file system but is built into node.`;
      const instructionForUser = `${forPages ? 'Add the "nodejs_compat" compatibility flag to your Pages project' : 'Add "node_compat = true" to your wrangler.toml file'} and make sure to prefix the module name with "node:" to enable Node.js compatibility.`;
      error2.notes = [
        {
          location: null,
          text: `${issue}
${instructionForUser}`
        }
      ];
    }
  }
}
__name(rewriteNodeCompatBuildFailure, "rewriteNodeCompatBuildFailure");
function isBuildFailure(err) {
  return typeof err === "object" && err !== null && "errors" in err && "warnings" in err;
}
__name(isBuildFailure, "isBuildFailure");

// src/deployment-bundle/dedupe-modules.ts
init_import_meta_url();
function dedupeModulesByName(modules) {
  return Object.values(
    modules.reduce((moduleMap, module3) => {
      moduleMap[module3.name] = module3;
      return moduleMap;
    }, {})
  );
}
__name(dedupeModulesByName, "dedupeModulesByName");

// src/deployment-bundle/entry-point-from-metafile.ts
init_import_meta_url();
var import_node_assert5 = __toESM(require("node:assert"));
function getEntryPointFromMetafile(entryFile, metafile) {
  const entryPoints = Object.entries(metafile.outputs).filter(
    ([_path, output]) => output.entryPoint !== void 0
  );
  if (entryPoints.length !== 1) {
    const entryPointList = entryPoints.map(([_input, output]) => output.entryPoint).join("\n");
    (0, import_node_assert5.default)(
      entryPoints.length > 0,
      `Cannot find entry-point "${entryFile}" in generated bundle.
${entryPointList}`
    );
    (0, import_node_assert5.default)(
      entryPoints.length < 2,
      `More than one entry-point found for generated bundle.
${entryPointList}`
    );
  }
  const [relativePath, entryPoint] = entryPoints[0];
  return {
    relativePath,
    exports: entryPoint.exports,
    dependencies: entryPoint.inputs
  };
}
__name(getEntryPointFromMetafile, "getEntryPointFromMetafile");

// src/deployment-bundle/esbuild-plugins/cloudflare-internal.ts
init_import_meta_url();
var cloudflareInternalPlugin = {
  name: "Cloudflare internal imports plugin",
  setup(pluginBuild) {
    pluginBuild.onResolve({ filter: /^cloudflare:.*/ }, () => {
      return { external: true };
    });
  }
};

// src/deployment-bundle/esbuild-plugins/config-provider.ts
init_import_meta_url();
function configProviderPlugin(config) {
  return {
    name: "middleware config provider plugin",
    setup(build5) {
      build5.onResolve({ filter: /^config:/ }, (args) => ({
        path: args.path,
        namespace: "wrangler-config"
      }));
      build5.onLoad(
        { filter: /.*/, namespace: "wrangler-config" },
        async (args) => {
          const middleware = args.path.split("config:middleware/")[1];
          if (!config[middleware]) {
            throw new Error(`No config found for ${middleware}`);
          }
          return {
            loader: "json",
            contents: JSON.stringify(config[middleware])
          };
        }
      );
    }
  };
}
__name(configProviderPlugin, "configProviderPlugin");

// src/deployment-bundle/esbuild-plugins/nodejs-compat.ts
init_import_meta_url();
var import_path5 = require("path");
var import_chalk3 = __toESM(require_chalk());
var nodejsCompatPlugin = /* @__PURE__ */ __name((silenceWarnings) => ({
  name: "nodejs_compat imports plugin",
  setup(pluginBuild) {
    const seen = /* @__PURE__ */ new Set();
    const warnedPackaged = /* @__PURE__ */ new Map();
    pluginBuild.onStart(() => {
      seen.clear();
      warnedPackaged.clear();
    });
    pluginBuild.onResolve(
      { filter: /node:.*/ },
      async ({ path: path67, kind, resolveDir, ...opts }) => {
        const specifier = `${path67}:${kind}:${resolveDir}:${opts.importer}`;
        if (seen.has(specifier)) {
          return;
        }
        seen.add(specifier);
        const result = await pluginBuild.resolve(path67, {
          kind,
          resolveDir,
          importer: opts.importer
        });
        if (result.errors.length > 0) {
          let pathWarnedPackaged = warnedPackaged.get(path67);
          if (pathWarnedPackaged === void 0) {
            warnedPackaged.set(path67, pathWarnedPackaged = []);
          }
          pathWarnedPackaged.push(opts.importer);
          return { external: true };
        }
        return result;
      }
    );
    pluginBuild.onEnd(() => {
      if (!silenceWarnings)
        warnedPackaged.forEach((importers, path67) => {
          logger.warn(
            `The package "${path67}" wasn't found on the file system but is built into node.
Your Worker may throw errors at runtime unless you enable the "nodejs_compat" compatibility flag. Refer to https://developers.cloudflare.com/workers/runtime-apis/nodejs/ for more details. Imported from:
${importers.map(
              (i) => ` - ${import_chalk3.default.blue(
                (0, import_path5.relative)(pluginBuild.initialOptions.absWorkingDir ?? "/", i)
              )}`
            ).join("\n")}`
          );
        });
    });
  }
}), "nodejsCompatPlugin");

// src/deployment-bundle/esbuild-plugins/standard-url.ts
init_import_meta_url();
var standardURLPlugin = /* @__PURE__ */ __name(() => ({
  name: "standard URL plugin",
  setup(pluginBuild) {
    pluginBuild.onResolve({ filter: /^node:url$|^url$/ }, ({ importer }) => {
      if (importer === "standard-url-plugin")
        return;
      return {
        path: "wrangler-url-polyfill",
        namespace: "wrangler-url"
      };
    });
    pluginBuild.onResolve(
      { filter: /^wrangler:url$/ },
      async ({ kind, resolveDir }) => {
        const result = await pluginBuild.resolve("url", {
          kind,
          resolveDir,
          importer: "standard-url-plugin"
        });
        return result;
      }
    );
    pluginBuild.onLoad(
      { filter: /^wrangler-url-polyfill$/, namespace: "wrangler-url" },
      () => {
        return {
          loader: "js",
          contents: `export * from "wrangler:url"; export const URL = globalThis.URL`
        };
      }
    );
  }
}), "standardURLPlugin");

// src/deployment-bundle/find-additional-modules.ts
init_import_meta_url();
var import_promises3 = require("node:fs/promises");
var import_node_path10 = __toESM(require("node:path"));
var import_chalk4 = __toESM(require_chalk());
var import_glob_to_regexp2 = __toESM(require_glob_to_regexp());

// src/deployment-bundle/bundle-type.ts
init_import_meta_url();
function getBundleType(format10, file) {
  if (file && file.endsWith(".py")) {
    return "python";
  }
  return format10 === "modules" ? "esm" : "commonjs";
}
__name(getBundleType, "getBundleType");

// src/deployment-bundle/module-collection.ts
init_import_meta_url();
var import_node_crypto3 = __toESM(require("node:crypto"));
var import_node_fs6 = require("node:fs");
var import_promises2 = require("node:fs/promises");
var import_node_path9 = __toESM(require("node:path"));
var import_glob_to_regexp = __toESM(require_glob_to_regexp());
var import_resolve = __toESM(require_resolve());

// ../../node_modules/.pnpm/resolve.exports@2.0.2/node_modules/resolve.exports/dist/index.mjs
init_import_meta_url();
function e(e3, n2, r3) {
  throw new Error(r3 ? `No known conditions for "${n2}" specifier in "${e3}" package` : `Missing "${n2}" specifier in "${e3}" package`);
}
__name(e, "e");
function n(n2, i, o2, f) {
  let s, u, l2 = r(n2, o2), c2 = function(e3) {
    let n3 = /* @__PURE__ */ new Set(["default", ...e3.conditions || []]);
    return e3.unsafe || n3.add(e3.require ? "require" : "import"), e3.unsafe || n3.add(e3.browser ? "browser" : "node"), n3;
  }(f || {}), a = i[l2];
  if (void 0 === a) {
    let e3, n3, r3, t3;
    for (t3 in i)
      n3 && t3.length < n3.length || ("/" === t3[t3.length - 1] && l2.startsWith(t3) ? (u = l2.substring(t3.length), n3 = t3) : t3.length > 1 && (r3 = t3.indexOf("*", 1), ~r3 && (e3 = RegExp("^" + t3.substring(0, r3) + "(.*)" + t3.substring(1 + r3)).exec(l2), e3 && e3[1] && (u = e3[1], n3 = t3))));
    a = i[n3];
  }
  return a || e(n2, l2), s = t(a, c2), s || e(n2, l2, 1), u && function(e3, n3) {
    let r3, t3 = 0, i2 = e3.length, o3 = /[*]/g, f2 = /[/]$/;
    for (; t3 < i2; t3++)
      e3[t3] = o3.test(r3 = e3[t3]) ? r3.replace(o3, n3) : f2.test(r3) ? r3 + n3 : r3;
  }(s, u), s;
}
__name(n, "n");
function r(e3, n2, r3) {
  if (e3 === n2 || "." === n2)
    return ".";
  let t3 = e3 + "/", i = t3.length, o2 = n2.slice(0, i) === t3, f = o2 ? n2.slice(i) : n2;
  return "#" === f[0] ? f : o2 || !r3 ? "./" === f.slice(0, 2) ? f : "./" + f : f;
}
__name(r, "r");
function t(e3, n2, r3) {
  if (e3) {
    if ("string" == typeof e3)
      return r3 && r3.add(e3), [e3];
    let i, o2;
    if (Array.isArray(e3)) {
      for (o2 = r3 || /* @__PURE__ */ new Set(), i = 0; i < e3.length; i++)
        t(e3[i], n2, o2);
      if (!r3 && o2.size)
        return [...o2];
    } else
      for (i in e3)
        if (n2.has(i))
          return t(e3[i], n2, r3);
  }
}
__name(t, "t");
function o(e3, r3, t3) {
  let i, o2 = e3.exports;
  if (o2) {
    if ("string" == typeof o2)
      o2 = { ".": o2 };
    else
      for (i in o2) {
        "." !== i[0] && (o2 = { ".": o2 });
        break;
      }
    return n(e3.name, o2, r3 || ".", t3);
  }
}
__name(o, "o");

// src/deployment-bundle/rules.ts
init_import_meta_url();
function isJavaScriptModuleRule(rule) {
  return rule.type === "ESModule" || rule.type === "CommonJS";
}
__name(isJavaScriptModuleRule, "isJavaScriptModuleRule");
var DEFAULT_MODULE_RULES = [
  { type: "Text", globs: ["**/*.txt", "**/*.html"] },
  { type: "Data", globs: ["**/*.bin"] },
  { type: "CompiledWasm", globs: ["**/*.wasm", "**/*.wasm?module"] }
];
function parseRules(userRules = []) {
  const rules = [...userRules, ...DEFAULT_MODULE_RULES];
  const completedRuleLocations = {};
  const redundantRules = {};
  let index = 0;
  const rulesToRemove = [];
  for (const rule of rules) {
    if (rule.type in completedRuleLocations) {
      if (rules[completedRuleLocations[rule.type]].fallthrough !== false) {
        if (rule.type in redundantRules) {
          redundantRules[rule.type].push({
            index,
            default: index >= userRules.length
          });
        } else {
          redundantRules[rule.type] = [
            { index, default: index >= userRules.length }
          ];
        }
      }
      rulesToRemove.push(rule);
    }
    if (!(rule.type in completedRuleLocations) && rule.fallthrough !== true) {
      completedRuleLocations[rule.type] = index;
    }
    index++;
  }
  for (const completedRuleType in completedRuleLocations) {
    const r3 = redundantRules[completedRuleType];
    if (r3) {
      const completedRuleIndex = completedRuleLocations[completedRuleType];
      let warning = `The ${completedRuleIndex >= userRules.length ? "default " : ""}module rule ${JSON.stringify(
        rules[completedRuleIndex]
      )} does not have a fallback, the following rules will be ignored:`;
      for (const rule of r3) {
        warning += `
 ${JSON.stringify(rules[rule.index])}${rule.default ? " (DEFAULT)" : ""}`;
      }
      warning += `

Add \`fallthrough = true\` to rule to allow next rule to be used or \`fallthrough = false\` to silence this warning`;
      logger.warn(warning);
    }
  }
  rulesToRemove.forEach((rule) => rules.splice(rules.indexOf(rule), 1));
  return { rules, removedRules: rulesToRemove };
}
__name(parseRules, "parseRules");

// src/deployment-bundle/module-collection.ts
function flipObject(obj) {
  return Object.fromEntries(Object.entries(obj).map(([k2, v2]) => [v2, k2]));
}
__name(flipObject, "flipObject");
var RuleTypeToModuleType = {
  ESModule: "esm",
  CommonJS: "commonjs",
  CompiledWasm: "compiled-wasm",
  Data: "buffer",
  Text: "text",
  PythonModule: "python",
  PythonRequirement: "python-requirement"
};
var ModuleTypeToRuleType = flipObject(RuleTypeToModuleType);
var modulesWatchRegexp = /^wrangler:modules-watch$/;
var modulesWatchNamespace = "wrangler-modules-watch";
var noopModuleCollector = {
  modules: [],
  plugin: {
    name: "wrangler-module-collector",
    setup: (build5) => {
      build5.onResolve({ filter: modulesWatchRegexp }, (args) => {
        return { namespace: modulesWatchNamespace, path: args.path };
      });
      build5.onLoad(
        { namespace: modulesWatchNamespace, filter: modulesWatchRegexp },
        () => ({ contents: "", loader: "js" })
      );
    }
  }
};
function extractPackageName(packagePath) {
  if (packagePath.startsWith("."))
    return null;
  const match = packagePath.match(/^(@[^/]+\/)?([^/]+)/);
  if (match) {
    const scoped = match[1] || "";
    const packageName = match[2];
    return `${scoped}${packageName}`;
  }
  return null;
}
__name(extractPackageName, "extractPackageName");
function createModuleCollector(props) {
  const parsedRules = parseRules(props.rules);
  const modules = [];
  return {
    modules,
    plugin: {
      name: "wrangler-module-collector",
      setup(build5) {
        let foundModulePaths = [];
        build5.onStart(async () => {
          modules.splice(0);
          if (props.findAdditionalModules) {
            if (props.entry.format !== "modules") {
              const error2 = "`find_additional_modules` can only be used with an ES module entrypoint.\nRemove `find_additional_modules = true` from your configuration, or migrate to the ES module Worker format: https://developers.cloudflare.com/workers/learning/migrate-to-module-workers/";
              return { errors: [{ text: error2 }] };
            }
            const found = await findAdditionalModules(props.entry, parsedRules);
            foundModulePaths = found.map(
              ({ name }) => import_node_path9.default.resolve(props.entry.moduleRoot, name)
            );
            modules.push(...found);
          }
        });
        build5.onResolve({ filter: modulesWatchRegexp }, (args) => {
          return { namespace: modulesWatchNamespace, path: args.path };
        });
        build5.onLoad(
          { namespace: modulesWatchNamespace, filter: modulesWatchRegexp },
          async () => {
            let watchFiles = [];
            const watchDirs = [];
            if (props.findAdditionalModules) {
              watchFiles = foundModulePaths;
              const root = import_node_path9.default.resolve(props.entry.moduleRoot);
              for await (const dir of findAdditionalModuleWatchDirs(root)) {
                watchDirs.push(dir);
              }
            }
            return { contents: "", loader: "js", watchFiles, watchDirs };
          }
        );
        const rulesMatchers = parsedRules.rules.flatMap((rule) => {
          return rule.globs.map((glob) => {
            const regex2 = (0, import_glob_to_regexp.default)(glob);
            return {
              regex: regex2,
              rule
            };
          });
        });
        if (props.wrangler1xLegacyModuleReferences && props.wrangler1xLegacyModuleReferences.fileNames.size > 0) {
          build5.onResolve(
            {
              filter: new RegExp(
                "^(" + [...props.wrangler1xLegacyModuleReferences.fileNames].map((name) => name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|") + ")$"
              )
            },
            async (args) => {
              if (args.kind !== "import-statement" && args.kind !== "require-call") {
                return;
              }
              logger.warn(
                `Deprecation: detected a legacy module import in "./${import_node_path9.default.relative(
                  process.cwd(),
                  args.importer
                )}". This will stop working in the future. Replace references to "${args.path}" with "./${args.path}";`
              );
              const filePath = import_node_path9.default.join(
                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                props.wrangler1xLegacyModuleReferences.rootDirectory,
                args.path
              );
              const fileContent = await (0, import_promises2.readFile)(filePath);
              const fileHash = import_node_crypto3.default.createHash("sha1").update(fileContent).digest("hex");
              const fileName = props.preserveFileNames ? args.path : `./${fileHash}-${import_node_path9.default.basename(args.path)}`;
              const { rule } = rulesMatchers.find(({ regex: regex2 }) => regex2.test(fileName)) || {};
              if (rule) {
                modules.push({
                  name: fileName,
                  filePath,
                  content: fileContent,
                  type: RuleTypeToModuleType[rule.type]
                });
                return {
                  path: fileName,
                  // change the reference to the changed module
                  external: props.entry.format === "modules",
                  // mark it as external in the bundle
                  namespace: `wrangler-module-${rule.type}`,
                  // just a tag, this isn't strictly necessary
                  watchFiles: [filePath]
                  // we also add the file to esbuild's watch list
                };
              }
            }
          );
        }
        parsedRules.rules?.forEach((rule) => {
          if (!props.findAdditionalModules && isJavaScriptModuleRule(rule)) {
            return;
          }
          rule.globs.forEach((glob) => {
            build5.onResolve(
              { filter: (0, import_glob_to_regexp.default)(glob) },
              async (args) => {
                let filePath = import_node_path9.default.join(args.resolveDir, args.path);
                if (foundModulePaths.includes(filePath)) {
                  return { path: args.path, external: true };
                }
                if (isJavaScriptModuleRule(rule))
                  return;
                if (args.path.includes("/") && !args.path.startsWith(".")) {
                  const packageName = extractPackageName(args.path);
                  if (!packageName) {
                    throw new Error(
                      `Unable to extract npm package name from ${args.path}`
                    );
                  }
                  const packageJsonPath = import_node_path9.default.join(
                    process.cwd(),
                    "node_modules",
                    packageName,
                    "package.json"
                  );
                  try {
                    const packageJson = JSON.parse(
                      await (0, import_promises2.readFile)(packageJsonPath, "utf8")
                    );
                    const testResolved = o(
                      packageJson,
                      args.path.replace(`${packageName}/`, ""),
                      {
                        conditions: BUILD_CONDITIONS
                      }
                    );
                    if (testResolved) {
                      filePath = import_node_path9.default.join(
                        process.cwd(),
                        "node_modules",
                        packageName,
                        testResolved[0]
                      );
                    }
                  } catch (e3) {
                  }
                }
                try {
                  const resolved = (0, import_resolve.sync)(args.path, {
                    basedir: args.resolveDir
                  });
                  filePath = resolved;
                } catch (e3) {
                }
                const fileContent = await (0, import_promises2.readFile)(filePath);
                const fileHash = import_node_crypto3.default.createHash("sha1").update(fileContent).digest("hex");
                const fileName = props.preserveFileNames ? args.path : `./${fileHash}-${import_node_path9.default.basename(args.path)}`;
                modules.push({
                  name: fileName,
                  filePath,
                  content: fileContent,
                  type: RuleTypeToModuleType[rule.type]
                });
                return {
                  path: fileName,
                  // change the reference to the changed module
                  external: props.entry.format === "modules",
                  // mark it as external in the bundle
                  namespace: `wrangler-module-${rule.type}`,
                  // just a tag, this isn't strictly necessary
                  watchFiles: [filePath]
                  // we also add the file to esbuild's watch list
                };
              }
            );
            if (props.entry.format === "service-worker") {
              build5.onLoad(
                { filter: (0, import_glob_to_regexp.default)(glob) },
                async (args) => {
                  return {
                    // We replace the the module with an identifier
                    // that we'll separately add to the form upload
                    // as part of [wasm_modules]/[text_blobs]/[data_blobs]. This identifier has to be a valid
                    // JS identifier, so we replace all non alphanumeric characters
                    // with an underscore.
                    contents: `export default ${args.path.replace(
                      /[^a-zA-Z0-9_$]/g,
                      "_"
                    )};`
                  };
                }
              );
            }
          });
        });
        parsedRules.removedRules.forEach((rule) => {
          rule.globs.forEach((glob) => {
            build5.onResolve(
              { filter: (0, import_glob_to_regexp.default)(glob) },
              async (args) => {
                throw new UserError(
                  `The file ${args.path} matched a module rule in your configuration (${JSON.stringify(
                    rule
                  )}), but was ignored because a previous rule with the same type was not marked as \`fallthrough = true\`.`
                );
              }
            );
          });
        });
      }
    }
  };
}
__name(createModuleCollector, "createModuleCollector");
function getWrangler1xLegacyModuleReferences(rootDirectory, entryPath) {
  return {
    rootDirectory,
    fileNames: new Set(
      (0, import_node_fs6.readdirSync)(rootDirectory, { withFileTypes: true }).filter(
        (dirEntry) => dirEntry.isFile() && dirEntry.name !== import_node_path9.default.basename(entryPath)
      ).map((dirEnt) => dirEnt.name)
    )
  };
}
__name(getWrangler1xLegacyModuleReferences, "getWrangler1xLegacyModuleReferences");

// src/deployment-bundle/find-additional-modules.ts
async function* getFiles(root, relativeTo) {
  for (const file of await (0, import_promises3.readdir)(root, { withFileTypes: true })) {
    if (file.isDirectory()) {
      yield* getFiles(import_node_path10.default.join(root, file.name), relativeTo);
    } else {
      yield import_node_path10.default.relative(relativeTo, import_node_path10.default.join(root, file.name)).replaceAll("\\", "/");
    }
  }
}
__name(getFiles, "getFiles");
function isValidPythonPackageName(name) {
  const regex2 = /^([A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])$/i;
  return regex2.test(name);
}
__name(isValidPythonPackageName, "isValidPythonPackageName");
async function findAdditionalModules(entry, rules) {
  const files = getFiles(entry.moduleRoot, entry.moduleRoot);
  const relativeEntryPoint = import_node_path10.default.relative(entry.moduleRoot, entry.file).replaceAll("\\", "/");
  if (Array.isArray(rules))
    rules = parseRules(rules);
  const modules = (await matchFiles(files, entry.moduleRoot, rules)).filter((m2) => m2.name !== relativeEntryPoint).map((m2) => ({
    ...m2,
    name: m2.name
  }));
  const isPythonEntrypoint = getBundleType(entry.format, entry.file) === "python";
  if (isPythonEntrypoint) {
    let pythonRequirements = "";
    try {
      pythonRequirements = await (0, import_promises3.readFile)(
        import_node_path10.default.resolve(entry.directory, "requirements.txt"),
        "utf-8"
      );
    } catch (e3) {
      logger.debug(
        "Python entrypoint detected, but no requirements.txt file found."
      );
    }
    for (const requirement of pythonRequirements.split("\n")) {
      if (requirement === "")
        continue;
      if (!isValidPythonPackageName(requirement)) {
        throw new UserError(
          `Invalid Python package name "${requirement}" found in requirements.txt. Note that requirements.txt should contain package names only, not version specifiers.`
        );
      }
      modules.push({
        type: "python-requirement",
        name: requirement,
        content: "",
        filePath: void 0
      });
    }
  }
  if (modules.length > 0) {
    logger.info(`Attaching additional modules:`);
    logger.table(
      modules.map(({ name, type, content }) => {
        return {
          Name: name,
          Type: type ?? "",
          Size: type === "python-requirement" ? "" : `${(content.length / 1024).toFixed(2)} KiB`
        };
      })
    );
  }
  return modules;
}
__name(findAdditionalModules, "findAdditionalModules");
async function matchFiles(files, relativeTo, { rules, removedRules }) {
  const modules = [];
  const moduleNames = /* @__PURE__ */ new Set();
  for await (const filePath of files) {
    for (const rule of rules) {
      for (const glob of rule.globs) {
        const regexp = (0, import_glob_to_regexp2.default)(glob, {
          globstar: true
        });
        if (!regexp.test(filePath)) {
          continue;
        }
        const absoluteFilePath = import_node_path10.default.join(relativeTo, filePath);
        const fileContent = await (0, import_promises3.readFile)(absoluteFilePath);
        const module3 = {
          name: filePath,
          content: fileContent,
          filePath: absoluteFilePath,
          type: RuleTypeToModuleType[rule.type]
        };
        if (!moduleNames.has(module3.name)) {
          moduleNames.add(module3.name);
          modules.push(module3);
        } else {
          logger.warn(
            `Ignoring duplicate module: ${import_chalk4.default.blue(
              module3.name
            )} (${import_chalk4.default.green(module3.type ?? "")})`
          );
        }
      }
    }
    for (const rule of removedRules) {
      for (const glob of rule.globs) {
        const regexp = (0, import_glob_to_regexp2.default)(glob);
        if (regexp.test(filePath)) {
          throw new UserError(
            `The file ${filePath} matched a module rule in your configuration (${JSON.stringify(
              rule
            )}), but was ignored because a previous rule with the same type was not marked as \`fallthrough = true\`.`
          );
        }
      }
    }
  }
  return modules;
}
__name(matchFiles, "matchFiles");
async function* findAdditionalModuleWatchDirs(root) {
  yield root;
  for (const entry of await (0, import_promises3.readdir)(root, { withFileTypes: true })) {
    if (entry.isDirectory()) {
      if (entry.name === "node_modules" || entry.name === ".git")
        continue;
      yield* findAdditionalModuleWatchDirs(import_node_path10.default.join(root, entry.name));
    }
  }
}
__name(findAdditionalModuleWatchDirs, "findAdditionalModuleWatchDirs");
async function writeAdditionalModules(modules, destination) {
  for (const module3 of modules) {
    const modulePath = import_node_path10.default.resolve(destination, module3.name);
    logger.debug("Writing additional module to output", modulePath);
    await (0, import_promises3.mkdir)(import_node_path10.default.dirname(modulePath), { recursive: true });
    await (0, import_promises3.writeFile)(modulePath, module3.content);
  }
}
__name(writeAdditionalModules, "writeAdditionalModules");

// src/deployment-bundle/bundle.ts
var COMMON_ESBUILD_OPTIONS = {
  // Our workerd runtime uses the same V8 version as recent Chrome, which is highly ES2022 compliant: https://kangax.github.io/compat-table/es2016plus/
  target: "es2022",
  loader: { ".js": "jsx", ".mjs": "jsx", ".cjs": "jsx" }
};
var BUILD_CONDITIONS = ["workerd", "worker", "browser"];
async function bundleWorker(entry, destination, {
  bundle,
  moduleCollector = noopModuleCollector,
  additionalModules = [],
  serveAssetsFromWorker,
  doBindings,
  jsxFactory,
  jsxFragment,
  entryName,
  watch: watch6,
  tsconfig,
  minify,
  legacyNodeCompat,
  nodejsCompat,
  define: define2,
  checkFetch,
  assets,
  bypassAssetCache,
  targetConsumer,
  testScheduled,
  inject: injectOption,
  loader,
  sourcemap,
  plugins,
  isOutfile,
  forPages,
  local,
  projectRoot,
  defineNavigatorUserAgent,
  external
}) {
  const tmpDir = getWranglerTmpDir(projectRoot, "bundle");
  const entryFile = entry.file;
  const middlewareToLoad = [];
  if (targetConsumer === "dev" && !process.env.WRANGLER_DISABLE_REQUEST_BODY_DRAINING) {
    middlewareToLoad.push({
      name: "ensure-req-body-drained",
      path: "templates/middleware/middleware-ensure-req-body-drained.ts",
      supports: ["modules", "service-worker"]
    });
  }
  if (targetConsumer === "dev" && !!testScheduled) {
    middlewareToLoad.push({
      name: "scheduled",
      path: "templates/middleware/middleware-scheduled.ts",
      supports: ["modules", "service-worker"]
    });
  }
  if (targetConsumer === "dev" && local) {
    middlewareToLoad.push({
      name: "miniflare3-json-error",
      path: "templates/middleware/middleware-miniflare3-json-error.ts",
      supports: ["modules", "service-worker"]
    });
  }
  if (serveAssetsFromWorker) {
    middlewareToLoad.push({
      name: "serve-static-assets",
      path: "templates/middleware/middleware-serve-static-assets.ts",
      config: {
        spaMode: typeof assets === "object" ? assets.serve_single_page_app : false,
        cacheControl: typeof assets === "object" ? {
          browserTTL: assets.browser_TTL || 172800,
          bypassCache: bypassAssetCache
        } : {}
      },
      supports: ["modules", "service-worker"]
    });
  }
  let initialBuildResult;
  const initialBuildResultPromise = new Promise(
    (resolve19) => initialBuildResult = resolve19
  );
  const buildResultPlugin = {
    name: "Initial build result plugin",
    setup(build5) {
      build5.onEnd(initialBuildResult);
    }
  };
  const inject = injectOption ?? [];
  if (checkFetch) {
    const checkedFetchFileToInject = path12.join(tmpDir.path, "checked-fetch.js");
    if (checkFetch && !fs7.existsSync(checkedFetchFileToInject)) {
      fs7.writeFileSync(
        checkedFetchFileToInject,
        fs7.readFileSync(
          path12.resolve(getBasePath(), "templates/checked-fetch.js")
        )
      );
    }
    inject.push(checkedFetchFileToInject);
  }
  for (const middleware of middlewareToLoad) {
    if (!middleware.supports.includes(entry.format)) {
      throw new UserError(
        `Your Worker is written using the "${entry.format}" format, which isn't supported by the "${middleware.name}" middleware. To use "${middleware.name}" middleware, convert your Worker to the "${middleware.supports[0]}" format`
      );
    }
  }
  if (middlewareToLoad.length > 0 || process.env.EXPERIMENTAL_MIDDLEWARE === "true") {
    const result2 = await applyMiddlewareLoaderFacade(
      entry,
      tmpDir.path,
      middlewareToLoad
    );
    entry = result2.entry;
    inject.push(...result2.inject ?? []);
  }
  inject.push(path12.resolve(getBasePath(), "templates/modules-watch-stub.js"));
  const buildOptions2 = {
    // Don't use entryFile here as the file may have been changed when applying the middleware
    entryPoints: [entry.file],
    bundle,
    absWorkingDir: entry.directory,
    outdir: destination,
    entryNames: entryName || path12.parse(entryFile).name,
    ...isOutfile ? {
      outdir: void 0,
      outfile: destination,
      entryNames: void 0
    } : {},
    inject,
    external: bundle ? ["__STATIC_CONTENT_MANIFEST", ...external ? external : []] : void 0,
    format: entry.format === "modules" ? "esm" : "iife",
    target: COMMON_ESBUILD_OPTIONS.target,
    sourcemap: sourcemap ?? true,
    // Include a reference to the output folder in the sourcemap.
    // This is omitted by default, but we need it to properly resolve source paths in error output.
    sourceRoot: destination,
    minify,
    metafile: true,
    conditions: BUILD_CONDITIONS,
    ...{
      define: {
        ...defineNavigatorUserAgent ? { "navigator.userAgent": `"Cloudflare-Workers"` } : {},
        // use process.env["NODE_ENV" + ""] so that esbuild doesn't replace it
        // when we do a build of wrangler. (re: https://github.com/cloudflare/workers-sdk/issues/1477)
        "process.env.NODE_ENV": `"${process.env["NODE_ENV"]}"`,
        ...legacyNodeCompat ? { global: "globalThis" } : {},
        ...define2
      }
    },
    loader: {
      ...COMMON_ESBUILD_OPTIONS.loader,
      ...loader || {}
    },
    plugins: [
      moduleCollector.plugin,
      ...legacyNodeCompat ? [
        (0, import_node_globals_polyfill.default)({ buffer: true }),
        standardURLPlugin(),
        (0, import_node_modules_polyfill.default)()
      ] : [],
      nodejsCompatPlugin(!!nodejsCompat),
      cloudflareInternalPlugin,
      buildResultPlugin,
      ...plugins || [],
      configProviderPlugin(
        Object.fromEntries(
          middlewareToLoad.filter((m2) => m2.config !== void 0).map((m2) => [m2.name, m2.config])
        )
      )
    ],
    ...jsxFactory && { jsxFactory },
    ...jsxFragment && { jsxFragment },
    ...tsconfig && { tsconfig },
    // The default logLevel is "warning". So that we can rewrite errors before
    // logging, we disable esbuild's default logging, and log build failures
    // ourselves.
    logLevel: "silent"
  };
  let result;
  let stop;
  try {
    if (watch6) {
      const ctx = await esbuild.context(buildOptions2);
      await ctx.watch();
      result = await initialBuildResultPromise;
      if (result.errors.length > 0) {
        throw new UserError("Failed to build");
      }
      stop = /* @__PURE__ */ __name(async function() {
        tmpDir.remove();
        await ctx.dispose();
      }, "stop");
    } else {
      result = await esbuild.build(buildOptions2);
      stop = /* @__PURE__ */ __name(async function() {
        tmpDir.remove();
      }, "stop");
    }
  } catch (e3) {
    if (!legacyNodeCompat && isBuildFailure(e3))
      rewriteNodeCompatBuildFailure(e3.errors, forPages);
    throw e3;
  }
  const entryPoint = getEntryPointFromMetafile(entryFile, result.metafile);
  const notExportedDOs = doBindings.filter((x2) => !x2.script_name && !entryPoint.exports.includes(x2.class_name)).map((x2) => x2.class_name);
  if (notExportedDOs.length) {
    const relativePath = path12.relative(process.cwd(), entryFile);
    throw new UserError(
      `Your Worker depends on the following Durable Objects, which are not exported in your entrypoint file: ${notExportedDOs.join(
        ", "
      )}.
You should export these objects from your entrypoint, ${relativePath}.`
    );
  }
  const bundleType = entryPoint.exports.length > 0 ? "esm" : "commonjs";
  const sourceMapPath = Object.keys(result.metafile.outputs).filter(
    (_path) => _path.includes(".map")
  )[0];
  const resolvedEntryPointPath = path12.resolve(
    entry.directory,
    entryPoint.relativePath
  );
  const modules = dedupeModulesByName([
    ...moduleCollector.modules,
    ...additionalModules
  ]);
  await writeAdditionalModules(modules, path12.dirname(resolvedEntryPointPath));
  return {
    modules,
    dependencies: entryPoint.dependencies,
    resolvedEntryPointPath,
    bundleType,
    stop,
    sourceMapPath,
    sourceMapMetadata: {
      tmpDir: tmpDir.path,
      entryDirectory: entry.directory
    }
  };
}
__name(bundleWorker, "bundleWorker");

// src/deployment-bundle/guess-worker-format.ts
async function guessWorkerFormat(entryFile, entryWorkingDirectory, hint, tsconfig) {
  const parsedEntryPath = import_node_path11.default.parse(entryFile);
  if (parsedEntryPath.ext == ".py") {
    logger.warn(
      `The entrypoint ${import_node_path11.default.relative(
        process.cwd(),
        entryFile
      )} defines a Python worker, support for Python workers is currently experimental.`
    );
    return "modules";
  }
  const result = await esbuild2.build({
    ...COMMON_ESBUILD_OPTIONS,
    entryPoints: [entryFile],
    absWorkingDir: entryWorkingDirectory,
    metafile: true,
    bundle: false,
    write: false,
    ...tsconfig && { tsconfig }
  });
  const metafile = result.metafile;
  const { exports: exports2 } = getEntryPointFromMetafile(entryFile, metafile);
  let guessedWorkerFormat;
  if (exports2.length > 0) {
    if (exports2.includes("default")) {
      guessedWorkerFormat = "modules";
    } else {
      logger.warn(
        `The entrypoint ${import_node_path11.default.relative(
          process.cwd(),
          entryFile
        )} has exports like an ES Module, but hasn't defined a default export like a module worker normally would. Building the worker using "service-worker" format...`
      );
      guessedWorkerFormat = "service-worker";
    }
  } else {
    guessedWorkerFormat = "service-worker";
  }
  if (hint) {
    if (hint !== guessedWorkerFormat) {
      if (hint === "service-worker") {
        throw new UserError(
          "You configured this worker to be a 'service-worker', but the file you are trying to build appears to have a `default` export like a module worker. Please pass `--format modules`, or simply remove the configuration."
        );
      } else {
        throw new UserError(
          "You configured this worker to be 'modules', but the file you are trying to build doesn't export a handler. Please pass `--format service-worker`, or simply remove the configuration."
        );
      }
    }
  }
  return guessedWorkerFormat;
}
__name(guessWorkerFormat, "guessWorkerFormat");

// src/deployment-bundle/run-custom-build.ts
init_import_meta_url();
var import_node_fs7 = require("node:fs");
var import_node_path14 = __toESM(require("node:path"));
init_execa();
async function runCustomBuild(expectedEntryAbsolute, expectedEntryRelative, build5) {
  if (build5.command) {
    logger.log("Running custom build:", build5.command);
    try {
      await execaCommand(build5.command, {
        shell: true,
        // we keep these two as "inherit" so that
        // logs are still visible.
        stdout: "inherit",
        stderr: "inherit",
        ...build5.cwd && { cwd: build5.cwd }
      });
    } catch (e3) {
      throw new UserError(
        `Running custom build \`${build5.command}\` failed. There are likely more logs from your build command above.`,
        {
          cause: e3
        }
      );
    }
    assertEntryPointExists(
      expectedEntryAbsolute,
      expectedEntryRelative,
      `The expected output file at "${expectedEntryRelative}" was not found after running custom build: ${build5.command}.
The \`main\` property in wrangler.toml should point to the file generated by the custom build.`
    );
  } else {
    assertEntryPointExists(
      expectedEntryAbsolute,
      expectedEntryRelative,
      `The entry-point file at "${expectedEntryRelative}" was not found.`
    );
  }
}
__name(runCustomBuild, "runCustomBuild");
function assertEntryPointExists(expectedEntryAbsolute, expectedEntryRelative, errorMessage) {
  if (!fileExists(expectedEntryAbsolute)) {
    throw new UserError(
      getMissingEntryPointMessage(
        errorMessage,
        expectedEntryAbsolute,
        expectedEntryRelative
      )
    );
  }
}
__name(assertEntryPointExists, "assertEntryPointExists");
function getMissingEntryPointMessage(message, absoluteEntryPointPath, relativeEntryPointPath) {
  if ((0, import_node_fs7.existsSync)(absoluteEntryPointPath) && (0, import_node_fs7.statSync)(absoluteEntryPointPath).isDirectory()) {
    message += `
The provided entry-point path, "${relativeEntryPointPath}", points to a directory, rather than a file.
`;
    const possiblePaths = [];
    for (const basenamePath of [
      "worker",
      "dist/worker",
      "index",
      "dist/index"
    ]) {
      for (const extension of [".ts", ".tsx", ".js", ".jsx"]) {
        const filePath = basenamePath + extension;
        if (fileExists(import_node_path14.default.resolve(absoluteEntryPointPath, filePath))) {
          possiblePaths.push(import_node_path14.default.join(relativeEntryPointPath, filePath));
        }
      }
    }
    if (possiblePaths.length > 0) {
      message += `
Did you mean to set the main field to${possiblePaths.length > 1 ? " one of" : ""}:
\`\`\`
` + possiblePaths.map((filePath) => `main = "./${filePath}"
`).join("") + "```";
    }
  }
  return message;
}
__name(getMissingEntryPointMessage, "getMissingEntryPointMessage");
function fileExists(filePath) {
  const SOURCE_FILE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
  if (import_node_path14.default.extname(filePath) !== "") {
    return (0, import_node_fs7.existsSync)(filePath);
  }
  const base = import_node_path14.default.join(import_node_path14.default.dirname(filePath), import_node_path14.default.basename(filePath));
  for (const ext of SOURCE_FILE_EXTENSIONS) {
    if ((0, import_node_fs7.existsSync)(base + ext)) {
      return true;
    }
  }
  return false;
}
__name(fileExists, "fileExists");

// src/deployment-bundle/entry.ts
async function getEntry(args, config, command2) {
  let file;
  let directory = process.cwd();
  if (args.script) {
    file = import_node_path15.default.resolve(args.script);
  } else if (config.main === void 0) {
    if (config.site?.["entry-point"]) {
      directory = import_node_path15.default.resolve(import_node_path15.default.dirname(config.configPath ?? "."));
      file = import_node_path15.default.extname(config.site?.["entry-point"]) ? import_node_path15.default.resolve(config.site?.["entry-point"]) : (
        // site.entry-point could be a directory
        import_node_path15.default.resolve(config.site?.["entry-point"], "index.js")
      );
    } else if (args.assets || config.assets) {
      file = import_node_path15.default.resolve(getBasePath(), "templates/no-op-worker.js");
    } else {
      throw new UserError(
        `Missing entry-point: The entry-point should be specified via the command line (e.g. \`wrangler ${command2} path/to/script\`) or the \`main\` config field.`
      );
    }
  } else {
    directory = import_node_path15.default.resolve(import_node_path15.default.dirname(config.configPath ?? "."));
    file = import_node_path15.default.resolve(directory, config.main);
  }
  const relativeFile = import_node_path15.default.relative(directory, file) || ".";
  await runCustomBuild(file, relativeFile, config.build);
  const format10 = await guessWorkerFormat(
    file,
    directory,
    args.format ?? config.build?.upload?.format,
    config.tsconfig
  );
  const { localBindings, remoteBindings } = partitionDurableObjectBindings(config);
  if (command2 === "dev" && remoteBindings.length > 0) {
    logger.warn(
      "WARNING: You have Durable Object bindings that are not defined locally in the worker being developed.\nBe aware that changes to the data stored in these Durable Objects will be permanent and affect the live instances.\nRemote Durable Objects that are affected:\n" + remoteBindings.map((b2) => `- ${JSON.stringify(b2)}`).join("\n")
    );
  }
  if (format10 === "service-worker" && localBindings.length > 0) {
    const errorMessage = "You seem to be trying to use Durable Objects in a Worker written as a service-worker.";
    const addScriptName = "You can use Durable Objects defined in other Workers by specifying a `script_name` in your wrangler.toml, where `script_name` is the name of the Worker that implements that Durable Object. For example:";
    const addScriptNameExamples = generateAddScriptNameExamples(localBindings);
    const migrateText = "Alternatively, migrate your worker to ES Module syntax to implement a Durable Object in this Worker:";
    const migrateUrl = "https://developers.cloudflare.com/workers/learning/migrating-to-module-workers/";
    throw new UserError(
      `${errorMessage}
${addScriptName}
${addScriptNameExamples}
${migrateText}
${migrateUrl}`
    );
  }
  return {
    file,
    directory,
    format: format10,
    moduleRoot: args.moduleRoot ?? config.base_dir ?? import_node_path15.default.dirname(file),
    name: config.name ?? "worker"
  };
}
__name(getEntry, "getEntry");
function partitionDurableObjectBindings(config) {
  const localBindings = [];
  const remoteBindings = [];
  for (const binding of config.durable_objects.bindings) {
    if (binding.script_name === void 0) {
      localBindings.push(binding);
    } else {
      remoteBindings.push(binding);
    }
  }
  return { localBindings, remoteBindings };
}
__name(partitionDurableObjectBindings, "partitionDurableObjectBindings");
function generateAddScriptNameExamples(localBindings) {
  function exampleScriptName(binding_name) {
    return `${binding_name.toLowerCase().replaceAll("_", "-")}-worker`;
  }
  __name(exampleScriptName, "exampleScriptName");
  return localBindings.map(({ name, class_name }) => {
    const script_name = exampleScriptName(name);
    const currentBinding = `{ name = ${name}, class_name = ${class_name} }`;
    const fixedBinding = `{ name = ${name}, class_name = ${class_name}, script_name = ${script_name} }`;
    return `${currentBinding} ==> ${fixedBinding}`;
  }).join("\n");
}
__name(generateAddScriptNameExamples, "generateAddScriptNameExamples");

// src/dev/dev.tsx
init_import_meta_url();
var import_node_child_process6 = require("node:child_process");
var path61 = __toESM(require("node:path"));
var util2 = __toESM(require("node:util"));
var import_chokidar4 = require("chokidar");

// ../../node_modules/.pnpm/clipboardy@3.0.0/node_modules/clipboardy/index.js
init_import_meta_url();
var import_node_process4 = __toESM(require("node:process"), 1);
var import_is_wsl = __toESM(require_is_wsl(), 1);

// ../../node_modules/.pnpm/clipboardy@3.0.0/node_modules/clipboardy/lib/termux.js
init_import_meta_url();
var import_execa2 = __toESM(require_execa(), 1);
var handler = /* @__PURE__ */ __name((error2) => {
  if (error2.code === "ENOENT") {
    throw new Error("Couldn't find the termux-api scripts. You can install them with: apt install termux-api");
  }
  throw error2;
}, "handler");
var clipboard = {
  copy: async (options29) => {
    try {
      await (0, import_execa2.default)("termux-clipboard-set", options29);
    } catch (error2) {
      handler(error2);
    }
  },
  paste: async (options29) => {
    try {
      const { stdout: stdout2 } = await (0, import_execa2.default)("termux-clipboard-get", options29);
      return stdout2;
    } catch (error2) {
      handler(error2);
    }
  },
  copySync: (options29) => {
    try {
      import_execa2.default.sync("termux-clipboard-set", options29);
    } catch (error2) {
      handler(error2);
    }
  },
  pasteSync: (options29) => {
    try {
      return import_execa2.default.sync("termux-clipboard-get", options29).stdout;
    } catch (error2) {
      handler(error2);
    }
  }
};
var termux_default = clipboard;

// ../../node_modules/.pnpm/clipboardy@3.0.0/node_modules/clipboardy/lib/linux.js
init_import_meta_url();
var import_node_path16 = __toESM(require("node:path"), 1);
var import_node_url6 = require("node:url");
var import_execa3 = __toESM(require_execa(), 1);
var __dirname3 = import_node_path16.default.dirname((0, import_node_url6.fileURLToPath)(import_meta_url));
var xsel = "xsel";
var xselFallback = import_node_path16.default.join(__dirname3, "../fallbacks/linux/xsel");
var copyArguments = ["--clipboard", "--input"];
var pasteArguments = ["--clipboard", "--output"];
var makeError2 = /* @__PURE__ */ __name((xselError, fallbackError) => {
  let error2;
  if (xselError.code === "ENOENT") {
    error2 = new Error("Couldn't find the `xsel` binary and fallback didn't work. On Debian/Ubuntu you can install xsel with: sudo apt install xsel");
  } else {
    error2 = new Error("Both xsel and fallback failed");
    error2.xselError = xselError;
  }
  error2.fallbackError = fallbackError;
  return error2;
}, "makeError");
var xselWithFallback = /* @__PURE__ */ __name(async (argumentList, options29) => {
  try {
    const { stdout: stdout2 } = await (0, import_execa3.default)(xsel, argumentList, options29);
    return stdout2;
  } catch (xselError) {
    try {
      const { stdout: stdout2 } = await (0, import_execa3.default)(xselFallback, argumentList, options29);
      return stdout2;
    } catch (fallbackError) {
      throw makeError2(xselError, fallbackError);
    }
  }
}, "xselWithFallback");
var xselWithFallbackSync = /* @__PURE__ */ __name((argumentList, options29) => {
  try {
    return import_execa3.default.sync(xsel, argumentList, options29).stdout;
  } catch (xselError) {
    try {
      return import_execa3.default.sync(xselFallback, argumentList, options29).stdout;
    } catch (fallbackError) {
      throw makeError2(xselError, fallbackError);
    }
  }
}, "xselWithFallbackSync");
var clipboard2 = {
  copy: async (options29) => {
    await xselWithFallback(copyArguments, options29);
  },
  copySync: (options29) => {
    xselWithFallbackSync(copyArguments, options29);
  },
  paste: (options29) => xselWithFallback(pasteArguments, options29),
  pasteSync: (options29) => xselWithFallbackSync(pasteArguments, options29)
};
var linux_default = clipboard2;

// ../../node_modules/.pnpm/clipboardy@3.0.0/node_modules/clipboardy/lib/macos.js
init_import_meta_url();
var import_execa4 = __toESM(require_execa(), 1);
var env2 = {
  LC_CTYPE: "UTF-8"
};
var clipboard3 = {
  copy: async (options29) => (0, import_execa4.default)("pbcopy", { ...options29, env: env2 }),
  paste: async (options29) => {
    const { stdout: stdout2 } = await (0, import_execa4.default)("pbpaste", { ...options29, env: env2 });
    return stdout2;
  },
  copySync: (options29) => import_execa4.default.sync("pbcopy", { ...options29, env: env2 }),
  pasteSync: (options29) => import_execa4.default.sync("pbpaste", { ...options29, env: env2 }).stdout
};
var macos_default = clipboard3;

// ../../node_modules/.pnpm/clipboardy@3.0.0/node_modules/clipboardy/lib/windows.js
init_import_meta_url();
var import_node_path17 = __toESM(require("node:path"), 1);
var import_node_url7 = require("node:url");
var import_execa5 = __toESM(require_execa(), 1);
var import_arch = __toESM(require_arch(), 1);
var __dirname4 = import_node_path17.default.dirname((0, import_node_url7.fileURLToPath)(import_meta_url));
var binarySuffix = (0, import_arch.default)() === "x64" ? "x86_64" : "i686";
var windowBinaryPath = import_node_path17.default.join(__dirname4, `../fallbacks/windows/clipboard_${binarySuffix}.exe`);
var clipboard4 = {
  copy: async (options29) => (0, import_execa5.default)(windowBinaryPath, ["--copy"], options29),
  paste: async (options29) => {
    const { stdout: stdout2 } = await (0, import_execa5.default)(windowBinaryPath, ["--paste"], options29);
    return stdout2;
  },
  copySync: (options29) => import_execa5.default.sync(windowBinaryPath, ["--copy"], options29),
  pasteSync: (options29) => import_execa5.default.sync(windowBinaryPath, ["--paste"], options29).stdout
};
var windows_default = clipboard4;

// ../../node_modules/.pnpm/clipboardy@3.0.0/node_modules/clipboardy/index.js
var platformLib = (() => {
  switch (import_node_process4.default.platform) {
    case "darwin":
      return macos_default;
    case "win32":
      return windows_default;
    case "android":
      if (import_node_process4.default.env.PREFIX !== "/data/data/com.termux/files/usr") {
        throw new Error("You need to install Termux for this module to work on Android: https://termux.com");
      }
      return termux_default;
    default:
      if (import_is_wsl.default) {
        return windows_default;
      }
      return linux_default;
  }
})();
var clipboard5 = {};
clipboard5.write = async (text) => {
  if (typeof text !== "string") {
    throw new TypeError(`Expected a string, got ${typeof text}`);
  }
  await platformLib.copy({ input: text });
};
clipboard5.read = async () => platformLib.paste({ stripFinalNewline: false });
clipboard5.writeSync = (text) => {
  if (typeof text !== "string") {
    throw new TypeError(`Expected a string, got ${typeof text}`);
  }
  platformLib.copySync({ input: text });
};
clipboard5.readSync = () => platformLib.pasteSync({ stripFinalNewline: false });
var clipboardy_default = clipboard5;

// src/dev/dev.tsx
var import_command_exists2 = __toESM(require_command_exists2());
var import_ink13 = __toESM(require_build2());
var import_react19 = __toESM(require_react());

// ../../node_modules/.pnpm/react-error-boundary@3.1.4_react@17.0.2/node_modules/react-error-boundary/dist/react-error-boundary.esm.js
init_import_meta_url();

// ../../node_modules/.pnpm/@babel+runtime@7.22.5/node_modules/@babel/runtime/helpers/esm/inheritsLoose.js
init_import_meta_url();

// ../../node_modules/.pnpm/@babel+runtime@7.22.5/node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js
init_import_meta_url();
function _setPrototypeOf(o2, p2) {
  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : /* @__PURE__ */ __name(function _setPrototypeOf2(o3, p3) {
    o3.__proto__ = p3;
    return o3;
  }, "_setPrototypeOf");
  return _setPrototypeOf(o2, p2);
}
__name(_setPrototypeOf, "_setPrototypeOf");

// ../../node_modules/.pnpm/@babel+runtime@7.22.5/node_modules/@babel/runtime/helpers/esm/inheritsLoose.js
function _inheritsLoose(subClass, superClass) {
  subClass.prototype = Object.create(superClass.prototype);
  subClass.prototype.constructor = subClass;
  _setPrototypeOf(subClass, superClass);
}
__name(_inheritsLoose, "_inheritsLoose");

// ../../node_modules/.pnpm/react-error-boundary@3.1.4_react@17.0.2/node_modules/react-error-boundary/dist/react-error-boundary.esm.js
var React = __toESM(require_react());
var changedArray = /* @__PURE__ */ __name(function changedArray2(a, b2) {
  if (a === void 0) {
    a = [];
  }
  if (b2 === void 0) {
    b2 = [];
  }
  return a.length !== b2.length || a.some(function(item, index) {
    return !Object.is(item, b2[index]);
  });
}, "changedArray");
var initialState = {
  error: null
};
var ErrorBoundary = /* @__PURE__ */ function(_React$Component) {
  _inheritsLoose(ErrorBoundary2, _React$Component);
  function ErrorBoundary2() {
    var _this;
    for (var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++) {
      _args[_key] = arguments[_key];
    }
    _this = _React$Component.call.apply(_React$Component, [this].concat(_args)) || this;
    _this.state = initialState;
    _this.resetErrorBoundary = function() {
      var _this$props;
      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        args[_key2] = arguments[_key2];
      }
      _this.props.onReset == null ? void 0 : (_this$props = _this.props).onReset.apply(_this$props, args);
      _this.reset();
    };
    return _this;
  }
  __name(ErrorBoundary2, "ErrorBoundary");
  ErrorBoundary2.getDerivedStateFromError = /* @__PURE__ */ __name(function getDerivedStateFromError(error2) {
    return {
      error: error2
    };
  }, "getDerivedStateFromError");
  var _proto = ErrorBoundary2.prototype;
  _proto.reset = /* @__PURE__ */ __name(function reset() {
    this.setState(initialState);
  }, "reset");
  _proto.componentDidCatch = /* @__PURE__ */ __name(function componentDidCatch(error2, info) {
    var _this$props$onError, _this$props2;
    (_this$props$onError = (_this$props2 = this.props).onError) == null ? void 0 : _this$props$onError.call(_this$props2, error2, info);
  }, "componentDidCatch");
  _proto.componentDidUpdate = /* @__PURE__ */ __name(function componentDidUpdate(prevProps, prevState) {
    var error2 = this.state.error;
    var resetKeys = this.props.resetKeys;
    if (error2 !== null && prevState.error !== null && changedArray(prevProps.resetKeys, resetKeys)) {
      var _this$props$onResetKe, _this$props3;
      (_this$props$onResetKe = (_this$props3 = this.props).onResetKeysChange) == null ? void 0 : _this$props$onResetKe.call(_this$props3, prevProps.resetKeys, resetKeys);
      this.reset();
    }
  }, "componentDidUpdate");
  _proto.render = /* @__PURE__ */ __name(function render7() {
    var error2 = this.state.error;
    var _this$props4 = this.props, fallbackRender = _this$props4.fallbackRender, FallbackComponent = _this$props4.FallbackComponent, fallback = _this$props4.fallback;
    if (error2 !== null) {
      var _props = {
        error: error2,
        resetErrorBoundary: this.resetErrorBoundary
      };
      if (/* @__PURE__ */ React.isValidElement(fallback)) {
        return fallback;
      } else if (typeof fallbackRender === "function") {
        return fallbackRender(_props);
      } else if (FallbackComponent) {
        return /* @__PURE__ */ React.createElement(FallbackComponent, _props);
      } else {
        throw new Error("react-error-boundary requires either a fallback, fallbackRender, or FallbackComponent prop");
      }
    }
    return this.props.children;
  }, "render");
  return ErrorBoundary2;
}(React.Component);
function withErrorBoundary(Component2, errorBoundaryProps) {
  var Wrapped = /* @__PURE__ */ __name(function Wrapped2(props) {
    return /* @__PURE__ */ React.createElement(ErrorBoundary, errorBoundaryProps, /* @__PURE__ */ React.createElement(Component2, props));
  }, "Wrapped");
  var name = Component2.displayName || Component2.name || "Unknown";
  Wrapped.displayName = "withErrorBoundary(" + name + ")";
  return Wrapped;
}
__name(withErrorBoundary, "withErrorBoundary");
function useErrorHandler(givenError) {
  var _React$useState = React.useState(null), error2 = _React$useState[0], setError = _React$useState[1];
  if (givenError != null)
    throw givenError;
  if (error2 != null)
    throw error2;
  return setError;
}
__name(useErrorHandler, "useErrorHandler");

// src/dev/dev.tsx
var import_signal_exit8 = __toESM(require_signal_exit());
var import_undici24 = __toESM(require_undici());

// src/dev-registry.ts
init_import_meta_url();
var import_node_events = __toESM(require("node:events"));
var import_node_http2 = require("node:http");
var import_node_net2 = __toESM(require("node:net"));
var import_body_parser = __toESM(require_body_parser());
var import_express = __toESM(require_express2());
var import_http_terminator = __toESM(require_src5());
var import_undici4 = __toESM(require_undici());
var DEV_REGISTRY_PORT = parseInt(process.env.WRANGLER_WORKER_REGISTRY_PORT);
if (Number.isNaN(DEV_REGISTRY_PORT))
  DEV_REGISTRY_PORT = 6284;
var DEV_REGISTRY_HOST = `http://127.0.0.1:${DEV_REGISTRY_PORT}`;
var globalServer;
var globalTerminator;
async function isPortAvailable() {
  return new Promise((resolve19, reject) => {
    const netServer = import_node_net2.default.createServer().once("error", (err) => {
      netServer.close();
      if (err.code === "EADDRINUSE") {
        resolve19(false);
      } else {
        reject(err);
      }
    }).once("listening", () => {
      netServer.close();
      resolve19(true);
    });
    netServer.listen(DEV_REGISTRY_PORT, "127.0.0.1");
  });
}
__name(isPortAvailable, "isPortAvailable");
var jsonBodyParser = import_body_parser.default.json();
async function startWorkerRegistryServer(port2) {
  const app = (0, import_express.default)();
  let workers = {};
  app.get("/workers", async (req, res) => {
    res.json(workers);
  }).post("/workers/:workerId", jsonBodyParser, async (req, res) => {
    workers[req.params.workerId] = req.body;
    res.json(null);
  }).delete(`/workers/:workerId`, async (req, res) => {
    delete workers[req.params.workerId];
    res.json(null);
  }).delete("/workers", async (req, res) => {
    workers = {};
    res.json(null);
  });
  const appServer = (0, import_node_http2.createServer)(app);
  const appTerminator = (0, import_http_terminator.createHttpTerminator)({ server: appServer });
  const listeningPromise = import_node_events.default.once(appServer, "listening");
  appServer.listen(port2, "127.0.0.1");
  await listeningPromise;
  return { server: appServer, terminator: appTerminator };
}
__name(startWorkerRegistryServer, "startWorkerRegistryServer");
async function startWorkerRegistry() {
  if (await isPortAvailable() && !globalServer) {
    const result = await startWorkerRegistryServer(DEV_REGISTRY_PORT);
    globalServer = result.server;
    globalTerminator = result.terminator;
    globalServer.once("error", (err) => {
      if (err.code !== "EADDRINUSE") {
        throw err;
      }
    });
    globalServer.on("close", () => {
      globalServer = null;
    });
  }
}
__name(startWorkerRegistry, "startWorkerRegistry");
async function stopWorkerRegistry() {
  await globalTerminator?.terminate();
  globalServer = null;
}
__name(stopWorkerRegistry, "stopWorkerRegistry");
async function registerWorker(name, definition) {
  await startWorkerRegistry();
  try {
    return await (0, import_undici4.fetch)(`${DEV_REGISTRY_HOST}/workers/${name}`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json"
      },
      body: JSON.stringify(definition)
    });
  } catch (e3) {
    if (!["ECONNRESET", "ECONNREFUSED"].includes(
      e3.cause?.code || "___"
    )) {
      logger.error("Failed to register worker in local service registry", e3);
    } else {
      logger.debug("Failed to register worker in local service registry", e3);
    }
  }
}
__name(registerWorker, "registerWorker");
async function unregisterWorker(name) {
  try {
    await (0, import_undici4.fetch)(`${DEV_REGISTRY_HOST}/workers/${name}`, {
      method: "DELETE"
    });
  } catch (e3) {
    if (!["ECONNRESET", "ECONNREFUSED"].includes(
      e3.cause?.code || "___"
    )) {
      throw e3;
    }
  }
}
__name(unregisterWorker, "unregisterWorker");
async function getRegisteredWorkers() {
  try {
    const response = await (0, import_undici4.fetch)(`${DEV_REGISTRY_HOST}/workers`);
    return await response.json();
  } catch (e3) {
    if (!["ECONNRESET", "ECONNREFUSED"].includes(
      e3.cause?.code || "___"
    )) {
      throw e3;
    }
  }
}
__name(getRegisteredWorkers, "getRegisteredWorkers");
async function getBoundRegisteredWorkers({
  name,
  services,
  durableObjects
}) {
  const serviceNames = (services || []).map(
    (serviceBinding) => serviceBinding.service
  );
  const durableObjectServices = (durableObjects || { bindings: [] }).bindings.map((durableObjectBinding) => durableObjectBinding.script_name);
  const workerDefinitions = await getRegisteredWorkers();
  const filteredWorkers = Object.fromEntries(
    Object.entries(workerDefinitions || {}).filter(
      ([key, _value]) => key !== name && // Always exclude current worker to avoid infinite loops
      (serviceNames.includes(key) || durableObjectServices.includes(key))
    )
  );
  return filteredWorkers;
}
__name(getBoundRegisteredWorkers, "getBoundRegisteredWorkers");

// src/navigator-user-agent.ts
init_import_meta_url();
function isNavigatorDefined(compatibility_date, compatibility_flags = []) {
  if (compatibility_flags.includes("global_navigator") && compatibility_flags.includes("no_global_navigator")) {
    throw new UserError("Can't both enable and disable a flag");
  }
  if (compatibility_flags.includes("global_navigator")) {
    return true;
  }
  if (compatibility_flags.includes("no_global_navigator")) {
    return false;
  }
  return !!compatibility_date && compatibility_date >= "2022-03-21";
}
__name(isNavigatorDefined, "isNavigatorDefined");

// src/dev/inspect.ts
init_import_meta_url();
var import_fs6 = require("fs");
var import_node_os4 = __toESM(require("node:os"));
var import_node_url10 = require("node:url");
var import_path6 = __toESM(require("path"));
var import_open2 = __toESM(require_open());

// src/api/startDevWorker/bundle-allowed-paths.ts
init_import_meta_url();
var import_node_assert6 = __toESM(require("node:assert"));
var import_node_fs8 = __toESM(require("node:fs"));
var import_node_path18 = __toESM(require("node:path"));
var import_node_url8 = require("node:url");
function isAllowedSourcePath(bundle, filePath) {
  const allowed = getBundleReferencedPaths(bundle);
  return allowed.sourcePaths.has(filePath);
}
__name(isAllowedSourcePath, "isAllowedSourcePath");
function isAllowedSourceMapPath(bundle, filePath) {
  const allowed = getBundleReferencedPaths(bundle);
  return allowed.sourceMapPaths.has(filePath);
}
__name(isAllowedSourceMapPath, "isAllowedSourceMapPath");
var bundleReferencedPathsCache = /* @__PURE__ */ new WeakMap();
function getBundleReferencedPaths(bundle) {
  let allowed = bundleReferencedPathsCache.get(bundle);
  if (allowed !== void 0)
    return allowed;
  allowed = { sourcePaths: /* @__PURE__ */ new Set(), sourceMapPaths: /* @__PURE__ */ new Set() };
  bundleReferencedPathsCache.set(bundle, allowed);
  for (const sourcePath of getBundleSourcePaths(bundle)) {
    const sourceMappingURL = maybeGetSourceMappingURL(sourcePath);
    if (sourceMappingURL === void 0)
      continue;
    const sourceMappingPath = (0, import_node_url8.fileURLToPath)(sourceMappingURL);
    allowed.sourceMapPaths.add(sourceMappingPath);
    const sourceMapData = import_node_fs8.default.readFileSync(sourceMappingPath, "utf8");
    const sourceMap = JSON.parse(sourceMapData);
    const sourceRoot = sourceMap.sourceRoot ?? "";
    for (const source of sourceMap.sources) {
      const sourceURL = new URL(
        import_node_path18.default.posix.join(sourceRoot, source),
        sourceMappingURL
      );
      allowed.sourcePaths.add((0, import_node_url8.fileURLToPath)(sourceURL));
    }
  }
  return allowed;
}
__name(getBundleReferencedPaths, "getBundleReferencedPaths");
function* getBundleSourcePaths(bundle) {
  yield bundle.path;
  for (const module3 of bundle.modules) {
    if (module3.type !== "esm" && module3.type !== "commonjs")
      continue;
    if (module3.filePath === void 0)
      continue;
    yield module3.filePath;
  }
}
__name(getBundleSourcePaths, "getBundleSourcePaths");
function maybeGetSourceMappingURL(sourcePath) {
  const source = import_node_fs8.default.readFileSync(sourcePath, "utf8");
  const sourceMappingURLIndex = source.lastIndexOf("//# sourceMappingURL=");
  if (sourceMappingURLIndex === -1)
    return;
  const sourceMappingURLMatch = source.substring(sourceMappingURLIndex).match(/^\/\/# sourceMappingURL=(.+)/);
  (0, import_node_assert6.default)(sourceMappingURLMatch !== null);
  const sourceMappingURLSpecifier = sourceMappingURLMatch[1];
  const sourceURL = (0, import_node_url8.pathToFileURL)(sourcePath);
  try {
    const sourceMappingURL = new URL(sourceMappingURLSpecifier, sourceURL);
    if (sourceMappingURL.protocol !== "file:")
      return;
    return sourceMappingURL;
  } catch {
  }
}
__name(maybeGetSourceMappingURL, "maybeGetSourceMappingURL");

// src/sourcemap.ts
init_import_meta_url();
var import_node_assert7 = __toESM(require("node:assert"));
var import_node_fs9 = __toESM(require("node:fs"));
var import_node_url9 = __toESM(require("node:url"));
var import_miniflare2 = require("miniflare");
function maybeGetFile(filePath) {
  try {
    return import_node_fs9.default.readFileSync(filePath, "utf8");
  } catch (e3) {
    const notFound = typeof e3 === "object" && e3 !== null && "code" in e3 && e3.code === "ENOENT";
    if (!notFound)
      throw e3;
  }
}
__name(maybeGetFile, "maybeGetFile");
function maybeRetrieveFileSourceMap(filePath) {
  if (filePath === void 0)
    return null;
  const contents = maybeGetFile(filePath);
  if (contents === void 0)
    return null;
  const mapRegexp = /# sourceMappingURL=(.+)/g;
  const matches = [...contents.matchAll(mapRegexp)];
  if (matches.length === 0)
    return null;
  const mapMatch = matches[matches.length - 1];
  const fileUrl = import_node_url9.default.pathToFileURL(filePath);
  const mapUrl = new URL(mapMatch[1], fileUrl);
  if (mapUrl.protocol === "data:" && mapUrl.pathname.startsWith("application/json;base64,")) {
    const base642 = mapUrl.href.substring(mapUrl.href.indexOf(",") + 1);
    const map = Buffer.from(base642, "base64").toString();
    return { map, url: fileUrl.href };
  } else {
    const map = maybeGetFile(mapUrl);
    if (map === void 0)
      return null;
    return { map, url: mapUrl.href };
  }
}
__name(maybeRetrieveFileSourceMap, "maybeRetrieveFileSourceMap");
var sourceMappingPrepareStackTrace;
var retrieveSourceMapOverride;
function getSourceMappingPrepareStackTrace(retrieveSourceMap) {
  retrieveSourceMapOverride = retrieveSourceMap;
  if (sourceMappingPrepareStackTrace !== void 0) {
    return sourceMappingPrepareStackTrace;
  }
  const support = (0, import_miniflare2.getFreshSourceMapSupport)();
  const originalPrepareStackTrace = Error.prepareStackTrace;
  support.install({
    environment: "node",
    // Don't add Node `uncaughtException` handler
    handleUncaughtExceptions: false,
    // Don't hook Node `require` function
    hookRequire: false,
    redirectConflictingLibrary: false,
    // Make sure we're using fresh copies of files each time we source map
    emptyCacheBetweenOperations: true,
    // Allow retriever to be overridden at prepare stack trace time
    retrieveSourceMap(path67) {
      return retrieveSourceMapOverride?.(path67) ?? null;
    }
  });
  sourceMappingPrepareStackTrace = Error.prepareStackTrace;
  (0, import_node_assert7.default)(sourceMappingPrepareStackTrace !== void 0);
  Error.prepareStackTrace = originalPrepareStackTrace;
  return sourceMappingPrepareStackTrace;
}
__name(getSourceMappingPrepareStackTrace, "getSourceMappingPrepareStackTrace");
function getSourceMappedStack(details) {
  const description = details.exception?.description ?? "";
  const callFrames = details.stackTrace?.callFrames;
  if (callFrames === void 0)
    return description;
  const nameMessage = details.exception?.description?.split("\n")[0] ?? "";
  const colonIndex = nameMessage.indexOf(":");
  const error2 = new Error(nameMessage.substring(colonIndex + 2));
  error2.name = nameMessage.substring(0, colonIndex);
  const callSites = callFrames.map(callFrameToCallSite);
  return getSourceMappingPrepareStackTrace()(error2, callSites);
}
__name(getSourceMappedStack, "getSourceMappedStack");
function callFrameToCallSite(frame) {
  return new CallSite({
    typeName: null,
    functionName: frame.functionName,
    methodName: null,
    fileName: frame.url,
    lineNumber: frame.lineNumber + 1,
    columnNumber: frame.columnNumber + 1,
    native: false
  });
}
__name(callFrameToCallSite, "callFrameToCallSite");
var placeholderError = new Error();
function getSourceMappedString(value, retrieveSourceMap) {
  const callSiteLines = Array.from(value.matchAll(CALL_SITE_REGEXP));
  const callSites = callSiteLines.map(lineMatchToCallSite);
  const prepareStack = getSourceMappingPrepareStackTrace(retrieveSourceMap);
  const sourceMappedStackTrace = prepareStack(
    placeholderError,
    callSites
  );
  const sourceMappedCallSiteLines = sourceMappedStackTrace.split("\n").slice(1);
  for (let i = 0; i < callSiteLines.length; i++) {
    if (callSites[i].getFileName() === void 0)
      continue;
    const callSiteLine = callSiteLines[i][0];
    const callSiteAtIndex = callSiteLine.indexOf("at");
    (0, import_node_assert7.default)(callSiteAtIndex !== -1);
    const callSiteLineLeftPad = callSiteLine.substring(0, callSiteAtIndex);
    value = value.replace(
      callSiteLine,
      callSiteLineLeftPad + sourceMappedCallSiteLines[i].trimStart()
    );
  }
  return value;
}
__name(getSourceMappedString, "getSourceMappedString");
var CALL_SITE_REGEXP = (
  // Validation errors from `wrangler deploy` have a 2 space indent, whereas
  // regular stack traces have a 4 space indent.
  // eslint-disable-next-line no-control-regex
  /^(?:\s+(?:\x1B\[\d+m)?'?)? {2,4}at (?:(.+?)\s+\()?(?:(.+?):(\d+)(?::(\d+))?|([^)]+))\)?/gm
);
function lineMatchToCallSite(lineMatch) {
  let object = null;
  let method = null;
  let functionName = null;
  let typeName = null;
  let methodName = null;
  const isNative = lineMatch[5] === "native";
  if (lineMatch[1]) {
    functionName = lineMatch[1];
    let methodStart = functionName.lastIndexOf(".");
    if (functionName[methodStart - 1] == ".")
      methodStart--;
    if (methodStart > 0) {
      object = functionName.substring(0, methodStart);
      method = functionName.substring(methodStart + 1);
      const objectEnd = object.indexOf(".Module");
      if (objectEnd > 0) {
        functionName = functionName.substring(objectEnd + 1);
        object = object.substring(0, objectEnd);
      }
    }
  }
  if (method) {
    typeName = object;
    methodName = method;
  }
  if (method === "<anonymous>") {
    methodName = null;
    functionName = null;
  }
  return new CallSite({
    typeName,
    functionName,
    methodName,
    fileName: lineMatch[2] || null,
    lineNumber: parseInt(lineMatch[3]) || null,
    columnNumber: parseInt(lineMatch[4]) || null,
    native: isNative
  });
}
__name(lineMatchToCallSite, "lineMatchToCallSite");
var CallSite = class {
  constructor(opts) {
    this.opts = opts;
  }
  getThis() {
    return null;
  }
  getTypeName() {
    return this.opts.typeName;
  }
  // eslint-disable-next-line @typescript-eslint/ban-types
  getFunction() {
    return void 0;
  }
  getFunctionName() {
    return this.opts.functionName;
  }
  getMethodName() {
    return this.opts.methodName;
  }
  getFileName() {
    return this.opts.fileName ?? void 0;
  }
  getScriptNameOrSourceURL() {
    return this.opts.fileName;
  }
  getLineNumber() {
    return this.opts.lineNumber;
  }
  getColumnNumber() {
    return this.opts.columnNumber;
  }
  getEvalOrigin() {
    return void 0;
  }
  isToplevel() {
    return false;
  }
  isEval() {
    return false;
  }
  isNative() {
    return this.opts.native;
  }
  isConstructor() {
    return false;
  }
  isAsync() {
    return false;
  }
  isPromiseAll() {
    return false;
  }
  isPromiseAny() {
    return false;
  }
  getPromiseIndex() {
    return null;
  }
};
__name(CallSite, "CallSite");

// src/dev/inspect.ts
var mapConsoleAPIMessageTypeToConsoleMethod = {
  log: "log",
  debug: "debug",
  info: "info",
  warning: "warn",
  error: "error",
  dir: "dir",
  dirxml: "dirxml",
  table: "table",
  trace: "trace",
  clear: "clear",
  count: "count",
  assert: "assert",
  profile: "profile",
  profileEnd: "profileEnd",
  timeEnd: "timeEnd",
  startGroup: "group",
  startGroupCollapsed: "groupCollapsed",
  endGroup: "groupEnd"
};
function logConsoleMessage(evt) {
  const args = [];
  for (const ro2 of evt.args) {
    switch (ro2.type) {
      case "string":
      case "number":
      case "boolean":
      case "undefined":
      case "symbol":
      case "bigint":
        if (typeof ro2.value === "string") {
          ro2.value = getSourceMappedString(ro2.value);
        }
        args.push(ro2.value);
        break;
      case "function":
        args.push(`[Function: ${ro2.description ?? "<no-description>"}]`);
        break;
      case "object":
        if (!ro2.preview) {
          args.push(
            ro2.subtype === "null" ? "null" : ro2.description ?? "<no-description>"
          );
        } else {
          args.push(ro2.preview.description ?? "<no-description>");
          switch (ro2.preview.subtype) {
            case "array":
              args.push(
                "[ " + ro2.preview.properties.map(({ value }) => {
                  return value;
                }).join(", ") + (ro2.preview.overflow ? "..." : "") + " ]"
              );
              break;
            case "weakmap":
            case "map":
              ro2.preview.entries === void 0 ? args.push("{}") : args.push(
                "{\n" + ro2.preview.entries.map(({ key, value }) => {
                  return `  ${key?.description ?? "<unknown>"} => ${value.description}`;
                }).join(",\n") + (ro2.preview.overflow ? "\n  ..." : "") + "\n}"
              );
              break;
            case "weakset":
            case "set":
              ro2.preview.entries === void 0 ? args.push("{}") : args.push(
                "{ " + ro2.preview.entries.map(({ value }) => {
                  return `${value.description}`;
                }).join(", ") + (ro2.preview.overflow ? ", ..." : "") + " }"
              );
              break;
            case "regexp":
              break;
            case "date":
              break;
            case "generator":
              args.push(ro2.preview.properties[0].value || "");
              break;
            case "promise":
              if (ro2.preview.properties[0].value === "pending") {
                args.push(`{<${ro2.preview.properties[0].value}>}`);
              } else {
                args.push(
                  `{<${ro2.preview.properties[0].value}>: ${ro2.preview.properties[1].value}}`
                );
              }
              break;
            case "node":
            case "iterator":
            case "proxy":
            case "typedarray":
            case "arraybuffer":
            case "dataview":
            case "webassemblymemory":
            case "wasmvalue":
              break;
            case "error":
            default:
              args.push(
                "{\n" + ro2.preview.properties.map(({ name, value }) => {
                  return `  ${name}: ${value}`;
                }).join(",\n") + (ro2.preview.overflow ? "\n  ..." : "") + "\n}"
              );
          }
        }
        break;
      default:
        args.push(ro2.description || ro2.unserializableValue || "\u{1F98B}");
        break;
    }
  }
  const method = mapConsoleAPIMessageTypeToConsoleMethod[evt.type];
  if (method in console) {
    switch (method) {
      case "dir":
        console.dir(args);
        break;
      case "table":
        console.table(args);
        break;
      default:
        console[method].apply(console, args);
        break;
    }
  } else {
    logger.warn(`Unsupported console method: ${method}`);
    logger.warn("console event:", evt);
  }
}
__name(logConsoleMessage, "logConsoleMessage");
function maybeHandleNetworkLoadResource(url4, bundle, tmpDir) {
  if (typeof url4 === "string")
    url4 = new import_node_url10.URL(url4);
  if (url4.protocol !== "file:")
    return;
  const filePath = (0, import_node_url10.fileURLToPath)(url4);
  if (isAllowedSourceMapPath(bundle, filePath)) {
    const sourceMap = JSON.parse((0, import_fs6.readFileSync)(filePath, "utf-8"));
    sourceMap.x_google_ignoreList = sourceMap.sources.map((source, i) => {
      if (source.includes("wrangler/templates"))
        return i;
      if (tmpDir !== void 0 && import_path6.default.resolve(sourceMap?.sourceRoot ?? "", source).includes(tmpDir))
        return i;
    }).filter((i) => i !== void 0);
    return JSON.stringify(sourceMap);
  }
  if (isAllowedSourcePath(bundle, filePath)) {
    return (0, import_fs6.readFileSync)(filePath, "utf-8");
  }
}
__name(maybeHandleNetworkLoadResource, "maybeHandleNetworkLoadResource");
var openInspector = /* @__PURE__ */ __name(async (inspectorPort, worker) => {
  const query = new URLSearchParams();
  query.set("theme", "systemPreferred");
  query.set("ws", `127.0.0.1:${inspectorPort}/ws`);
  if (worker)
    query.set("domain", worker);
  query.set("debugger", "true");
  const url4 = `https://devtools.devprod.cloudflare.dev/js_app?${query.toString()}`;
  const errorMessage = "Failed to open inspector.\nInspector depends on having a Chromium-based browser installed, maybe you need to install one?";
  let braveBrowser;
  switch (import_node_os4.default.platform()) {
    case "darwin":
    case "win32":
      braveBrowser = "Brave";
      break;
    default:
      braveBrowser = "brave";
  }
  const childProcess2 = await (0, import_open2.default)(url4, {
    app: [
      {
        name: import_open2.default.apps.chrome
      },
      {
        name: braveBrowser
      },
      {
        name: import_open2.default.apps.edge
      },
      {
        name: import_open2.default.apps.firefox
      }
    ]
  });
  childProcess2.on("error", () => {
    logger.warn(errorMessage);
  });
}, "openInspector");

// src/dev/local.tsx
init_import_meta_url();
var import_node_assert10 = __toESM(require("node:assert"));
var import_chalk6 = __toESM(require_chalk());
var import_react = __toESM(require_react());
var import_signal_exit4 = __toESM(require_signal_exit());

// src/dev/miniflare.ts
init_import_meta_url();
var import_node_assert8 = __toESM(require("node:assert"));
var import_node_crypto4 = require("node:crypto");
var import_node_fs11 = require("node:fs");
var import_node_path19 = __toESM(require("node:path"));

// ../../node_modules/.pnpm/es-module-lexer@1.3.1/node_modules/es-module-lexer/dist/lexer.js
init_import_meta_url();
var A = 1 === new Uint8Array(new Uint16Array([1]).buffer)[0];
function parse4(E2, g2 = "@") {
  if (!C)
    return init.then(() => parse4(E2));
  const I2 = E2.length + 1, o2 = (C.__heap_base.value || C.__heap_base) + 4 * I2 - C.memory.buffer.byteLength;
  o2 > 0 && C.memory.grow(Math.ceil(o2 / 65536));
  const K2 = C.sa(I2 - 1);
  if ((A ? B : Q)(E2, new Uint16Array(C.memory.buffer, K2, I2)), !C.parse())
    throw Object.assign(new Error(`Parse error ${g2}:${E2.slice(0, C.e()).split("\n").length}:${C.e() - E2.lastIndexOf("\n", C.e() - 1)}`), { idx: C.e() });
  const D = [], k2 = [];
  for (; C.ri(); ) {
    const A2 = C.is(), Q3 = C.ie(), B2 = C.ai(), g3 = C.id(), I3 = C.ss(), o3 = C.se();
    let K3;
    C.ip() && (K3 = J2(E2.slice(-1 === g3 ? A2 - 1 : A2, -1 === g3 ? Q3 + 1 : Q3))), D.push({ n: K3, s: A2, e: Q3, ss: I3, se: o3, d: g3, a: B2 });
  }
  for (; C.re(); ) {
    const A2 = C.es(), Q3 = C.ee(), B2 = C.els(), g3 = C.ele(), I3 = E2.slice(A2, Q3), o3 = I3[0], K3 = B2 < 0 ? void 0 : E2.slice(B2, g3), D2 = K3 ? K3[0] : "";
    k2.push({ s: A2, e: Q3, ls: B2, le: g3, n: '"' === o3 || "'" === o3 ? J2(I3) : I3, ln: '"' === D2 || "'" === D2 ? J2(K3) : K3 });
  }
  function J2(A2) {
    try {
      return (0, eval)(A2);
    } catch (A3) {
    }
  }
  __name(J2, "J");
  return [D, k2, !!C.f()];
}
__name(parse4, "parse");
function Q(A2, Q3) {
  const B2 = A2.length;
  let C2 = 0;
  for (; C2 < B2; ) {
    const B3 = A2.charCodeAt(C2);
    Q3[C2++] = (255 & B3) << 8 | B3 >>> 8;
  }
}
__name(Q, "Q");
function B(A2, Q3) {
  const B2 = A2.length;
  let C2 = 0;
  for (; C2 < B2; )
    Q3[C2] = A2.charCodeAt(C2++);
}
__name(B, "B");
var C;
var init = WebAssembly.compile((E = "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", "undefined" != typeof Buffer ? Buffer.from(E, "base64") : Uint8Array.from(atob(E), (A2) => A2.charCodeAt(0)))).then(WebAssembly.instantiate).then(({ exports: A2 }) => {
  C = A2;
});
var E;

// src/dev/miniflare.ts
var import_miniflare5 = require("miniflare");

// src/ai/fetcher.ts
init_import_meta_url();
var import_miniflare3 = require("miniflare");
var EXTERNAL_AI_WORKER_NAME = "__WRANGLER_EXTERNAL_AI_WORKER";
var EXTERNAL_AI_WORKER_SCRIPT = `
import { Ai } from 'cloudflare-internal:ai-api'

export default function (env) {
    return new Ai(env.FETCHER);
}
`;
async function AIFetcher(request3) {
  const accountId = await getAccountId();
  request3.headers.delete("Host");
  request3.headers.delete("Content-Length");
  const res = await performApiFetch(`/accounts/${accountId}/ai/run/proxy`, {
    method: "POST",
    headers: Object.fromEntries(request3.headers.entries()),
    body: request3.body,
    duplex: "half"
  });
  const respHeaders = new import_miniflare3.Headers(res.headers);
  respHeaders.delete("Host");
  respHeaders.delete("Content-Length");
  return new import_miniflare3.Response(res.body, { status: res.status, headers: respHeaders });
}
__name(AIFetcher, "AIFetcher");

// src/deployment-bundle/source-url.ts
init_import_meta_url();
var import_node_fs10 = __toESM(require("node:fs"));
var import_url2 = require("url");
function withSourceURL(source, sourcePath) {
  return `${source}
//# sourceURL=${(0, import_url2.pathToFileURL)(sourcePath)}`;
}
__name(withSourceURL, "withSourceURL");
function withSourceURLs(entrypointPath, modules) {
  let entrypointSource = import_node_fs10.default.readFileSync(entrypointPath, "utf8");
  if (!entrypointPath.endsWith(".py")) {
    entrypointSource = withSourceURL(entrypointSource, entrypointPath);
  }
  modules = modules.map((module3) => {
    if (module3.filePath !== void 0 && (module3.type === "esm" || module3.type === "commonjs")) {
      let newContent = module3.content.toString();
      newContent = withSourceURL(newContent, module3.filePath);
      return { ...module3, content: newContent };
    } else {
      return module3;
    }
  });
  return { entrypointSource, modules };
}
__name(withSourceURLs, "withSourceURLs");

// src/https-options.ts
init_import_meta_url();
var fs11 = __toESM(require("node:fs"));
var path22 = __toESM(require("node:path"));
var import_miniflare4 = require("miniflare");
var CERT_EXPIRY_DAYS = 30;
var ONE_DAY_IN_MS = 864e5;
function getHttpsOptions(customHttpsKeyPath, customHttpsCertPath) {
  if (customHttpsKeyPath !== void 0 || customHttpsCertPath !== void 0) {
    if (customHttpsKeyPath === void 0 || customHttpsCertPath === void 0) {
      throw new UserError(
        "Must specify both certificate path and key path to use a Custom Certificate."
      );
    }
    if (!fs11.existsSync(customHttpsKeyPath)) {
      throw new UserError(
        "Missing Custom Certificate Key at " + customHttpsKeyPath
      );
    }
    if (!fs11.existsSync(customHttpsCertPath)) {
      throw new UserError(
        "Missing Custom Certificate File at " + customHttpsCertPath
      );
    }
    if (hasCertificateExpired(customHttpsKeyPath, customHttpsCertPath)) {
      throw new UserError("Custom Certificate is invalid");
    }
    logger.log("Using custom certificate at ", customHttpsKeyPath);
    return {
      key: fs11.readFileSync(customHttpsKeyPath, "utf8"),
      cert: fs11.readFileSync(customHttpsCertPath, "utf8")
    };
  }
  const certDirectory = path22.join(getGlobalWranglerConfigPath(), "local-cert");
  const keyPath = path22.join(certDirectory, "key.pem");
  const certPath = path22.join(certDirectory, "cert.pem");
  const regenerate = !fs11.existsSync(keyPath) || !fs11.existsSync(certPath) || hasCertificateExpired(keyPath, certPath);
  if (regenerate) {
    logger.log("Generating new self-signed certificate...");
    const { key, cert } = generateCertificate();
    try {
      fs11.mkdirSync(certDirectory, { recursive: true });
      fs11.writeFileSync(keyPath, key, "utf8");
      fs11.writeFileSync(certPath, cert, "utf8");
    } catch (e3) {
      const message = e3 instanceof Error ? e3.message : `${e3}`;
      logger.warn(
        `Unable to cache generated self-signed certificate in ${path22.relative(
          process.cwd(),
          certDirectory
        )}.
${message}`
      );
    }
    return { key, cert };
  } else {
    return {
      key: fs11.readFileSync(keyPath, "utf8"),
      cert: fs11.readFileSync(certPath, "utf8")
    };
  }
}
__name(getHttpsOptions, "getHttpsOptions");
function hasCertificateExpired(keyPath, certPath) {
  const keyStat = fs11.statSync(keyPath);
  const certStat = fs11.statSync(certPath);
  const created = Math.max(keyStat.mtimeMs, certStat.mtimeMs);
  return Date.now() - created > (CERT_EXPIRY_DAYS - 2) * ONE_DAY_IN_MS;
}
__name(hasCertificateExpired, "hasCertificateExpired");
function generateCertificate() {
  const generate = (
    // eslint-disable-next-line @typescript-eslint/no-var-requires
    require("selfsigned").generate
  );
  const certAttrs = [{ name: "commonName", value: "localhost" }];
  const certOptions = {
    algorithm: "sha256",
    days: CERT_EXPIRY_DAYS,
    keySize: 2048,
    extensions: [
      { name: "basicConstraints", cA: true },
      {
        name: "keyUsage",
        keyCertSign: true,
        digitalSignature: true,
        nonRepudiation: true,
        keyEncipherment: true,
        dataEncipherment: true
      },
      {
        name: "extKeyUsage",
        serverAuth: true,
        clientAuth: true,
        codeSigning: true,
        timeStamping: true
      },
      {
        name: "subjectAltName",
        altNames: [
          { type: 2, value: "localhost" },
          ...(0, import_miniflare4.getAccessibleHosts)(false).map((ip2) => ({ type: 7, ip: ip2 }))
        ]
      }
    ]
  };
  const { private: key, cert } = generate(certAttrs, certOptions);
  return { key, cert };
}
__name(generateCertificate, "generateCertificate");

// src/update-check.ts
init_import_meta_url();
var import_chalk5 = __toESM(require_chalk());
init_supports_color();
var import_update_check = __toESM(require_update_check());
async function printWranglerBanner(performUpdateCheck = true) {
  let text = ` \u26C5\uFE0F wrangler ${version}`;
  let maybeNewVersion;
  if (performUpdateCheck) {
    maybeNewVersion = await updateCheck();
    if (maybeNewVersion !== void 0) {
      text += ` (update available ${import_chalk5.default.green(maybeNewVersion)})`;
    }
  }
  logger.log(
    text + "\n" + (supports_color_default.stdout ? import_chalk5.default.hex("#FF8800")("-".repeat(text.length)) : "-".repeat(text.length))
  );
  if (maybeNewVersion !== void 0) {
    const currentMajor = parseInt(version.split(".")[0]);
    const newMajor = parseInt(maybeNewVersion.split(".")[0]);
    if (newMajor > currentMajor) {
      logger.warn(
        `The version of Wrangler you are using is now out-of-date.
Please update to the latest version to prevent critical errors.
Run \`npm install --save-dev wrangler@${newMajor}\` to update to the latest version.
After installation, run Wrangler with \`npx wrangler\`.`
      );
    }
  }
}
__name(printWranglerBanner, "printWranglerBanner");
async function doUpdateCheck() {
  let update = null;
  try {
    update = await (0, import_update_check.default)(package_default, {
      distTag: package_default.version.startsWith("0.0.0") ? "beta" : "latest"
    });
  } catch (err) {
  }
  return update?.latest;
}
__name(doUpdateCheck, "doUpdateCheck");
var updateCheckPromise;
function updateCheck() {
  return updateCheckPromise ??= doUpdateCheck();
}
__name(updateCheck, "updateCheck");

// src/dev/miniflare.ts
var EXTERNAL_SERVICE_WORKER_NAME = "__WRANGLER_EXTERNAL_DURABLE_OBJECTS_WORKER";
var EXTERNAL_SERVICE_WORKER_SCRIPT = `
import { DurableObject, WorkerEntrypoint } from "cloudflare:workers";

const HEADER_URL = "X-Miniflare-Durable-Object-URL";
const HEADER_NAME = "X-Miniflare-Durable-Object-Name";
const HEADER_ID = "X-Miniflare-Durable-Object-Id";
const HEADER_CF_BLOB = "X-Miniflare-Durable-Object-Cf-Blob";

const HANDLER_RESERVED_KEYS = new Set([
	"tail",
	"trace",
	"scheduled",
	"alarm",
	"test",
	"webSocketMessage",
	"webSocketClose",
	"webSocketError",
	"self",
]);

function createProxyPrototypeClass(handlerSuperKlass, getUnknownPrototypeKey) {
	// Build a class with a "Proxy"-prototype, so we can intercept RPC calls and
	// throw unsupported exceptions :see_no_evil:
	function klass(ctx, env) {
		// Delay proxying prototype until construction, so workerd sees this as a
		// regular class when introspecting it. This check fails if we don't do this:
		// https://github.com/cloudflare/workerd/blob/9e915ed637d65adb3c57522607d2cd8b8d692b6b/src/workerd/io/worker.c%2B%2B#L1920-L1921
		klass.prototype = new Proxy(klass.prototype, {
			get(target, key, receiver) {
				const value = Reflect.get(target, key, receiver);
				if (value !== undefined) return value;
				if (HANDLER_RESERVED_KEYS.has(key)) return;
				return getUnknownPrototypeKey(key);
			}
		});

		return Reflect.construct(handlerSuperKlass, [ctx, env], klass);
	}

	Reflect.setPrototypeOf(klass.prototype, handlerSuperKlass.prototype);
	Reflect.setPrototypeOf(klass, handlerSuperKlass);

	return klass;
}

function createDurableObjectClass({ className, proxyUrl }) {
	const klass = createProxyPrototypeClass(DurableObject, (key) => {
		throw new Error(\`Cannot access \\\`\${className}#\${key}\\\` as Durable Object RPC is not yet supported between multiple \\\`wrangler dev\\\` sessions.\`);
	});

	// Forward regular HTTP requests to the other "wrangler dev" session
	klass.prototype.fetch = function(request) {
		if (proxyUrl === undefined) {
			return new Response(\`[wrangler] Couldn't find \\\`wrangler dev\\\` session for class "\${className}" to proxy to\`, { status: 503 });
		}
		const proxyRequest = new Request(proxyUrl, request);
		proxyRequest.headers.set(HEADER_URL, request.url);
		proxyRequest.headers.set(HEADER_NAME, className);
		proxyRequest.headers.set(HEADER_ID, this.ctx.id.toString());
		proxyRequest.headers.set(HEADER_CF_BLOB, JSON.stringify(request.cf ?? {}));
		return fetch(proxyRequest);
	};

	return klass;
}

function createNotFoundWorkerEntrypointClass({ service }) {
	const klass = createProxyPrototypeClass(WorkerEntrypoint, (key) => {
		throw new Error(\`Cannot access \\\`\${key}\\\` as we couldn't find a \\\`wrangler dev\\\` session for service "\${service}" to proxy to.\`);
	});

	// Return regular HTTP response for HTTP requests
	klass.prototype.fetch = function(request) {
		const message = \`[wrangler] Couldn't find \\\`wrangler dev\\\` session for service "\${service}" to proxy to\`;
		return new Response(message, { status: 503 });
	};

	return klass;
}

export default {
	async fetch(request, env) {
		const originalUrl = request.headers.get(HEADER_URL);
		const className = request.headers.get(HEADER_NAME);
		const idString = request.headers.get(HEADER_ID);
		const cf = JSON.parse(request.headers.get(HEADER_CF_BLOB));
		if (originalUrl === null || className === null || idString === null) {
			return new Response("[wrangler] Received Durable Object proxy request with missing headers", { status: 400 });
		}
		request = new Request(originalUrl, request);
		request.headers.delete(HEADER_URL);
		request.headers.delete(HEADER_NAME);
		request.headers.delete(HEADER_ID);
		request.headers.delete(HEADER_CF_BLOB);
		const ns = env[className];
		const id = ns.idFromString(idString);
		const stub = ns.get(id);
		return stub.fetch(request, { cf });
	}
}
`;
var WranglerLog = class extends import_miniflare5.Log {
  #warnedCompatibilityDateFallback = false;
  log(message) {
    if (message.includes(EXTERNAL_SERVICE_WORKER_NAME))
      return;
    super.log(message);
  }
  warn(message) {
    if (message.startsWith("The latest compatibility date supported by")) {
      if (this.#warnedCompatibilityDateFallback)
        return;
      this.#warnedCompatibilityDateFallback = true;
      return void updateCheck().then((maybeNewVersion) => {
        if (maybeNewVersion === void 0)
          return;
        message += [
          "",
          "Features enabled by your requested compatibility date may not be available.",
          `Upgrade to \`wrangler@${maybeNewVersion}\` to remove this warning.`
        ].join("\n");
        super.warn(message);
      });
    }
    super.warn(message);
  }
};
__name(WranglerLog, "WranglerLog");
var DEFAULT_WORKER_NAME = "worker";
function getName(config) {
  return config.name ?? DEFAULT_WORKER_NAME;
}
__name(getName, "getName");
var IDENTIFIER_UNSAFE_REGEXP = /[^a-zA-Z0-9_$]/g;
function getIdentifier(name) {
  return name.replace(IDENTIFIER_UNSAFE_REGEXP, "_");
}
__name(getIdentifier, "getIdentifier");
function castLogLevel(level) {
  let key = level.toUpperCase();
  if (key === "LOG")
    key = "INFO";
  return import_miniflare5.LogLevel[key];
}
__name(castLogLevel, "castLogLevel");
function buildLog() {
  let level = castLogLevel(logger.loggerLevel);
  if (level <= import_miniflare5.LogLevel.DEBUG) {
    level = Math.min(level, import_miniflare5.LogLevel.WARN);
  }
  return new WranglerLog(level, { prefix: "wrangler-UserWorker" });
}
__name(buildLog, "buildLog");
async function getEntrypointNames(entrypointSource) {
  await init;
  const [_imports, exports2] = parse4(entrypointSource);
  return exports2.map(({ n: n2 }) => n2);
}
__name(getEntrypointNames, "getEntrypointNames");
async function buildSourceOptions(config) {
  const scriptPath3 = (0, import_node_fs11.realpathSync)(config.bundle.path);
  if (config.format === "modules") {
    const isPython = config.bundle.type === "python";
    const { entrypointSource, modules } = isPython ? {
      entrypointSource: (0, import_node_fs11.readFileSync)(scriptPath3, "utf8"),
      modules: config.bundle.modules
    } : withSourceURLs(scriptPath3, config.bundle.modules);
    const entrypointNames = isPython ? [] : await getEntrypointNames(entrypointSource);
    const modulesRoot = import_node_path19.default.dirname(scriptPath3);
    const sourceOptions = {
      modulesRoot,
      modules: [
        // Entrypoint
        {
          type: ModuleTypeToRuleType[config.bundle.type],
          path: scriptPath3,
          contents: entrypointSource
        },
        // Misc (WebAssembly, etc, ...)
        ...modules.map((module3) => ({
          type: ModuleTypeToRuleType[module3.type ?? "esm"],
          path: import_node_path19.default.resolve(modulesRoot, module3.name),
          contents: module3.content
        }))
      ]
    };
    return { sourceOptions, entrypointNames };
  } else {
    return { sourceOptions: { scriptPath: scriptPath3 }, entrypointNames: [] };
  }
}
__name(buildSourceOptions, "buildSourceOptions");
function kvNamespaceEntry({ binding, id }) {
  return [binding, id];
}
__name(kvNamespaceEntry, "kvNamespaceEntry");
function r2BucketEntry({ binding, bucket_name }) {
  return [binding, bucket_name];
}
__name(r2BucketEntry, "r2BucketEntry");
function d1DatabaseEntry(db) {
  return [db.binding, db.preview_database_id ?? db.database_id];
}
__name(d1DatabaseEntry, "d1DatabaseEntry");
function queueProducerEntry(queue) {
  return [
    queue.binding,
    { queueName: queue.queue_name, deliveryDelay: queue.delivery_delay }
  ];
}
__name(queueProducerEntry, "queueProducerEntry");
function hyperdriveEntry(hyperdrive2) {
  return [hyperdrive2.binding, hyperdrive2.localConnectionString ?? ""];
}
__name(hyperdriveEntry, "hyperdriveEntry");
function ratelimitEntry(ratelimit) {
  return [ratelimit.name, ratelimit];
}
__name(ratelimitEntry, "ratelimitEntry");
function queueConsumerEntry(consumer) {
  const options29 = {
    maxBatchSize: consumer.max_batch_size,
    maxBatchTimeout: consumer.max_batch_timeout,
    maxRetires: consumer.max_retries,
    deadLetterQueue: consumer.dead_letter_queue,
    retryDelay: consumer.retry_delay
  };
  return [consumer.queue, options29];
}
__name(queueConsumerEntry, "queueConsumerEntry");
function buildMiniflareBindingOptions(config) {
  const bindings = config.bindings;
  const textBlobBindings = { ...bindings.text_blobs };
  const dataBlobBindings = { ...bindings.data_blobs };
  const wasmBindings = { ...bindings.wasm_modules };
  if (config.format === "service-worker" && config.bundle) {
    const scriptPath3 = (0, import_node_fs11.realpathSync)(config.bundle.path);
    const modulesRoot = import_node_path19.default.dirname(scriptPath3);
    for (const { type, name } of config.bundle.modules) {
      if (type === "text") {
        textBlobBindings[getIdentifier(name)] = import_node_path19.default.resolve(modulesRoot, name);
      } else if (type === "buffer") {
        dataBlobBindings[getIdentifier(name)] = import_node_path19.default.resolve(modulesRoot, name);
      } else if (type === "compiled-wasm") {
        wasmBindings[getIdentifier(name)] = import_node_path19.default.resolve(modulesRoot, name);
      }
    }
  }
  const serviceBindings = {
    ...config.serviceBindings
  };
  const notFoundServices = /* @__PURE__ */ new Set();
  for (const service of config.services ?? []) {
    if (service.service === config.name) {
      serviceBindings[service.binding] = {
        name: getName(config),
        entrypoint: service.entrypoint
      };
      continue;
    }
    const target = config.workerDefinitions?.[service.service];
    if (target?.host === void 0 || target.port === void 0) {
      notFoundServices.add(service.service);
      serviceBindings[service.binding] = {
        name: EXTERNAL_SERVICE_WORKER_NAME,
        entrypoint: getIdentifier(`service_${service.service}`)
      };
    } else {
      let address;
      if (service.entrypoint !== void 0) {
        if (target.entrypointAddresses === void 0) {
          throw new UserError(
            `The \`wrangler dev\` session for service "${service.service}" does not support proxying entrypoints. Please upgrade "${service.service}"'s \`wrangler\` version.`
          );
        }
        const entrypointAddress = target.entrypointAddresses[service.entrypoint];
        if (entrypointAddress === void 0) {
          throw new UserError(
            `The \`wrangler dev\` session for service "${service.service}" does not export an entrypoint named "${service.entrypoint}"`
          );
        }
        address = `${entrypointAddress.host}:${entrypointAddress.port}`;
      } else {
        const defaultEntrypointAddress = target.entrypointAddresses?.["default"];
        if (defaultEntrypointAddress === void 0) {
          if (target.protocol === "https") {
            throw new UserError(
              `Cannot proxy to \`wrangler dev\` session for service "${service.service}" because it uses HTTPS. Please upgrade "${service.service}"'s \`wrangler\` version, or remove the \`--local-protocol\`/\`dev.local_protocol\` option.`
            );
          }
          address = `${target.host}:${target.port}`;
        } else {
          address = `${defaultEntrypointAddress.host}:${defaultEntrypointAddress.port}`;
        }
      }
      serviceBindings[service.binding] = {
        external: {
          address,
          http: {
            style: import_miniflare5.HttpOptions_Style.PROXY,
            cfBlobHeader: import_miniflare5.CoreHeaders.CF_BLOB
          }
        }
      };
    }
  }
  const internalObjects = [];
  const externalObjects = [];
  const externalWorkers = [];
  for (const binding of bindings.durable_objects?.bindings ?? []) {
    const internal = binding.script_name === void 0 || binding.script_name === config.name;
    (internal ? internalObjects : externalObjects).push(binding);
  }
  externalWorkers.push({
    name: EXTERNAL_SERVICE_WORKER_NAME,
    // Bind all internal objects, so they're accessible by all other sessions
    // that proxy requests for our objects to this worker
    durableObjects: Object.fromEntries(
      internalObjects.map(({ class_name }) => [
        class_name,
        { className: class_name, scriptName: getName(config) }
      ])
    ),
    // Use this worker instead of the user worker if the pathname is
    // `/${EXTERNAL_SERVICE_WORKER_NAME}`
    routes: [`*/${EXTERNAL_SERVICE_WORKER_NAME}`],
    // Use in-memory storage for the stub object classes *declared* by this
    // script. They don't need to persist anything, and would end up using the
    // incorrect unsafe unique key.
    unsafeEphemeralDurableObjects: true,
    compatibilityDate: "2024-01-01",
    modules: true,
    script: EXTERNAL_SERVICE_WORKER_SCRIPT + // Add stub object classes that proxy requests to the correct session
    externalObjects.map(({ class_name, script_name }) => {
      (0, import_node_assert8.default)(script_name !== void 0);
      const target = config.workerDefinitions?.[script_name];
      const targetHasClass = target?.durableObjects.some(
        ({ className }) => className === class_name
      );
      const identifier = getIdentifier(`do_${script_name}_${class_name}`);
      const classNameJson = JSON.stringify(class_name);
      if (target?.host === void 0 || target.port === void 0 || !targetHasClass) {
        return `export const ${identifier} = createDurableObjectClass({ className: ${classNameJson} });`;
      } else if (target.protocol === "https") {
        throw new UserError(
          `Cannot proxy to \`wrangler dev\` session for class ${classNameJson} because it uses HTTPS. Please remove the \`--local-protocol\`/\`dev.local_protocol\` option.`
        );
      } else {
        const proxyUrl = `http://${target.host}:${target.port}/${EXTERNAL_SERVICE_WORKER_NAME}`;
        const proxyUrlJson = JSON.stringify(proxyUrl);
        return `export const ${identifier} = createDurableObjectClass({ className: ${classNameJson}, proxyUrl: ${proxyUrlJson} });`;
      }
    }).join("\n") + Array.from(notFoundServices).map((service) => {
      const identifier = getIdentifier(`service_${service}`);
      const serviceJson = JSON.stringify(service);
      return `export const ${identifier} = createNotFoundWorkerEntrypointClass({ service: ${serviceJson} });`;
    }).join("\n")
  });
  const wrappedBindings = {};
  if (bindings.ai?.binding) {
    externalWorkers.push({
      name: EXTERNAL_AI_WORKER_NAME,
      modules: [
        {
          type: "ESModule",
          path: "index.mjs",
          contents: EXTERNAL_AI_WORKER_SCRIPT
        }
      ],
      serviceBindings: {
        FETCHER: AIFetcher
      }
    });
    wrappedBindings[bindings.ai.binding] = {
      scriptName: EXTERNAL_AI_WORKER_NAME
    };
  }
  const bindingOptions = {
    bindings: {
      ...bindings.vars,
      // emulate version_metadata binding via a JSON var
      ...bindings.version_metadata ? { [bindings.version_metadata.binding]: { id: (0, import_node_crypto4.randomUUID)(), tag: "" } } : void 0
    },
    textBlobBindings,
    dataBlobBindings,
    wasmBindings,
    kvNamespaces: Object.fromEntries(
      bindings.kv_namespaces?.map(kvNamespaceEntry) ?? []
    ),
    r2Buckets: Object.fromEntries(
      bindings.r2_buckets?.map(r2BucketEntry) ?? []
    ),
    d1Databases: Object.fromEntries(
      bindings.d1_databases?.map(d1DatabaseEntry) ?? []
    ),
    queueProducers: Object.fromEntries(
      bindings.queues?.map(queueProducerEntry) ?? []
    ),
    queueConsumers: Object.fromEntries(
      config.queueConsumers?.map(queueConsumerEntry) ?? []
    ),
    hyperdrives: Object.fromEntries(
      bindings.hyperdrive?.map(hyperdriveEntry) ?? []
    ),
    durableObjects: Object.fromEntries([
      ...internalObjects.map(({ name, class_name }) => [name, class_name]),
      ...externalObjects.map(({ name, class_name, script_name }) => {
        const identifier = getIdentifier(`do_${script_name}_${class_name}`);
        return [
          name,
          {
            className: identifier,
            scriptName: EXTERNAL_SERVICE_WORKER_NAME,
            // Matches the unique key Miniflare will generate for this object in
            // the target session. We need to do this so workerd generates the
            // same IDs it would if this were part of the same process. workerd
            // doesn't allow IDs from Durable Objects with different unique keys
            // to be used with each other.
            unsafeUniqueKey: `${script_name}-${class_name}`
          }
        ];
      })
    ]),
    ratelimits: Object.fromEntries(
      bindings.unsafe?.bindings?.filter((b2) => b2.type == "ratelimit").map(ratelimitEntry) ?? []
    ),
    serviceBindings,
    wrappedBindings
  };
  return {
    bindingOptions,
    internalObjects,
    externalWorkers
  };
}
__name(buildMiniflareBindingOptions, "buildMiniflareBindingOptions");
function buildPersistOptions(localPersistencePath) {
  if (localPersistencePath !== null) {
    const v3Path = import_node_path19.default.join(localPersistencePath, "v3");
    return {
      cachePersist: import_node_path19.default.join(v3Path, "cache"),
      durableObjectsPersist: import_node_path19.default.join(v3Path, "do"),
      kvPersist: import_node_path19.default.join(v3Path, "kv"),
      r2Persist: import_node_path19.default.join(v3Path, "r2"),
      d1Persist: import_node_path19.default.join(v3Path, "d1")
    };
  }
}
__name(buildPersistOptions, "buildPersistOptions");
function buildSitesOptions({
  assetPaths
}) {
  if (assetPaths !== void 0) {
    const { baseDirectory, assetDirectory, includePatterns, excludePatterns } = assetPaths;
    return {
      sitePath: import_node_path19.default.join(baseDirectory, assetDirectory),
      siteInclude: includePatterns.length > 0 ? includePatterns : void 0,
      siteExclude: excludePatterns.length > 0 ? excludePatterns : void 0
    };
  }
}
__name(buildSitesOptions, "buildSitesOptions");
function handleRuntimeStdio(stdout2, stderr2) {
  const classifiers = {
    // Is this chunk a big chonky barf from workerd that we want to hijack to cleanup/ignore?
    isBarf(chunk) {
      const containsLlvmSymbolizerWarning = chunk.includes(
        "Not symbolizing stack traces because $LLVM_SYMBOLIZER is not set"
      );
      const containsRecursiveIsolateLockWarning = chunk.includes(
        "took recursive isolate lock"
      );
      const containsHexStack = /stack:( (0|[a-f\d]{4,})){3,}/.test(chunk);
      return containsLlvmSymbolizerWarning || containsRecursiveIsolateLockWarning || containsHexStack;
    },
    // Is this chunk an Address In Use error?
    isAddressInUse(chunk) {
      return chunk.includes("Address already in use; toString() = ");
    },
    isWarning(chunk) {
      return /\.c\+\+:\d+: warning:/.test(chunk);
    }
  };
  stdout2.on("data", (chunk) => {
    chunk = chunk.toString().trim();
    if (classifiers.isBarf(chunk)) {
      logger.debug(chunk);
    } else if (classifiers.isWarning(chunk)) {
      logger.warn(chunk);
    } else {
      logger.info(getSourceMappedString(chunk));
    }
  });
  stderr2.on("data", (chunk) => {
    chunk = chunk.toString().trim();
    if (classifiers.isBarf(chunk)) {
      if (classifiers.isAddressInUse(chunk)) {
        const address = chunk.match(
          /Address already in use; toString\(\) = (.+)\n/
        )?.[1];
        logger.error(
          `Address already in use (${address}). Please check that you are not already running a server on this address or specify a different port with --port.`
        );
      }
      logger.debug(chunk);
    } else if (classifiers.isWarning(chunk)) {
      logger.warn(chunk);
    } else {
      logger.error(getSourceMappedString(chunk));
    }
  });
}
__name(handleRuntimeStdio, "handleRuntimeStdio");
async function buildMiniflareOptions(log2, config, proxyToUserWorkerAuthenticationSecret) {
  if (config.crons.length > 0) {
    logger.warn("Miniflare 3 does not support CRON triggers yet, ignoring...");
  }
  if (config.bindings.ai) {
    logger.warn(
      "Using Workers AI always accesses your Cloudflare account in order to run AI models, and so will incur usage charges even in local development."
    );
  }
  if (config.bindings.vectorize?.length) {
    logger.warn(
      "Vectorize bindings are not currently supported in local mode. Please use --remote if you are working with them."
    );
  }
  const upstream = typeof config.localUpstream === "string" ? `${config.upstreamProtocol}://${config.localUpstream}` : void 0;
  const { sourceOptions, entrypointNames } = await buildSourceOptions(config);
  const { bindingOptions, internalObjects, externalWorkers } = buildMiniflareBindingOptions(config);
  const sitesOptions = buildSitesOptions(config);
  const persistOptions = buildPersistOptions(config.localPersistencePath);
  let httpsOptions;
  if (config.localProtocol === "https") {
    const cert = await getHttpsOptions(
      config.httpsKeyPath,
      config.httpsCertPath
    );
    httpsOptions = {
      httpsKey: cert.key,
      httpsCert: cert.cert
    };
  }
  const options29 = {
    host: config.initialIp,
    port: config.initialPort,
    inspectorPort: config.inspect ? config.inspectorPort : void 0,
    liveReload: config.liveReload,
    upstream,
    unsafeProxySharedSecret: proxyToUserWorkerAuthenticationSecret,
    log: log2,
    verbose: logger.loggerLevel === "debug",
    handleRuntimeStdio,
    ...httpsOptions,
    ...persistOptions,
    workers: [
      {
        name: getName(config),
        compatibilityDate: config.compatibilityDate,
        compatibilityFlags: config.compatibilityFlags,
        ...sourceOptions,
        ...bindingOptions,
        ...sitesOptions,
        // Allow each entrypoint to be accessed directly over `127.0.0.1:0`
        unsafeDirectSockets: entrypointNames.map((name) => ({
          host: "127.0.0.1",
          port: 0,
          entrypoint: name,
          proxy: true
        }))
      },
      ...externalWorkers
    ]
  };
  return { options: options29, internalObjects, entrypointNames };
}
__name(buildMiniflareOptions, "buildMiniflareOptions");
var ReloadedEvent = class extends Event {
  url;
  internalDurableObjects;
  entrypointAddresses;
  proxyToUserWorkerAuthenticationSecret;
  constructor(type, options29) {
    super(type);
    this.url = options29.url;
    this.internalDurableObjects = options29.internalDurableObjects;
    this.entrypointAddresses = options29.entrypointAddresses;
    this.proxyToUserWorkerAuthenticationSecret = options29.proxyToUserWorkerAuthenticationSecret;
  }
};
__name(ReloadedEvent, "ReloadedEvent");
var ErrorEvent = class extends Event {
  error;
  constructor(type, options29) {
    super(type);
    this.error = options29.error;
  }
};
__name(ErrorEvent, "ErrorEvent");
var MiniflareServer = class extends import_miniflare5.TypedEventTarget {
  #log = buildLog();
  #mf;
  // This is given as a shared secret to the Proxy and User workers
  // so that the User Worker can trust aspects of HTTP requests from the Proxy Worker
  // if it provides the secret in a `MF-Proxy-Shared-Secret` header.
  #proxyToUserWorkerAuthenticationSecret = (0, import_node_crypto4.randomUUID)();
  // `buildMiniflareOptions()` is asynchronous, meaning if multiple bundle
  // updates were submitted, the second may apply before the first. Therefore,
  // wrap updates in a mutex, so they're always applied in invocation order.
  #mutex = new import_miniflare5.Mutex();
  async #onBundleUpdate(config, opts) {
    if (opts?.signal?.aborted)
      return;
    try {
      const { options: options29, internalObjects, entrypointNames } = await buildMiniflareOptions(
        this.#log,
        config,
        this.#proxyToUserWorkerAuthenticationSecret
      );
      if (opts?.signal?.aborted)
        return;
      if (this.#mf === void 0) {
        this.#mf = new import_miniflare5.Miniflare(options29);
      } else {
        await this.#mf.setOptions(options29);
      }
      const url4 = await this.#mf.ready;
      const entrypointAddresses = {};
      for (const name of entrypointNames) {
        const directUrl = await this.#mf.unsafeGetDirectURL(void 0, name);
        const port2 = parseInt(directUrl.port);
        entrypointAddresses[name] = { host: directUrl.hostname, port: port2 };
      }
      if (opts?.signal?.aborted)
        return;
      const event = new ReloadedEvent("reloaded", {
        url: url4,
        internalDurableObjects: internalObjects,
        proxyToUserWorkerAuthenticationSecret: this.#proxyToUserWorkerAuthenticationSecret,
        entrypointAddresses
      });
      this.dispatchEvent(event);
    } catch (error2) {
      this.dispatchEvent(new ErrorEvent("error", { error: error2 }));
    }
  }
  onBundleUpdate(config, opts) {
    return this.#mutex.runWith(() => this.#onBundleUpdate(config, opts));
  }
  #onDispose = async () => {
    await this.#mf?.dispose();
    this.#mf = void 0;
  };
  onDispose() {
    return this.#mutex.runWith(this.#onDispose);
  }
};
__name(MiniflareServer, "MiniflareServer");

// src/dev/local.tsx
async function localPropsToConfigBundle(props) {
  (0, import_node_assert10.default)(props.bundle !== void 0);
  const serviceBindings = {};
  if (props.enablePagesAssetsServiceBinding !== void 0) {
    const generateASSETSBinding2 = (init_assets(), __toCommonJS(assets_exports)).default;
    serviceBindings.ASSETS = await generateASSETSBinding2({
      log: logger,
      ...props.enablePagesAssetsServiceBinding
    });
  }
  return {
    name: props.name,
    bundle: props.bundle,
    format: props.format,
    compatibilityDate: props.compatibilityDate,
    compatibilityFlags: props.compatibilityFlags,
    inspectorPort: props.runtimeInspectorPort,
    usageModel: props.usageModel,
    bindings: props.bindings,
    workerDefinitions: props.workerDefinitions,
    assetPaths: props.assetPaths,
    initialPort: props.initialPort,
    initialIp: props.initialIp,
    rules: props.rules,
    localPersistencePath: props.localPersistencePath,
    liveReload: props.liveReload,
    crons: props.crons,
    queueConsumers: props.queueConsumers,
    localProtocol: props.localProtocol,
    httpsKeyPath: props.httpsKeyPath,
    httpsCertPath: props.httpsCertPath,
    localUpstream: props.localUpstream,
    upstreamProtocol: props.upstreamProtocol,
    inspect: props.inspect,
    services: props.services,
    serviceBindings
  };
}
__name(localPropsToConfigBundle, "localPropsToConfigBundle");
function maybeRegisterLocalWorker(url4, name, internalDurableObjects, entrypointAddresses) {
  if (name === void 0)
    return;
  let protocol = url4.protocol;
  protocol = protocol.substring(0, url4.protocol.length - 1);
  if (protocol !== "http" && protocol !== "https")
    return;
  const port2 = parseInt(url4.port);
  return registerWorker(name, {
    protocol,
    mode: "local",
    port: port2,
    host: url4.hostname,
    durableObjects: (internalDurableObjects ?? []).map((binding) => ({
      name: binding.name,
      className: binding.class_name
    })),
    durableObjectsHost: url4.hostname,
    durableObjectsPort: port2,
    entrypointAddresses
  });
}
__name(maybeRegisterLocalWorker, "maybeRegisterLocalWorker");
function Local(props) {
  useLocalWorker(props);
  return null;
}
__name(Local, "Local");
function useLocalWorker(props) {
  const miniflareServerRef = (0, import_react.useRef)();
  const removeMiniflareServerExitListenerRef = (0, import_react.useRef)();
  (0, import_react.useEffect)(() => {
    if (props.bindings.services && props.bindings.services.length > 0) {
      logger.warn(
        "\u2394 Support for service bindings in local mode is experimental and may change."
      );
    }
  }, [props.bindings.services]);
  (0, import_react.useEffect)(() => {
    const externalDurableObjects = (props.bindings.durable_objects?.bindings || []).filter((binding) => binding.script_name);
    if (externalDurableObjects.length > 0) {
      logger.warn(
        "\u2394 Support for external Durable Objects in local mode is experimental and may change."
      );
    }
  }, [props.bindings.durable_objects?.bindings]);
  (0, import_react.useEffect)(() => {
    const abortController = new AbortController();
    if (!props.bundle || !props.format)
      return;
    let server = miniflareServerRef.current;
    if (server === void 0) {
      logger.log(import_chalk6.default.dim("\u2394 Starting local server..."));
      const newServer = new MiniflareServer();
      miniflareServerRef.current = server = newServer;
      server.addEventListener("reloaded", async (event) => {
        const proxyData = {
          userWorkerUrl: {
            protocol: event.url.protocol,
            hostname: event.url.hostname,
            port: event.url.port
          },
          userWorkerInspectorUrl: {
            protocol: "ws:",
            hostname: "127.0.0.1",
            port: props.runtimeInspectorPort.toString(),
            pathname: `/core:user:${props.name ?? DEFAULT_WORKER_NAME}`
          },
          userWorkerInnerUrlOverrides: {
            protocol: props.upstreamProtocol,
            hostname: props.localUpstream,
            port: props.localUpstream ? "" : void 0
            // `localUpstream` was essentially `host`, not `hostname`, so if it was set delete the `port`
          },
          headers: {
            // Passing this signature from Proxy Worker allows the User Worker to trust the request.
            "MF-Proxy-Shared-Secret": event.proxyToUserWorkerAuthenticationSecret
          },
          liveReload: props.liveReload,
          // in local mode, the logs are already being printed to the console by workerd but only for workers written in "module" format
          // workers written in "service-worker" format still need to proxy logs to the ProxyController
          proxyLogsToController: props.format === "service-worker",
          internalDurableObjects: event.internalDurableObjects,
          entrypointAddresses: event.entrypointAddresses
        };
        props.onReady?.(
          event.url.hostname,
          parseInt(event.url.port),
          proxyData
        );
      });
      server.addEventListener("error", ({ error: error2 }) => {
        if (typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ERR_RUNTIME_FAILURE") {
          logger.error(String(error2));
        } else {
          logger.error("Error reloading local server:", error2);
        }
      });
      removeMiniflareServerExitListenerRef.current = (0, import_signal_exit4.default)(() => {
        logger.log(import_chalk6.default.dim("\u2394 Shutting down local server..."));
        void newServer.onDispose();
        miniflareServerRef.current = void 0;
      });
    } else {
      logger.log(import_chalk6.default.dim("\u2394 Reloading local server..."));
    }
    const currentServer = server;
    void localPropsToConfigBundle(props).then(
      (config) => currentServer.onBundleUpdate(config, { signal: abortController.signal })
    );
    return () => abortController.abort();
  }, [props]);
  (0, import_react.useEffect)(
    () => () => {
      if (miniflareServerRef.current) {
        logger.log(import_chalk6.default.dim("\u2394 Shutting down local server..."));
        void miniflareServerRef.current.onDispose().catch(() => {
        });
        miniflareServerRef.current = void 0;
      }
      removeMiniflareServerExitListenerRef.current?.();
      removeMiniflareServerExitListenerRef.current = void 0;
    },
    []
  );
}
__name(useLocalWorker, "useLocalWorker");

// src/dev/remote.tsx
init_import_meta_url();
var import_node_path54 = __toESM(require("node:path"));
var import_ink11 = __toESM(require_build2());
var import_ink_select_input3 = __toESM(require_build3());
var import_react17 = __toESM(require_react());

// src/deploy/deploy.ts
init_import_meta_url();
var import_node_assert17 = __toESM(require("node:assert"));
var import_node_fs34 = require("node:fs");
var import_node_path53 = __toESM(require("node:path"));
var import_node_url15 = require("node:url");

// src/deployment-bundle/bundle-reporter.ts
init_import_meta_url();
var import_node_buffer2 = require("node:buffer");
var import_node_zlib = require("node:zlib");
var import_chalk7 = __toESM(require_chalk());
var ONE_KIB_BYTES = 1024;
var ALLOWED_INITIAL_MAX = ONE_KIB_BYTES * 1024;
async function getSize(modules) {
  const gzipSize = (0, import_node_zlib.gzipSync)(
    await new import_node_buffer2.Blob(modules.map((file) => file.content)).arrayBuffer()
  ).byteLength;
  const aggregateSize = new import_node_buffer2.Blob(modules.map((file) => file.content)).size;
  return { size: aggregateSize, gzipSize };
}
__name(getSize, "getSize");
async function printBundleSize(main2, modules) {
  const { size, gzipSize } = await getSize([...modules, main2]);
  const bundleReport = `${(size / ONE_KIB_BYTES).toFixed(2)} KiB / gzip: ${(gzipSize / ONE_KIB_BYTES).toFixed(2)} KiB`;
  const percentage = gzipSize / ALLOWED_INITIAL_MAX * 100;
  const colorizedReport = percentage > 90 ? import_chalk7.default.red(bundleReport) : percentage > 70 ? import_chalk7.default.yellow(bundleReport) : import_chalk7.default.green(bundleReport);
  logger.log(`Total Upload: ${colorizedReport}`);
  if (gzipSize > ALLOWED_INITIAL_MAX && !process.env.NO_SCRIPT_SIZE_WARNING) {
    logger.warn(
      "We recommend keeping your script less than 1MiB (1024 KiB) after gzip. Exceeding this can affect cold start time. Consider using Wrangler's `--minify` option to reduce your bundle size."
    );
  }
}
__name(printBundleSize, "printBundleSize");
function printOffendingDependencies(dependencies) {
  const warning = [];
  const dependenciesSorted = Object.entries(dependencies);
  dependenciesSorted.sort(
    ([_adep, aData], [_bdep, bData]) => bData.bytesInOutput - aData.bytesInOutput
  );
  const topLargest = dependenciesSorted.slice(0, 5);
  if (topLargest.length > 0) {
    warning.push(
      `Here are the ${topLargest.length} largest dependencies included in your script:`
    );
    for (const [dep, data] of topLargest) {
      warning.push(
        `- ${dep} - ${(data.bytesInOutput / ONE_KIB_BYTES).toFixed(2)} KiB`
      );
    }
    warning.push("If these are unnecessary, consider removing them");
    logger.warn(warning.join("\n"));
  }
}
__name(printOffendingDependencies, "printOffendingDependencies");

// src/deployment-bundle/create-worker-upload-form.ts
init_import_meta_url();
var import_node_assert11 = __toESM(require("node:assert"));
var import_node_fs15 = require("node:fs");
var import_node_path24 = __toESM(require("node:path"));
var import_undici6 = __toESM(require_undici());

// src/deployment-bundle/capnp.ts
init_import_meta_url();
var import_node_child_process2 = require("node:child_process");
var import_node_fs14 = require("node:fs");
var import_node_path23 = require("node:path");
var import_command_exists = __toESM(require_command_exists2());
function handleUnsafeCapnp(capnp) {
  if (capnp.compiled_schema) {
    return (0, import_node_fs14.readFileSync)((0, import_node_path23.resolve)(capnp.compiled_schema));
  }
  const { base_path, source_schemas } = capnp;
  const capnpSchemas = (source_schemas ?? []).map(
    (x2) => (0, import_node_path23.resolve)(base_path, x2)
  );
  if (!(0, import_command_exists.sync)("capnp")) {
    throw new UserError(
      "The capnp compiler is required to upload capnp schemas, but is not present."
    );
  }
  const srcPrefix = (0, import_node_path23.resolve)(base_path ?? ".");
  const capnpProcess = (0, import_node_child_process2.spawnSync)("capnp", [
    "compile",
    "-o-",
    `--src-prefix=${srcPrefix}`,
    ...capnpSchemas
  ]);
  if (capnpProcess.error)
    throw capnpProcess.error;
  if (capnpProcess.stderr.length)
    throw new Error(capnpProcess.stderr.toString());
  return capnpProcess.stdout;
}
__name(handleUnsafeCapnp, "handleUnsafeCapnp");

// src/deployment-bundle/create-worker-upload-form.ts
function toMimeType(type) {
  switch (type) {
    case "esm":
      return "application/javascript+module";
    case "commonjs":
      return "application/javascript";
    case "compiled-wasm":
      return "application/wasm";
    case "buffer":
      return "application/octet-stream";
    case "text":
      return "text/plain";
    case "python":
      return "text/x-python";
    case "python-requirement":
      return "text/x-python-requirement";
    default:
      throw new TypeError("Unsupported module: " + type);
  }
}
__name(toMimeType, "toMimeType");
function createWorkerUploadForm(worker) {
  const formData = new import_undici6.FormData();
  const {
    main: main2,
    sourceMaps,
    bindings,
    migrations,
    usage_model,
    compatibility_date,
    compatibility_flags,
    keepVars,
    keepSecrets,
    logpush,
    placement,
    tail_consumers,
    limits,
    annotations
  } = worker;
  let { modules } = worker;
  const metadataBindings = [];
  Object.entries(bindings.vars || {})?.forEach(([key, value]) => {
    if (typeof value === "string") {
      metadataBindings.push({ name: key, type: "plain_text", text: value });
    } else {
      metadataBindings.push({ name: key, type: "json", json: value });
    }
  });
  bindings.kv_namespaces?.forEach(({ id, binding }) => {
    metadataBindings.push({
      name: binding,
      type: "kv_namespace",
      namespace_id: id
    });
  });
  bindings.send_email?.forEach(
    ({ name, destination_address, allowed_destination_addresses }) => {
      metadataBindings.push({
        name,
        type: "send_email",
        destination_address,
        allowed_destination_addresses
      });
    }
  );
  bindings.durable_objects?.bindings.forEach(
    ({ name, class_name, script_name, environment }) => {
      metadataBindings.push({
        name,
        type: "durable_object_namespace",
        class_name,
        ...script_name && { script_name },
        ...environment && { environment }
      });
    }
  );
  bindings.queues?.forEach(({ binding, queue_name, delivery_delay }) => {
    metadataBindings.push({
      type: "queue",
      name: binding,
      queue_name,
      delivery_delay
    });
  });
  bindings.r2_buckets?.forEach(({ binding, bucket_name, jurisdiction }) => {
    metadataBindings.push({
      name: binding,
      type: "r2_bucket",
      bucket_name,
      jurisdiction
    });
  });
  bindings.d1_databases?.forEach(
    ({ binding, database_id, database_internal_env }) => {
      metadataBindings.push({
        name: binding,
        type: "d1",
        id: database_id,
        internalEnv: database_internal_env
      });
    }
  );
  bindings.vectorize?.forEach(({ binding, index_name }) => {
    metadataBindings.push({
      name: binding,
      type: "vectorize",
      index_name
    });
  });
  bindings.constellation?.forEach(({ binding, project_id }) => {
    metadataBindings.push({
      name: binding,
      type: "constellation",
      project: project_id
    });
  });
  bindings.hyperdrive?.forEach(({ binding, id }) => {
    metadataBindings.push({
      name: binding,
      type: "hyperdrive",
      id
    });
  });
  bindings.services?.forEach(
    ({ binding, service, environment, entrypoint }) => {
      metadataBindings.push({
        name: binding,
        type: "service",
        service,
        ...environment && { environment },
        ...entrypoint && { entrypoint }
      });
    }
  );
  bindings.analytics_engine_datasets?.forEach(({ binding, dataset }) => {
    metadataBindings.push({
      name: binding,
      type: "analytics_engine",
      dataset
    });
  });
  bindings.dispatch_namespaces?.forEach(({ binding, namespace, outbound }) => {
    metadataBindings.push({
      name: binding,
      type: "dispatch_namespace",
      namespace,
      ...outbound && {
        outbound: {
          worker: {
            service: outbound.service,
            environment: outbound.environment
          },
          params: outbound.parameters?.map((p2) => ({ name: p2 }))
        }
      }
    });
  });
  bindings.mtls_certificates?.forEach(({ binding, certificate_id }) => {
    metadataBindings.push({
      name: binding,
      type: "mtls_certificate",
      certificate_id
    });
  });
  bindings.logfwdr?.bindings.forEach(({ name, destination }) => {
    metadataBindings.push({
      name,
      type: "logfwdr",
      destination
    });
  });
  for (const [name, filePath] of Object.entries(bindings.wasm_modules || {})) {
    metadataBindings.push({
      name,
      type: "wasm_module",
      part: name
    });
    formData.set(
      name,
      new import_undici6.File([(0, import_node_fs15.readFileSync)(filePath)], filePath, {
        type: "application/wasm"
      })
    );
  }
  if (bindings.browser !== void 0) {
    metadataBindings.push({
      name: bindings.browser.binding,
      type: "browser"
    });
  }
  if (bindings.ai !== void 0) {
    metadataBindings.push({
      name: bindings.ai.binding,
      staging: bindings.ai.staging,
      type: "ai"
    });
  }
  if (bindings.version_metadata !== void 0) {
    metadataBindings.push({
      name: bindings.version_metadata.binding,
      type: "version_metadata"
    });
  }
  for (const [name, filePath] of Object.entries(bindings.text_blobs || {})) {
    metadataBindings.push({
      name,
      type: "text_blob",
      part: name
    });
    if (name !== "__STATIC_CONTENT_MANIFEST") {
      formData.set(
        name,
        new import_undici6.File([(0, import_node_fs15.readFileSync)(filePath)], filePath, {
          type: "text/plain"
        })
      );
    }
  }
  for (const [name, filePath] of Object.entries(bindings.data_blobs || {})) {
    metadataBindings.push({
      name,
      type: "data_blob",
      part: name
    });
    formData.set(
      name,
      new import_undici6.File([(0, import_node_fs15.readFileSync)(filePath)], filePath, {
        type: "application/octet-stream"
      })
    );
  }
  const manifestModuleName = "__STATIC_CONTENT_MANIFEST";
  const hasManifest = modules?.some(({ name }) => name === manifestModuleName);
  if (hasManifest && main2.type === "esm") {
    (0, import_node_assert11.default)(modules !== void 0);
    const subDirs = new Set(
      modules.map((module3) => import_node_path24.default.posix.dirname(module3.name))
    );
    for (const subDir of subDirs) {
      if (subDir === ".")
        continue;
      const relativePath = import_node_path24.default.posix.relative(subDir, manifestModuleName);
      const filePath = import_node_path24.default.posix.join(subDir, manifestModuleName);
      modules.push({
        name: filePath,
        filePath,
        content: `export { default } from ${JSON.stringify(relativePath)};`,
        type: "esm"
      });
    }
  }
  if (main2.type === "commonjs") {
    for (const module3 of Object.values([...modules || []])) {
      if (module3.name === "__STATIC_CONTENT_MANIFEST") {
        formData.set(
          module3.name,
          new import_undici6.File([module3.content], module3.name, {
            type: "text/plain"
          })
        );
        modules = modules?.filter((m2) => m2 !== module3);
      } else if (module3.type === "compiled-wasm" || module3.type === "text" || module3.type === "buffer") {
        const name = module3.name.replace(/[^a-zA-Z0-9_$]/g, "_");
        metadataBindings.push({
          name,
          type: module3.type === "compiled-wasm" ? "wasm_module" : module3.type === "text" ? "text_blob" : "data_blob",
          part: name
        });
        formData.set(
          name,
          new import_undici6.File([module3.content], module3.name, {
            type: module3.type === "compiled-wasm" ? "application/wasm" : module3.type === "text" ? "text/plain" : "application/octet-stream"
          })
        );
        modules = modules?.filter((m2) => m2 !== module3);
      }
    }
  }
  if (bindings.unsafe?.bindings) {
    metadataBindings.push(...bindings.unsafe.bindings);
  }
  let capnpSchemaOutputFile;
  if (bindings.unsafe?.capnp) {
    const capnpOutput = handleUnsafeCapnp(bindings.unsafe.capnp);
    capnpSchemaOutputFile = `./capnp-${Date.now()}.compiled`;
    formData.set(
      capnpSchemaOutputFile,
      new import_undici6.File([capnpOutput], capnpSchemaOutputFile, {
        type: "application/octet-stream"
      })
    );
  }
  let keep_bindings = void 0;
  if (keepVars) {
    keep_bindings ??= [];
    keep_bindings.push("plain_text", "json");
  }
  if (keepSecrets) {
    keep_bindings ??= [];
    keep_bindings.push("secret_text", "secret_key");
  }
  const metadata = {
    ...main2.type !== "commonjs" ? { main_module: main2.name } : { body_part: main2.name },
    bindings: metadataBindings,
    ...compatibility_date && { compatibility_date },
    ...compatibility_flags && { compatibility_flags },
    ...usage_model && { usage_model },
    ...migrations && { migrations },
    capnp_schema: capnpSchemaOutputFile,
    ...keep_bindings && { keep_bindings },
    ...logpush !== void 0 && { logpush },
    ...placement && { placement },
    ...tail_consumers && { tail_consumers },
    ...limits && { limits },
    ...annotations && { annotations }
  };
  if (bindings.unsafe?.metadata !== void 0) {
    for (const key of Object.keys(bindings.unsafe.metadata)) {
      metadata[key] = bindings.unsafe.metadata[key];
    }
  }
  formData.set("metadata", JSON.stringify(metadata));
  if (main2.type === "commonjs" && modules && modules.length > 0) {
    throw new TypeError(
      "More than one module can only be specified when type = 'esm'"
    );
  }
  for (const module3 of [main2].concat(modules || [])) {
    formData.set(
      module3.name,
      new import_undici6.File([module3.content], module3.name, {
        type: toMimeType(module3.type ?? main2.type ?? "esm")
      })
    );
  }
  for (const sourceMap of sourceMaps || []) {
    formData.set(
      sourceMap.name,
      new import_undici6.File([sourceMap.content], sourceMap.name, {
        type: "application/source-map"
      })
    );
  }
  return formData;
}
__name(createWorkerUploadForm, "createWorkerUploadForm");

// src/deployment-bundle/source-maps.ts
init_import_meta_url();
var import_node_fs16 = __toESM(require("node:fs"));
var import_node_path25 = __toESM(require("node:path"));
function loadSourceMaps(main2, modules, bundle) {
  const { sourceMapPath, sourceMapMetadata } = bundle;
  if (sourceMapPath && sourceMapMetadata) {
    return loadSourceMap(main2, sourceMapPath, sourceMapMetadata);
  } else {
    return scanSourceMaps([main2, ...modules]);
  }
}
__name(loadSourceMaps, "loadSourceMaps");
function loadSourceMap({ name, filePath }, sourceMapPath, { entryDirectory }) {
  if (filePath === void 0) {
    return [];
  }
  const map = JSON.parse(
    import_node_fs16.default.readFileSync(import_node_path25.default.join(entryDirectory, sourceMapPath), "utf8")
  );
  map.file = name;
  if (map.sourceRoot) {
    const sourceRootPath = import_node_path25.default.dirname(
      import_node_path25.default.join(entryDirectory, sourceMapPath)
    );
    map.sourceRoot = import_node_path25.default.relative(sourceRootPath, map.sourceRoot);
  }
  map.sources = map.sources.map((source) => {
    const originalPath = import_node_path25.default.join(import_node_path25.default.dirname(filePath), source);
    return import_node_path25.default.relative(entryDirectory, originalPath);
  });
  return [
    {
      name: name + ".map",
      content: JSON.stringify(map)
    }
  ];
}
__name(loadSourceMap, "loadSourceMap");
function scanSourceMaps(modules) {
  const maps = [];
  for (const module3 of modules) {
    const commentPrefix = "//# sourceMappingURL=";
    const lastLine = module3.content.toString().split("\n").pop();
    if (lastLine === void 0 || !lastLine.startsWith(commentPrefix) || module3.filePath === void 0) {
      continue;
    }
    const commentPath = stripPrefix(commentPrefix, lastLine).trim();
    if (commentPath.startsWith("data:")) {
      throw new Error(
        `Unsupported source map path in ${module3.filePath}: expected file path but found data URL.`
      );
    }
    const wranglerPath = import_node_path25.default.join(import_node_path25.default.dirname(module3.filePath), commentPath);
    if (!import_node_fs16.default.existsSync(wranglerPath)) {
      throw new Error(
        `Invalid source map path in ${module3.filePath}: ${wranglerPath} does not exist.`
      );
    }
    const map = JSON.parse(
      import_node_fs16.default.readFileSync(wranglerPath, "utf8")
    );
    map.file = module3.name;
    if (map.sourceRoot) {
      map.sourceRoot = cleanPathPrefix(map.sourceRoot);
    }
    map.sources = map.sources.map(cleanPathPrefix);
    maps.push({
      name: module3.name + ".map",
      content: JSON.stringify(map)
    });
  }
  return maps;
}
__name(scanSourceMaps, "scanSourceMaps");
function cleanPathPrefix(filePath) {
  return stripPrefix(
    "..\\",
    stripPrefix("../", stripPrefix(".\\", stripPrefix("./", filePath)))
  );
}
__name(cleanPathPrefix, "cleanPathPrefix");
function stripPrefix(prefix, input) {
  let stripped = input;
  while (stripped.startsWith(prefix)) {
    stripped = stripped.slice(prefix.length);
  }
  return stripped;
}
__name(stripPrefix, "stripPrefix");

// src/deployments.ts
init_import_meta_url();
var import_url8 = require("url");
var import_toml7 = __toESM(require_toml());
var import_chalk19 = __toESM(require_chalk());
var import_undici22 = __toESM(require_undici());

// src/init.ts
init_import_meta_url();
var fs25 = __toESM(require("node:fs"));
var import_promises20 = require("node:fs/promises");
var import_node_path52 = __toESM(require("node:path"));
var import_toml6 = __toESM(require_toml());
init_execa();

// src/git-client.ts
init_import_meta_url();
var import_node_fs17 = __toESM(require("node:fs"));
var import_node_os7 = __toESM(require("node:os"));
var import_node_path26 = __toESM(require("node:path"));
init_execa();

// ../../node_modules/.pnpm/semiver@1.1.0/node_modules/semiver/dist/semiver.mjs
init_import_meta_url();
var fn = new Intl.Collator(0, { numeric: 1 }).compare;
function semiver_default(a, b2, bool) {
  a = a.split(".");
  b2 = b2.split(".");
  return fn(a[0], b2[0]) || fn(a[1], b2[1]) || (b2[2] = b2.slice(2).join("."), bool = /[.-]/.test(a[2] = a.slice(2).join(".")), bool == /[.-]/.test(b2[2]) ? fn(a[2], b2[2]) : bool ? -1 : 1);
}
__name(semiver_default, "default");

// src/git-client.ts
async function isInsideGitRepo(cwd2) {
  const res = await findUp(".git", { cwd: cwd2, type: "directory" });
  return res !== void 0;
}
__name(isInsideGitRepo, "isInsideGitRepo");
async function getGitVersioon() {
  try {
    const gitVersionExecutionResult = await execa("git", ["--version"]);
    if (gitVersionExecutionResult.exitCode !== 0) {
      return null;
    }
    const [gitVersion] = /\d+.\d+.\d+/.exec(gitVersionExecutionResult.stdout) || [];
    return gitVersion ?? null;
  } catch (err) {
    return null;
  }
}
__name(getGitVersioon, "getGitVersioon");
async function initializeGit(cwd2) {
  try {
    const { stdout: defaultBranchName } = await execa("git", [
      "config",
      "--get",
      "init.defaultBranch"
    ]);
    await execa(
      "git",
      ["init", "--initial-branch", defaultBranchName.trim() ?? "main"],
      {
        cwd: cwd2
      }
    );
  } catch {
    await execa("git", ["init"], {
      cwd: cwd2
    });
  }
}
__name(initializeGit, "initializeGit");
async function cloneIntoDirectory(remote, targetDirectory, subdirectory) {
  const args = ["clone", "--depth", "1"];
  const gitVersion = await getGitVersioon();
  if (!gitVersion) {
    throw new UserError("Failed to find git installation");
  }
  const useSparseCheckout = subdirectory && semiver_default(gitVersion, "2.26.0") > -1;
  if (useSparseCheckout) {
    args.push("--filter=blob:none", "--sparse");
  }
  const tagIndex = remote.lastIndexOf("#");
  if (tagIndex === -1) {
    args.push(remote);
  } else {
    args.push("-b", remote.substring(tagIndex + 1));
    args.push(remote.substring(0, tagIndex));
  }
  const tempDir = import_node_fs17.default.mkdtempSync(
    import_node_path26.default.join(import_node_os7.default.tmpdir(), `wrangler-generate-repo-`)
  );
  args.push(tempDir);
  await execa("git", args);
  if (useSparseCheckout) {
    await execa("git", [`sparse-checkout`, `set`, subdirectory], {
      cwd: tempDir
    });
  }
  const templatePath = subdirectory !== void 0 ? import_node_path26.default.join(tempDir, subdirectory) : tempDir;
  try {
    import_node_fs17.default.renameSync(templatePath, targetDirectory);
  } catch (err) {
    if (err.code !== "EXDEV") {
      logger.debug(err);
      throw new UserError(`Failed to find "${subdirectory}" in ${remote}`);
    }
    try {
      import_node_fs17.default.cpSync(templatePath, targetDirectory, { recursive: true });
      import_node_fs17.default.rmSync(templatePath, {
        recursive: true,
        force: true
      });
    } catch (moveErr) {
      logger.debug(moveErr);
      throw new UserError(`Failed to find "${subdirectory}" in ${remote}`);
    }
  }
  import_node_fs17.default.rmSync(import_node_path26.default.join(targetDirectory, ".git"), {
    recursive: true,
    force: true
  });
}
__name(cloneIntoDirectory, "cloneIntoDirectory");

// src/package-manager.ts
init_import_meta_url();
var import_node_fs18 = require("node:fs");
var import_node_path27 = require("node:path");
var import_node_process6 = require("node:process");
init_execa();
async function getPackageManager2(cwd2) {
  const [hasYarn, hasNpm, hasPnpm] = await Promise.all([
    supportsYarn(),
    supportsNpm(),
    supportsPnpm()
  ]);
  const hasYarnLock = (0, import_node_fs18.existsSync)((0, import_node_path27.join)(cwd2, "yarn.lock"));
  const hasNpmLock = (0, import_node_fs18.existsSync)((0, import_node_path27.join)(cwd2, "package-lock.json"));
  const hasPnpmLock = (0, import_node_fs18.existsSync)((0, import_node_path27.join)(cwd2, "pnpm-lock.yaml"));
  const userAgent = sniffUserAgent();
  if (hasNpmLock) {
    if (hasNpm) {
      logger.log(
        "Using npm as package manager, as there is already a package-lock.json file."
      );
      return { ...NpmPackageManager, cwd: cwd2 };
    } else if (hasYarn) {
      logger.log("Using yarn as package manager.");
      logger.warn(
        "There is already a package-lock.json file but could not find npm on the PATH."
      );
      return { ...YarnPackageManager, cwd: cwd2 };
    }
  } else if (hasPnpmLock) {
    if (hasPnpm) {
      logger.log(
        "Using pnpm as package manager, as there is already a pnpm-lock.yaml file."
      );
      return { ...PnpmPackageManager, cwd: cwd2 };
    } else {
      logger.warn(
        "There is already a pnpm-lock.yaml file but could not find pnpm on the PATH."
      );
    }
  } else if (hasYarnLock) {
    if (hasYarn) {
      logger.log(
        "Using yarn as package manager, as there is already a yarn.lock file."
      );
      return { ...YarnPackageManager, cwd: cwd2 };
    } else if (hasNpm) {
      logger.log("Using npm as package manager.");
      logger.warn(
        "There is already a yarn.lock file but could not find yarn on the PATH."
      );
      return { ...NpmPackageManager, cwd: cwd2 };
    }
  }
  if (userAgent === "npm" && hasNpm) {
    logger.log("Using npm as package manager.");
    return { ...NpmPackageManager, cwd: cwd2 };
  } else if (userAgent === "pnpm" && hasPnpm) {
    logger.log("Using pnpm as package manager.");
    return { ...PnpmPackageManager, cwd: cwd2 };
  } else if (userAgent === "yarn" && hasYarn) {
    logger.log("Using yarn as package manager.");
    return { ...YarnPackageManager, cwd: cwd2 };
  }
  if (hasNpm) {
    logger.log("Using npm as package manager.");
    return { ...NpmPackageManager, cwd: cwd2 };
  } else if (hasYarn) {
    logger.log("Using yarn as package manager.");
    return { ...YarnPackageManager, cwd: cwd2 };
  } else if (hasPnpm) {
    logger.log("Using pnpm as package manager.");
    return { ...PnpmPackageManager, cwd: cwd2 };
  } else {
    throw new UserError(
      "Unable to find a package manager. Supported managers are: npm, yarn, and pnpm."
    );
  }
}
__name(getPackageManager2, "getPackageManager");
var NpmPackageManager = {
  cwd: process.cwd(),
  type: "npm",
  /** Add and install a new devDependency into the local package.json. */
  async addDevDeps(...packages) {
    await execa("npm", ["install", ...packages, "--save-dev"], {
      stdio: "inherit",
      cwd: this.cwd
    });
  },
  /** Install all the dependencies in the local package.json. */
  async install() {
    await execa("npm", ["install"], {
      stdio: "inherit",
      cwd: this.cwd
    });
  }
};
var PnpmPackageManager = {
  cwd: process.cwd(),
  type: "pnpm",
  /** Add and install a new devDependency into the local package.json. */
  async addDevDeps(...packages) {
    await execa("pnpm", ["install", ...packages, "--save-dev"], {
      stdio: "inherit",
      cwd: this.cwd
    });
  },
  /** Install all the dependencies in the local package.json. */
  async install() {
    await execa("pnpm", ["install"], {
      stdio: "inherit",
      cwd: this.cwd
    });
  }
};
var YarnPackageManager = {
  cwd: process.cwd(),
  type: "yarn",
  /** Add and install a new devDependency into the local package.json. */
  async addDevDeps(...packages) {
    await execa("yarn", ["add", ...packages, "--dev"], {
      stdio: "inherit",
      cwd: this.cwd
    });
  },
  /** Install all the dependencies in the local package.json. */
  async install() {
    await execa("yarn", ["install"], {
      stdio: "inherit",
      cwd: this.cwd
    });
  }
};
async function supports(name) {
  try {
    execaCommandSync(`${name} --version`, { stdio: "ignore" });
    return true;
  } catch {
    return false;
  }
}
__name(supports, "supports");
function supportsYarn() {
  return supports("yarn");
}
__name(supportsYarn, "supportsYarn");
function supportsNpm() {
  return supports("npm");
}
__name(supportsNpm, "supportsNpm");
function supportsPnpm() {
  return supports("pnpm");
}
__name(supportsPnpm, "supportsPnpm");
function sniffUserAgent() {
  const userAgent = import_node_process6.env.npm_config_user_agent;
  if (userAgent === void 0) {
    return void 0;
  }
  if (userAgent.includes("yarn")) {
    return "yarn";
  }
  if (userAgent.includes("pnpm")) {
    return "pnpm";
  }
  if (userAgent.includes("npm")) {
    return "npm";
  }
}
__name(sniffUserAgent, "sniffUserAgent");

// src/utils/shell-quote.ts
init_import_meta_url();
var import_shell_quote = __toESM(require_shell_quote());
var quote = /* @__PURE__ */ __name(function(args) {
  const stringArgs = args.map((arg) => String(arg));
  return import_shell_quote.default.quote(stringArgs);
}, "quote");
function parse6(cmd, env5) {
  if (process.platform === "win32") {
    cmd = cmd.replaceAll("\\", "\\\\");
  }
  const entries = import_shell_quote.default.parse(cmd, env5);
  const argv = [];
  for (const entry of entries) {
    if (typeof entry === "string") {
      argv.push(entry);
      continue;
    }
    if ("comment" in entry) {
      continue;
    }
    if (entry.op === "glob") {
      argv.push(entry.pattern);
      continue;
    }
    throw new Error(
      `Only simple commands are supported, please don't use the "${entry.op}" operator in "${cmd}".`
    );
  }
  return argv;
}
__name(parse6, "parse");

// src/index.ts
init_import_meta_url();
var import_node_module3 = __toESM(require("node:module"));
var import_node_os8 = __toESM(require("node:os"));
var import_toml5 = __toESM(require_toml());
var import_chalk18 = __toESM(require_chalk());
var import_undici21 = __toESM(require_undici());

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/index.mjs
init_import_meta_url();

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/yargs-factory.js
init_import_meta_url();

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/command.js
init_import_meta_url();

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/typings/common-types.js
init_import_meta_url();
function assertNotStrictEqual(actual, expected, shim3, message) {
  shim3.assert.notStrictEqual(actual, expected, message);
}
__name(assertNotStrictEqual, "assertNotStrictEqual");
function assertSingleKey(actual, shim3) {
  shim3.assert.strictEqual(typeof actual, "string");
}
__name(assertSingleKey, "assertSingleKey");
function objectKeys(object) {
  return Object.keys(object);
}
__name(objectKeys, "objectKeys");

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/utils/is-promise.js
init_import_meta_url();
function isPromise(maybePromise) {
  return !!maybePromise && !!maybePromise.then && typeof maybePromise.then === "function";
}
__name(isPromise, "isPromise");

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/middleware.js
init_import_meta_url();

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/argsert.js
init_import_meta_url();

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/parse-command.js
init_import_meta_url();
function parseCommand2(cmd) {
  const extraSpacesStrippedCommand = cmd.replace(/\s{2,}/g, " ");
  const splitCommand = extraSpacesStrippedCommand.split(/\s+(?![^[]*]|[^<]*>)/);
  const bregex = /\.*[\][<>]/g;
  const firstCommand = splitCommand.shift();
  if (!firstCommand)
    throw new Error(`No command found in: ${cmd}`);
  const parsedCommand = {
    cmd: firstCommand.replace(bregex, ""),
    demanded: [],
    optional: []
  };
  splitCommand.forEach((cmd2, i) => {
    let variadic = false;
    cmd2 = cmd2.replace(/\s/g, "");
    if (/\.+[\]>]/.test(cmd2) && i === splitCommand.length - 1)
      variadic = true;
    if (/^\[/.test(cmd2)) {
      parsedCommand.optional.push({
        cmd: cmd2.replace(bregex, "").split("|"),
        variadic
      });
    } else {
      parsedCommand.demanded.push({
        cmd: cmd2.replace(bregex, "").split("|"),
        variadic
      });
    }
  });
  return parsedCommand;
}
__name(parseCommand2, "parseCommand");

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/argsert.js
var positionName = ["first", "second", "third", "fourth", "fifth", "sixth"];
function argsert(arg1, arg2, arg3) {
  function parseArgs() {
    return typeof arg1 === "object" ? [{ demanded: [], optional: [] }, arg1, arg2] : [
      parseCommand2(`cmd ${arg1}`),
      arg2,
      arg3
    ];
  }
  __name(parseArgs, "parseArgs");
  try {
    let position = 0;
    const [parsed, callerArguments, _length] = parseArgs();
    const args = [].slice.call(callerArguments);
    while (args.length && args[args.length - 1] === void 0)
      args.pop();
    const length = _length || args.length;
    if (length < parsed.demanded.length) {
      throw new YError(`Not enough arguments provided. Expected ${parsed.demanded.length} but received ${args.length}.`);
    }
    const totalCommands = parsed.demanded.length + parsed.optional.length;
    if (length > totalCommands) {
      throw new YError(`Too many arguments provided. Expected max ${totalCommands} but received ${length}.`);
    }
    parsed.demanded.forEach((demanded) => {
      const arg = args.shift();
      const observedType = guessType(arg);
      const matchingTypes = demanded.cmd.filter((type) => type === observedType || type === "*");
      if (matchingTypes.length === 0)
        argumentTypeError(observedType, demanded.cmd, position);
      position += 1;
    });
    parsed.optional.forEach((optional) => {
      if (args.length === 0)
        return;
      const arg = args.shift();
      const observedType = guessType(arg);
      const matchingTypes = optional.cmd.filter((type) => type === observedType || type === "*");
      if (matchingTypes.length === 0)
        argumentTypeError(observedType, optional.cmd, position);
      position += 1;
    });
  } catch (err) {
    console.warn(err.stack);
  }
}
__name(argsert, "argsert");
function guessType(arg) {
  if (Array.isArray(arg)) {
    return "array";
  } else if (arg === null) {
    return "null";
  }
  return typeof arg;
}
__name(guessType, "guessType");
function argumentTypeError(observedType, allowedTypes, position) {
  throw new YError(`Invalid ${positionName[position] || "manyith"} argument. Expected ${allowedTypes.join(" or ")} but received ${observedType}.`);
}
__name(argumentTypeError, "argumentTypeError");

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/middleware.js
var GlobalMiddleware = class {
  constructor(yargs) {
    this.globalMiddleware = [];
    this.frozens = [];
    this.yargs = yargs;
  }
  addMiddleware(callback, applyBeforeValidation, global2 = true, mutates = false) {
    argsert("<array|function> [boolean] [boolean] [boolean]", [callback, applyBeforeValidation, global2], arguments.length);
    if (Array.isArray(callback)) {
      for (let i = 0; i < callback.length; i++) {
        if (typeof callback[i] !== "function") {
          throw Error("middleware must be a function");
        }
        const m2 = callback[i];
        m2.applyBeforeValidation = applyBeforeValidation;
        m2.global = global2;
      }
      Array.prototype.push.apply(this.globalMiddleware, callback);
    } else if (typeof callback === "function") {
      const m2 = callback;
      m2.applyBeforeValidation = applyBeforeValidation;
      m2.global = global2;
      m2.mutates = mutates;
      this.globalMiddleware.push(callback);
    }
    return this.yargs;
  }
  addCoerceMiddleware(callback, option) {
    const aliases2 = this.yargs.getAliases();
    this.globalMiddleware = this.globalMiddleware.filter((m2) => {
      const toCheck = [...aliases2[option] || [], option];
      if (!m2.option)
        return true;
      else
        return !toCheck.includes(m2.option);
    });
    callback.option = option;
    return this.addMiddleware(callback, true, true, true);
  }
  getMiddleware() {
    return this.globalMiddleware;
  }
  freeze() {
    this.frozens.push([...this.globalMiddleware]);
  }
  unfreeze() {
    const frozen = this.frozens.pop();
    if (frozen !== void 0)
      this.globalMiddleware = frozen;
  }
  reset() {
    this.globalMiddleware = this.globalMiddleware.filter((m2) => m2.global);
  }
};
__name(GlobalMiddleware, "GlobalMiddleware");
function commandMiddlewareFactory(commandMiddleware) {
  if (!commandMiddleware)
    return [];
  return commandMiddleware.map((middleware) => {
    middleware.applyBeforeValidation = false;
    return middleware;
  });
}
__name(commandMiddlewareFactory, "commandMiddlewareFactory");
function applyMiddleware(argv, yargs, middlewares, beforeValidation) {
  return middlewares.reduce((acc, middleware) => {
    if (middleware.applyBeforeValidation !== beforeValidation) {
      return acc;
    }
    if (middleware.mutates) {
      if (middleware.applied)
        return acc;
      middleware.applied = true;
    }
    if (isPromise(acc)) {
      return acc.then((initialObj) => Promise.all([initialObj, middleware(initialObj, yargs)])).then(([initialObj, middlewareObj]) => Object.assign(initialObj, middlewareObj));
    } else {
      const result = middleware(acc, yargs);
      return isPromise(result) ? result.then((middlewareObj) => Object.assign(acc, middlewareObj)) : Object.assign(acc, result);
    }
  }, argv);
}
__name(applyMiddleware, "applyMiddleware");

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/utils/maybe-async-result.js
init_import_meta_url();
function maybeAsyncResult(getResult, resultHandler, errorHandler = (err) => {
  throw err;
}) {
  try {
    const result = isFunction(getResult) ? getResult() : getResult;
    return isPromise(result) ? result.then((result2) => resultHandler(result2)) : resultHandler(result);
  } catch (err) {
    return errorHandler(err);
  }
}
__name(maybeAsyncResult, "maybeAsyncResult");
function isFunction(arg) {
  return typeof arg === "function";
}
__name(isFunction, "isFunction");

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/utils/which-module.js
init_import_meta_url();
function whichModule(exported) {
  if (typeof require === "undefined")
    return null;
  for (let i = 0, files = Object.keys(require.cache), mod; i < files.length; i++) {
    mod = require.cache[files[i]];
    if (mod.exports === exported)
      return mod;
  }
  return null;
}
__name(whichModule, "whichModule");

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/command.js
var DEFAULT_MARKER = /(^\*)|(^\$0)/;
var CommandInstance = class {
  constructor(usage2, validation2, globalMiddleware, shim3) {
    this.requireCache = /* @__PURE__ */ new Set();
    this.handlers = {};
    this.aliasMap = {};
    this.frozens = [];
    this.shim = shim3;
    this.usage = usage2;
    this.globalMiddleware = globalMiddleware;
    this.validation = validation2;
  }
  addDirectory(dir, req, callerFile, opts) {
    opts = opts || {};
    if (typeof opts.recurse !== "boolean")
      opts.recurse = false;
    if (!Array.isArray(opts.extensions))
      opts.extensions = ["js"];
    const parentVisit = typeof opts.visit === "function" ? opts.visit : (o2) => o2;
    opts.visit = (obj, joined, filename) => {
      const visited = parentVisit(obj, joined, filename);
      if (visited) {
        if (this.requireCache.has(joined))
          return visited;
        else
          this.requireCache.add(joined);
        this.addHandler(visited);
      }
      return visited;
    };
    this.shim.requireDirectory({ require: req, filename: callerFile }, dir, opts);
  }
  addHandler(cmd, description, builder, handler30, commandMiddleware, deprecated2) {
    let aliases2 = [];
    const middlewares = commandMiddlewareFactory(commandMiddleware);
    handler30 = handler30 || (() => {
    });
    if (Array.isArray(cmd)) {
      if (isCommandAndAliases(cmd)) {
        [cmd, ...aliases2] = cmd;
      } else {
        for (const command2 of cmd) {
          this.addHandler(command2);
        }
      }
    } else if (isCommandHandlerDefinition(cmd)) {
      let command2 = Array.isArray(cmd.command) || typeof cmd.command === "string" ? cmd.command : this.moduleName(cmd);
      if (cmd.aliases)
        command2 = [].concat(command2).concat(cmd.aliases);
      this.addHandler(command2, this.extractDesc(cmd), cmd.builder, cmd.handler, cmd.middlewares, cmd.deprecated);
      return;
    } else if (isCommandBuilderDefinition(builder)) {
      this.addHandler([cmd].concat(aliases2), description, builder.builder, builder.handler, builder.middlewares, builder.deprecated);
      return;
    }
    if (typeof cmd === "string") {
      const parsedCommand = parseCommand2(cmd);
      aliases2 = aliases2.map((alias) => parseCommand2(alias).cmd);
      let isDefault = false;
      const parsedAliases = [parsedCommand.cmd].concat(aliases2).filter((c2) => {
        if (DEFAULT_MARKER.test(c2)) {
          isDefault = true;
          return false;
        }
        return true;
      });
      if (parsedAliases.length === 0 && isDefault)
        parsedAliases.push("$0");
      if (isDefault) {
        parsedCommand.cmd = parsedAliases[0];
        aliases2 = parsedAliases.slice(1);
        cmd = cmd.replace(DEFAULT_MARKER, parsedCommand.cmd);
      }
      aliases2.forEach((alias) => {
        this.aliasMap[alias] = parsedCommand.cmd;
      });
      if (description !== false) {
        this.usage.command(cmd, description, isDefault, aliases2, deprecated2);
      }
      this.handlers[parsedCommand.cmd] = {
        original: cmd,
        description,
        handler: handler30,
        builder: builder || {},
        middlewares,
        deprecated: deprecated2,
        demanded: parsedCommand.demanded,
        optional: parsedCommand.optional
      };
      if (isDefault)
        this.defaultCommand = this.handlers[parsedCommand.cmd];
    }
  }
  getCommandHandlers() {
    return this.handlers;
  }
  getCommands() {
    return Object.keys(this.handlers).concat(Object.keys(this.aliasMap));
  }
  hasDefaultCommand() {
    return !!this.defaultCommand;
  }
  runCommand(command2, yargs, parsed, commandIndex, helpOnly, helpOrVersionSet) {
    const commandHandler = this.handlers[command2] || this.handlers[this.aliasMap[command2]] || this.defaultCommand;
    const currentContext = yargs.getInternalMethods().getContext();
    const parentCommands = currentContext.commands.slice();
    const isDefaultCommand = !command2;
    if (command2) {
      currentContext.commands.push(command2);
      currentContext.fullCommands.push(commandHandler.original);
    }
    const builderResult = this.applyBuilderUpdateUsageAndParse(isDefaultCommand, commandHandler, yargs, parsed.aliases, parentCommands, commandIndex, helpOnly, helpOrVersionSet);
    return isPromise(builderResult) ? builderResult.then((result) => this.applyMiddlewareAndGetResult(isDefaultCommand, commandHandler, result.innerArgv, currentContext, helpOnly, result.aliases, yargs)) : this.applyMiddlewareAndGetResult(isDefaultCommand, commandHandler, builderResult.innerArgv, currentContext, helpOnly, builderResult.aliases, yargs);
  }
  applyBuilderUpdateUsageAndParse(isDefaultCommand, commandHandler, yargs, aliases2, parentCommands, commandIndex, helpOnly, helpOrVersionSet) {
    const builder = commandHandler.builder;
    let innerYargs = yargs;
    if (isCommandBuilderCallback(builder)) {
      yargs.getInternalMethods().getUsageInstance().freeze();
      const builderOutput = builder(yargs.getInternalMethods().reset(aliases2), helpOrVersionSet);
      if (isPromise(builderOutput)) {
        return builderOutput.then((output) => {
          innerYargs = isYargsInstance(output) ? output : yargs;
          return this.parseAndUpdateUsage(isDefaultCommand, commandHandler, innerYargs, parentCommands, commandIndex, helpOnly);
        });
      }
    } else if (isCommandBuilderOptionDefinitions(builder)) {
      yargs.getInternalMethods().getUsageInstance().freeze();
      innerYargs = yargs.getInternalMethods().reset(aliases2);
      Object.keys(commandHandler.builder).forEach((key) => {
        innerYargs.option(key, builder[key]);
      });
    }
    return this.parseAndUpdateUsage(isDefaultCommand, commandHandler, innerYargs, parentCommands, commandIndex, helpOnly);
  }
  parseAndUpdateUsage(isDefaultCommand, commandHandler, innerYargs, parentCommands, commandIndex, helpOnly) {
    if (isDefaultCommand)
      innerYargs.getInternalMethods().getUsageInstance().unfreeze(true);
    if (this.shouldUpdateUsage(innerYargs)) {
      innerYargs.getInternalMethods().getUsageInstance().usage(this.usageFromParentCommandsCommandHandler(parentCommands, commandHandler), commandHandler.description);
    }
    const innerArgv = innerYargs.getInternalMethods().runYargsParserAndExecuteCommands(null, void 0, true, commandIndex, helpOnly);
    return isPromise(innerArgv) ? innerArgv.then((argv) => ({
      aliases: innerYargs.parsed.aliases,
      innerArgv: argv
    })) : {
      aliases: innerYargs.parsed.aliases,
      innerArgv
    };
  }
  shouldUpdateUsage(yargs) {
    return !yargs.getInternalMethods().getUsageInstance().getUsageDisabled() && yargs.getInternalMethods().getUsageInstance().getUsage().length === 0;
  }
  usageFromParentCommandsCommandHandler(parentCommands, commandHandler) {
    const c2 = DEFAULT_MARKER.test(commandHandler.original) ? commandHandler.original.replace(DEFAULT_MARKER, "").trim() : commandHandler.original;
    const pc = parentCommands.filter((c3) => {
      return !DEFAULT_MARKER.test(c3);
    });
    pc.push(c2);
    return `$0 ${pc.join(" ")}`;
  }
  handleValidationAndGetResult(isDefaultCommand, commandHandler, innerArgv, currentContext, aliases2, yargs, middlewares, positionalMap) {
    if (!yargs.getInternalMethods().getHasOutput()) {
      const validation2 = yargs.getInternalMethods().runValidation(aliases2, positionalMap, yargs.parsed.error, isDefaultCommand);
      innerArgv = maybeAsyncResult(innerArgv, (result) => {
        validation2(result);
        return result;
      });
    }
    if (commandHandler.handler && !yargs.getInternalMethods().getHasOutput()) {
      yargs.getInternalMethods().setHasOutput();
      const populateDoubleDash = !!yargs.getOptions().configuration["populate--"];
      yargs.getInternalMethods().postProcess(innerArgv, populateDoubleDash, false, false);
      innerArgv = applyMiddleware(innerArgv, yargs, middlewares, false);
      innerArgv = maybeAsyncResult(innerArgv, (result) => {
        const handlerResult = commandHandler.handler(result);
        return isPromise(handlerResult) ? handlerResult.then(() => result) : result;
      });
      if (!isDefaultCommand) {
        yargs.getInternalMethods().getUsageInstance().cacheHelpMessage();
      }
      if (isPromise(innerArgv) && !yargs.getInternalMethods().hasParseCallback()) {
        innerArgv.catch((error2) => {
          try {
            yargs.getInternalMethods().getUsageInstance().fail(null, error2);
          } catch (_err) {
          }
        });
      }
    }
    if (!isDefaultCommand) {
      currentContext.commands.pop();
      currentContext.fullCommands.pop();
    }
    return innerArgv;
  }
  applyMiddlewareAndGetResult(isDefaultCommand, commandHandler, innerArgv, currentContext, helpOnly, aliases2, yargs) {
    let positionalMap = {};
    if (helpOnly)
      return innerArgv;
    if (!yargs.getInternalMethods().getHasOutput()) {
      positionalMap = this.populatePositionals(commandHandler, innerArgv, currentContext, yargs);
    }
    const middlewares = this.globalMiddleware.getMiddleware().slice(0).concat(commandHandler.middlewares);
    const maybePromiseArgv = applyMiddleware(innerArgv, yargs, middlewares, true);
    return isPromise(maybePromiseArgv) ? maybePromiseArgv.then((resolvedInnerArgv) => this.handleValidationAndGetResult(isDefaultCommand, commandHandler, resolvedInnerArgv, currentContext, aliases2, yargs, middlewares, positionalMap)) : this.handleValidationAndGetResult(isDefaultCommand, commandHandler, maybePromiseArgv, currentContext, aliases2, yargs, middlewares, positionalMap);
  }
  populatePositionals(commandHandler, argv, context2, yargs) {
    argv._ = argv._.slice(context2.commands.length);
    const demanded = commandHandler.demanded.slice(0);
    const optional = commandHandler.optional.slice(0);
    const positionalMap = {};
    this.validation.positionalCount(demanded.length, argv._.length);
    while (demanded.length) {
      const demand = demanded.shift();
      this.populatePositional(demand, argv, positionalMap);
    }
    while (optional.length) {
      const maybe = optional.shift();
      this.populatePositional(maybe, argv, positionalMap);
    }
    argv._ = context2.commands.concat(argv._.map((a) => "" + a));
    this.postProcessPositionals(argv, positionalMap, this.cmdToParseOptions(commandHandler.original), yargs);
    return positionalMap;
  }
  populatePositional(positional, argv, positionalMap) {
    const cmd = positional.cmd[0];
    if (positional.variadic) {
      positionalMap[cmd] = argv._.splice(0).map(String);
    } else {
      if (argv._.length)
        positionalMap[cmd] = [String(argv._.shift())];
    }
  }
  cmdToParseOptions(cmdString) {
    const parseOptions = {
      array: [],
      default: {},
      alias: {},
      demand: {}
    };
    const parsed = parseCommand2(cmdString);
    parsed.demanded.forEach((d2) => {
      const [cmd, ...aliases2] = d2.cmd;
      if (d2.variadic) {
        parseOptions.array.push(cmd);
        parseOptions.default[cmd] = [];
      }
      parseOptions.alias[cmd] = aliases2;
      parseOptions.demand[cmd] = true;
    });
    parsed.optional.forEach((o2) => {
      const [cmd, ...aliases2] = o2.cmd;
      if (o2.variadic) {
        parseOptions.array.push(cmd);
        parseOptions.default[cmd] = [];
      }
      parseOptions.alias[cmd] = aliases2;
    });
    return parseOptions;
  }
  postProcessPositionals(argv, positionalMap, parseOptions, yargs) {
    const options29 = Object.assign({}, yargs.getOptions());
    options29.default = Object.assign(parseOptions.default, options29.default);
    for (const key of Object.keys(parseOptions.alias)) {
      options29.alias[key] = (options29.alias[key] || []).concat(parseOptions.alias[key]);
    }
    options29.array = options29.array.concat(parseOptions.array);
    options29.config = {};
    const unparsed = [];
    Object.keys(positionalMap).forEach((key) => {
      positionalMap[key].map((value) => {
        if (options29.configuration["unknown-options-as-args"])
          options29.key[key] = true;
        unparsed.push(`--${key}`);
        unparsed.push(value);
      });
    });
    if (!unparsed.length)
      return;
    const config = Object.assign({}, options29.configuration, {
      "populate--": false
    });
    const parsed = this.shim.Parser.detailed(unparsed, Object.assign({}, options29, {
      configuration: config
    }));
    if (parsed.error) {
      yargs.getInternalMethods().getUsageInstance().fail(parsed.error.message, parsed.error);
    } else {
      const positionalKeys = Object.keys(positionalMap);
      Object.keys(positionalMap).forEach((key) => {
        positionalKeys.push(...parsed.aliases[key]);
      });
      Object.keys(parsed.argv).forEach((key) => {
        if (positionalKeys.includes(key)) {
          if (!positionalMap[key])
            positionalMap[key] = parsed.argv[key];
          if (!this.isInConfigs(yargs, key) && !this.isDefaulted(yargs, key) && Object.prototype.hasOwnProperty.call(argv, key) && Object.prototype.hasOwnProperty.call(parsed.argv, key) && (Array.isArray(argv[key]) || Array.isArray(parsed.argv[key]))) {
            argv[key] = [].concat(argv[key], parsed.argv[key]);
          } else {
            argv[key] = parsed.argv[key];
          }
        }
      });
    }
  }
  isDefaulted(yargs, key) {
    const { default: defaults } = yargs.getOptions();
    return Object.prototype.hasOwnProperty.call(defaults, key) || Object.prototype.hasOwnProperty.call(defaults, this.shim.Parser.camelCase(key));
  }
  isInConfigs(yargs, key) {
    const { configObjects } = yargs.getOptions();
    return configObjects.some((c2) => Object.prototype.hasOwnProperty.call(c2, key)) || configObjects.some((c2) => Object.prototype.hasOwnProperty.call(c2, this.shim.Parser.camelCase(key)));
  }
  runDefaultBuilderOn(yargs) {
    if (!this.defaultCommand)
      return;
    if (this.shouldUpdateUsage(yargs)) {
      const commandString = DEFAULT_MARKER.test(this.defaultCommand.original) ? this.defaultCommand.original : this.defaultCommand.original.replace(/^[^[\]<>]*/, "$0 ");
      yargs.getInternalMethods().getUsageInstance().usage(commandString, this.defaultCommand.description);
    }
    const builder = this.defaultCommand.builder;
    if (isCommandBuilderCallback(builder)) {
      return builder(yargs, true);
    } else if (!isCommandBuilderDefinition(builder)) {
      Object.keys(builder).forEach((key) => {
        yargs.option(key, builder[key]);
      });
    }
    return void 0;
  }
  moduleName(obj) {
    const mod = whichModule(obj);
    if (!mod)
      throw new Error(`No command name given for module: ${this.shim.inspect(obj)}`);
    return this.commandFromFilename(mod.filename);
  }
  commandFromFilename(filename) {
    return this.shim.path.basename(filename, this.shim.path.extname(filename));
  }
  extractDesc({ describe, description, desc }) {
    for (const test of [describe, description, desc]) {
      if (typeof test === "string" || test === false)
        return test;
      assertNotStrictEqual(test, true, this.shim);
    }
    return false;
  }
  freeze() {
    this.frozens.push({
      handlers: this.handlers,
      aliasMap: this.aliasMap,
      defaultCommand: this.defaultCommand
    });
  }
  unfreeze() {
    const frozen = this.frozens.pop();
    assertNotStrictEqual(frozen, void 0, this.shim);
    ({
      handlers: this.handlers,
      aliasMap: this.aliasMap,
      defaultCommand: this.defaultCommand
    } = frozen);
  }
  reset() {
    this.handlers = {};
    this.aliasMap = {};
    this.defaultCommand = void 0;
    this.requireCache = /* @__PURE__ */ new Set();
    return this;
  }
};
__name(CommandInstance, "CommandInstance");
function command(usage2, validation2, globalMiddleware, shim3) {
  return new CommandInstance(usage2, validation2, globalMiddleware, shim3);
}
__name(command, "command");
function isCommandBuilderDefinition(builder) {
  return typeof builder === "object" && !!builder.builder && typeof builder.handler === "function";
}
__name(isCommandBuilderDefinition, "isCommandBuilderDefinition");
function isCommandAndAliases(cmd) {
  return cmd.every((c2) => typeof c2 === "string");
}
__name(isCommandAndAliases, "isCommandAndAliases");
function isCommandBuilderCallback(builder) {
  return typeof builder === "function";
}
__name(isCommandBuilderCallback, "isCommandBuilderCallback");
function isCommandBuilderOptionDefinitions(builder) {
  return typeof builder === "object";
}
__name(isCommandBuilderOptionDefinitions, "isCommandBuilderOptionDefinitions");
function isCommandHandlerDefinition(cmd) {
  return typeof cmd === "object" && !Array.isArray(cmd);
}
__name(isCommandHandlerDefinition, "isCommandHandlerDefinition");

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/usage.js
init_import_meta_url();

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/utils/obj-filter.js
init_import_meta_url();
function objFilter(original = {}, filter = () => true) {
  const obj = {};
  objectKeys(original).forEach((key) => {
    if (filter(key, original[key])) {
      obj[key] = original[key];
    }
  });
  return obj;
}
__name(objFilter, "objFilter");

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/utils/set-blocking.js
init_import_meta_url();
function setBlocking(blocking) {
  if (typeof process === "undefined")
    return;
  [process.stdout, process.stderr].forEach((_stream) => {
    const stream2 = _stream;
    if (stream2._handle && stream2.isTTY && typeof stream2._handle.setBlocking === "function") {
      stream2._handle.setBlocking(blocking);
    }
  });
}
__name(setBlocking, "setBlocking");

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/usage.js
function isBoolean2(fail) {
  return typeof fail === "boolean";
}
__name(isBoolean2, "isBoolean");
function usage(yargs, shim3) {
  const __ = shim3.y18n.__;
  const self2 = {};
  const fails = [];
  self2.failFn = /* @__PURE__ */ __name(function failFn(f) {
    fails.push(f);
  }, "failFn");
  let failMessage = null;
  let globalFailMessage = null;
  let showHelpOnFail = true;
  self2.showHelpOnFail = /* @__PURE__ */ __name(function showHelpOnFailFn(arg1 = true, arg2) {
    const [enabled, message] = typeof arg1 === "string" ? [true, arg1] : [arg1, arg2];
    if (yargs.getInternalMethods().isGlobalContext()) {
      globalFailMessage = message;
    }
    failMessage = message;
    showHelpOnFail = enabled;
    return self2;
  }, "showHelpOnFailFn");
  let failureOutput = false;
  self2.fail = /* @__PURE__ */ __name(function fail(msg, err) {
    const logger3 = yargs.getInternalMethods().getLoggerInstance();
    if (fails.length) {
      for (let i = fails.length - 1; i >= 0; --i) {
        const fail2 = fails[i];
        if (isBoolean2(fail2)) {
          if (err)
            throw err;
          else if (msg)
            throw Error(msg);
        } else {
          fail2(msg, err, self2);
        }
      }
    } else {
      if (yargs.getExitProcess())
        setBlocking(true);
      if (!failureOutput) {
        failureOutput = true;
        if (showHelpOnFail) {
          yargs.showHelp("error");
          logger3.error();
        }
        if (msg || err)
          logger3.error(msg || err);
        const globalOrCommandFailMessage = failMessage || globalFailMessage;
        if (globalOrCommandFailMessage) {
          if (msg || err)
            logger3.error("");
          logger3.error(globalOrCommandFailMessage);
        }
      }
      err = err || new YError(msg);
      if (yargs.getExitProcess()) {
        return yargs.exit(1);
      } else if (yargs.getInternalMethods().hasParseCallback()) {
        return yargs.exit(1, err);
      } else {
        throw err;
      }
    }
  }, "fail");
  let usages = [];
  let usageDisabled = false;
  self2.usage = (msg, description) => {
    if (msg === null) {
      usageDisabled = true;
      usages = [];
      return self2;
    }
    usageDisabled = false;
    usages.push([msg, description || ""]);
    return self2;
  };
  self2.getUsage = () => {
    return usages;
  };
  self2.getUsageDisabled = () => {
    return usageDisabled;
  };
  self2.getPositionalGroupName = () => {
    return __("Positionals:");
  };
  let examples = [];
  self2.example = (cmd, description) => {
    examples.push([cmd, description || ""]);
  };
  let commands = [];
  self2.command = /* @__PURE__ */ __name(function command2(cmd, description, isDefault, aliases2, deprecated2 = false) {
    if (isDefault) {
      commands = commands.map((cmdArray) => {
        cmdArray[2] = false;
        return cmdArray;
      });
    }
    commands.push([cmd, description || "", isDefault, aliases2, deprecated2]);
  }, "command");
  self2.getCommands = () => commands;
  let descriptions = {};
  self2.describe = /* @__PURE__ */ __name(function describe(keyOrKeys, desc) {
    if (Array.isArray(keyOrKeys)) {
      keyOrKeys.forEach((k2) => {
        self2.describe(k2, desc);
      });
    } else if (typeof keyOrKeys === "object") {
      Object.keys(keyOrKeys).forEach((k2) => {
        self2.describe(k2, keyOrKeys[k2]);
      });
    } else {
      descriptions[keyOrKeys] = desc;
    }
  }, "describe");
  self2.getDescriptions = () => descriptions;
  let epilogs = [];
  self2.epilog = (msg) => {
    epilogs.push(msg);
  };
  let wrapSet = false;
  let wrap4;
  self2.wrap = (cols) => {
    wrapSet = true;
    wrap4 = cols;
  };
  self2.getWrap = () => {
    if (shim3.getEnv("YARGS_DISABLE_WRAP")) {
      return null;
    }
    if (!wrapSet) {
      wrap4 = windowWidth();
      wrapSet = true;
    }
    return wrap4;
  };
  const deferY18nLookupPrefix = "__yargsString__:";
  self2.deferY18nLookup = (str) => deferY18nLookupPrefix + str;
  self2.help = /* @__PURE__ */ __name(function help() {
    if (cachedHelpMessage)
      return cachedHelpMessage;
    normalizeAliases();
    const base$0 = yargs.customScriptName ? yargs.$0 : shim3.path.basename(yargs.$0);
    const demandedOptions = yargs.getDemandedOptions();
    const demandedCommands = yargs.getDemandedCommands();
    const deprecatedOptions = yargs.getDeprecatedOptions();
    const groups = yargs.getGroups();
    const options29 = yargs.getOptions();
    let keys = [];
    keys = keys.concat(Object.keys(descriptions));
    keys = keys.concat(Object.keys(demandedOptions));
    keys = keys.concat(Object.keys(demandedCommands));
    keys = keys.concat(Object.keys(options29.default));
    keys = keys.filter(filterHiddenOptions);
    keys = Object.keys(keys.reduce((acc, key) => {
      if (key !== "_")
        acc[key] = true;
      return acc;
    }, {}));
    const theWrap = self2.getWrap();
    const ui2 = shim3.cliui({
      width: theWrap,
      wrap: !!theWrap
    });
    if (!usageDisabled) {
      if (usages.length) {
        usages.forEach((usage2) => {
          ui2.div({ text: `${usage2[0].replace(/\$0/g, base$0)}` });
          if (usage2[1]) {
            ui2.div({ text: `${usage2[1]}`, padding: [1, 0, 0, 0] });
          }
        });
        ui2.div();
      } else if (commands.length) {
        let u = null;
        if (demandedCommands._) {
          u = `${base$0} <${__("command")}>
`;
        } else {
          u = `${base$0} [${__("command")}]
`;
        }
        ui2.div(`${u}`);
      }
    }
    if (commands.length > 1 || commands.length === 1 && !commands[0][2]) {
      ui2.div(__("Commands:"));
      const context2 = yargs.getInternalMethods().getContext();
      const parentCommands = context2.commands.length ? `${context2.commands.join(" ")} ` : "";
      if (yargs.getInternalMethods().getParserConfiguration()["sort-commands"] === true) {
        commands = commands.sort((a, b2) => a[0].localeCompare(b2[0]));
      }
      const prefix = base$0 ? `${base$0} ` : "";
      commands.forEach((command2) => {
        const commandString = `${prefix}${parentCommands}${command2[0].replace(/^\$0 ?/, "")}`;
        ui2.span({
          text: commandString,
          padding: [0, 2, 0, 2],
          width: maxWidth(commands, theWrap, `${base$0}${parentCommands}`) + 4
        }, { text: command2[1] });
        const hints = [];
        if (command2[2])
          hints.push(`[${__("default")}]`);
        if (command2[3] && command2[3].length) {
          hints.push(`[${__("aliases:")} ${command2[3].join(", ")}]`);
        }
        if (command2[4]) {
          if (typeof command2[4] === "string") {
            hints.push(`[${__("deprecated: %s", command2[4])}]`);
          } else {
            hints.push(`[${__("deprecated")}]`);
          }
        }
        if (hints.length) {
          ui2.div({
            text: hints.join(" "),
            padding: [0, 0, 0, 2],
            align: "right"
          });
        } else {
          ui2.div();
        }
      });
      ui2.div();
    }
    const aliasKeys = (Object.keys(options29.alias) || []).concat(Object.keys(yargs.parsed.newAliases) || []);
    keys = keys.filter((key) => !yargs.parsed.newAliases[key] && aliasKeys.every((alias) => (options29.alias[alias] || []).indexOf(key) === -1));
    const defaultGroup = __("Options:");
    if (!groups[defaultGroup])
      groups[defaultGroup] = [];
    addUngroupedKeys(keys, options29.alias, groups, defaultGroup);
    const isLongSwitch = /* @__PURE__ */ __name((sw) => /^--/.test(getText(sw)), "isLongSwitch");
    const displayedGroups = Object.keys(groups).filter((groupName) => groups[groupName].length > 0).map((groupName) => {
      const normalizedKeys = groups[groupName].filter(filterHiddenOptions).map((key) => {
        if (aliasKeys.includes(key))
          return key;
        for (let i = 0, aliasKey; (aliasKey = aliasKeys[i]) !== void 0; i++) {
          if ((options29.alias[aliasKey] || []).includes(key))
            return aliasKey;
        }
        return key;
      });
      return { groupName, normalizedKeys };
    }).filter(({ normalizedKeys }) => normalizedKeys.length > 0).map(({ groupName, normalizedKeys }) => {
      const switches = normalizedKeys.reduce((acc, key) => {
        acc[key] = [key].concat(options29.alias[key] || []).map((sw) => {
          if (groupName === self2.getPositionalGroupName())
            return sw;
          else {
            return (/^[0-9]$/.test(sw) ? options29.boolean.includes(key) ? "-" : "--" : sw.length > 1 ? "--" : "-") + sw;
          }
        }).sort((sw1, sw2) => isLongSwitch(sw1) === isLongSwitch(sw2) ? 0 : isLongSwitch(sw1) ? 1 : -1).join(", ");
        return acc;
      }, {});
      return { groupName, normalizedKeys, switches };
    });
    const shortSwitchesUsed = displayedGroups.filter(({ groupName }) => groupName !== self2.getPositionalGroupName()).some(({ normalizedKeys, switches }) => !normalizedKeys.every((key) => isLongSwitch(switches[key])));
    if (shortSwitchesUsed) {
      displayedGroups.filter(({ groupName }) => groupName !== self2.getPositionalGroupName()).forEach(({ normalizedKeys, switches }) => {
        normalizedKeys.forEach((key) => {
          if (isLongSwitch(switches[key])) {
            switches[key] = addIndentation(switches[key], "-x, ".length);
          }
        });
      });
    }
    displayedGroups.forEach(({ groupName, normalizedKeys, switches }) => {
      ui2.div(groupName);
      normalizedKeys.forEach((key) => {
        const kswitch = switches[key];
        let desc = descriptions[key] || "";
        let type = null;
        if (desc.includes(deferY18nLookupPrefix))
          desc = __(desc.substring(deferY18nLookupPrefix.length));
        if (options29.boolean.includes(key))
          type = `[${__("boolean")}]`;
        if (options29.count.includes(key))
          type = `[${__("count")}]`;
        if (options29.string.includes(key))
          type = `[${__("string")}]`;
        if (options29.normalize.includes(key))
          type = `[${__("string")}]`;
        if (options29.array.includes(key))
          type = `[${__("array")}]`;
        if (options29.number.includes(key))
          type = `[${__("number")}]`;
        const deprecatedExtra = /* @__PURE__ */ __name((deprecated2) => typeof deprecated2 === "string" ? `[${__("deprecated: %s", deprecated2)}]` : `[${__("deprecated")}]`, "deprecatedExtra");
        const extra = [
          key in deprecatedOptions ? deprecatedExtra(deprecatedOptions[key]) : null,
          type,
          key in demandedOptions ? `[${__("required")}]` : null,
          options29.choices && options29.choices[key] ? `[${__("choices:")} ${self2.stringifiedValues(options29.choices[key])}]` : null,
          defaultString(options29.default[key], options29.defaultDescription[key])
        ].filter(Boolean).join(" ");
        ui2.span({
          text: getText(kswitch),
          padding: [0, 2, 0, 2 + getIndentation(kswitch)],
          width: maxWidth(switches, theWrap) + 4
        }, desc);
        const shouldHideOptionExtras = yargs.getInternalMethods().getUsageConfiguration()["hide-types"] === true;
        if (extra && !shouldHideOptionExtras)
          ui2.div({ text: extra, padding: [0, 0, 0, 2], align: "right" });
        else
          ui2.div();
      });
      ui2.div();
    });
    if (examples.length) {
      ui2.div(__("Examples:"));
      examples.forEach((example) => {
        example[0] = example[0].replace(/\$0/g, base$0);
      });
      examples.forEach((example) => {
        if (example[1] === "") {
          ui2.div({
            text: example[0],
            padding: [0, 2, 0, 2]
          });
        } else {
          ui2.div({
            text: example[0],
            padding: [0, 2, 0, 2],
            width: maxWidth(examples, theWrap) + 4
          }, {
            text: example[1]
          });
        }
      });
      ui2.div();
    }
    if (epilogs.length > 0) {
      const e3 = epilogs.map((epilog) => epilog.replace(/\$0/g, base$0)).join("\n");
      ui2.div(`${e3}
`);
    }
    return ui2.toString().replace(/\s*$/, "");
  }, "help");
  function maxWidth(table, theWrap, modifier) {
    let width = 0;
    if (!Array.isArray(table)) {
      table = Object.values(table).map((v2) => [v2]);
    }
    table.forEach((v2) => {
      width = Math.max(shim3.stringWidth(modifier ? `${modifier} ${getText(v2[0])}` : getText(v2[0])) + getIndentation(v2[0]), width);
    });
    if (theWrap)
      width = Math.min(width, parseInt((theWrap * 0.5).toString(), 10));
    return width;
  }
  __name(maxWidth, "maxWidth");
  function normalizeAliases() {
    const demandedOptions = yargs.getDemandedOptions();
    const options29 = yargs.getOptions();
    (Object.keys(options29.alias) || []).forEach((key) => {
      options29.alias[key].forEach((alias) => {
        if (descriptions[alias])
          self2.describe(key, descriptions[alias]);
        if (alias in demandedOptions)
          yargs.demandOption(key, demandedOptions[alias]);
        if (options29.boolean.includes(alias))
          yargs.boolean(key);
        if (options29.count.includes(alias))
          yargs.count(key);
        if (options29.string.includes(alias))
          yargs.string(key);
        if (options29.normalize.includes(alias))
          yargs.normalize(key);
        if (options29.array.includes(alias))
          yargs.array(key);
        if (options29.number.includes(alias))
          yargs.number(key);
      });
    });
  }
  __name(normalizeAliases, "normalizeAliases");
  let cachedHelpMessage;
  self2.cacheHelpMessage = function() {
    cachedHelpMessage = this.help();
  };
  self2.clearCachedHelpMessage = function() {
    cachedHelpMessage = void 0;
  };
  self2.hasCachedHelpMessage = function() {
    return !!cachedHelpMessage;
  };
  function addUngroupedKeys(keys, aliases2, groups, defaultGroup) {
    let groupedKeys = [];
    let toCheck = null;
    Object.keys(groups).forEach((group) => {
      groupedKeys = groupedKeys.concat(groups[group]);
    });
    keys.forEach((key) => {
      toCheck = [key].concat(aliases2[key]);
      if (!toCheck.some((k2) => groupedKeys.indexOf(k2) !== -1)) {
        groups[defaultGroup].push(key);
      }
    });
    return groupedKeys;
  }
  __name(addUngroupedKeys, "addUngroupedKeys");
  function filterHiddenOptions(key) {
    return yargs.getOptions().hiddenOptions.indexOf(key) < 0 || yargs.parsed.argv[yargs.getOptions().showHiddenOpt];
  }
  __name(filterHiddenOptions, "filterHiddenOptions");
  self2.showHelp = (level) => {
    const logger3 = yargs.getInternalMethods().getLoggerInstance();
    if (!level)
      level = "error";
    const emit = typeof level === "function" ? level : logger3[level];
    emit(self2.help());
  };
  self2.functionDescription = (fn2) => {
    const description = fn2.name ? shim3.Parser.decamelize(fn2.name, "-") : __("generated-value");
    return ["(", description, ")"].join("");
  };
  self2.stringifiedValues = /* @__PURE__ */ __name(function stringifiedValues(values, separator) {
    let string = "";
    const sep3 = separator || ", ";
    const array = [].concat(values);
    if (!values || !array.length)
      return string;
    array.forEach((value) => {
      if (string.length)
        string += sep3;
      string += JSON.stringify(value);
    });
    return string;
  }, "stringifiedValues");
  function defaultString(value, defaultDescription) {
    let string = `[${__("default:")} `;
    if (value === void 0 && !defaultDescription)
      return null;
    if (defaultDescription) {
      string += defaultDescription;
    } else {
      switch (typeof value) {
        case "string":
          string += `"${value}"`;
          break;
        case "object":
          string += JSON.stringify(value);
          break;
        default:
          string += value;
      }
    }
    return `${string}]`;
  }
  __name(defaultString, "defaultString");
  function windowWidth() {
    const maxWidth2 = 80;
    if (shim3.process.stdColumns) {
      return Math.min(maxWidth2, shim3.process.stdColumns);
    } else {
      return maxWidth2;
    }
  }
  __name(windowWidth, "windowWidth");
  let version3 = null;
  self2.version = (ver) => {
    version3 = ver;
  };
  self2.showVersion = (level) => {
    const logger3 = yargs.getInternalMethods().getLoggerInstance();
    if (!level)
      level = "error";
    const emit = typeof level === "function" ? level : logger3[level];
    emit(version3);
  };
  self2.reset = /* @__PURE__ */ __name(function reset(localLookup) {
    failMessage = null;
    failureOutput = false;
    usages = [];
    usageDisabled = false;
    epilogs = [];
    examples = [];
    commands = [];
    descriptions = objFilter(descriptions, (k2) => !localLookup[k2]);
    return self2;
  }, "reset");
  const frozens = [];
  self2.freeze = /* @__PURE__ */ __name(function freeze() {
    frozens.push({
      failMessage,
      failureOutput,
      usages,
      usageDisabled,
      epilogs,
      examples,
      commands,
      descriptions
    });
  }, "freeze");
  self2.unfreeze = /* @__PURE__ */ __name(function unfreeze(defaultCommand = false) {
    const frozen = frozens.pop();
    if (!frozen)
      return;
    if (defaultCommand) {
      descriptions = { ...frozen.descriptions, ...descriptions };
      commands = [...frozen.commands, ...commands];
      usages = [...frozen.usages, ...usages];
      examples = [...frozen.examples, ...examples];
      epilogs = [...frozen.epilogs, ...epilogs];
    } else {
      ({
        failMessage,
        failureOutput,
        usages,
        usageDisabled,
        epilogs,
        examples,
        commands,
        descriptions
      } = frozen);
    }
  }, "unfreeze");
  return self2;
}
__name(usage, "usage");
function isIndentedText(text) {
  return typeof text === "object";
}
__name(isIndentedText, "isIndentedText");
function addIndentation(text, indent) {
  return isIndentedText(text) ? { text: text.text, indentation: text.indentation + indent } : { text, indentation: indent };
}
__name(addIndentation, "addIndentation");
function getIndentation(text) {
  return isIndentedText(text) ? text.indentation : 0;
}
__name(getIndentation, "getIndentation");
function getText(text) {
  return isIndentedText(text) ? text.text : text;
}
__name(getText, "getText");

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/completion.js
init_import_meta_url();

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/completion-templates.js
init_import_meta_url();
var completionShTemplate = `###-begin-{{app_name}}-completions-###
#
# yargs command completion script
#
# Installation: {{app_path}} {{completion_command}} >> ~/.bashrc
#    or {{app_path}} {{completion_command}} >> ~/.bash_profile on OSX.
#
_{{app_name}}_yargs_completions()
{
    local cur_word args type_list

    cur_word="\${COMP_WORDS[COMP_CWORD]}"
    args=("\${COMP_WORDS[@]}")

    # ask yargs to generate completions.
    type_list=$({{app_path}} --get-yargs-completions "\${args[@]}")

    COMPREPLY=( $(compgen -W "\${type_list}" -- \${cur_word}) )

    # if no match was found, fall back to filename completion
    if [ \${#COMPREPLY[@]} -eq 0 ]; then
      COMPREPLY=()
    fi

    return 0
}
complete -o bashdefault -o default -F _{{app_name}}_yargs_completions {{app_name}}
###-end-{{app_name}}-completions-###
`;
var completionZshTemplate = `#compdef {{app_name}}
###-begin-{{app_name}}-completions-###
#
# yargs command completion script
#
# Installation: {{app_path}} {{completion_command}} >> ~/.zshrc
#    or {{app_path}} {{completion_command}} >> ~/.zprofile on OSX.
#
_{{app_name}}_yargs_completions()
{
  local reply
  local si=$IFS
  IFS=$'
' reply=($(COMP_CWORD="$((CURRENT-1))" COMP_LINE="$BUFFER" COMP_POINT="$CURSOR" {{app_path}} --get-yargs-completions "\${words[@]}"))
  IFS=$si
  _describe 'values' reply
}
compdef _{{app_name}}_yargs_completions {{app_name}}
###-end-{{app_name}}-completions-###
`;

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/completion.js
var Completion = class {
  constructor(yargs, usage2, command2, shim3) {
    var _a2, _b2, _c2;
    this.yargs = yargs;
    this.usage = usage2;
    this.command = command2;
    this.shim = shim3;
    this.completionKey = "get-yargs-completions";
    this.aliases = null;
    this.customCompletionFunction = null;
    this.indexAfterLastReset = 0;
    this.zshShell = (_c2 = ((_a2 = this.shim.getEnv("SHELL")) === null || _a2 === void 0 ? void 0 : _a2.includes("zsh")) || ((_b2 = this.shim.getEnv("ZSH_NAME")) === null || _b2 === void 0 ? void 0 : _b2.includes("zsh"))) !== null && _c2 !== void 0 ? _c2 : false;
  }
  defaultCompletion(args, argv, current, done) {
    const handlers2 = this.command.getCommandHandlers();
    for (let i = 0, ii = args.length; i < ii; ++i) {
      if (handlers2[args[i]] && handlers2[args[i]].builder) {
        const builder = handlers2[args[i]].builder;
        if (isCommandBuilderCallback(builder)) {
          this.indexAfterLastReset = i + 1;
          const y2 = this.yargs.getInternalMethods().reset();
          builder(y2, true);
          return y2.argv;
        }
      }
    }
    const completions = [];
    this.commandCompletions(completions, args, current);
    this.optionCompletions(completions, args, argv, current);
    this.choicesFromOptionsCompletions(completions, args, argv, current);
    this.choicesFromPositionalsCompletions(completions, args, argv, current);
    done(null, completions);
  }
  commandCompletions(completions, args, current) {
    const parentCommands = this.yargs.getInternalMethods().getContext().commands;
    if (!current.match(/^-/) && parentCommands[parentCommands.length - 1] !== current && !this.previousArgHasChoices(args)) {
      this.usage.getCommands().forEach((usageCommand) => {
        const commandName = parseCommand2(usageCommand[0]).cmd;
        if (args.indexOf(commandName) === -1) {
          if (!this.zshShell) {
            completions.push(commandName);
          } else {
            const desc = usageCommand[1] || "";
            completions.push(commandName.replace(/:/g, "\\:") + ":" + desc);
          }
        }
      });
    }
  }
  optionCompletions(completions, args, argv, current) {
    if ((current.match(/^-/) || current === "" && completions.length === 0) && !this.previousArgHasChoices(args)) {
      const options29 = this.yargs.getOptions();
      const positionalKeys = this.yargs.getGroups()[this.usage.getPositionalGroupName()] || [];
      Object.keys(options29.key).forEach((key) => {
        const negable = !!options29.configuration["boolean-negation"] && options29.boolean.includes(key);
        const isPositionalKey = positionalKeys.includes(key);
        if (!isPositionalKey && !options29.hiddenOptions.includes(key) && !this.argsContainKey(args, key, negable)) {
          this.completeOptionKey(key, completions, current, negable && !!options29.default[key]);
        }
      });
    }
  }
  choicesFromOptionsCompletions(completions, args, argv, current) {
    if (this.previousArgHasChoices(args)) {
      const choices = this.getPreviousArgChoices(args);
      if (choices && choices.length > 0) {
        completions.push(...choices.map((c2) => c2.replace(/:/g, "\\:")));
      }
    }
  }
  choicesFromPositionalsCompletions(completions, args, argv, current) {
    if (current === "" && completions.length > 0 && this.previousArgHasChoices(args)) {
      return;
    }
    const positionalKeys = this.yargs.getGroups()[this.usage.getPositionalGroupName()] || [];
    const offset = Math.max(this.indexAfterLastReset, this.yargs.getInternalMethods().getContext().commands.length + 1);
    const positionalKey = positionalKeys[argv._.length - offset - 1];
    if (!positionalKey) {
      return;
    }
    const choices = this.yargs.getOptions().choices[positionalKey] || [];
    for (const choice of choices) {
      if (choice.startsWith(current)) {
        completions.push(choice.replace(/:/g, "\\:"));
      }
    }
  }
  getPreviousArgChoices(args) {
    if (args.length < 1)
      return;
    let previousArg = args[args.length - 1];
    let filter = "";
    if (!previousArg.startsWith("-") && args.length > 1) {
      filter = previousArg;
      previousArg = args[args.length - 2];
    }
    if (!previousArg.startsWith("-"))
      return;
    const previousArgKey = previousArg.replace(/^-+/, "");
    const options29 = this.yargs.getOptions();
    const possibleAliases = [
      previousArgKey,
      ...this.yargs.getAliases()[previousArgKey] || []
    ];
    let choices;
    for (const possibleAlias of possibleAliases) {
      if (Object.prototype.hasOwnProperty.call(options29.key, possibleAlias) && Array.isArray(options29.choices[possibleAlias])) {
        choices = options29.choices[possibleAlias];
        break;
      }
    }
    if (choices) {
      return choices.filter((choice) => !filter || choice.startsWith(filter));
    }
  }
  previousArgHasChoices(args) {
    const choices = this.getPreviousArgChoices(args);
    return choices !== void 0 && choices.length > 0;
  }
  argsContainKey(args, key, negable) {
    const argsContains = /* @__PURE__ */ __name((s) => args.indexOf((/^[^0-9]$/.test(s) ? "-" : "--") + s) !== -1, "argsContains");
    if (argsContains(key))
      return true;
    if (negable && argsContains(`no-${key}`))
      return true;
    if (this.aliases) {
      for (const alias of this.aliases[key]) {
        if (argsContains(alias))
          return true;
      }
    }
    return false;
  }
  completeOptionKey(key, completions, current, negable) {
    var _a2, _b2, _c2, _d;
    let keyWithDesc = key;
    if (this.zshShell) {
      const descs = this.usage.getDescriptions();
      const aliasKey = (_b2 = (_a2 = this === null || this === void 0 ? void 0 : this.aliases) === null || _a2 === void 0 ? void 0 : _a2[key]) === null || _b2 === void 0 ? void 0 : _b2.find((alias) => {
        const desc2 = descs[alias];
        return typeof desc2 === "string" && desc2.length > 0;
      });
      const descFromAlias = aliasKey ? descs[aliasKey] : void 0;
      const desc = (_d = (_c2 = descs[key]) !== null && _c2 !== void 0 ? _c2 : descFromAlias) !== null && _d !== void 0 ? _d : "";
      keyWithDesc = `${key.replace(/:/g, "\\:")}:${desc.replace("__yargsString__:", "").replace(/(\r\n|\n|\r)/gm, " ")}`;
    }
    const startsByTwoDashes = /* @__PURE__ */ __name((s) => /^--/.test(s), "startsByTwoDashes");
    const isShortOption = /* @__PURE__ */ __name((s) => /^[^0-9]$/.test(s), "isShortOption");
    const dashes = !startsByTwoDashes(current) && isShortOption(key) ? "-" : "--";
    completions.push(dashes + keyWithDesc);
    if (negable) {
      completions.push(dashes + "no-" + keyWithDesc);
    }
  }
  customCompletion(args, argv, current, done) {
    assertNotStrictEqual(this.customCompletionFunction, null, this.shim);
    if (isSyncCompletionFunction(this.customCompletionFunction)) {
      const result = this.customCompletionFunction(current, argv);
      if (isPromise(result)) {
        return result.then((list) => {
          this.shim.process.nextTick(() => {
            done(null, list);
          });
        }).catch((err) => {
          this.shim.process.nextTick(() => {
            done(err, void 0);
          });
        });
      }
      return done(null, result);
    } else if (isFallbackCompletionFunction(this.customCompletionFunction)) {
      return this.customCompletionFunction(current, argv, (onCompleted = done) => this.defaultCompletion(args, argv, current, onCompleted), (completions) => {
        done(null, completions);
      });
    } else {
      return this.customCompletionFunction(current, argv, (completions) => {
        done(null, completions);
      });
    }
  }
  getCompletion(args, done) {
    const current = args.length ? args[args.length - 1] : "";
    const argv = this.yargs.parse(args, true);
    const completionFunction = this.customCompletionFunction ? (argv2) => this.customCompletion(args, argv2, current, done) : (argv2) => this.defaultCompletion(args, argv2, current, done);
    return isPromise(argv) ? argv.then(completionFunction) : completionFunction(argv);
  }
  generateCompletionScript($0, cmd) {
    let script = this.zshShell ? completionZshTemplate : completionShTemplate;
    const name = this.shim.path.basename($0);
    if ($0.match(/\.js$/))
      $0 = `./${$0}`;
    script = script.replace(/{{app_name}}/g, name);
    script = script.replace(/{{completion_command}}/g, cmd);
    return script.replace(/{{app_path}}/g, $0);
  }
  registerFunction(fn2) {
    this.customCompletionFunction = fn2;
  }
  setParsed(parsed) {
    this.aliases = parsed.aliases;
  }
};
__name(Completion, "Completion");
function completion(yargs, usage2, command2, shim3) {
  return new Completion(yargs, usage2, command2, shim3);
}
__name(completion, "completion");
function isSyncCompletionFunction(completionFunction) {
  return completionFunction.length < 3;
}
__name(isSyncCompletionFunction, "isSyncCompletionFunction");
function isFallbackCompletionFunction(completionFunction) {
  return completionFunction.length > 3;
}
__name(isFallbackCompletionFunction, "isFallbackCompletionFunction");

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/validation.js
init_import_meta_url();

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/utils/levenshtein.js
init_import_meta_url();
function levenshtein(a, b2) {
  if (a.length === 0)
    return b2.length;
  if (b2.length === 0)
    return a.length;
  const matrix = [];
  let i;
  for (i = 0; i <= b2.length; i++) {
    matrix[i] = [i];
  }
  let j2;
  for (j2 = 0; j2 <= a.length; j2++) {
    matrix[0][j2] = j2;
  }
  for (i = 1; i <= b2.length; i++) {
    for (j2 = 1; j2 <= a.length; j2++) {
      if (b2.charAt(i - 1) === a.charAt(j2 - 1)) {
        matrix[i][j2] = matrix[i - 1][j2 - 1];
      } else {
        if (i > 1 && j2 > 1 && b2.charAt(i - 2) === a.charAt(j2 - 1) && b2.charAt(i - 1) === a.charAt(j2 - 2)) {
          matrix[i][j2] = matrix[i - 2][j2 - 2] + 1;
        } else {
          matrix[i][j2] = Math.min(matrix[i - 1][j2 - 1] + 1, Math.min(matrix[i][j2 - 1] + 1, matrix[i - 1][j2] + 1));
        }
      }
    }
  }
  return matrix[b2.length][a.length];
}
__name(levenshtein, "levenshtein");

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/validation.js
var specialKeys = ["$0", "--", "_"];
function validation(yargs, usage2, shim3) {
  const __ = shim3.y18n.__;
  const __n = shim3.y18n.__n;
  const self2 = {};
  self2.nonOptionCount = /* @__PURE__ */ __name(function nonOptionCount(argv) {
    const demandedCommands = yargs.getDemandedCommands();
    const positionalCount = argv._.length + (argv["--"] ? argv["--"].length : 0);
    const _s = positionalCount - yargs.getInternalMethods().getContext().commands.length;
    if (demandedCommands._ && (_s < demandedCommands._.min || _s > demandedCommands._.max)) {
      if (_s < demandedCommands._.min) {
        if (demandedCommands._.minMsg !== void 0) {
          usage2.fail(demandedCommands._.minMsg ? demandedCommands._.minMsg.replace(/\$0/g, _s.toString()).replace(/\$1/, demandedCommands._.min.toString()) : null);
        } else {
          usage2.fail(__n("Not enough non-option arguments: got %s, need at least %s", "Not enough non-option arguments: got %s, need at least %s", _s, _s.toString(), demandedCommands._.min.toString()));
        }
      } else if (_s > demandedCommands._.max) {
        if (demandedCommands._.maxMsg !== void 0) {
          usage2.fail(demandedCommands._.maxMsg ? demandedCommands._.maxMsg.replace(/\$0/g, _s.toString()).replace(/\$1/, demandedCommands._.max.toString()) : null);
        } else {
          usage2.fail(__n("Too many non-option arguments: got %s, maximum of %s", "Too many non-option arguments: got %s, maximum of %s", _s, _s.toString(), demandedCommands._.max.toString()));
        }
      }
    }
  }, "nonOptionCount");
  self2.positionalCount = /* @__PURE__ */ __name(function positionalCount(required, observed) {
    if (observed < required) {
      usage2.fail(__n("Not enough non-option arguments: got %s, need at least %s", "Not enough non-option arguments: got %s, need at least %s", observed, observed + "", required + ""));
    }
  }, "positionalCount");
  self2.requiredArguments = /* @__PURE__ */ __name(function requiredArguments(argv, demandedOptions) {
    let missing = null;
    for (const key of Object.keys(demandedOptions)) {
      if (!Object.prototype.hasOwnProperty.call(argv, key) || typeof argv[key] === "undefined") {
        missing = missing || {};
        missing[key] = demandedOptions[key];
      }
    }
    if (missing) {
      const customMsgs = [];
      for (const key of Object.keys(missing)) {
        const msg = missing[key];
        if (msg && customMsgs.indexOf(msg) < 0) {
          customMsgs.push(msg);
        }
      }
      const customMsg = customMsgs.length ? `
${customMsgs.join("\n")}` : "";
      usage2.fail(__n("Missing required argument: %s", "Missing required arguments: %s", Object.keys(missing).length, Object.keys(missing).join(", ") + customMsg));
    }
  }, "requiredArguments");
  self2.unknownArguments = /* @__PURE__ */ __name(function unknownArguments(argv, aliases2, positionalMap, isDefaultCommand, checkPositionals = true) {
    var _a2;
    const commandKeys = yargs.getInternalMethods().getCommandInstance().getCommands();
    const unknown = [];
    const currentContext = yargs.getInternalMethods().getContext();
    Object.keys(argv).forEach((key) => {
      if (!specialKeys.includes(key) && !Object.prototype.hasOwnProperty.call(positionalMap, key) && !Object.prototype.hasOwnProperty.call(yargs.getInternalMethods().getParseContext(), key) && !self2.isValidAndSomeAliasIsNotNew(key, aliases2)) {
        unknown.push(key);
      }
    });
    if (checkPositionals && (currentContext.commands.length > 0 || commandKeys.length > 0 || isDefaultCommand)) {
      argv._.slice(currentContext.commands.length).forEach((key) => {
        if (!commandKeys.includes("" + key)) {
          unknown.push("" + key);
        }
      });
    }
    if (checkPositionals) {
      const demandedCommands = yargs.getDemandedCommands();
      const maxNonOptDemanded = ((_a2 = demandedCommands._) === null || _a2 === void 0 ? void 0 : _a2.max) || 0;
      const expected = currentContext.commands.length + maxNonOptDemanded;
      if (expected < argv._.length) {
        argv._.slice(expected).forEach((key) => {
          key = String(key);
          if (!currentContext.commands.includes(key) && !unknown.includes(key)) {
            unknown.push(key);
          }
        });
      }
    }
    if (unknown.length) {
      usage2.fail(__n("Unknown argument: %s", "Unknown arguments: %s", unknown.length, unknown.map((s) => s.trim() ? s : `"${s}"`).join(", ")));
    }
  }, "unknownArguments");
  self2.unknownCommands = /* @__PURE__ */ __name(function unknownCommands(argv) {
    const commandKeys = yargs.getInternalMethods().getCommandInstance().getCommands();
    const unknown = [];
    const currentContext = yargs.getInternalMethods().getContext();
    if (currentContext.commands.length > 0 || commandKeys.length > 0) {
      argv._.slice(currentContext.commands.length).forEach((key) => {
        if (!commandKeys.includes("" + key)) {
          unknown.push("" + key);
        }
      });
    }
    if (unknown.length > 0) {
      usage2.fail(__n("Unknown command: %s", "Unknown commands: %s", unknown.length, unknown.join(", ")));
      return true;
    } else {
      return false;
    }
  }, "unknownCommands");
  self2.isValidAndSomeAliasIsNotNew = /* @__PURE__ */ __name(function isValidAndSomeAliasIsNotNew(key, aliases2) {
    if (!Object.prototype.hasOwnProperty.call(aliases2, key)) {
      return false;
    }
    const newAliases = yargs.parsed.newAliases;
    return [key, ...aliases2[key]].some((a) => !Object.prototype.hasOwnProperty.call(newAliases, a) || !newAliases[key]);
  }, "isValidAndSomeAliasIsNotNew");
  self2.limitedChoices = /* @__PURE__ */ __name(function limitedChoices(argv) {
    const options29 = yargs.getOptions();
    const invalid = {};
    if (!Object.keys(options29.choices).length)
      return;
    Object.keys(argv).forEach((key) => {
      if (specialKeys.indexOf(key) === -1 && Object.prototype.hasOwnProperty.call(options29.choices, key)) {
        [].concat(argv[key]).forEach((value) => {
          if (options29.choices[key].indexOf(value) === -1 && value !== void 0) {
            invalid[key] = (invalid[key] || []).concat(value);
          }
        });
      }
    });
    const invalidKeys = Object.keys(invalid);
    if (!invalidKeys.length)
      return;
    let msg = __("Invalid values:");
    invalidKeys.forEach((key) => {
      msg += `
  ${__("Argument: %s, Given: %s, Choices: %s", key, usage2.stringifiedValues(invalid[key]), usage2.stringifiedValues(options29.choices[key]))}`;
    });
    usage2.fail(msg);
  }, "limitedChoices");
  let implied = {};
  self2.implies = /* @__PURE__ */ __name(function implies(key, value) {
    argsert("<string|object> [array|number|string]", [key, value], arguments.length);
    if (typeof key === "object") {
      Object.keys(key).forEach((k2) => {
        self2.implies(k2, key[k2]);
      });
    } else {
      yargs.global(key);
      if (!implied[key]) {
        implied[key] = [];
      }
      if (Array.isArray(value)) {
        value.forEach((i) => self2.implies(key, i));
      } else {
        assertNotStrictEqual(value, void 0, shim3);
        implied[key].push(value);
      }
    }
  }, "implies");
  self2.getImplied = /* @__PURE__ */ __name(function getImplied() {
    return implied;
  }, "getImplied");
  function keyExists(argv, val) {
    const num = Number(val);
    val = isNaN(num) ? val : num;
    if (typeof val === "number") {
      val = argv._.length >= val;
    } else if (val.match(/^--no-.+/)) {
      val = val.match(/^--no-(.+)/)[1];
      val = !Object.prototype.hasOwnProperty.call(argv, val);
    } else {
      val = Object.prototype.hasOwnProperty.call(argv, val);
    }
    return val;
  }
  __name(keyExists, "keyExists");
  self2.implications = /* @__PURE__ */ __name(function implications(argv) {
    const implyFail = [];
    Object.keys(implied).forEach((key) => {
      const origKey = key;
      (implied[key] || []).forEach((value) => {
        let key2 = origKey;
        const origValue = value;
        key2 = keyExists(argv, key2);
        value = keyExists(argv, value);
        if (key2 && !value) {
          implyFail.push(` ${origKey} -> ${origValue}`);
        }
      });
    });
    if (implyFail.length) {
      let msg = `${__("Implications failed:")}
`;
      implyFail.forEach((value) => {
        msg += value;
      });
      usage2.fail(msg);
    }
  }, "implications");
  let conflicting = {};
  self2.conflicts = /* @__PURE__ */ __name(function conflicts(key, value) {
    argsert("<string|object> [array|string]", [key, value], arguments.length);
    if (typeof key === "object") {
      Object.keys(key).forEach((k2) => {
        self2.conflicts(k2, key[k2]);
      });
    } else {
      yargs.global(key);
      if (!conflicting[key]) {
        conflicting[key] = [];
      }
      if (Array.isArray(value)) {
        value.forEach((i) => self2.conflicts(key, i));
      } else {
        conflicting[key].push(value);
      }
    }
  }, "conflicts");
  self2.getConflicting = () => conflicting;
  self2.conflicting = /* @__PURE__ */ __name(function conflictingFn(argv) {
    Object.keys(argv).forEach((key) => {
      if (conflicting[key]) {
        conflicting[key].forEach((value) => {
          if (value && argv[key] !== void 0 && argv[value] !== void 0) {
            usage2.fail(__("Arguments %s and %s are mutually exclusive", key, value));
          }
        });
      }
    });
    if (yargs.getInternalMethods().getParserConfiguration()["strip-dashed"]) {
      Object.keys(conflicting).forEach((key) => {
        conflicting[key].forEach((value) => {
          if (value && argv[shim3.Parser.camelCase(key)] !== void 0 && argv[shim3.Parser.camelCase(value)] !== void 0) {
            usage2.fail(__("Arguments %s and %s are mutually exclusive", key, value));
          }
        });
      });
    }
  }, "conflictingFn");
  self2.recommendCommands = /* @__PURE__ */ __name(function recommendCommands(cmd, potentialCommands) {
    const threshold = 3;
    potentialCommands = potentialCommands.sort((a, b2) => b2.length - a.length);
    let recommended = null;
    let bestDistance = Infinity;
    for (let i = 0, candidate; (candidate = potentialCommands[i]) !== void 0; i++) {
      const d2 = levenshtein(cmd, candidate);
      if (d2 <= threshold && d2 < bestDistance) {
        bestDistance = d2;
        recommended = candidate;
      }
    }
    if (recommended)
      usage2.fail(__("Did you mean %s?", recommended));
  }, "recommendCommands");
  self2.reset = /* @__PURE__ */ __name(function reset(localLookup) {
    implied = objFilter(implied, (k2) => !localLookup[k2]);
    conflicting = objFilter(conflicting, (k2) => !localLookup[k2]);
    return self2;
  }, "reset");
  const frozens = [];
  self2.freeze = /* @__PURE__ */ __name(function freeze() {
    frozens.push({
      implied,
      conflicting
    });
  }, "freeze");
  self2.unfreeze = /* @__PURE__ */ __name(function unfreeze() {
    const frozen = frozens.pop();
    assertNotStrictEqual(frozen, void 0, shim3);
    ({ implied, conflicting } = frozen);
  }, "unfreeze");
  return self2;
}
__name(validation, "validation");

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/yargs-factory.js
var __classPrivateFieldSet = function(receiver, state, value, kind, f) {
  if (kind === "m")
    throw new TypeError("Private method is not writable");
  if (kind === "a" && !f)
    throw new TypeError("Private accessor was defined without a setter");
  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
    throw new TypeError("Cannot write private member to an object whose class did not declare it");
  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
};
var __classPrivateFieldGet = function(receiver, state, kind, f) {
  if (kind === "a" && !f)
    throw new TypeError("Private accessor was defined without a getter");
  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
    throw new TypeError("Cannot read private member from an object whose class did not declare it");
  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _YargsInstance_command;
var _YargsInstance_cwd;
var _YargsInstance_context;
var _YargsInstance_completion;
var _YargsInstance_completionCommand;
var _YargsInstance_defaultShowHiddenOpt;
var _YargsInstance_exitError;
var _YargsInstance_detectLocale;
var _YargsInstance_emittedWarnings;
var _YargsInstance_exitProcess;
var _YargsInstance_frozens;
var _YargsInstance_globalMiddleware;
var _YargsInstance_groups;
var _YargsInstance_hasOutput;
var _YargsInstance_helpOpt;
var _YargsInstance_isGlobalContext;
var _YargsInstance_logger;
var _YargsInstance_output;
var _YargsInstance_options;
var _YargsInstance_parentRequire;
var _YargsInstance_parserConfig;
var _YargsInstance_parseFn;
var _YargsInstance_parseContext;
var _YargsInstance_pkgs;
var _YargsInstance_preservedGroups;
var _YargsInstance_processArgs;
var _YargsInstance_recommendCommands;
var _YargsInstance_shim;
var _YargsInstance_strict;
var _YargsInstance_strictCommands;
var _YargsInstance_strictOptions;
var _YargsInstance_usage;
var _YargsInstance_usageConfig;
var _YargsInstance_versionOpt;
var _YargsInstance_validation;
function YargsFactory(_shim) {
  return (processArgs = [], cwd2 = _shim.process.cwd(), parentRequire) => {
    const yargs = new YargsInstance(processArgs, cwd2, parentRequire, _shim);
    Object.defineProperty(yargs, "argv", {
      get: () => {
        return yargs.parse();
      },
      enumerable: true
    });
    yargs.help();
    yargs.version();
    return yargs;
  };
}
__name(YargsFactory, "YargsFactory");
var kCopyDoubleDash = Symbol("copyDoubleDash");
var kCreateLogger = Symbol("copyDoubleDash");
var kDeleteFromParserHintObject = Symbol("deleteFromParserHintObject");
var kEmitWarning = Symbol("emitWarning");
var kFreeze = Symbol("freeze");
var kGetDollarZero = Symbol("getDollarZero");
var kGetParserConfiguration = Symbol("getParserConfiguration");
var kGetUsageConfiguration = Symbol("getUsageConfiguration");
var kGuessLocale = Symbol("guessLocale");
var kGuessVersion = Symbol("guessVersion");
var kParsePositionalNumbers = Symbol("parsePositionalNumbers");
var kPkgUp = Symbol("pkgUp");
var kPopulateParserHintArray = Symbol("populateParserHintArray");
var kPopulateParserHintSingleValueDictionary = Symbol("populateParserHintSingleValueDictionary");
var kPopulateParserHintArrayDictionary = Symbol("populateParserHintArrayDictionary");
var kPopulateParserHintDictionary = Symbol("populateParserHintDictionary");
var kSanitizeKey = Symbol("sanitizeKey");
var kSetKey = Symbol("setKey");
var kUnfreeze = Symbol("unfreeze");
var kValidateAsync = Symbol("validateAsync");
var kGetCommandInstance = Symbol("getCommandInstance");
var kGetContext = Symbol("getContext");
var kGetHasOutput = Symbol("getHasOutput");
var kGetLoggerInstance = Symbol("getLoggerInstance");
var kGetParseContext = Symbol("getParseContext");
var kGetUsageInstance = Symbol("getUsageInstance");
var kGetValidationInstance = Symbol("getValidationInstance");
var kHasParseCallback = Symbol("hasParseCallback");
var kIsGlobalContext = Symbol("isGlobalContext");
var kPostProcess = Symbol("postProcess");
var kRebase = Symbol("rebase");
var kReset = Symbol("reset");
var kRunYargsParserAndExecuteCommands = Symbol("runYargsParserAndExecuteCommands");
var kRunValidation = Symbol("runValidation");
var kSetHasOutput = Symbol("setHasOutput");
var kTrackManuallySetKeys = Symbol("kTrackManuallySetKeys");
var YargsInstance = class {
  constructor(processArgs = [], cwd2, parentRequire, shim3) {
    this.customScriptName = false;
    this.parsed = false;
    _YargsInstance_command.set(this, void 0);
    _YargsInstance_cwd.set(this, void 0);
    _YargsInstance_context.set(this, { commands: [], fullCommands: [] });
    _YargsInstance_completion.set(this, null);
    _YargsInstance_completionCommand.set(this, null);
    _YargsInstance_defaultShowHiddenOpt.set(this, "show-hidden");
    _YargsInstance_exitError.set(this, null);
    _YargsInstance_detectLocale.set(this, true);
    _YargsInstance_emittedWarnings.set(this, {});
    _YargsInstance_exitProcess.set(this, true);
    _YargsInstance_frozens.set(this, []);
    _YargsInstance_globalMiddleware.set(this, void 0);
    _YargsInstance_groups.set(this, {});
    _YargsInstance_hasOutput.set(this, false);
    _YargsInstance_helpOpt.set(this, null);
    _YargsInstance_isGlobalContext.set(this, true);
    _YargsInstance_logger.set(this, void 0);
    _YargsInstance_output.set(this, "");
    _YargsInstance_options.set(this, void 0);
    _YargsInstance_parentRequire.set(this, void 0);
    _YargsInstance_parserConfig.set(this, {});
    _YargsInstance_parseFn.set(this, null);
    _YargsInstance_parseContext.set(this, null);
    _YargsInstance_pkgs.set(this, {});
    _YargsInstance_preservedGroups.set(this, {});
    _YargsInstance_processArgs.set(this, void 0);
    _YargsInstance_recommendCommands.set(this, false);
    _YargsInstance_shim.set(this, void 0);
    _YargsInstance_strict.set(this, false);
    _YargsInstance_strictCommands.set(this, false);
    _YargsInstance_strictOptions.set(this, false);
    _YargsInstance_usage.set(this, void 0);
    _YargsInstance_usageConfig.set(this, {});
    _YargsInstance_versionOpt.set(this, null);
    _YargsInstance_validation.set(this, void 0);
    __classPrivateFieldSet(this, _YargsInstance_shim, shim3, "f");
    __classPrivateFieldSet(this, _YargsInstance_processArgs, processArgs, "f");
    __classPrivateFieldSet(this, _YargsInstance_cwd, cwd2, "f");
    __classPrivateFieldSet(this, _YargsInstance_parentRequire, parentRequire, "f");
    __classPrivateFieldSet(this, _YargsInstance_globalMiddleware, new GlobalMiddleware(this), "f");
    this.$0 = this[kGetDollarZero]();
    this[kReset]();
    __classPrivateFieldSet(this, _YargsInstance_command, __classPrivateFieldGet(this, _YargsInstance_command, "f"), "f");
    __classPrivateFieldSet(this, _YargsInstance_usage, __classPrivateFieldGet(this, _YargsInstance_usage, "f"), "f");
    __classPrivateFieldSet(this, _YargsInstance_validation, __classPrivateFieldGet(this, _YargsInstance_validation, "f"), "f");
    __classPrivateFieldSet(this, _YargsInstance_options, __classPrivateFieldGet(this, _YargsInstance_options, "f"), "f");
    __classPrivateFieldGet(this, _YargsInstance_options, "f").showHiddenOpt = __classPrivateFieldGet(this, _YargsInstance_defaultShowHiddenOpt, "f");
    __classPrivateFieldSet(this, _YargsInstance_logger, this[kCreateLogger](), "f");
  }
  addHelpOpt(opt, msg) {
    const defaultHelpOpt = "help";
    argsert("[string|boolean] [string]", [opt, msg], arguments.length);
    if (__classPrivateFieldGet(this, _YargsInstance_helpOpt, "f")) {
      this[kDeleteFromParserHintObject](__classPrivateFieldGet(this, _YargsInstance_helpOpt, "f"));
      __classPrivateFieldSet(this, _YargsInstance_helpOpt, null, "f");
    }
    if (opt === false && msg === void 0)
      return this;
    __classPrivateFieldSet(this, _YargsInstance_helpOpt, typeof opt === "string" ? opt : defaultHelpOpt, "f");
    this.boolean(__classPrivateFieldGet(this, _YargsInstance_helpOpt, "f"));
    this.describe(__classPrivateFieldGet(this, _YargsInstance_helpOpt, "f"), msg || __classPrivateFieldGet(this, _YargsInstance_usage, "f").deferY18nLookup("Show help"));
    return this;
  }
  help(opt, msg) {
    return this.addHelpOpt(opt, msg);
  }
  addShowHiddenOpt(opt, msg) {
    argsert("[string|boolean] [string]", [opt, msg], arguments.length);
    if (opt === false && msg === void 0)
      return this;
    const showHiddenOpt = typeof opt === "string" ? opt : __classPrivateFieldGet(this, _YargsInstance_defaultShowHiddenOpt, "f");
    this.boolean(showHiddenOpt);
    this.describe(showHiddenOpt, msg || __classPrivateFieldGet(this, _YargsInstance_usage, "f").deferY18nLookup("Show hidden options"));
    __classPrivateFieldGet(this, _YargsInstance_options, "f").showHiddenOpt = showHiddenOpt;
    return this;
  }
  showHidden(opt, msg) {
    return this.addShowHiddenOpt(opt, msg);
  }
  alias(key, value) {
    argsert("<object|string|array> [string|array]", [key, value], arguments.length);
    this[kPopulateParserHintArrayDictionary](this.alias.bind(this), "alias", key, value);
    return this;
  }
  array(keys) {
    argsert("<array|string>", [keys], arguments.length);
    this[kPopulateParserHintArray]("array", keys);
    this[kTrackManuallySetKeys](keys);
    return this;
  }
  boolean(keys) {
    argsert("<array|string>", [keys], arguments.length);
    this[kPopulateParserHintArray]("boolean", keys);
    this[kTrackManuallySetKeys](keys);
    return this;
  }
  check(f, global2) {
    argsert("<function> [boolean]", [f, global2], arguments.length);
    this.middleware((argv, _yargs) => {
      return maybeAsyncResult(() => {
        return f(argv, _yargs.getOptions());
      }, (result) => {
        if (!result) {
          __classPrivateFieldGet(this, _YargsInstance_usage, "f").fail(__classPrivateFieldGet(this, _YargsInstance_shim, "f").y18n.__("Argument check failed: %s", f.toString()));
        } else if (typeof result === "string" || result instanceof Error) {
          __classPrivateFieldGet(this, _YargsInstance_usage, "f").fail(result.toString(), result);
        }
        return argv;
      }, (err) => {
        __classPrivateFieldGet(this, _YargsInstance_usage, "f").fail(err.message ? err.message : err.toString(), err);
        return argv;
      });
    }, false, global2);
    return this;
  }
  choices(key, value) {
    argsert("<object|string|array> [string|array]", [key, value], arguments.length);
    this[kPopulateParserHintArrayDictionary](this.choices.bind(this), "choices", key, value);
    return this;
  }
  coerce(keys, value) {
    argsert("<object|string|array> [function]", [keys, value], arguments.length);
    if (Array.isArray(keys)) {
      if (!value) {
        throw new YError("coerce callback must be provided");
      }
      for (const key of keys) {
        this.coerce(key, value);
      }
      return this;
    } else if (typeof keys === "object") {
      for (const key of Object.keys(keys)) {
        this.coerce(key, keys[key]);
      }
      return this;
    }
    if (!value) {
      throw new YError("coerce callback must be provided");
    }
    __classPrivateFieldGet(this, _YargsInstance_options, "f").key[keys] = true;
    __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, "f").addCoerceMiddleware((argv, yargs) => {
      let aliases2;
      const shouldCoerce = Object.prototype.hasOwnProperty.call(argv, keys);
      if (!shouldCoerce) {
        return argv;
      }
      return maybeAsyncResult(() => {
        aliases2 = yargs.getAliases();
        return value(argv[keys]);
      }, (result) => {
        argv[keys] = result;
        const stripAliased = yargs.getInternalMethods().getParserConfiguration()["strip-aliased"];
        if (aliases2[keys] && stripAliased !== true) {
          for (const alias of aliases2[keys]) {
            argv[alias] = result;
          }
        }
        return argv;
      }, (err) => {
        throw new YError(err.message);
      });
    }, keys);
    return this;
  }
  conflicts(key1, key2) {
    argsert("<string|object> [string|array]", [key1, key2], arguments.length);
    __classPrivateFieldGet(this, _YargsInstance_validation, "f").conflicts(key1, key2);
    return this;
  }
  config(key = "config", msg, parseFn) {
    argsert("[object|string] [string|function] [function]", [key, msg, parseFn], arguments.length);
    if (typeof key === "object" && !Array.isArray(key)) {
      key = applyExtends(key, __classPrivateFieldGet(this, _YargsInstance_cwd, "f"), this[kGetParserConfiguration]()["deep-merge-config"] || false, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
      __classPrivateFieldGet(this, _YargsInstance_options, "f").configObjects = (__classPrivateFieldGet(this, _YargsInstance_options, "f").configObjects || []).concat(key);
      return this;
    }
    if (typeof msg === "function") {
      parseFn = msg;
      msg = void 0;
    }
    this.describe(key, msg || __classPrivateFieldGet(this, _YargsInstance_usage, "f").deferY18nLookup("Path to JSON config file"));
    (Array.isArray(key) ? key : [key]).forEach((k2) => {
      __classPrivateFieldGet(this, _YargsInstance_options, "f").config[k2] = parseFn || true;
    });
    return this;
  }
  completion(cmd, desc, fn2) {
    argsert("[string] [string|boolean|function] [function]", [cmd, desc, fn2], arguments.length);
    if (typeof desc === "function") {
      fn2 = desc;
      desc = void 0;
    }
    __classPrivateFieldSet(this, _YargsInstance_completionCommand, cmd || __classPrivateFieldGet(this, _YargsInstance_completionCommand, "f") || "completion", "f");
    if (!desc && desc !== false) {
      desc = "generate completion script";
    }
    this.command(__classPrivateFieldGet(this, _YargsInstance_completionCommand, "f"), desc);
    if (fn2)
      __classPrivateFieldGet(this, _YargsInstance_completion, "f").registerFunction(fn2);
    return this;
  }
  command(cmd, description, builder, handler30, middlewares, deprecated2) {
    argsert("<string|array|object> [string|boolean] [function|object] [function] [array] [boolean|string]", [cmd, description, builder, handler30, middlewares, deprecated2], arguments.length);
    __classPrivateFieldGet(this, _YargsInstance_command, "f").addHandler(cmd, description, builder, handler30, middlewares, deprecated2);
    return this;
  }
  commands(cmd, description, builder, handler30, middlewares, deprecated2) {
    return this.command(cmd, description, builder, handler30, middlewares, deprecated2);
  }
  commandDir(dir, opts) {
    argsert("<string> [object]", [dir, opts], arguments.length);
    const req = __classPrivateFieldGet(this, _YargsInstance_parentRequire, "f") || __classPrivateFieldGet(this, _YargsInstance_shim, "f").require;
    __classPrivateFieldGet(this, _YargsInstance_command, "f").addDirectory(dir, req, __classPrivateFieldGet(this, _YargsInstance_shim, "f").getCallerFile(), opts);
    return this;
  }
  count(keys) {
    argsert("<array|string>", [keys], arguments.length);
    this[kPopulateParserHintArray]("count", keys);
    this[kTrackManuallySetKeys](keys);
    return this;
  }
  default(key, value, defaultDescription) {
    argsert("<object|string|array> [*] [string]", [key, value, defaultDescription], arguments.length);
    if (defaultDescription) {
      assertSingleKey(key, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
      __classPrivateFieldGet(this, _YargsInstance_options, "f").defaultDescription[key] = defaultDescription;
    }
    if (typeof value === "function") {
      assertSingleKey(key, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
      if (!__classPrivateFieldGet(this, _YargsInstance_options, "f").defaultDescription[key])
        __classPrivateFieldGet(this, _YargsInstance_options, "f").defaultDescription[key] = __classPrivateFieldGet(this, _YargsInstance_usage, "f").functionDescription(value);
      value = value.call();
    }
    this[kPopulateParserHintSingleValueDictionary](this.default.bind(this), "default", key, value);
    return this;
  }
  defaults(key, value, defaultDescription) {
    return this.default(key, value, defaultDescription);
  }
  demandCommand(min = 1, max, minMsg, maxMsg) {
    argsert("[number] [number|string] [string|null|undefined] [string|null|undefined]", [min, max, minMsg, maxMsg], arguments.length);
    if (typeof max !== "number") {
      minMsg = max;
      max = Infinity;
    }
    this.global("_", false);
    __classPrivateFieldGet(this, _YargsInstance_options, "f").demandedCommands._ = {
      min,
      max,
      minMsg,
      maxMsg
    };
    return this;
  }
  demand(keys, max, msg) {
    if (Array.isArray(max)) {
      max.forEach((key) => {
        assertNotStrictEqual(msg, true, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
        this.demandOption(key, msg);
      });
      max = Infinity;
    } else if (typeof max !== "number") {
      msg = max;
      max = Infinity;
    }
    if (typeof keys === "number") {
      assertNotStrictEqual(msg, true, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
      this.demandCommand(keys, max, msg, msg);
    } else if (Array.isArray(keys)) {
      keys.forEach((key) => {
        assertNotStrictEqual(msg, true, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
        this.demandOption(key, msg);
      });
    } else {
      if (typeof msg === "string") {
        this.demandOption(keys, msg);
      } else if (msg === true || typeof msg === "undefined") {
        this.demandOption(keys);
      }
    }
    return this;
  }
  demandOption(keys, msg) {
    argsert("<object|string|array> [string]", [keys, msg], arguments.length);
    this[kPopulateParserHintSingleValueDictionary](this.demandOption.bind(this), "demandedOptions", keys, msg);
    return this;
  }
  deprecateOption(option, message) {
    argsert("<string> [string|boolean]", [option, message], arguments.length);
    __classPrivateFieldGet(this, _YargsInstance_options, "f").deprecatedOptions[option] = message;
    return this;
  }
  describe(keys, description) {
    argsert("<object|string|array> [string]", [keys, description], arguments.length);
    this[kSetKey](keys, true);
    __classPrivateFieldGet(this, _YargsInstance_usage, "f").describe(keys, description);
    return this;
  }
  detectLocale(detect) {
    argsert("<boolean>", [detect], arguments.length);
    __classPrivateFieldSet(this, _YargsInstance_detectLocale, detect, "f");
    return this;
  }
  env(prefix) {
    argsert("[string|boolean]", [prefix], arguments.length);
    if (prefix === false)
      delete __classPrivateFieldGet(this, _YargsInstance_options, "f").envPrefix;
    else
      __classPrivateFieldGet(this, _YargsInstance_options, "f").envPrefix = prefix || "";
    return this;
  }
  epilogue(msg) {
    argsert("<string>", [msg], arguments.length);
    __classPrivateFieldGet(this, _YargsInstance_usage, "f").epilog(msg);
    return this;
  }
  epilog(msg) {
    return this.epilogue(msg);
  }
  example(cmd, description) {
    argsert("<string|array> [string]", [cmd, description], arguments.length);
    if (Array.isArray(cmd)) {
      cmd.forEach((exampleParams) => this.example(...exampleParams));
    } else {
      __classPrivateFieldGet(this, _YargsInstance_usage, "f").example(cmd, description);
    }
    return this;
  }
  exit(code, err) {
    __classPrivateFieldSet(this, _YargsInstance_hasOutput, true, "f");
    __classPrivateFieldSet(this, _YargsInstance_exitError, err, "f");
    if (__classPrivateFieldGet(this, _YargsInstance_exitProcess, "f"))
      __classPrivateFieldGet(this, _YargsInstance_shim, "f").process.exit(code);
  }
  exitProcess(enabled = true) {
    argsert("[boolean]", [enabled], arguments.length);
    __classPrivateFieldSet(this, _YargsInstance_exitProcess, enabled, "f");
    return this;
  }
  fail(f) {
    argsert("<function|boolean>", [f], arguments.length);
    if (typeof f === "boolean" && f !== false) {
      throw new YError("Invalid first argument. Expected function or boolean 'false'");
    }
    __classPrivateFieldGet(this, _YargsInstance_usage, "f").failFn(f);
    return this;
  }
  getAliases() {
    return this.parsed ? this.parsed.aliases : {};
  }
  async getCompletion(args, done) {
    argsert("<array> [function]", [args, done], arguments.length);
    if (!done) {
      return new Promise((resolve19, reject) => {
        __classPrivateFieldGet(this, _YargsInstance_completion, "f").getCompletion(args, (err, completions) => {
          if (err)
            reject(err);
          else
            resolve19(completions);
        });
      });
    } else {
      return __classPrivateFieldGet(this, _YargsInstance_completion, "f").getCompletion(args, done);
    }
  }
  getDemandedOptions() {
    argsert([], 0);
    return __classPrivateFieldGet(this, _YargsInstance_options, "f").demandedOptions;
  }
  getDemandedCommands() {
    argsert([], 0);
    return __classPrivateFieldGet(this, _YargsInstance_options, "f").demandedCommands;
  }
  getDeprecatedOptions() {
    argsert([], 0);
    return __classPrivateFieldGet(this, _YargsInstance_options, "f").deprecatedOptions;
  }
  getDetectLocale() {
    return __classPrivateFieldGet(this, _YargsInstance_detectLocale, "f");
  }
  getExitProcess() {
    return __classPrivateFieldGet(this, _YargsInstance_exitProcess, "f");
  }
  getGroups() {
    return Object.assign({}, __classPrivateFieldGet(this, _YargsInstance_groups, "f"), __classPrivateFieldGet(this, _YargsInstance_preservedGroups, "f"));
  }
  getHelp() {
    __classPrivateFieldSet(this, _YargsInstance_hasOutput, true, "f");
    if (!__classPrivateFieldGet(this, _YargsInstance_usage, "f").hasCachedHelpMessage()) {
      if (!this.parsed) {
        const parse7 = this[kRunYargsParserAndExecuteCommands](__classPrivateFieldGet(this, _YargsInstance_processArgs, "f"), void 0, void 0, 0, true);
        if (isPromise(parse7)) {
          return parse7.then(() => {
            return __classPrivateFieldGet(this, _YargsInstance_usage, "f").help();
          });
        }
      }
      const builderResponse = __classPrivateFieldGet(this, _YargsInstance_command, "f").runDefaultBuilderOn(this);
      if (isPromise(builderResponse)) {
        return builderResponse.then(() => {
          return __classPrivateFieldGet(this, _YargsInstance_usage, "f").help();
        });
      }
    }
    return Promise.resolve(__classPrivateFieldGet(this, _YargsInstance_usage, "f").help());
  }
  getOptions() {
    return __classPrivateFieldGet(this, _YargsInstance_options, "f");
  }
  getStrict() {
    return __classPrivateFieldGet(this, _YargsInstance_strict, "f");
  }
  getStrictCommands() {
    return __classPrivateFieldGet(this, _YargsInstance_strictCommands, "f");
  }
  getStrictOptions() {
    return __classPrivateFieldGet(this, _YargsInstance_strictOptions, "f");
  }
  global(globals, global2) {
    argsert("<string|array> [boolean]", [globals, global2], arguments.length);
    globals = [].concat(globals);
    if (global2 !== false) {
      __classPrivateFieldGet(this, _YargsInstance_options, "f").local = __classPrivateFieldGet(this, _YargsInstance_options, "f").local.filter((l2) => globals.indexOf(l2) === -1);
    } else {
      globals.forEach((g2) => {
        if (!__classPrivateFieldGet(this, _YargsInstance_options, "f").local.includes(g2))
          __classPrivateFieldGet(this, _YargsInstance_options, "f").local.push(g2);
      });
    }
    return this;
  }
  group(opts, groupName) {
    argsert("<string|array> <string>", [opts, groupName], arguments.length);
    const existing = __classPrivateFieldGet(this, _YargsInstance_preservedGroups, "f")[groupName] || __classPrivateFieldGet(this, _YargsInstance_groups, "f")[groupName];
    if (__classPrivateFieldGet(this, _YargsInstance_preservedGroups, "f")[groupName]) {
      delete __classPrivateFieldGet(this, _YargsInstance_preservedGroups, "f")[groupName];
    }
    const seen = {};
    __classPrivateFieldGet(this, _YargsInstance_groups, "f")[groupName] = (existing || []).concat(opts).filter((key) => {
      if (seen[key])
        return false;
      return seen[key] = true;
    });
    return this;
  }
  hide(key) {
    argsert("<string>", [key], arguments.length);
    __classPrivateFieldGet(this, _YargsInstance_options, "f").hiddenOptions.push(key);
    return this;
  }
  implies(key, value) {
    argsert("<string|object> [number|string|array]", [key, value], arguments.length);
    __classPrivateFieldGet(this, _YargsInstance_validation, "f").implies(key, value);
    return this;
  }
  locale(locale) {
    argsert("[string]", [locale], arguments.length);
    if (locale === void 0) {
      this[kGuessLocale]();
      return __classPrivateFieldGet(this, _YargsInstance_shim, "f").y18n.getLocale();
    }
    __classPrivateFieldSet(this, _YargsInstance_detectLocale, false, "f");
    __classPrivateFieldGet(this, _YargsInstance_shim, "f").y18n.setLocale(locale);
    return this;
  }
  middleware(callback, applyBeforeValidation, global2) {
    return __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, "f").addMiddleware(callback, !!applyBeforeValidation, global2);
  }
  nargs(key, value) {
    argsert("<string|object|array> [number]", [key, value], arguments.length);
    this[kPopulateParserHintSingleValueDictionary](this.nargs.bind(this), "narg", key, value);
    return this;
  }
  normalize(keys) {
    argsert("<array|string>", [keys], arguments.length);
    this[kPopulateParserHintArray]("normalize", keys);
    return this;
  }
  number(keys) {
    argsert("<array|string>", [keys], arguments.length);
    this[kPopulateParserHintArray]("number", keys);
    this[kTrackManuallySetKeys](keys);
    return this;
  }
  option(key, opt) {
    argsert("<string|object> [object]", [key, opt], arguments.length);
    if (typeof key === "object") {
      Object.keys(key).forEach((k2) => {
        this.options(k2, key[k2]);
      });
    } else {
      if (typeof opt !== "object") {
        opt = {};
      }
      this[kTrackManuallySetKeys](key);
      if (__classPrivateFieldGet(this, _YargsInstance_versionOpt, "f") && (key === "version" || (opt === null || opt === void 0 ? void 0 : opt.alias) === "version")) {
        this[kEmitWarning]([
          '"version" is a reserved word.',
          "Please do one of the following:",
          '- Disable version with `yargs.version(false)` if using "version" as an option',
          "- Use the built-in `yargs.version` method instead (if applicable)",
          "- Use a different option key",
          "https://yargs.js.org/docs/#api-reference-version"
        ].join("\n"), void 0, "versionWarning");
      }
      __classPrivateFieldGet(this, _YargsInstance_options, "f").key[key] = true;
      if (opt.alias)
        this.alias(key, opt.alias);
      const deprecate = opt.deprecate || opt.deprecated;
      if (deprecate) {
        this.deprecateOption(key, deprecate);
      }
      const demand = opt.demand || opt.required || opt.require;
      if (demand) {
        this.demand(key, demand);
      }
      if (opt.demandOption) {
        this.demandOption(key, typeof opt.demandOption === "string" ? opt.demandOption : void 0);
      }
      if (opt.conflicts) {
        this.conflicts(key, opt.conflicts);
      }
      if ("default" in opt) {
        this.default(key, opt.default);
      }
      if (opt.implies !== void 0) {
        this.implies(key, opt.implies);
      }
      if (opt.nargs !== void 0) {
        this.nargs(key, opt.nargs);
      }
      if (opt.config) {
        this.config(key, opt.configParser);
      }
      if (opt.normalize) {
        this.normalize(key);
      }
      if (opt.choices) {
        this.choices(key, opt.choices);
      }
      if (opt.coerce) {
        this.coerce(key, opt.coerce);
      }
      if (opt.group) {
        this.group(key, opt.group);
      }
      if (opt.boolean || opt.type === "boolean") {
        this.boolean(key);
        if (opt.alias)
          this.boolean(opt.alias);
      }
      if (opt.array || opt.type === "array") {
        this.array(key);
        if (opt.alias)
          this.array(opt.alias);
      }
      if (opt.number || opt.type === "number") {
        this.number(key);
        if (opt.alias)
          this.number(opt.alias);
      }
      if (opt.string || opt.type === "string") {
        this.string(key);
        if (opt.alias)
          this.string(opt.alias);
      }
      if (opt.count || opt.type === "count") {
        this.count(key);
      }
      if (typeof opt.global === "boolean") {
        this.global(key, opt.global);
      }
      if (opt.defaultDescription) {
        __classPrivateFieldGet(this, _YargsInstance_options, "f").defaultDescription[key] = opt.defaultDescription;
      }
      if (opt.skipValidation) {
        this.skipValidation(key);
      }
      const desc = opt.describe || opt.description || opt.desc;
      const descriptions = __classPrivateFieldGet(this, _YargsInstance_usage, "f").getDescriptions();
      if (!Object.prototype.hasOwnProperty.call(descriptions, key) || typeof desc === "string") {
        this.describe(key, desc);
      }
      if (opt.hidden) {
        this.hide(key);
      }
      if (opt.requiresArg) {
        this.requiresArg(key);
      }
    }
    return this;
  }
  options(key, opt) {
    return this.option(key, opt);
  }
  parse(args, shortCircuit, _parseFn) {
    argsert("[string|array] [function|boolean|object] [function]", [args, shortCircuit, _parseFn], arguments.length);
    this[kFreeze]();
    if (typeof args === "undefined") {
      args = __classPrivateFieldGet(this, _YargsInstance_processArgs, "f");
    }
    if (typeof shortCircuit === "object") {
      __classPrivateFieldSet(this, _YargsInstance_parseContext, shortCircuit, "f");
      shortCircuit = _parseFn;
    }
    if (typeof shortCircuit === "function") {
      __classPrivateFieldSet(this, _YargsInstance_parseFn, shortCircuit, "f");
      shortCircuit = false;
    }
    if (!shortCircuit)
      __classPrivateFieldSet(this, _YargsInstance_processArgs, args, "f");
    if (__classPrivateFieldGet(this, _YargsInstance_parseFn, "f"))
      __classPrivateFieldSet(this, _YargsInstance_exitProcess, false, "f");
    const parsed = this[kRunYargsParserAndExecuteCommands](args, !!shortCircuit);
    const tmpParsed = this.parsed;
    __classPrivateFieldGet(this, _YargsInstance_completion, "f").setParsed(this.parsed);
    if (isPromise(parsed)) {
      return parsed.then((argv) => {
        if (__classPrivateFieldGet(this, _YargsInstance_parseFn, "f"))
          __classPrivateFieldGet(this, _YargsInstance_parseFn, "f").call(this, __classPrivateFieldGet(this, _YargsInstance_exitError, "f"), argv, __classPrivateFieldGet(this, _YargsInstance_output, "f"));
        return argv;
      }).catch((err) => {
        if (__classPrivateFieldGet(this, _YargsInstance_parseFn, "f")) {
          __classPrivateFieldGet(this, _YargsInstance_parseFn, "f")(err, this.parsed.argv, __classPrivateFieldGet(this, _YargsInstance_output, "f"));
        }
        throw err;
      }).finally(() => {
        this[kUnfreeze]();
        this.parsed = tmpParsed;
      });
    } else {
      if (__classPrivateFieldGet(this, _YargsInstance_parseFn, "f"))
        __classPrivateFieldGet(this, _YargsInstance_parseFn, "f").call(this, __classPrivateFieldGet(this, _YargsInstance_exitError, "f"), parsed, __classPrivateFieldGet(this, _YargsInstance_output, "f"));
      this[kUnfreeze]();
      this.parsed = tmpParsed;
    }
    return parsed;
  }
  parseAsync(args, shortCircuit, _parseFn) {
    const maybePromise = this.parse(args, shortCircuit, _parseFn);
    return !isPromise(maybePromise) ? Promise.resolve(maybePromise) : maybePromise;
  }
  parseSync(args, shortCircuit, _parseFn) {
    const maybePromise = this.parse(args, shortCircuit, _parseFn);
    if (isPromise(maybePromise)) {
      throw new YError(".parseSync() must not be used with asynchronous builders, handlers, or middleware");
    }
    return maybePromise;
  }
  parserConfiguration(config) {
    argsert("<object>", [config], arguments.length);
    __classPrivateFieldSet(this, _YargsInstance_parserConfig, config, "f");
    return this;
  }
  pkgConf(key, rootPath) {
    argsert("<string> [string]", [key, rootPath], arguments.length);
    let conf = null;
    const obj = this[kPkgUp](rootPath || __classPrivateFieldGet(this, _YargsInstance_cwd, "f"));
    if (obj[key] && typeof obj[key] === "object") {
      conf = applyExtends(obj[key], rootPath || __classPrivateFieldGet(this, _YargsInstance_cwd, "f"), this[kGetParserConfiguration]()["deep-merge-config"] || false, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
      __classPrivateFieldGet(this, _YargsInstance_options, "f").configObjects = (__classPrivateFieldGet(this, _YargsInstance_options, "f").configObjects || []).concat(conf);
    }
    return this;
  }
  positional(key, opts) {
    argsert("<string> <object>", [key, opts], arguments.length);
    const supportedOpts = [
      "default",
      "defaultDescription",
      "implies",
      "normalize",
      "choices",
      "conflicts",
      "coerce",
      "type",
      "describe",
      "desc",
      "description",
      "alias"
    ];
    opts = objFilter(opts, (k2, v2) => {
      if (k2 === "type" && !["string", "number", "boolean"].includes(v2))
        return false;
      return supportedOpts.includes(k2);
    });
    const fullCommand = __classPrivateFieldGet(this, _YargsInstance_context, "f").fullCommands[__classPrivateFieldGet(this, _YargsInstance_context, "f").fullCommands.length - 1];
    const parseOptions = fullCommand ? __classPrivateFieldGet(this, _YargsInstance_command, "f").cmdToParseOptions(fullCommand) : {
      array: [],
      alias: {},
      default: {},
      demand: {}
    };
    objectKeys(parseOptions).forEach((pk) => {
      const parseOption = parseOptions[pk];
      if (Array.isArray(parseOption)) {
        if (parseOption.indexOf(key) !== -1)
          opts[pk] = true;
      } else {
        if (parseOption[key] && !(pk in opts))
          opts[pk] = parseOption[key];
      }
    });
    this.group(key, __classPrivateFieldGet(this, _YargsInstance_usage, "f").getPositionalGroupName());
    return this.option(key, opts);
  }
  recommendCommands(recommend = true) {
    argsert("[boolean]", [recommend], arguments.length);
    __classPrivateFieldSet(this, _YargsInstance_recommendCommands, recommend, "f");
    return this;
  }
  required(keys, max, msg) {
    return this.demand(keys, max, msg);
  }
  require(keys, max, msg) {
    return this.demand(keys, max, msg);
  }
  requiresArg(keys) {
    argsert("<array|string|object> [number]", [keys], arguments.length);
    if (typeof keys === "string" && __classPrivateFieldGet(this, _YargsInstance_options, "f").narg[keys]) {
      return this;
    } else {
      this[kPopulateParserHintSingleValueDictionary](this.requiresArg.bind(this), "narg", keys, NaN);
    }
    return this;
  }
  showCompletionScript($0, cmd) {
    argsert("[string] [string]", [$0, cmd], arguments.length);
    $0 = $0 || this.$0;
    __classPrivateFieldGet(this, _YargsInstance_logger, "f").log(__classPrivateFieldGet(this, _YargsInstance_completion, "f").generateCompletionScript($0, cmd || __classPrivateFieldGet(this, _YargsInstance_completionCommand, "f") || "completion"));
    return this;
  }
  showHelp(level) {
    argsert("[string|function]", [level], arguments.length);
    __classPrivateFieldSet(this, _YargsInstance_hasOutput, true, "f");
    if (!__classPrivateFieldGet(this, _YargsInstance_usage, "f").hasCachedHelpMessage()) {
      if (!this.parsed) {
        const parse7 = this[kRunYargsParserAndExecuteCommands](__classPrivateFieldGet(this, _YargsInstance_processArgs, "f"), void 0, void 0, 0, true);
        if (isPromise(parse7)) {
          parse7.then(() => {
            __classPrivateFieldGet(this, _YargsInstance_usage, "f").showHelp(level);
          });
          return this;
        }
      }
      const builderResponse = __classPrivateFieldGet(this, _YargsInstance_command, "f").runDefaultBuilderOn(this);
      if (isPromise(builderResponse)) {
        builderResponse.then(() => {
          __classPrivateFieldGet(this, _YargsInstance_usage, "f").showHelp(level);
        });
        return this;
      }
    }
    __classPrivateFieldGet(this, _YargsInstance_usage, "f").showHelp(level);
    return this;
  }
  scriptName(scriptName) {
    this.customScriptName = true;
    this.$0 = scriptName;
    return this;
  }
  showHelpOnFail(enabled, message) {
    argsert("[boolean|string] [string]", [enabled, message], arguments.length);
    __classPrivateFieldGet(this, _YargsInstance_usage, "f").showHelpOnFail(enabled, message);
    return this;
  }
  showVersion(level) {
    argsert("[string|function]", [level], arguments.length);
    __classPrivateFieldGet(this, _YargsInstance_usage, "f").showVersion(level);
    return this;
  }
  skipValidation(keys) {
    argsert("<array|string>", [keys], arguments.length);
    this[kPopulateParserHintArray]("skipValidation", keys);
    return this;
  }
  strict(enabled) {
    argsert("[boolean]", [enabled], arguments.length);
    __classPrivateFieldSet(this, _YargsInstance_strict, enabled !== false, "f");
    return this;
  }
  strictCommands(enabled) {
    argsert("[boolean]", [enabled], arguments.length);
    __classPrivateFieldSet(this, _YargsInstance_strictCommands, enabled !== false, "f");
    return this;
  }
  strictOptions(enabled) {
    argsert("[boolean]", [enabled], arguments.length);
    __classPrivateFieldSet(this, _YargsInstance_strictOptions, enabled !== false, "f");
    return this;
  }
  string(keys) {
    argsert("<array|string>", [keys], arguments.length);
    this[kPopulateParserHintArray]("string", keys);
    this[kTrackManuallySetKeys](keys);
    return this;
  }
  terminalWidth() {
    argsert([], 0);
    return __classPrivateFieldGet(this, _YargsInstance_shim, "f").process.stdColumns;
  }
  updateLocale(obj) {
    return this.updateStrings(obj);
  }
  updateStrings(obj) {
    argsert("<object>", [obj], arguments.length);
    __classPrivateFieldSet(this, _YargsInstance_detectLocale, false, "f");
    __classPrivateFieldGet(this, _YargsInstance_shim, "f").y18n.updateLocale(obj);
    return this;
  }
  usage(msg, description, builder, handler30) {
    argsert("<string|null|undefined> [string|boolean] [function|object] [function]", [msg, description, builder, handler30], arguments.length);
    if (description !== void 0) {
      assertNotStrictEqual(msg, null, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
      if ((msg || "").match(/^\$0( |$)/)) {
        return this.command(msg, description, builder, handler30);
      } else {
        throw new YError(".usage() description must start with $0 if being used as alias for .command()");
      }
    } else {
      __classPrivateFieldGet(this, _YargsInstance_usage, "f").usage(msg);
      return this;
    }
  }
  usageConfiguration(config) {
    argsert("<object>", [config], arguments.length);
    __classPrivateFieldSet(this, _YargsInstance_usageConfig, config, "f");
    return this;
  }
  version(opt, msg, ver) {
    const defaultVersionOpt = "version";
    argsert("[boolean|string] [string] [string]", [opt, msg, ver], arguments.length);
    if (__classPrivateFieldGet(this, _YargsInstance_versionOpt, "f")) {
      this[kDeleteFromParserHintObject](__classPrivateFieldGet(this, _YargsInstance_versionOpt, "f"));
      __classPrivateFieldGet(this, _YargsInstance_usage, "f").version(void 0);
      __classPrivateFieldSet(this, _YargsInstance_versionOpt, null, "f");
    }
    if (arguments.length === 0) {
      ver = this[kGuessVersion]();
      opt = defaultVersionOpt;
    } else if (arguments.length === 1) {
      if (opt === false) {
        return this;
      }
      ver = opt;
      opt = defaultVersionOpt;
    } else if (arguments.length === 2) {
      ver = msg;
      msg = void 0;
    }
    __classPrivateFieldSet(this, _YargsInstance_versionOpt, typeof opt === "string" ? opt : defaultVersionOpt, "f");
    msg = msg || __classPrivateFieldGet(this, _YargsInstance_usage, "f").deferY18nLookup("Show version number");
    __classPrivateFieldGet(this, _YargsInstance_usage, "f").version(ver || void 0);
    this.boolean(__classPrivateFieldGet(this, _YargsInstance_versionOpt, "f"));
    this.describe(__classPrivateFieldGet(this, _YargsInstance_versionOpt, "f"), msg);
    return this;
  }
  wrap(cols) {
    argsert("<number|null|undefined>", [cols], arguments.length);
    __classPrivateFieldGet(this, _YargsInstance_usage, "f").wrap(cols);
    return this;
  }
  [(_YargsInstance_command = /* @__PURE__ */ new WeakMap(), _YargsInstance_cwd = /* @__PURE__ */ new WeakMap(), _YargsInstance_context = /* @__PURE__ */ new WeakMap(), _YargsInstance_completion = /* @__PURE__ */ new WeakMap(), _YargsInstance_completionCommand = /* @__PURE__ */ new WeakMap(), _YargsInstance_defaultShowHiddenOpt = /* @__PURE__ */ new WeakMap(), _YargsInstance_exitError = /* @__PURE__ */ new WeakMap(), _YargsInstance_detectLocale = /* @__PURE__ */ new WeakMap(), _YargsInstance_emittedWarnings = /* @__PURE__ */ new WeakMap(), _YargsInstance_exitProcess = /* @__PURE__ */ new WeakMap(), _YargsInstance_frozens = /* @__PURE__ */ new WeakMap(), _YargsInstance_globalMiddleware = /* @__PURE__ */ new WeakMap(), _YargsInstance_groups = /* @__PURE__ */ new WeakMap(), _YargsInstance_hasOutput = /* @__PURE__ */ new WeakMap(), _YargsInstance_helpOpt = /* @__PURE__ */ new WeakMap(), _YargsInstance_isGlobalContext = /* @__PURE__ */ new WeakMap(), _YargsInstance_logger = /* @__PURE__ */ new WeakMap(), _YargsInstance_output = /* @__PURE__ */ new WeakMap(), _YargsInstance_options = /* @__PURE__ */ new WeakMap(), _YargsInstance_parentRequire = /* @__PURE__ */ new WeakMap(), _YargsInstance_parserConfig = /* @__PURE__ */ new WeakMap(), _YargsInstance_parseFn = /* @__PURE__ */ new WeakMap(), _YargsInstance_parseContext = /* @__PURE__ */ new WeakMap(), _YargsInstance_pkgs = /* @__PURE__ */ new WeakMap(), _YargsInstance_preservedGroups = /* @__PURE__ */ new WeakMap(), _YargsInstance_processArgs = /* @__PURE__ */ new WeakMap(), _YargsInstance_recommendCommands = /* @__PURE__ */ new WeakMap(), _YargsInstance_shim = /* @__PURE__ */ new WeakMap(), _YargsInstance_strict = /* @__PURE__ */ new WeakMap(), _YargsInstance_strictCommands = /* @__PURE__ */ new WeakMap(), _YargsInstance_strictOptions = /* @__PURE__ */ new WeakMap(), _YargsInstance_usage = /* @__PURE__ */ new WeakMap(), _YargsInstance_usageConfig = /* @__PURE__ */ new WeakMap(), _YargsInstance_versionOpt = /* @__PURE__ */ new WeakMap(), _YargsInstance_validation = /* @__PURE__ */ new WeakMap(), kCopyDoubleDash)](argv) {
    if (!argv._ || !argv["--"])
      return argv;
    argv._.push.apply(argv._, argv["--"]);
    try {
      delete argv["--"];
    } catch (_err) {
    }
    return argv;
  }
  [kCreateLogger]() {
    return {
      log: (...args) => {
        if (!this[kHasParseCallback]())
          console.log(...args);
        __classPrivateFieldSet(this, _YargsInstance_hasOutput, true, "f");
        if (__classPrivateFieldGet(this, _YargsInstance_output, "f").length)
          __classPrivateFieldSet(this, _YargsInstance_output, __classPrivateFieldGet(this, _YargsInstance_output, "f") + "\n", "f");
        __classPrivateFieldSet(this, _YargsInstance_output, __classPrivateFieldGet(this, _YargsInstance_output, "f") + args.join(" "), "f");
      },
      error: (...args) => {
        if (!this[kHasParseCallback]())
          console.error(...args);
        __classPrivateFieldSet(this, _YargsInstance_hasOutput, true, "f");
        if (__classPrivateFieldGet(this, _YargsInstance_output, "f").length)
          __classPrivateFieldSet(this, _YargsInstance_output, __classPrivateFieldGet(this, _YargsInstance_output, "f") + "\n", "f");
        __classPrivateFieldSet(this, _YargsInstance_output, __classPrivateFieldGet(this, _YargsInstance_output, "f") + args.join(" "), "f");
      }
    };
  }
  [kDeleteFromParserHintObject](optionKey) {
    objectKeys(__classPrivateFieldGet(this, _YargsInstance_options, "f")).forEach((hintKey) => {
      if (((key) => key === "configObjects")(hintKey))
        return;
      const hint = __classPrivateFieldGet(this, _YargsInstance_options, "f")[hintKey];
      if (Array.isArray(hint)) {
        if (hint.includes(optionKey))
          hint.splice(hint.indexOf(optionKey), 1);
      } else if (typeof hint === "object") {
        delete hint[optionKey];
      }
    });
    delete __classPrivateFieldGet(this, _YargsInstance_usage, "f").getDescriptions()[optionKey];
  }
  [kEmitWarning](warning, type, deduplicationId) {
    if (!__classPrivateFieldGet(this, _YargsInstance_emittedWarnings, "f")[deduplicationId]) {
      __classPrivateFieldGet(this, _YargsInstance_shim, "f").process.emitWarning(warning, type);
      __classPrivateFieldGet(this, _YargsInstance_emittedWarnings, "f")[deduplicationId] = true;
    }
  }
  [kFreeze]() {
    __classPrivateFieldGet(this, _YargsInstance_frozens, "f").push({
      options: __classPrivateFieldGet(this, _YargsInstance_options, "f"),
      configObjects: __classPrivateFieldGet(this, _YargsInstance_options, "f").configObjects.slice(0),
      exitProcess: __classPrivateFieldGet(this, _YargsInstance_exitProcess, "f"),
      groups: __classPrivateFieldGet(this, _YargsInstance_groups, "f"),
      strict: __classPrivateFieldGet(this, _YargsInstance_strict, "f"),
      strictCommands: __classPrivateFieldGet(this, _YargsInstance_strictCommands, "f"),
      strictOptions: __classPrivateFieldGet(this, _YargsInstance_strictOptions, "f"),
      completionCommand: __classPrivateFieldGet(this, _YargsInstance_completionCommand, "f"),
      output: __classPrivateFieldGet(this, _YargsInstance_output, "f"),
      exitError: __classPrivateFieldGet(this, _YargsInstance_exitError, "f"),
      hasOutput: __classPrivateFieldGet(this, _YargsInstance_hasOutput, "f"),
      parsed: this.parsed,
      parseFn: __classPrivateFieldGet(this, _YargsInstance_parseFn, "f"),
      parseContext: __classPrivateFieldGet(this, _YargsInstance_parseContext, "f")
    });
    __classPrivateFieldGet(this, _YargsInstance_usage, "f").freeze();
    __classPrivateFieldGet(this, _YargsInstance_validation, "f").freeze();
    __classPrivateFieldGet(this, _YargsInstance_command, "f").freeze();
    __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, "f").freeze();
  }
  [kGetDollarZero]() {
    let $0 = "";
    let default$0;
    if (/\b(node|iojs|electron)(\.exe)?$/.test(__classPrivateFieldGet(this, _YargsInstance_shim, "f").process.argv()[0])) {
      default$0 = __classPrivateFieldGet(this, _YargsInstance_shim, "f").process.argv().slice(1, 2);
    } else {
      default$0 = __classPrivateFieldGet(this, _YargsInstance_shim, "f").process.argv().slice(0, 1);
    }
    $0 = default$0.map((x2) => {
      const b2 = this[kRebase](__classPrivateFieldGet(this, _YargsInstance_cwd, "f"), x2);
      return x2.match(/^(\/|([a-zA-Z]:)?\\)/) && b2.length < x2.length ? b2 : x2;
    }).join(" ").trim();
    if (__classPrivateFieldGet(this, _YargsInstance_shim, "f").getEnv("_") && __classPrivateFieldGet(this, _YargsInstance_shim, "f").getProcessArgvBin() === __classPrivateFieldGet(this, _YargsInstance_shim, "f").getEnv("_")) {
      $0 = __classPrivateFieldGet(this, _YargsInstance_shim, "f").getEnv("_").replace(`${__classPrivateFieldGet(this, _YargsInstance_shim, "f").path.dirname(__classPrivateFieldGet(this, _YargsInstance_shim, "f").process.execPath())}/`, "");
    }
    return $0;
  }
  [kGetParserConfiguration]() {
    return __classPrivateFieldGet(this, _YargsInstance_parserConfig, "f");
  }
  [kGetUsageConfiguration]() {
    return __classPrivateFieldGet(this, _YargsInstance_usageConfig, "f");
  }
  [kGuessLocale]() {
    if (!__classPrivateFieldGet(this, _YargsInstance_detectLocale, "f"))
      return;
    const locale = __classPrivateFieldGet(this, _YargsInstance_shim, "f").getEnv("LC_ALL") || __classPrivateFieldGet(this, _YargsInstance_shim, "f").getEnv("LC_MESSAGES") || __classPrivateFieldGet(this, _YargsInstance_shim, "f").getEnv("LANG") || __classPrivateFieldGet(this, _YargsInstance_shim, "f").getEnv("LANGUAGE") || "en_US";
    this.locale(locale.replace(/[.:].*/, ""));
  }
  [kGuessVersion]() {
    const obj = this[kPkgUp]();
    return obj.version || "unknown";
  }
  [kParsePositionalNumbers](argv) {
    const args = argv["--"] ? argv["--"] : argv._;
    for (let i = 0, arg; (arg = args[i]) !== void 0; i++) {
      if (__classPrivateFieldGet(this, _YargsInstance_shim, "f").Parser.looksLikeNumber(arg) && Number.isSafeInteger(Math.floor(parseFloat(`${arg}`)))) {
        args[i] = Number(arg);
      }
    }
    return argv;
  }
  [kPkgUp](rootPath) {
    const npath = rootPath || "*";
    if (__classPrivateFieldGet(this, _YargsInstance_pkgs, "f")[npath])
      return __classPrivateFieldGet(this, _YargsInstance_pkgs, "f")[npath];
    let obj = {};
    try {
      let startDir = rootPath || __classPrivateFieldGet(this, _YargsInstance_shim, "f").mainFilename;
      if (!rootPath && __classPrivateFieldGet(this, _YargsInstance_shim, "f").path.extname(startDir)) {
        startDir = __classPrivateFieldGet(this, _YargsInstance_shim, "f").path.dirname(startDir);
      }
      const pkgJsonPath = __classPrivateFieldGet(this, _YargsInstance_shim, "f").findUp(startDir, (dir, names) => {
        if (names.includes("package.json")) {
          return "package.json";
        } else {
          return void 0;
        }
      });
      assertNotStrictEqual(pkgJsonPath, void 0, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
      obj = JSON.parse(__classPrivateFieldGet(this, _YargsInstance_shim, "f").readFileSync(pkgJsonPath, "utf8"));
    } catch (_noop) {
    }
    __classPrivateFieldGet(this, _YargsInstance_pkgs, "f")[npath] = obj || {};
    return __classPrivateFieldGet(this, _YargsInstance_pkgs, "f")[npath];
  }
  [kPopulateParserHintArray](type, keys) {
    keys = [].concat(keys);
    keys.forEach((key) => {
      key = this[kSanitizeKey](key);
      __classPrivateFieldGet(this, _YargsInstance_options, "f")[type].push(key);
    });
  }
  [kPopulateParserHintSingleValueDictionary](builder, type, key, value) {
    this[kPopulateParserHintDictionary](builder, type, key, value, (type2, key2, value2) => {
      __classPrivateFieldGet(this, _YargsInstance_options, "f")[type2][key2] = value2;
    });
  }
  [kPopulateParserHintArrayDictionary](builder, type, key, value) {
    this[kPopulateParserHintDictionary](builder, type, key, value, (type2, key2, value2) => {
      __classPrivateFieldGet(this, _YargsInstance_options, "f")[type2][key2] = (__classPrivateFieldGet(this, _YargsInstance_options, "f")[type2][key2] || []).concat(value2);
    });
  }
  [kPopulateParserHintDictionary](builder, type, key, value, singleKeyHandler) {
    if (Array.isArray(key)) {
      key.forEach((k2) => {
        builder(k2, value);
      });
    } else if (((key2) => typeof key2 === "object")(key)) {
      for (const k2 of objectKeys(key)) {
        builder(k2, key[k2]);
      }
    } else {
      singleKeyHandler(type, this[kSanitizeKey](key), value);
    }
  }
  [kSanitizeKey](key) {
    if (key === "__proto__")
      return "___proto___";
    return key;
  }
  [kSetKey](key, set) {
    this[kPopulateParserHintSingleValueDictionary](this[kSetKey].bind(this), "key", key, set);
    return this;
  }
  [kUnfreeze]() {
    var _a2, _b2, _c2, _d, _e, _f, _g, _h, _j, _k, _l, _m;
    const frozen = __classPrivateFieldGet(this, _YargsInstance_frozens, "f").pop();
    assertNotStrictEqual(frozen, void 0, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
    let configObjects;
    _a2 = this, _b2 = this, _c2 = this, _d = this, _e = this, _f = this, _g = this, _h = this, _j = this, _k = this, _l = this, _m = this, {
      options: { set value(_o) {
        __classPrivateFieldSet(_a2, _YargsInstance_options, _o, "f");
      } }.value,
      configObjects,
      exitProcess: { set value(_o) {
        __classPrivateFieldSet(_b2, _YargsInstance_exitProcess, _o, "f");
      } }.value,
      groups: { set value(_o) {
        __classPrivateFieldSet(_c2, _YargsInstance_groups, _o, "f");
      } }.value,
      output: { set value(_o) {
        __classPrivateFieldSet(_d, _YargsInstance_output, _o, "f");
      } }.value,
      exitError: { set value(_o) {
        __classPrivateFieldSet(_e, _YargsInstance_exitError, _o, "f");
      } }.value,
      hasOutput: { set value(_o) {
        __classPrivateFieldSet(_f, _YargsInstance_hasOutput, _o, "f");
      } }.value,
      parsed: this.parsed,
      strict: { set value(_o) {
        __classPrivateFieldSet(_g, _YargsInstance_strict, _o, "f");
      } }.value,
      strictCommands: { set value(_o) {
        __classPrivateFieldSet(_h, _YargsInstance_strictCommands, _o, "f");
      } }.value,
      strictOptions: { set value(_o) {
        __classPrivateFieldSet(_j, _YargsInstance_strictOptions, _o, "f");
      } }.value,
      completionCommand: { set value(_o) {
        __classPrivateFieldSet(_k, _YargsInstance_completionCommand, _o, "f");
      } }.value,
      parseFn: { set value(_o) {
        __classPrivateFieldSet(_l, _YargsInstance_parseFn, _o, "f");
      } }.value,
      parseContext: { set value(_o) {
        __classPrivateFieldSet(_m, _YargsInstance_parseContext, _o, "f");
      } }.value
    } = frozen;
    __classPrivateFieldGet(this, _YargsInstance_options, "f").configObjects = configObjects;
    __classPrivateFieldGet(this, _YargsInstance_usage, "f").unfreeze();
    __classPrivateFieldGet(this, _YargsInstance_validation, "f").unfreeze();
    __classPrivateFieldGet(this, _YargsInstance_command, "f").unfreeze();
    __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, "f").unfreeze();
  }
  [kValidateAsync](validation2, argv) {
    return maybeAsyncResult(argv, (result) => {
      validation2(result);
      return result;
    });
  }
  getInternalMethods() {
    return {
      getCommandInstance: this[kGetCommandInstance].bind(this),
      getContext: this[kGetContext].bind(this),
      getHasOutput: this[kGetHasOutput].bind(this),
      getLoggerInstance: this[kGetLoggerInstance].bind(this),
      getParseContext: this[kGetParseContext].bind(this),
      getParserConfiguration: this[kGetParserConfiguration].bind(this),
      getUsageConfiguration: this[kGetUsageConfiguration].bind(this),
      getUsageInstance: this[kGetUsageInstance].bind(this),
      getValidationInstance: this[kGetValidationInstance].bind(this),
      hasParseCallback: this[kHasParseCallback].bind(this),
      isGlobalContext: this[kIsGlobalContext].bind(this),
      postProcess: this[kPostProcess].bind(this),
      reset: this[kReset].bind(this),
      runValidation: this[kRunValidation].bind(this),
      runYargsParserAndExecuteCommands: this[kRunYargsParserAndExecuteCommands].bind(this),
      setHasOutput: this[kSetHasOutput].bind(this)
    };
  }
  [kGetCommandInstance]() {
    return __classPrivateFieldGet(this, _YargsInstance_command, "f");
  }
  [kGetContext]() {
    return __classPrivateFieldGet(this, _YargsInstance_context, "f");
  }
  [kGetHasOutput]() {
    return __classPrivateFieldGet(this, _YargsInstance_hasOutput, "f");
  }
  [kGetLoggerInstance]() {
    return __classPrivateFieldGet(this, _YargsInstance_logger, "f");
  }
  [kGetParseContext]() {
    return __classPrivateFieldGet(this, _YargsInstance_parseContext, "f") || {};
  }
  [kGetUsageInstance]() {
    return __classPrivateFieldGet(this, _YargsInstance_usage, "f");
  }
  [kGetValidationInstance]() {
    return __classPrivateFieldGet(this, _YargsInstance_validation, "f");
  }
  [kHasParseCallback]() {
    return !!__classPrivateFieldGet(this, _YargsInstance_parseFn, "f");
  }
  [kIsGlobalContext]() {
    return __classPrivateFieldGet(this, _YargsInstance_isGlobalContext, "f");
  }
  [kPostProcess](argv, populateDoubleDash, calledFromCommand, runGlobalMiddleware) {
    if (calledFromCommand)
      return argv;
    if (isPromise(argv))
      return argv;
    if (!populateDoubleDash) {
      argv = this[kCopyDoubleDash](argv);
    }
    const parsePositionalNumbers = this[kGetParserConfiguration]()["parse-positional-numbers"] || this[kGetParserConfiguration]()["parse-positional-numbers"] === void 0;
    if (parsePositionalNumbers) {
      argv = this[kParsePositionalNumbers](argv);
    }
    if (runGlobalMiddleware) {
      argv = applyMiddleware(argv, this, __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, "f").getMiddleware(), false);
    }
    return argv;
  }
  [kReset](aliases2 = {}) {
    __classPrivateFieldSet(this, _YargsInstance_options, __classPrivateFieldGet(this, _YargsInstance_options, "f") || {}, "f");
    const tmpOptions = {};
    tmpOptions.local = __classPrivateFieldGet(this, _YargsInstance_options, "f").local || [];
    tmpOptions.configObjects = __classPrivateFieldGet(this, _YargsInstance_options, "f").configObjects || [];
    const localLookup = {};
    tmpOptions.local.forEach((l2) => {
      localLookup[l2] = true;
      (aliases2[l2] || []).forEach((a) => {
        localLookup[a] = true;
      });
    });
    Object.assign(__classPrivateFieldGet(this, _YargsInstance_preservedGroups, "f"), Object.keys(__classPrivateFieldGet(this, _YargsInstance_groups, "f")).reduce((acc, groupName) => {
      const keys = __classPrivateFieldGet(this, _YargsInstance_groups, "f")[groupName].filter((key) => !(key in localLookup));
      if (keys.length > 0) {
        acc[groupName] = keys;
      }
      return acc;
    }, {}));
    __classPrivateFieldSet(this, _YargsInstance_groups, {}, "f");
    const arrayOptions = [
      "array",
      "boolean",
      "string",
      "skipValidation",
      "count",
      "normalize",
      "number",
      "hiddenOptions"
    ];
    const objectOptions = [
      "narg",
      "key",
      "alias",
      "default",
      "defaultDescription",
      "config",
      "choices",
      "demandedOptions",
      "demandedCommands",
      "deprecatedOptions"
    ];
    arrayOptions.forEach((k2) => {
      tmpOptions[k2] = (__classPrivateFieldGet(this, _YargsInstance_options, "f")[k2] || []).filter((k3) => !localLookup[k3]);
    });
    objectOptions.forEach((k2) => {
      tmpOptions[k2] = objFilter(__classPrivateFieldGet(this, _YargsInstance_options, "f")[k2], (k3) => !localLookup[k3]);
    });
    tmpOptions.envPrefix = __classPrivateFieldGet(this, _YargsInstance_options, "f").envPrefix;
    __classPrivateFieldSet(this, _YargsInstance_options, tmpOptions, "f");
    __classPrivateFieldSet(this, _YargsInstance_usage, __classPrivateFieldGet(this, _YargsInstance_usage, "f") ? __classPrivateFieldGet(this, _YargsInstance_usage, "f").reset(localLookup) : usage(this, __classPrivateFieldGet(this, _YargsInstance_shim, "f")), "f");
    __classPrivateFieldSet(this, _YargsInstance_validation, __classPrivateFieldGet(this, _YargsInstance_validation, "f") ? __classPrivateFieldGet(this, _YargsInstance_validation, "f").reset(localLookup) : validation(this, __classPrivateFieldGet(this, _YargsInstance_usage, "f"), __classPrivateFieldGet(this, _YargsInstance_shim, "f")), "f");
    __classPrivateFieldSet(this, _YargsInstance_command, __classPrivateFieldGet(this, _YargsInstance_command, "f") ? __classPrivateFieldGet(this, _YargsInstance_command, "f").reset() : command(__classPrivateFieldGet(this, _YargsInstance_usage, "f"), __classPrivateFieldGet(this, _YargsInstance_validation, "f"), __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, "f"), __classPrivateFieldGet(this, _YargsInstance_shim, "f")), "f");
    if (!__classPrivateFieldGet(this, _YargsInstance_completion, "f"))
      __classPrivateFieldSet(this, _YargsInstance_completion, completion(this, __classPrivateFieldGet(this, _YargsInstance_usage, "f"), __classPrivateFieldGet(this, _YargsInstance_command, "f"), __classPrivateFieldGet(this, _YargsInstance_shim, "f")), "f");
    __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, "f").reset();
    __classPrivateFieldSet(this, _YargsInstance_completionCommand, null, "f");
    __classPrivateFieldSet(this, _YargsInstance_output, "", "f");
    __classPrivateFieldSet(this, _YargsInstance_exitError, null, "f");
    __classPrivateFieldSet(this, _YargsInstance_hasOutput, false, "f");
    this.parsed = false;
    return this;
  }
  [kRebase](base, dir) {
    return __classPrivateFieldGet(this, _YargsInstance_shim, "f").path.relative(base, dir);
  }
  [kRunYargsParserAndExecuteCommands](args, shortCircuit, calledFromCommand, commandIndex = 0, helpOnly = false) {
    let skipValidation = !!calledFromCommand || helpOnly;
    args = args || __classPrivateFieldGet(this, _YargsInstance_processArgs, "f");
    __classPrivateFieldGet(this, _YargsInstance_options, "f").__ = __classPrivateFieldGet(this, _YargsInstance_shim, "f").y18n.__;
    __classPrivateFieldGet(this, _YargsInstance_options, "f").configuration = this[kGetParserConfiguration]();
    const populateDoubleDash = !!__classPrivateFieldGet(this, _YargsInstance_options, "f").configuration["populate--"];
    const config = Object.assign({}, __classPrivateFieldGet(this, _YargsInstance_options, "f").configuration, {
      "populate--": true
    });
    const parsed = __classPrivateFieldGet(this, _YargsInstance_shim, "f").Parser.detailed(args, Object.assign({}, __classPrivateFieldGet(this, _YargsInstance_options, "f"), {
      configuration: { "parse-positional-numbers": false, ...config }
    }));
    const argv = Object.assign(parsed.argv, __classPrivateFieldGet(this, _YargsInstance_parseContext, "f"));
    let argvPromise = void 0;
    const aliases2 = parsed.aliases;
    let helpOptSet = false;
    let versionOptSet = false;
    Object.keys(argv).forEach((key) => {
      if (key === __classPrivateFieldGet(this, _YargsInstance_helpOpt, "f") && argv[key]) {
        helpOptSet = true;
      } else if (key === __classPrivateFieldGet(this, _YargsInstance_versionOpt, "f") && argv[key]) {
        versionOptSet = true;
      }
    });
    argv.$0 = this.$0;
    this.parsed = parsed;
    if (commandIndex === 0) {
      __classPrivateFieldGet(this, _YargsInstance_usage, "f").clearCachedHelpMessage();
    }
    try {
      this[kGuessLocale]();
      if (shortCircuit) {
        return this[kPostProcess](argv, populateDoubleDash, !!calledFromCommand, false);
      }
      if (__classPrivateFieldGet(this, _YargsInstance_helpOpt, "f")) {
        const helpCmds = [__classPrivateFieldGet(this, _YargsInstance_helpOpt, "f")].concat(aliases2[__classPrivateFieldGet(this, _YargsInstance_helpOpt, "f")] || []).filter((k2) => k2.length > 1);
        if (helpCmds.includes("" + argv._[argv._.length - 1])) {
          argv._.pop();
          helpOptSet = true;
        }
      }
      __classPrivateFieldSet(this, _YargsInstance_isGlobalContext, false, "f");
      const handlerKeys = __classPrivateFieldGet(this, _YargsInstance_command, "f").getCommands();
      const requestCompletions = __classPrivateFieldGet(this, _YargsInstance_completion, "f").completionKey in argv;
      const skipRecommendation = helpOptSet || requestCompletions || helpOnly;
      if (argv._.length) {
        if (handlerKeys.length) {
          let firstUnknownCommand;
          for (let i = commandIndex || 0, cmd; argv._[i] !== void 0; i++) {
            cmd = String(argv._[i]);
            if (handlerKeys.includes(cmd) && cmd !== __classPrivateFieldGet(this, _YargsInstance_completionCommand, "f")) {
              const innerArgv = __classPrivateFieldGet(this, _YargsInstance_command, "f").runCommand(cmd, this, parsed, i + 1, helpOnly, helpOptSet || versionOptSet || helpOnly);
              return this[kPostProcess](innerArgv, populateDoubleDash, !!calledFromCommand, false);
            } else if (!firstUnknownCommand && cmd !== __classPrivateFieldGet(this, _YargsInstance_completionCommand, "f")) {
              firstUnknownCommand = cmd;
              break;
            }
          }
          if (!__classPrivateFieldGet(this, _YargsInstance_command, "f").hasDefaultCommand() && __classPrivateFieldGet(this, _YargsInstance_recommendCommands, "f") && firstUnknownCommand && !skipRecommendation) {
            __classPrivateFieldGet(this, _YargsInstance_validation, "f").recommendCommands(firstUnknownCommand, handlerKeys);
          }
        }
        if (__classPrivateFieldGet(this, _YargsInstance_completionCommand, "f") && argv._.includes(__classPrivateFieldGet(this, _YargsInstance_completionCommand, "f")) && !requestCompletions) {
          if (__classPrivateFieldGet(this, _YargsInstance_exitProcess, "f"))
            setBlocking(true);
          this.showCompletionScript();
          this.exit(0);
        }
      }
      if (__classPrivateFieldGet(this, _YargsInstance_command, "f").hasDefaultCommand() && !skipRecommendation) {
        const innerArgv = __classPrivateFieldGet(this, _YargsInstance_command, "f").runCommand(null, this, parsed, 0, helpOnly, helpOptSet || versionOptSet || helpOnly);
        return this[kPostProcess](innerArgv, populateDoubleDash, !!calledFromCommand, false);
      }
      if (requestCompletions) {
        if (__classPrivateFieldGet(this, _YargsInstance_exitProcess, "f"))
          setBlocking(true);
        args = [].concat(args);
        const completionArgs = args.slice(args.indexOf(`--${__classPrivateFieldGet(this, _YargsInstance_completion, "f").completionKey}`) + 1);
        __classPrivateFieldGet(this, _YargsInstance_completion, "f").getCompletion(completionArgs, (err, completions) => {
          if (err)
            throw new YError(err.message);
          (completions || []).forEach((completion2) => {
            __classPrivateFieldGet(this, _YargsInstance_logger, "f").log(completion2);
          });
          this.exit(0);
        });
        return this[kPostProcess](argv, !populateDoubleDash, !!calledFromCommand, false);
      }
      if (!__classPrivateFieldGet(this, _YargsInstance_hasOutput, "f")) {
        if (helpOptSet) {
          if (__classPrivateFieldGet(this, _YargsInstance_exitProcess, "f"))
            setBlocking(true);
          skipValidation = true;
          this.showHelp("log");
          this.exit(0);
        } else if (versionOptSet) {
          if (__classPrivateFieldGet(this, _YargsInstance_exitProcess, "f"))
            setBlocking(true);
          skipValidation = true;
          __classPrivateFieldGet(this, _YargsInstance_usage, "f").showVersion("log");
          this.exit(0);
        }
      }
      if (!skipValidation && __classPrivateFieldGet(this, _YargsInstance_options, "f").skipValidation.length > 0) {
        skipValidation = Object.keys(argv).some((key) => __classPrivateFieldGet(this, _YargsInstance_options, "f").skipValidation.indexOf(key) >= 0 && argv[key] === true);
      }
      if (!skipValidation) {
        if (parsed.error)
          throw new YError(parsed.error.message);
        if (!requestCompletions) {
          const validation2 = this[kRunValidation](aliases2, {}, parsed.error);
          if (!calledFromCommand) {
            argvPromise = applyMiddleware(argv, this, __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, "f").getMiddleware(), true);
          }
          argvPromise = this[kValidateAsync](validation2, argvPromise !== null && argvPromise !== void 0 ? argvPromise : argv);
          if (isPromise(argvPromise) && !calledFromCommand) {
            argvPromise = argvPromise.then(() => {
              return applyMiddleware(argv, this, __classPrivateFieldGet(this, _YargsInstance_globalMiddleware, "f").getMiddleware(), false);
            });
          }
        }
      }
    } catch (err) {
      if (err instanceof YError)
        __classPrivateFieldGet(this, _YargsInstance_usage, "f").fail(err.message, err);
      else
        throw err;
    }
    return this[kPostProcess](argvPromise !== null && argvPromise !== void 0 ? argvPromise : argv, populateDoubleDash, !!calledFromCommand, true);
  }
  [kRunValidation](aliases2, positionalMap, parseErrors, isDefaultCommand) {
    const demandedOptions = { ...this.getDemandedOptions() };
    return (argv) => {
      if (parseErrors)
        throw new YError(parseErrors.message);
      __classPrivateFieldGet(this, _YargsInstance_validation, "f").nonOptionCount(argv);
      __classPrivateFieldGet(this, _YargsInstance_validation, "f").requiredArguments(argv, demandedOptions);
      let failedStrictCommands = false;
      if (__classPrivateFieldGet(this, _YargsInstance_strictCommands, "f")) {
        failedStrictCommands = __classPrivateFieldGet(this, _YargsInstance_validation, "f").unknownCommands(argv);
      }
      if (__classPrivateFieldGet(this, _YargsInstance_strict, "f") && !failedStrictCommands) {
        __classPrivateFieldGet(this, _YargsInstance_validation, "f").unknownArguments(argv, aliases2, positionalMap, !!isDefaultCommand);
      } else if (__classPrivateFieldGet(this, _YargsInstance_strictOptions, "f")) {
        __classPrivateFieldGet(this, _YargsInstance_validation, "f").unknownArguments(argv, aliases2, {}, false, false);
      }
      __classPrivateFieldGet(this, _YargsInstance_validation, "f").limitedChoices(argv);
      __classPrivateFieldGet(this, _YargsInstance_validation, "f").implications(argv);
      __classPrivateFieldGet(this, _YargsInstance_validation, "f").conflicting(argv);
    };
  }
  [kSetHasOutput]() {
    __classPrivateFieldSet(this, _YargsInstance_hasOutput, true, "f");
  }
  [kTrackManuallySetKeys](keys) {
    if (typeof keys === "string") {
      __classPrivateFieldGet(this, _YargsInstance_options, "f").key[keys] = true;
    } else {
      for (const k2 of keys) {
        __classPrivateFieldGet(this, _YargsInstance_options, "f").key[k2] = true;
      }
    }
  }
};
__name(YargsInstance, "YargsInstance");
function isYargsInstance(y2) {
  return !!y2 && typeof y2.getInternalMethods === "function";
}
__name(isYargsInstance, "isYargsInstance");

// ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/index.mjs
var Yargs = YargsFactory(esm_default);
var yargs_default = Yargs;

// src/ai/index.ts
init_import_meta_url();

// src/ai/createFinetune.tsx
init_import_meta_url();
var import_fs7 = __toESM(require("fs"));
var import_path7 = __toESM(require("path"));
var import_undici7 = __toESM(require_undici());

// src/ai/utils.ts
init_import_meta_url();
function getErrorMessage(error2) {
  return `${error2.text || error2.toString()}${error2.notes ? ` ${error2.notes.map((note) => note.text).join(", ")}` : ""}`;
}
__name(getErrorMessage, "getErrorMessage");
function truncate2(str, maxLen) {
  return str.slice(0, maxLen) + (str.length > maxLen ? "..." : "");
}
__name(truncate2, "truncate");
function truncateDescription(description, alreadyUsed) {
  if (description === void 0 || description === null) {
    return "";
  }
  if (process.stdout.columns === void 0) {
    return truncate2(description, 100);
  }
  return truncate2(description, process.stdout.columns - alreadyUsed);
}
__name(truncateDescription, "truncateDescription");
async function aiCatalogList(accountId, partialUrl) {
  const pageSize = 50;
  let page = 1;
  const results = [];
  while (results.length % pageSize === 0) {
    const json = await fetchResult(
      `/accounts/${accountId}/ai/${partialUrl}`,
      {},
      new URLSearchParams({
        per_page: pageSize.toString(),
        page: page.toString()
      })
    );
    page++;
    results.push(...json);
    if (json.length < pageSize) {
      break;
    }
  }
  return results;
}
__name(aiCatalogList, "aiCatalogList");
async function aiFinetuneList(accountId) {
  const results = await fetchResult(
    `/accounts/${accountId}/ai/finetunes`,
    {},
    new URLSearchParams({})
  );
  return results;
}
__name(aiFinetuneList, "aiFinetuneList");
var listCatalogEntries2 = /* @__PURE__ */ __name(async (accountId) => {
  return await aiCatalogList(accountId, "models/search");
}, "listCatalogEntries");
var listFinetuneEntries = /* @__PURE__ */ __name(async (accountId) => {
  return await aiFinetuneList(accountId);
}, "listFinetuneEntries");

// src/ai/createFinetune.tsx
var requiredAssets = ["adapter_config.json", "adapter_model.safetensors"];
function options(yargs) {
  return yargs.positional("model_name", {
    describe: "The catalog model name",
    type: "string",
    demandOption: true
  }).positional("finetune_name", {
    describe: "The finetune name",
    type: "string",
    demandOption: true
  }).positional("folder_path", {
    describe: "The folder path containing the finetune assets",
    type: "string",
    demandOption: true
  });
}
__name(options, "options");
var handler2 = withConfig(
  async ({ finetune_name, model_name, folder_path, config }) => {
    const accountId = await requireAuth(config);
    logger.log(
      `\u{1F300} Creating new finetune "${finetune_name}" for model "${model_name}"...`
    );
    try {
      const files = import_fs7.default.readdirSync(folder_path, {
        withFileTypes: true
      });
      if (requiredAssets.every(
        (asset) => files.some((file) => file.name === asset)
      )) {
        try {
          const finetune = await fetchResult(
            `/accounts/${accountId}/ai/finetunes`,
            {
              method: "POST",
              body: JSON.stringify({
                model: model_name,
                name: finetune_name,
                description: ""
              })
            }
          );
          for (let i = 0; i < files.length; i++) {
            const file = files[i];
            if (requiredAssets.includes(file.name)) {
              const filePath = import_path7.default.join(folder_path, file.name);
              logger.log(
                `\u{1F300} Uploading file "${filePath}" to "${finetune_name}"...`
              );
              try {
                const formdata = new import_undici7.FormData();
                formdata.set("file_name", file.name);
                formdata.set("file", new Blob([import_fs7.default.readFileSync(filePath)]));
                await fetchResult(
                  `/accounts/${accountId}/ai/finetunes/${finetune.id}/finetune-assets`,
                  {
                    method: "POST",
                    body: formdata
                  }
                );
              } catch (e3) {
                logger.error(
                  `\u{1F6A8} Couldn't upload file: ${getErrorMessage(
                    e3
                  )}, quiting...`
                );
                return;
              }
            }
          }
          logger.log(
            `\u2705 Assets uploaded, finetune "${finetune_name}" is ready to use.`
          );
        } catch (e3) {
          logger.error(
            `\u{1F6A8} Finetune couldn't be created: ${getErrorMessage(e3)}`
          );
        }
      } else {
        logger.error(
          `\u{1F6A8} Asset missing. Required assets: ${requiredAssets.join(", ")}`
        );
      }
    } catch (e3) {
      logger.error(
        `\u{1F6A8} Folder does not exist: ${getErrorMessage(e3)}`
      );
    }
  }
);

// src/ai/listCatalog.tsx
init_import_meta_url();

// src/yargs-types.ts
init_import_meta_url();
function asJson(yargs) {
  return yargs.option("json", {
    describe: "Return output as clean JSON",
    type: "boolean",
    default: false
  });
}
__name(asJson, "asJson");

// src/ai/listCatalog.tsx
function options2(yargs) {
  return asJson(yargs);
}
__name(options2, "options");
var handler3 = withConfig(
  async ({ json, config }) => {
    const accountId = await requireAuth(config);
    const entries = await listCatalogEntries2(accountId);
    if (json) {
      logger.log(JSON.stringify(entries, null, 2));
    } else {
      if (entries.length === 0) {
        logger.log(`No models found.`);
      } else {
        logger.table(
          entries.map((entry) => ({
            model: entry.id,
            name: entry.name,
            description: truncateDescription(
              entry.description,
              entry.id.length + entry.name.length + (entry.task ? entry.task.name.length : 0) + 10
            ),
            task: entry.task ? entry.task.name : ""
          }))
        );
      }
    }
  }
);

// src/ai/listFinetune.tsx
init_import_meta_url();
function options3(yargs) {
  return asJson(yargs);
}
__name(options3, "options");
var handler4 = withConfig(
  async ({ json, config }) => {
    const accountId = await requireAuth(config);
    const entries = await listFinetuneEntries(accountId);
    if (json) {
      logger.log(JSON.stringify(entries, null, 2));
    } else {
      if (entries.length === 0) {
        logger.log(`No finetune assets found.`);
      } else {
        logger.table(
          entries.map((entry) => ({
            finetune_id: entry.id,
            name: entry.name,
            description: truncateDescription(
              entry.description,
              entry.id.length + entry.name.length + 10
            )
          }))
        );
      }
    }
  }
);

// src/ai/index.ts
function ai(yargs) {
  return yargs.command(
    "models",
    "List catalog models",
    options2,
    handler3
  ).command(
    "finetune",
    "Interact with finetune files",
    (finetuneArgs) => finetuneArgs.demandCommand().command(
      "list",
      "List your finetune files",
      options3,
      handler4
    ).command(
      "create <model_name> <finetune_name> <folder_path>",
      "Create finetune and upload assets",
      options,
      handler2
    )
  );
}
__name(ai, "ai");

// src/cloudchamber/index.ts
init_import_meta_url();

// src/cloudchamber/common.ts
init_import_meta_url();
var import_promises4 = require("fs/promises");
var import_process2 = require("process");

// ../cli/index.ts
init_import_meta_url();
var import_process = require("process");

// ../cli/colors.ts
init_import_meta_url();
var import_chalk8 = __toESM(require_chalk());
var { white, gray, dim, hidden, bold, cyanBright, bgCyan } = import_chalk8.default;
var brandColor = import_chalk8.default.hex("#BD5B08");
var black = import_chalk8.default.hex("#111");
var blue = import_chalk8.default.hex("#0E838F");
var bgBlue = black.bgHex("#0E838F");
var red = import_chalk8.default.hex("#AB2526");
var bgRed = black.bgHex("#AB2526");
var green = import_chalk8.default.hex("#218529");
var bgGreen = black.bgHex("#218529");
var yellow = import_chalk8.default.hex("#7F7322");
var bgYellow = black.bgHex("#7F7322");

// ../cli/streams.ts
init_import_meta_url();
var stdout = process.stdout;
var stderr = process.stderr;

// ../cli/index.ts
var shapes = {
  diamond: "\u25C7",
  dash: "\u2500",
  radioInactive: "\u25CB",
  radioActive: "\u25CF",
  bar: "\u2502",
  leftT: "\u251C",
  rigthT: "\u2524",
  arrows: {
    left: "\u2039",
    right: "\u203A"
  },
  corners: {
    tl: "\u256D",
    bl: "\u2570",
    tr: "\u256E",
    br: "\u256F"
  }
};
var status = {
  error: bgRed(` ERROR `),
  warning: bgYellow(` WARNING `),
  info: bgBlue(` INFO `),
  success: bgGreen(` SUCCESS `),
  cancel: white.bgRed(` X `)
};
var space = /* @__PURE__ */ __name((n2 = 1) => {
  return hidden("\u200A".repeat(n2));
}, "space");
var logRaw = /* @__PURE__ */ __name((msg) => {
  stdout.write(`${msg}
`);
}, "logRaw");
var log = /* @__PURE__ */ __name((msg) => {
  const lines = msg.split("\n").map((ln) => `${gray(shapes.bar)} ${white(ln)}`);
  logRaw(lines.join("\n"));
}, "log");
var newline = /* @__PURE__ */ __name(() => {
  log("");
}, "newline");
var format5 = /* @__PURE__ */ __name((msg, {
  linePrefix = gray(shapes.bar),
  firstLinePrefix = linePrefix,
  newlineBefore = false,
  newlineAfter = false,
  formatLine = /* @__PURE__ */ __name((line) => white(line), "formatLine"),
  multiline = true
} = {}) => {
  const lines = multiline ? msg.split("\n") : [msg];
  const formattedLines = lines.map(
    (line, i) => (i === 0 ? firstLinePrefix : linePrefix) + space() + formatLine(line)
  );
  if (newlineBefore)
    formattedLines.unshift(linePrefix);
  if (newlineAfter)
    formattedLines.push(linePrefix);
  return formattedLines.join("\n");
}, "format");
var updateStatus = /* @__PURE__ */ __name((msg, printNewLine = true) => {
  logRaw(
    format5(msg, {
      firstLinePrefix: gray(shapes.leftT),
      linePrefix: gray(shapes.bar),
      newlineAfter: printNewLine
    })
  );
}, "updateStatus");
var startSection = /* @__PURE__ */ __name((heading, subheading, printNewLine = true) => {
  logRaw(
    `${gray(shapes.corners.tl)} ${brandColor(heading)} ${subheading ? dim(subheading) : ""}`
  );
  if (printNewLine)
    newline();
}, "startSection");
var endSection = /* @__PURE__ */ __name((heading, subheading) => {
  logRaw(
    `${gray(shapes.corners.bl)} ${brandColor(heading)} ${subheading ? dim(subheading) : ""}
`
  );
}, "endSection");
var cancel = /* @__PURE__ */ __name((msg, {
  // current default is backcompat and makes sense going forward too
  shape = shapes.corners.bl,
  // current default for backcompat -- TODO: change default to true once all callees have been updated
  multiline = false
} = {}) => {
  logRaw(
    format5(msg, {
      firstLinePrefix: `${gray(shape)} ${status.cancel}`,
      linePrefix: gray(shapes.bar),
      newlineBefore: true,
      formatLine: (line) => dim(line),
      // for backcompat but it's not ideal for this to be "dim"
      multiline
    })
  );
}, "cancel");
var warn = /* @__PURE__ */ __name((msg, {
  // current default for backcompat -- TODO: change default to shapes.bar once all callees have been updated
  shape = shapes.corners.bl,
  // current default for backcompat -- TODO: change default to true once all callees have been updated
  multiline = false
} = {}) => {
  logRaw(
    format5(msg, {
      firstLinePrefix: gray(shape) + space() + status.warning,
      linePrefix: gray(shapes.bar),
      newlineBefore: true,
      formatLine: (line) => dim(line),
      // for backcompat but it's not ideal for this to be "dim"
      multiline
    })
  );
}, "warn");
var success = /* @__PURE__ */ __name((msg, {
  // current default for backcompat -- TODO: change default to shapes.bar once all callees have been updated
  shape = shapes.corners.bl,
  // current default for backcompat -- TODO: change default to true once all callees have been updated
  multiline = false
} = {}) => {
  logRaw(
    format5(msg, {
      firstLinePrefix: gray(shape) + space() + status.success,
      linePrefix: gray(shapes.bar),
      newlineBefore: true,
      formatLine: (line) => dim(line),
      // for backcompat but it's not ideal for this to be "dim"
      multiline
    })
  );
}, "success");
var crash = /* @__PURE__ */ __name((msg, extra) => {
  error(msg, extra);
  (0, import_process.exit)(1);
}, "crash");
var error = /* @__PURE__ */ __name((msg, extra, corner = shapes.corners.bl) => {
  if (msg) {
    stderr.write(
      `${gray(corner)} ${status.error} ${dim(msg)}
${extra ? space() + extra + "\n" : ""}`
    );
  }
}, "error");

// ../cli/interactive.ts
init_import_meta_url();

// ../../node_modules/.pnpm/@clack+core@0.3.2/node_modules/@clack/core/dist/index.mjs
init_import_meta_url();
var import_sisteransi = __toESM(require_src(), 1);
var import_node_process7 = require("node:process");
var import_node_readline = __toESM(require("node:readline"), 1);
var import_node_tty2 = require("node:tty");
var import_picocolors = __toESM(require_picocolors(), 1);
function z({ onlyFirst: t3 = false } = {}) {
  const u = ["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)", "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))"].join("|");
  return new RegExp(u, t3 ? void 0 : "g");
}
__name(z, "z");
function $(t3) {
  if (typeof t3 != "string")
    throw new TypeError(`Expected a \`string\`, got \`${typeof t3}\``);
  return t3.replace(z(), "");
}
__name($, "$");
var m = {};
var G = { get exports() {
  return m;
}, set exports(t3) {
  m = t3;
} };
(function(t3) {
  var u = {};
  t3.exports = u, u.eastAsianWidth = function(e3) {
    var s = e3.charCodeAt(0), C2 = e3.length == 2 ? e3.charCodeAt(1) : 0, D = s;
    return 55296 <= s && s <= 56319 && 56320 <= C2 && C2 <= 57343 && (s &= 1023, C2 &= 1023, D = s << 10 | C2, D += 65536), D == 12288 || 65281 <= D && D <= 65376 || 65504 <= D && D <= 65510 ? "F" : D == 8361 || 65377 <= D && D <= 65470 || 65474 <= D && D <= 65479 || 65482 <= D && D <= 65487 || 65490 <= D && D <= 65495 || 65498 <= D && D <= 65500 || 65512 <= D && D <= 65518 ? "H" : 4352 <= D && D <= 4447 || 4515 <= D && D <= 4519 || 4602 <= D && D <= 4607 || 9001 <= D && D <= 9002 || 11904 <= D && D <= 11929 || 11931 <= D && D <= 12019 || 12032 <= D && D <= 12245 || 12272 <= D && D <= 12283 || 12289 <= D && D <= 12350 || 12353 <= D && D <= 12438 || 12441 <= D && D <= 12543 || 12549 <= D && D <= 12589 || 12593 <= D && D <= 12686 || 12688 <= D && D <= 12730 || 12736 <= D && D <= 12771 || 12784 <= D && D <= 12830 || 12832 <= D && D <= 12871 || 12880 <= D && D <= 13054 || 13056 <= D && D <= 19903 || 19968 <= D && D <= 42124 || 42128 <= D && D <= 42182 || 43360 <= D && D <= 43388 || 44032 <= D && D <= 55203 || 55216 <= D && D <= 55238 || 55243 <= D && D <= 55291 || 63744 <= D && D <= 64255 || 65040 <= D && D <= 65049 || 65072 <= D && D <= 65106 || 65108 <= D && D <= 65126 || 65128 <= D && D <= 65131 || 110592 <= D && D <= 110593 || 127488 <= D && D <= 127490 || 127504 <= D && D <= 127546 || 127552 <= D && D <= 127560 || 127568 <= D && D <= 127569 || 131072 <= D && D <= 194367 || 177984 <= D && D <= 196605 || 196608 <= D && D <= 262141 ? "W" : 32 <= D && D <= 126 || 162 <= D && D <= 163 || 165 <= D && D <= 166 || D == 172 || D == 175 || 10214 <= D && D <= 10221 || 10629 <= D && D <= 10630 ? "Na" : D == 161 || D == 164 || 167 <= D && D <= 168 || D == 170 || 173 <= D && D <= 174 || 176 <= D && D <= 180 || 182 <= D && D <= 186 || 188 <= D && D <= 191 || D == 198 || D == 208 || 215 <= D && D <= 216 || 222 <= D && D <= 225 || D == 230 || 232 <= D && D <= 234 || 236 <= D && D <= 237 || D == 240 || 242 <= D && D <= 243 || 247 <= D && D <= 250 || D == 252 || D == 254 || D == 257 || D == 273 || D == 275 || D == 283 || 294 <= D && D <= 295 || D == 299 || 305 <= D && D <= 307 || D == 312 || 319 <= D && D <= 322 || D == 324 || 328 <= D && D <= 331 || D == 333 || 338 <= D && D <= 339 || 358 <= D && D <= 359 || D == 363 || D == 462 || D == 464 || D == 466 || D == 468 || D == 470 || D == 472 || D == 474 || D == 476 || D == 593 || D == 609 || D == 708 || D == 711 || 713 <= D && D <= 715 || D == 717 || D == 720 || 728 <= D && D <= 731 || D == 733 || D == 735 || 768 <= D && D <= 879 || 913 <= D && D <= 929 || 931 <= D && D <= 937 || 945 <= D && D <= 961 || 963 <= D && D <= 969 || D == 1025 || 1040 <= D && D <= 1103 || D == 1105 || D == 8208 || 8211 <= D && D <= 8214 || 8216 <= D && D <= 8217 || 8220 <= D && D <= 8221 || 8224 <= D && D <= 8226 || 8228 <= D && D <= 8231 || D == 8240 || 8242 <= D && D <= 8243 || D == 8245 || D == 8251 || D == 8254 || D == 8308 || D == 8319 || 8321 <= D && D <= 8324 || D == 8364 || D == 8451 || D == 8453 || D == 8457 || D == 8467 || D == 8470 || 8481 <= D && D <= 8482 || D == 8486 || D == 8491 || 8531 <= D && D <= 8532 || 8539 <= D && D <= 8542 || 8544 <= D && D <= 8555 || 8560 <= D && D <= 8569 || D == 8585 || 8592 <= D && D <= 8601 || 8632 <= D && D <= 8633 || D == 8658 || D == 8660 || D == 8679 || D == 8704 || 8706 <= D && D <= 8707 || 8711 <= D && D <= 8712 || D == 8715 || D == 8719 || D == 8721 || D == 8725 || D == 8730 || 8733 <= D && D <= 8736 || D == 8739 || D == 8741 || 8743 <= D && D <= 8748 || D == 8750 || 8756 <= D && D <= 8759 || 8764 <= D && D <= 8765 || D == 8776 || D == 8780 || D == 8786 || 8800 <= D && D <= 8801 || 8804 <= D && D <= 8807 || 8810 <= D && D <= 8811 || 8814 <= D && D <= 8815 || 8834 <= D && D <= 8835 || 8838 <= D && D <= 8839 || D == 8853 || D == 8857 || D == 8869 || D == 8895 || D == 8978 || 9312 <= D && D <= 9449 || 9451 <= D && D <= 9547 || 9552 <= D && D <= 9587 || 9600 <= D && D <= 9615 || 9618 <= D && D <= 9621 || 9632 <= D && D <= 9633 || 9635 <= D && D <= 9641 || 9650 <= D && D <= 9651 || 9654 <= D && D <= 9655 || 9660 <= D && D <= 9661 || 9664 <= D && D <= 9665 || 9670 <= D && D <= 9672 || D == 9675 || 9678 <= D && D <= 9681 || 9698 <= D && D <= 9701 || D == 9711 || 9733 <= D && D <= 9734 || D == 9737 || 9742 <= D && D <= 9743 || 9748 <= D && D <= 9749 || D == 9756 || D == 9758 || D == 9792 || D == 9794 || 9824 <= D && D <= 9825 || 9827 <= D && D <= 9829 || 9831 <= D && D <= 9834 || 9836 <= D && D <= 9837 || D == 9839 || 9886 <= D && D <= 9887 || 9918 <= D && D <= 9919 || 9924 <= D && D <= 9933 || 9935 <= D && D <= 9953 || D == 9955 || 9960 <= D && D <= 9983 || D == 10045 || D == 10071 || 10102 <= D && D <= 10111 || 11093 <= D && D <= 11097 || 12872 <= D && D <= 12879 || 57344 <= D && D <= 63743 || 65024 <= D && D <= 65039 || D == 65533 || 127232 <= D && D <= 127242 || 127248 <= D && D <= 127277 || 127280 <= D && D <= 127337 || 127344 <= D && D <= 127386 || 917760 <= D && D <= 917999 || 983040 <= D && D <= 1048573 || 1048576 <= D && D <= 1114109 ? "A" : "N";
  }, u.characterLength = function(e3) {
    var s = this.eastAsianWidth(e3);
    return s == "F" || s == "W" || s == "A" ? 2 : 1;
  };
  function F(e3) {
    return e3.match(/[\uD800-\uDBFF][\uDC00-\uDFFF]|[^\uD800-\uDFFF]/g) || [];
  }
  __name(F, "F");
  u.length = function(e3) {
    for (var s = F(e3), C2 = 0, D = 0; D < s.length; D++)
      C2 = C2 + this.characterLength(s[D]);
    return C2;
  }, u.slice = function(e3, s, C2) {
    textLen = u.length(e3), s = s || 0, C2 = C2 || 1, s < 0 && (s = textLen + s), C2 < 0 && (C2 = textLen + C2);
    for (var D = "", i = 0, o2 = F(e3), E2 = 0; E2 < o2.length; E2++) {
      var a = o2[E2], n2 = u.length(a);
      if (i >= s - (n2 == 2 ? 1 : 0))
        if (i + n2 <= C2)
          D += a;
        else
          break;
      i += n2;
    }
    return D;
  };
})(G);
var K = m;
var Y = /* @__PURE__ */ __name(function() {
  return /\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62(?:\uDB40\uDC77\uDB40\uDC6C\uDB40\uDC73|\uDB40\uDC73\uDB40\uDC63\uDB40\uDC74|\uDB40\uDC65\uDB40\uDC6E\uDB40\uDC67)\uDB40\uDC7F|(?:\uD83E\uDDD1\uD83C\uDFFF\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB-\uDFFE])|(?:\uD83E\uDDD1\uD83C\uDFFE\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFD\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFC\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFB\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFC-\uDFFF])|\uD83D\uDC68(?:\uD83C\uDFFB(?:\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF]))|\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFC-\uDFFF])|[\u2695\u2696\u2708]\uFE0F|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))?|(?:\uD83C[\uDFFC-\uDFFF])\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF]))|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83D\uDC68|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFE])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])\uFE0F|\u200D(?:(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D[\uDC66\uDC67])|\uD83D[\uDC66\uDC67])|\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC)?|(?:\uD83D\uDC69(?:\uD83C\uDFFB\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|(?:\uD83C[\uDFFC-\uDFFF])\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69]))|\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1)(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC69(?:\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83E\uDDD1(?:\u200D(?:\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D[\uDC66\uDC67])|\uD83D\uDC69\u200D\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D\uDC41\uFE0F\u200D\uD83D\uDDE8|\uD83E\uDDD1(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|\uD83D\uDC69(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|\uD83D\uDE36\u200D\uD83C\uDF2B|\uD83C\uDFF3\uFE0F\u200D\u26A7|\uD83D\uDC3B\u200D\u2744|(?:(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC6F|\uD83E[\uDD3C\uDDDE\uDDDF])\u200D[\u2640\u2642]|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|\uD83C\uDFF4\u200D\u2620|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])\u200D[\u2640\u2642]|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u2600-\u2604\u260E\u2611\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26B0\u26B1\u26C8\u26CF\u26D1\u26D3\u26E9\u26F0\u26F1\u26F4\u26F7\u26F8\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u3030\u303D\u3297\u3299]|\uD83C[\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]|\uD83D[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3])\uFE0F|\uD83C\uDFF3\uFE0F\u200D\uD83C\uDF08|\uD83D\uDC69\u200D\uD83D\uDC67|\uD83D\uDC69\u200D\uD83D\uDC66|\uD83D\uDE35\u200D\uD83D\uDCAB|\uD83D\uDE2E\u200D\uD83D\uDCA8|\uD83D\uDC15\u200D\uD83E\uDDBA|\uD83E\uDDD1(?:\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC|\uD83C\uDFFB)?|\uD83D\uDC69(?:\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC|\uD83C\uDFFB)?|\uD83C\uDDFD\uD83C\uDDF0|\uD83C\uDDF6\uD83C\uDDE6|\uD83C\uDDF4\uD83C\uDDF2|\uD83D\uDC08\u200D\u2B1B|\u2764\uFE0F\u200D(?:\uD83D\uDD25|\uD83E\uDE79)|\uD83D\uDC41\uFE0F|\uD83C\uDFF3\uFE0F|\uD83C\uDDFF(?:\uD83C[\uDDE6\uDDF2\uDDFC])|\uD83C\uDDFE(?:\uD83C[\uDDEA\uDDF9])|\uD83C\uDDFC(?:\uD83C[\uDDEB\uDDF8])|\uD83C\uDDFB(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA])|\uD83C\uDDFA(?:\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF])|\uD83C\uDDF9(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF])|\uD83C\uDDF8(?:\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF])|\uD83C\uDDF7(?:\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC])|\uD83C\uDDF5(?:\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE])|\uD83C\uDDF3(?:\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF])|\uD83C\uDDF2(?:\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF])|\uD83C\uDDF1(?:\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE])|\uD83C\uDDF0(?:\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF])|\uD83C\uDDEF(?:\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5])|\uD83C\uDDEE(?:\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9])|\uD83C\uDDED(?:\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA])|\uD83C\uDDEC(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE])|\uD83C\uDDEB(?:\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7])|\uD83C\uDDEA(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA])|\uD83C\uDDE9(?:\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF])|\uD83C\uDDE8(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF])|\uD83C\uDDE7(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF])|\uD83C\uDDE6(?:\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF])|[#\*0-9]\uFE0F\u20E3|\u2764\uFE0F|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])|\uD83C\uDFF4|(?:[\u270A\u270B]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0C\uDD0F\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5])(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u261D\u270C\u270D]|\uD83D[\uDD74\uDD90])(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])|[\u270A\u270B]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC08\uDC15\uDC3B\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE2E\uDE35\uDE36\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0C\uDD0F\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5]|\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD]|\uD83D\uDC6F|\uD83E[\uDD3C\uDDDE\uDDDF]|[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB]|\uD83E[\uDD0D\uDD0E\uDD10-\uDD17\uDD1D\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78\uDD7A-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCB\uDDD0\uDDE0-\uDDFF\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6]|(?:[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u270A\u270B\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF93\uDFA0-\uDFCA\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF4\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC3E\uDC40\uDC42-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDD7A\uDD95\uDD96\uDDA4\uDDFB-\uDE4F\uDE80-\uDEC5\uDECC\uDED0-\uDED2\uDED5-\uDED7\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB]|\uD83E[\uDD0C-\uDD3A\uDD3C-\uDD45\uDD47-\uDD78\uDD7A-\uDDCB\uDDCD-\uDDFF\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6])|(?:[#\*0-9\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23E9-\u23F3\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB-\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u261D\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692-\u2697\u2699\u269B\u269C\u26A0\u26A1\u26A7\u26AA\u26AB\u26B0\u26B1\u26BD\u26BE\u26C4\u26C5\u26C8\u26CE\u26CF\u26D1\u26D3\u26D4\u26E9\u26EA\u26F0-\u26F5\u26F7-\u26FA\u26FD\u2702\u2705\u2708-\u270D\u270F\u2712\u2714\u2716\u271D\u2721\u2728\u2733\u2734\u2744\u2747\u274C\u274E\u2753-\u2755\u2757\u2763\u2764\u2795-\u2797\u27A1\u27B0\u27BF\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B50\u2B55\u3030\u303D\u3297\u3299]|\uD83C[\uDC04\uDCCF\uDD70\uDD71\uDD7E\uDD7F\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE02\uDE1A\uDE2F\uDE32-\uDE3A\uDE50\uDE51\uDF00-\uDF21\uDF24-\uDF93\uDF96\uDF97\uDF99-\uDF9B\uDF9E-\uDFF0\uDFF3-\uDFF5\uDFF7-\uDFFF]|\uD83D[\uDC00-\uDCFD\uDCFF-\uDD3D\uDD49-\uDD4E\uDD50-\uDD67\uDD6F\uDD70\uDD73-\uDD7A\uDD87\uDD8A-\uDD8D\uDD90\uDD95\uDD96\uDDA4\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA-\uDE4F\uDE80-\uDEC5\uDECB-\uDED2\uDED5-\uDED7\uDEE0-\uDEE5\uDEE9\uDEEB\uDEEC\uDEF0\uDEF3-\uDEFC\uDFE0-\uDFEB]|\uD83E[\uDD0C-\uDD3A\uDD3C-\uDD45\uDD47-\uDD78\uDD7A-\uDDCB\uDDCD-\uDDFF\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6])\uFE0F|(?:[\u261D\u26F9\u270A-\u270D]|\uD83C[\uDF85\uDFC2-\uDFC4\uDFC7\uDFCA-\uDFCC]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66-\uDC78\uDC7C\uDC81-\uDC83\uDC85-\uDC87\uDC8F\uDC91\uDCAA\uDD74\uDD75\uDD7A\uDD90\uDD95\uDD96\uDE45-\uDE47\uDE4B-\uDE4F\uDEA3\uDEB4-\uDEB6\uDEC0\uDECC]|\uD83E[\uDD0C\uDD0F\uDD18-\uDD1F\uDD26\uDD30-\uDD39\uDD3C-\uDD3E\uDD77\uDDB5\uDDB6\uDDB8\uDDB9\uDDBB\uDDCD-\uDDCF\uDDD1-\uDDDD])/g;
}, "Y");
function c(t3, u = {}) {
  if (typeof t3 != "string" || t3.length === 0 || (u = { ambiguousIsNarrow: true, ...u }, t3 = $(t3), t3.length === 0))
    return 0;
  t3 = t3.replace(Y(), "  ");
  const F = u.ambiguousIsNarrow ? 1 : 2;
  let e3 = 0;
  for (const s of t3) {
    const C2 = s.codePointAt(0);
    if (C2 <= 31 || C2 >= 127 && C2 <= 159 || C2 >= 768 && C2 <= 879)
      continue;
    switch (K.eastAsianWidth(s)) {
      case "F":
      case "W":
        e3 += 2;
        break;
      case "A":
        e3 += F;
        break;
      default:
        e3 += 1;
    }
  }
  return e3;
}
__name(c, "c");
var v = 10;
var L = /* @__PURE__ */ __name((t3 = 0) => (u) => `\x1B[${u + t3}m`, "L");
var M = /* @__PURE__ */ __name((t3 = 0) => (u) => `\x1B[${38 + t3};5;${u}m`, "M");
var T = /* @__PURE__ */ __name((t3 = 0) => (u, F, e3) => `\x1B[${38 + t3};2;${u};${F};${e3}m`, "T");
var r2 = { modifier: { reset: [0, 0], bold: [1, 22], dim: [2, 22], italic: [3, 23], underline: [4, 24], overline: [53, 55], inverse: [7, 27], hidden: [8, 28], strikethrough: [9, 29] }, color: { black: [30, 39], red: [31, 39], green: [32, 39], yellow: [33, 39], blue: [34, 39], magenta: [35, 39], cyan: [36, 39], white: [37, 39], blackBright: [90, 39], gray: [90, 39], grey: [90, 39], redBright: [91, 39], greenBright: [92, 39], yellowBright: [93, 39], blueBright: [94, 39], magentaBright: [95, 39], cyanBright: [96, 39], whiteBright: [97, 39] }, bgColor: { bgBlack: [40, 49], bgRed: [41, 49], bgGreen: [42, 49], bgYellow: [43, 49], bgBlue: [44, 49], bgMagenta: [45, 49], bgCyan: [46, 49], bgWhite: [47, 49], bgBlackBright: [100, 49], bgGray: [100, 49], bgGrey: [100, 49], bgRedBright: [101, 49], bgGreenBright: [102, 49], bgYellowBright: [103, 49], bgBlueBright: [104, 49], bgMagentaBright: [105, 49], bgCyanBright: [106, 49], bgWhiteBright: [107, 49] } };
Object.keys(r2.modifier);
var Z = Object.keys(r2.color);
var H = Object.keys(r2.bgColor);
[...Z, ...H];
function U() {
  const t3 = /* @__PURE__ */ new Map();
  for (const [u, F] of Object.entries(r2)) {
    for (const [e3, s] of Object.entries(F))
      r2[e3] = { open: `\x1B[${s[0]}m`, close: `\x1B[${s[1]}m` }, F[e3] = r2[e3], t3.set(s[0], s[1]);
    Object.defineProperty(r2, u, { value: F, enumerable: false });
  }
  return Object.defineProperty(r2, "codes", { value: t3, enumerable: false }), r2.color.close = "\x1B[39m", r2.bgColor.close = "\x1B[49m", r2.color.ansi = L(), r2.color.ansi256 = M(), r2.color.ansi16m = T(), r2.bgColor.ansi = L(v), r2.bgColor.ansi256 = M(v), r2.bgColor.ansi16m = T(v), Object.defineProperties(r2, { rgbToAnsi256: { value: (u, F, e3) => u === F && F === e3 ? u < 8 ? 16 : u > 248 ? 231 : Math.round((u - 8) / 247 * 24) + 232 : 16 + 36 * Math.round(u / 255 * 5) + 6 * Math.round(F / 255 * 5) + Math.round(e3 / 255 * 5), enumerable: false }, hexToRgb: { value: (u) => {
    const F = /[a-f\d]{6}|[a-f\d]{3}/i.exec(u.toString(16));
    if (!F)
      return [0, 0, 0];
    let [e3] = F;
    e3.length === 3 && (e3 = [...e3].map((C2) => C2 + C2).join(""));
    const s = Number.parseInt(e3, 16);
    return [s >> 16 & 255, s >> 8 & 255, s & 255];
  }, enumerable: false }, hexToAnsi256: { value: (u) => r2.rgbToAnsi256(...r2.hexToRgb(u)), enumerable: false }, ansi256ToAnsi: { value: (u) => {
    if (u < 8)
      return 30 + u;
    if (u < 16)
      return 90 + (u - 8);
    let F, e3, s;
    if (u >= 232)
      F = ((u - 232) * 10 + 8) / 255, e3 = F, s = F;
    else {
      u -= 16;
      const i = u % 36;
      F = Math.floor(u / 36) / 5, e3 = Math.floor(i / 6) / 5, s = i % 6 / 5;
    }
    const C2 = Math.max(F, e3, s) * 2;
    if (C2 === 0)
      return 30;
    let D = 30 + (Math.round(s) << 2 | Math.round(e3) << 1 | Math.round(F));
    return C2 === 2 && (D += 60), D;
  }, enumerable: false }, rgbToAnsi: { value: (u, F, e3) => r2.ansi256ToAnsi(r2.rgbToAnsi256(u, F, e3)), enumerable: false }, hexToAnsi: { value: (u) => r2.ansi256ToAnsi(r2.hexToAnsi256(u)), enumerable: false } }), r2;
}
__name(U, "U");
var q = U();
var p = /* @__PURE__ */ new Set(["\x1B", "\x9B"]);
var J = 39;
var b = "\x07";
var W = "[";
var Q2 = "]";
var I = "m";
var w = `${Q2}8;;`;
var N = /* @__PURE__ */ __name((t3) => `${p.values().next().value}${W}${t3}${I}`, "N");
var j = /* @__PURE__ */ __name((t3) => `${p.values().next().value}${w}${t3}${b}`, "j");
var X = /* @__PURE__ */ __name((t3) => t3.split(" ").map((u) => c(u)), "X");
var _2 = /* @__PURE__ */ __name((t3, u, F) => {
  const e3 = [...u];
  let s = false, C2 = false, D = c($(t3[t3.length - 1]));
  for (const [i, o2] of e3.entries()) {
    const E2 = c(o2);
    if (D + E2 <= F ? t3[t3.length - 1] += o2 : (t3.push(o2), D = 0), p.has(o2) && (s = true, C2 = e3.slice(i + 1).join("").startsWith(w)), s) {
      C2 ? o2 === b && (s = false, C2 = false) : o2 === I && (s = false);
      continue;
    }
    D += E2, D === F && i < e3.length - 1 && (t3.push(""), D = 0);
  }
  !D && t3[t3.length - 1].length > 0 && t3.length > 1 && (t3[t3.length - 2] += t3.pop());
}, "_");
var DD = /* @__PURE__ */ __name((t3) => {
  const u = t3.split(" ");
  let F = u.length;
  for (; F > 0 && !(c(u[F - 1]) > 0); )
    F--;
  return F === u.length ? t3 : u.slice(0, F).join(" ") + u.slice(F).join("");
}, "DD");
var uD = /* @__PURE__ */ __name((t3, u, F = {}) => {
  if (F.trim !== false && t3.trim() === "")
    return "";
  let e3 = "", s, C2;
  const D = X(t3);
  let i = [""];
  for (const [E2, a] of t3.split(" ").entries()) {
    F.trim !== false && (i[i.length - 1] = i[i.length - 1].trimStart());
    let n2 = c(i[i.length - 1]);
    if (E2 !== 0 && (n2 >= u && (F.wordWrap === false || F.trim === false) && (i.push(""), n2 = 0), (n2 > 0 || F.trim === false) && (i[i.length - 1] += " ", n2++)), F.hard && D[E2] > u) {
      const B2 = u - n2, A2 = 1 + Math.floor((D[E2] - B2 - 1) / u);
      Math.floor((D[E2] - 1) / u) < A2 && i.push(""), _2(i, a, u);
      continue;
    }
    if (n2 + D[E2] > u && n2 > 0 && D[E2] > 0) {
      if (F.wordWrap === false && n2 < u) {
        _2(i, a, u);
        continue;
      }
      i.push("");
    }
    if (n2 + D[E2] > u && F.wordWrap === false) {
      _2(i, a, u);
      continue;
    }
    i[i.length - 1] += a;
  }
  F.trim !== false && (i = i.map((E2) => DD(E2)));
  const o2 = [...i.join(`
`)];
  for (const [E2, a] of o2.entries()) {
    if (e3 += a, p.has(a)) {
      const { groups: B2 } = new RegExp(`(?:\\${W}(?<code>\\d+)m|\\${w}(?<uri>.*)${b})`).exec(o2.slice(E2).join("")) || { groups: {} };
      if (B2.code !== void 0) {
        const A2 = Number.parseFloat(B2.code);
        s = A2 === J ? void 0 : A2;
      } else
        B2.uri !== void 0 && (C2 = B2.uri.length === 0 ? void 0 : B2.uri);
    }
    const n2 = q.codes.get(Number(s));
    o2[E2 + 1] === `
` ? (C2 && (e3 += j("")), s && n2 && (e3 += N(n2))) : a === `
` && (s && n2 && (e3 += N(s)), C2 && (e3 += j(C2)));
  }
  return e3;
}, "uD");
function P(t3, u, F) {
  return String(t3).normalize().replace(/\r\n/g, `
`).split(`
`).map((e3) => uD(e3, u, F)).join(`
`);
}
__name(P, "P");
function FD(t3, u) {
  if (t3 === u)
    return;
  const F = t3.split(`
`), e3 = u.split(`
`), s = [];
  for (let C2 = 0; C2 < Math.max(F.length, e3.length); C2++)
    F[C2] !== e3[C2] && s.push(C2);
  return s;
}
__name(FD, "FD");
var R = Symbol("clack:cancel");
function eD(t3) {
  return t3 === R;
}
__name(eD, "eD");
function g(t3, u) {
  t3.isTTY && t3.setRawMode(u);
}
__name(g, "g");
var V = /* @__PURE__ */ new Map([["k", "up"], ["j", "down"], ["h", "left"], ["l", "right"]]);
var tD = /* @__PURE__ */ new Set(["up", "down", "left", "right", "space", "enter"]);
var h = class {
  constructor({ render: u, input: F = import_node_process7.stdin, output: e3 = import_node_process7.stdout, ...s }, C2 = true) {
    this._track = false, this._cursor = 0, this.state = "initial", this.error = "", this.subscribers = /* @__PURE__ */ new Map(), this._prevFrame = "", this.opts = s, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = u.bind(this), this._track = C2, this.input = F, this.output = e3;
  }
  prompt() {
    const u = new import_node_tty2.WriteStream(0);
    return u._write = (F, e3, s) => {
      this._track && (this.value = this.rl.line.replace(/\t/g, ""), this._cursor = this.rl.cursor, this.emit("value", this.value)), s();
    }, this.input.pipe(u), this.rl = import_node_readline.default.createInterface({ input: this.input, output: u, tabSize: 2, prompt: "", escapeCodeTimeout: 50 }), import_node_readline.default.emitKeypressEvents(this.input, this.rl), this.rl.prompt(), this.opts.initialValue !== void 0 && this._track && this.rl.write(this.opts.initialValue), this.input.on("keypress", this.onKeypress), g(this.input, true), this.output.on("resize", this.render), this.render(), new Promise((F, e3) => {
      this.once("submit", () => {
        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), g(this.input, false), F(this.value);
      }), this.once("cancel", () => {
        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), g(this.input, false), F(R);
      });
    });
  }
  on(u, F) {
    const e3 = this.subscribers.get(u) ?? [];
    e3.push({ cb: F }), this.subscribers.set(u, e3);
  }
  once(u, F) {
    const e3 = this.subscribers.get(u) ?? [];
    e3.push({ cb: F, once: true }), this.subscribers.set(u, e3);
  }
  emit(u, ...F) {
    const e3 = this.subscribers.get(u) ?? [], s = [];
    for (const C2 of e3)
      C2.cb(...F), C2.once && s.push(() => e3.splice(e3.indexOf(C2), 1));
    for (const C2 of s)
      C2();
  }
  unsubscribe() {
    this.subscribers.clear();
  }
  onKeypress(u, F) {
    if (this.state === "error" && (this.state = "active"), F?.name && !this._track && V.has(F.name) && this.emit("cursor", V.get(F.name)), F?.name && tD.has(F.name) && this.emit("cursor", F.name), u && (u.toLowerCase() === "y" || u.toLowerCase() === "n") && this.emit("confirm", u.toLowerCase() === "y"), u && this.emit("key", u.toLowerCase()), F?.name === "return") {
      if (this.opts.validate) {
        const e3 = this.opts.validate(this.value);
        e3 && (this.error = e3, this.state = "error", this.rl.write(this.value));
      }
      this.state !== "error" && (this.state = "submit");
    }
    u === "" && (this.state = "cancel"), (this.state === "submit" || this.state === "cancel") && this.emit("finalize"), this.render(), (this.state === "submit" || this.state === "cancel") && this.close();
  }
  close() {
    this.input.unpipe(), this.input.removeListener("keypress", this.onKeypress), this.output.write(`
`), g(this.input, false), this.rl.close(), this.emit(`${this.state}`, this.value), this.unsubscribe();
  }
  restoreCursor() {
    const u = P(this._prevFrame, process.stdout.columns, { hard: true }).split(`
`).length - 1;
    this.output.write(import_sisteransi.cursor.move(-999, u * -1));
  }
  render() {
    const u = P(this._render(this) ?? "", process.stdout.columns, { hard: true });
    if (u !== this._prevFrame) {
      if (this.state === "initial")
        this.output.write(import_sisteransi.cursor.hide);
      else {
        const F = FD(this._prevFrame, u);
        if (this.restoreCursor(), F && F?.length === 1) {
          const e3 = F[0];
          this.output.write(import_sisteransi.cursor.move(0, e3)), this.output.write(import_sisteransi.erase.lines(1));
          const s = u.split(`
`);
          this.output.write(s[e3]), this._prevFrame = u, this.output.write(import_sisteransi.cursor.move(0, s.length - e3 - 1));
          return;
        } else if (F && F?.length > 1) {
          const e3 = F[0];
          this.output.write(import_sisteransi.cursor.move(0, e3)), this.output.write(import_sisteransi.erase.down());
          const C2 = u.split(`
`).slice(e3);
          this.output.write(C2.join(`
`)), this._prevFrame = u;
          return;
        }
        this.output.write(import_sisteransi.erase.down());
      }
      this.output.write(u), this.state === "initial" && (this.state = "active"), this._prevFrame = u;
    }
  }
};
__name(h, "h");
var sD = class extends h {
  get cursor() {
    return this.value ? 0 : 1;
  }
  get _value() {
    return this.cursor === 0;
  }
  constructor(u) {
    super(u, false), this.value = !!u.initialValue, this.on("value", () => {
      this.value = this._value;
    }), this.on("confirm", (F) => {
      this.output.write(import_sisteransi.cursor.move(0, -1)), this.value = F, this.state = "submit", this.close();
    }), this.on("cursor", () => {
      this.value = !this.value;
    });
  }
};
__name(sD, "sD");
var iD = class extends h {
  constructor(u) {
    super(u, false), this.cursor = 0, this.options = u.options, this.value = [...u.initialValues ?? []], this.cursor = Math.max(this.options.findIndex(({ value: F }) => F === u.cursorAt), 0), this.on("key", (F) => {
      F === "a" && this.toggleAll();
    }), this.on("cursor", (F) => {
      switch (F) {
        case "left":
        case "up":
          this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
          break;
        case "down":
        case "right":
          this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
          break;
        case "space":
          this.toggleValue();
          break;
      }
    });
  }
  get _value() {
    return this.options[this.cursor].value;
  }
  toggleAll() {
    const u = this.value.length === this.options.length;
    this.value = u ? [] : this.options.map((F) => F.value);
  }
  toggleValue() {
    const u = this.value.includes(this._value);
    this.value = u ? this.value.filter((F) => F !== this._value) : [...this.value, this._value];
  }
};
__name(iD, "iD");
var ED = class extends h {
  constructor(u) {
    super(u, false), this.cursor = 0, this.options = u.options, this.cursor = this.options.findIndex(({ value: F }) => F === u.initialValue), this.cursor === -1 && (this.cursor = 0), this.changeValue(), this.on("cursor", (F) => {
      switch (F) {
        case "left":
        case "up":
          this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
          break;
        case "down":
        case "right":
          this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
          break;
      }
      this.changeValue();
    });
  }
  get _value() {
    return this.options[this.cursor];
  }
  changeValue() {
    this.value = this._value.value;
  }
};
__name(ED, "ED");
var oD = class extends h {
  constructor(u) {
    super(u), this.valueWithCursor = "", this.on("finalize", () => {
      this.value || (this.value = u.defaultValue), this.valueWithCursor = this.value;
    }), this.on("value", () => {
      if (this.cursor >= this.value.length)
        this.valueWithCursor = `${this.value}${import_picocolors.default.inverse(import_picocolors.default.hidden("_"))}`;
      else {
        const F = this.value.slice(0, this.cursor), e3 = this.value.slice(this.cursor);
        this.valueWithCursor = `${F}${import_picocolors.default.inverse(e3[0])}${e3.slice(1)}`;
      }
    });
  }
  get cursor() {
    return this._cursor;
  }
};
__name(oD, "oD");

// ../../node_modules/.pnpm/log-update@5.0.1/node_modules/log-update/index.js
init_import_meta_url();
var import_node_process10 = __toESM(require("node:process"), 1);

// ../../node_modules/.pnpm/ansi-escapes@5.0.0/node_modules/ansi-escapes/index.js
init_import_meta_url();
var ESC = "\x1B[";
var OSC = "\x1B]";
var BEL = "\x07";
var SEP = ";";
var isTerminalApp = process.env.TERM_PROGRAM === "Apple_Terminal";
var ansiEscapes = {};
ansiEscapes.cursorTo = (x2, y2) => {
  if (typeof x2 !== "number") {
    throw new TypeError("The `x` argument is required");
  }
  if (typeof y2 !== "number") {
    return ESC + (x2 + 1) + "G";
  }
  return ESC + (y2 + 1) + ";" + (x2 + 1) + "H";
};
ansiEscapes.cursorMove = (x2, y2) => {
  if (typeof x2 !== "number") {
    throw new TypeError("The `x` argument is required");
  }
  let returnValue = "";
  if (x2 < 0) {
    returnValue += ESC + -x2 + "D";
  } else if (x2 > 0) {
    returnValue += ESC + x2 + "C";
  }
  if (y2 < 0) {
    returnValue += ESC + -y2 + "A";
  } else if (y2 > 0) {
    returnValue += ESC + y2 + "B";
  }
  return returnValue;
};
ansiEscapes.cursorUp = (count = 1) => ESC + count + "A";
ansiEscapes.cursorDown = (count = 1) => ESC + count + "B";
ansiEscapes.cursorForward = (count = 1) => ESC + count + "C";
ansiEscapes.cursorBackward = (count = 1) => ESC + count + "D";
ansiEscapes.cursorLeft = ESC + "G";
ansiEscapes.cursorSavePosition = isTerminalApp ? "\x1B7" : ESC + "s";
ansiEscapes.cursorRestorePosition = isTerminalApp ? "\x1B8" : ESC + "u";
ansiEscapes.cursorGetPosition = ESC + "6n";
ansiEscapes.cursorNextLine = ESC + "E";
ansiEscapes.cursorPrevLine = ESC + "F";
ansiEscapes.cursorHide = ESC + "?25l";
ansiEscapes.cursorShow = ESC + "?25h";
ansiEscapes.eraseLines = (count) => {
  let clear = "";
  for (let i = 0; i < count; i++) {
    clear += ansiEscapes.eraseLine + (i < count - 1 ? ansiEscapes.cursorUp() : "");
  }
  if (count) {
    clear += ansiEscapes.cursorLeft;
  }
  return clear;
};
ansiEscapes.eraseEndLine = ESC + "K";
ansiEscapes.eraseStartLine = ESC + "1K";
ansiEscapes.eraseLine = ESC + "2K";
ansiEscapes.eraseDown = ESC + "J";
ansiEscapes.eraseUp = ESC + "1J";
ansiEscapes.eraseScreen = ESC + "2J";
ansiEscapes.scrollUp = ESC + "S";
ansiEscapes.scrollDown = ESC + "T";
ansiEscapes.clearScreen = "\x1Bc";
ansiEscapes.clearTerminal = process.platform === "win32" ? `${ansiEscapes.eraseScreen}${ESC}0f` : (
  // 1. Erases the screen (Only done in case `2` is not supported)
  // 2. Erases the whole screen including scrollback buffer
  // 3. Moves cursor to the top-left position
  // More info: https://www.real-world-systems.com/docs/ANSIcode.html
  `${ansiEscapes.eraseScreen}${ESC}3J${ESC}H`
);
ansiEscapes.beep = BEL;
ansiEscapes.link = (text, url4) => {
  return [
    OSC,
    "8",
    SEP,
    SEP,
    url4,
    BEL,
    text,
    OSC,
    "8",
    SEP,
    SEP,
    BEL
  ].join("");
};
ansiEscapes.image = (buffer, options29 = {}) => {
  let returnValue = `${OSC}1337;File=inline=1`;
  if (options29.width) {
    returnValue += `;width=${options29.width}`;
  }
  if (options29.height) {
    returnValue += `;height=${options29.height}`;
  }
  if (options29.preserveAspectRatio === false) {
    returnValue += ";preserveAspectRatio=0";
  }
  return returnValue + ":" + buffer.toString("base64") + BEL;
};
ansiEscapes.iTerm = {
  setCwd: (cwd2 = process.cwd()) => `${OSC}50;CurrentDir=${cwd2}${BEL}`,
  annotation: (message, options29 = {}) => {
    let returnValue = `${OSC}1337;`;
    const hasX = typeof options29.x !== "undefined";
    const hasY = typeof options29.y !== "undefined";
    if ((hasX || hasY) && !(hasX && hasY && typeof options29.length !== "undefined")) {
      throw new Error("`x`, `y` and `length` must be defined when `x` or `y` is defined");
    }
    message = message.replace(/\|/g, "");
    returnValue += options29.isHidden ? "AddHiddenAnnotation=" : "AddAnnotation=";
    if (options29.length > 0) {
      returnValue += (hasX ? [message, options29.length, options29.x, options29.y] : [options29.length, message]).join("|");
    } else {
      returnValue += message;
    }
    return returnValue + BEL;
  }
};
var ansi_escapes_default = ansiEscapes;

// ../../node_modules/.pnpm/cli-cursor@4.0.0/node_modules/cli-cursor/index.js
init_import_meta_url();
var import_node_process9 = __toESM(require("node:process"), 1);

// ../../node_modules/.pnpm/restore-cursor@4.0.0/node_modules/restore-cursor/index.js
init_import_meta_url();
var import_node_process8 = __toESM(require("node:process"), 1);
var import_onetime2 = __toESM(require_onetime(), 1);
var import_signal_exit5 = __toESM(require_signal_exit(), 1);
var restoreCursor = (0, import_onetime2.default)(() => {
  (0, import_signal_exit5.default)(() => {
    import_node_process8.default.stderr.write("\x1B[?25h");
  }, { alwaysLast: true });
});
var restore_cursor_default = restoreCursor;

// ../../node_modules/.pnpm/cli-cursor@4.0.0/node_modules/cli-cursor/index.js
var isHidden = false;
var cliCursor = {};
cliCursor.show = (writableStream = import_node_process9.default.stderr) => {
  if (!writableStream.isTTY) {
    return;
  }
  isHidden = false;
  writableStream.write("\x1B[?25h");
};
cliCursor.hide = (writableStream = import_node_process9.default.stderr) => {
  if (!writableStream.isTTY) {
    return;
  }
  restore_cursor_default();
  isHidden = true;
  writableStream.write("\x1B[?25l");
};
cliCursor.toggle = (force, writableStream) => {
  if (force !== void 0) {
    isHidden = force;
  }
  if (isHidden) {
    cliCursor.show(writableStream);
  } else {
    cliCursor.hide(writableStream);
  }
};
var cli_cursor_default = cliCursor;

// ../../node_modules/.pnpm/wrap-ansi@8.1.0/node_modules/wrap-ansi/index.js
init_import_meta_url();

// ../../node_modules/.pnpm/string-width@5.1.2/node_modules/string-width/index.js
init_import_meta_url();

// ../../node_modules/.pnpm/strip-ansi@7.1.0/node_modules/strip-ansi/index.js
init_import_meta_url();

// ../../node_modules/.pnpm/ansi-regex@6.0.1/node_modules/ansi-regex/index.js
init_import_meta_url();
function ansiRegex({ onlyFirst = false } = {}) {
  const pattern = [
    "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))"
  ].join("|");
  return new RegExp(pattern, onlyFirst ? void 0 : "g");
}
__name(ansiRegex, "ansiRegex");

// ../../node_modules/.pnpm/strip-ansi@7.1.0/node_modules/strip-ansi/index.js
var regex = ansiRegex();
function stripAnsi2(string) {
  if (typeof string !== "string") {
    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
  }
  return string.replace(regex, "");
}
__name(stripAnsi2, "stripAnsi");

// ../../node_modules/.pnpm/string-width@5.1.2/node_modules/string-width/index.js
var import_eastasianwidth = __toESM(require_eastasianwidth(), 1);
var import_emoji_regex = __toESM(require_emoji_regex2(), 1);
function stringWidth(string, options29 = {}) {
  if (typeof string !== "string" || string.length === 0) {
    return 0;
  }
  options29 = {
    ambiguousIsNarrow: true,
    ...options29
  };
  string = stripAnsi2(string);
  if (string.length === 0) {
    return 0;
  }
  string = string.replace((0, import_emoji_regex.default)(), "  ");
  const ambiguousCharacterWidth = options29.ambiguousIsNarrow ? 1 : 2;
  let width = 0;
  for (const character of string) {
    const codePoint = character.codePointAt(0);
    if (codePoint <= 31 || codePoint >= 127 && codePoint <= 159) {
      continue;
    }
    if (codePoint >= 768 && codePoint <= 879) {
      continue;
    }
    const code = import_eastasianwidth.default.eastAsianWidth(character);
    switch (code) {
      case "F":
      case "W":
        width += 2;
        break;
      case "A":
        width += ambiguousCharacterWidth;
        break;
      default:
        width += 1;
    }
  }
  return width;
}
__name(stringWidth, "stringWidth");

// ../../node_modules/.pnpm/ansi-styles@6.2.1/node_modules/ansi-styles/index.js
init_import_meta_url();
var ANSI_BACKGROUND_OFFSET = 10;
var wrapAnsi16 = /* @__PURE__ */ __name((offset = 0) => (code) => `\x1B[${code + offset}m`, "wrapAnsi16");
var wrapAnsi256 = /* @__PURE__ */ __name((offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`, "wrapAnsi256");
var wrapAnsi16m = /* @__PURE__ */ __name((offset = 0) => (red2, green2, blue2) => `\x1B[${38 + offset};2;${red2};${green2};${blue2}m`, "wrapAnsi16m");
var styles = {
  modifier: {
    reset: [0, 0],
    // 21 isn't widely supported and 22 does the same thing
    bold: [1, 22],
    dim: [2, 22],
    italic: [3, 23],
    underline: [4, 24],
    overline: [53, 55],
    inverse: [7, 27],
    hidden: [8, 28],
    strikethrough: [9, 29]
  },
  color: {
    black: [30, 39],
    red: [31, 39],
    green: [32, 39],
    yellow: [33, 39],
    blue: [34, 39],
    magenta: [35, 39],
    cyan: [36, 39],
    white: [37, 39],
    // Bright color
    blackBright: [90, 39],
    gray: [90, 39],
    // Alias of `blackBright`
    grey: [90, 39],
    // Alias of `blackBright`
    redBright: [91, 39],
    greenBright: [92, 39],
    yellowBright: [93, 39],
    blueBright: [94, 39],
    magentaBright: [95, 39],
    cyanBright: [96, 39],
    whiteBright: [97, 39]
  },
  bgColor: {
    bgBlack: [40, 49],
    bgRed: [41, 49],
    bgGreen: [42, 49],
    bgYellow: [43, 49],
    bgBlue: [44, 49],
    bgMagenta: [45, 49],
    bgCyan: [46, 49],
    bgWhite: [47, 49],
    // Bright color
    bgBlackBright: [100, 49],
    bgGray: [100, 49],
    // Alias of `bgBlackBright`
    bgGrey: [100, 49],
    // Alias of `bgBlackBright`
    bgRedBright: [101, 49],
    bgGreenBright: [102, 49],
    bgYellowBright: [103, 49],
    bgBlueBright: [104, 49],
    bgMagentaBright: [105, 49],
    bgCyanBright: [106, 49],
    bgWhiteBright: [107, 49]
  }
};
var modifierNames = Object.keys(styles.modifier);
var foregroundColorNames = Object.keys(styles.color);
var backgroundColorNames = Object.keys(styles.bgColor);
var colorNames = [...foregroundColorNames, ...backgroundColorNames];
function assembleStyles() {
  const codes = /* @__PURE__ */ new Map();
  for (const [groupName, group] of Object.entries(styles)) {
    for (const [styleName, style] of Object.entries(group)) {
      styles[styleName] = {
        open: `\x1B[${style[0]}m`,
        close: `\x1B[${style[1]}m`
      };
      group[styleName] = styles[styleName];
      codes.set(style[0], style[1]);
    }
    Object.defineProperty(styles, groupName, {
      value: group,
      enumerable: false
    });
  }
  Object.defineProperty(styles, "codes", {
    value: codes,
    enumerable: false
  });
  styles.color.close = "\x1B[39m";
  styles.bgColor.close = "\x1B[49m";
  styles.color.ansi = wrapAnsi16();
  styles.color.ansi256 = wrapAnsi256();
  styles.color.ansi16m = wrapAnsi16m();
  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
  Object.defineProperties(styles, {
    rgbToAnsi256: {
      value: (red2, green2, blue2) => {
        if (red2 === green2 && green2 === blue2) {
          if (red2 < 8) {
            return 16;
          }
          if (red2 > 248) {
            return 231;
          }
          return Math.round((red2 - 8) / 247 * 24) + 232;
        }
        return 16 + 36 * Math.round(red2 / 255 * 5) + 6 * Math.round(green2 / 255 * 5) + Math.round(blue2 / 255 * 5);
      },
      enumerable: false
    },
    hexToRgb: {
      value: (hex) => {
        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
        if (!matches) {
          return [0, 0, 0];
        }
        let [colorString] = matches;
        if (colorString.length === 3) {
          colorString = [...colorString].map((character) => character + character).join("");
        }
        const integer = Number.parseInt(colorString, 16);
        return [
          /* eslint-disable no-bitwise */
          integer >> 16 & 255,
          integer >> 8 & 255,
          integer & 255
          /* eslint-enable no-bitwise */
        ];
      },
      enumerable: false
    },
    hexToAnsi256: {
      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
      enumerable: false
    },
    ansi256ToAnsi: {
      value: (code) => {
        if (code < 8) {
          return 30 + code;
        }
        if (code < 16) {
          return 90 + (code - 8);
        }
        let red2;
        let green2;
        let blue2;
        if (code >= 232) {
          red2 = ((code - 232) * 10 + 8) / 255;
          green2 = red2;
          blue2 = red2;
        } else {
          code -= 16;
          const remainder = code % 36;
          red2 = Math.floor(code / 36) / 5;
          green2 = Math.floor(remainder / 6) / 5;
          blue2 = remainder % 6 / 5;
        }
        const value = Math.max(red2, green2, blue2) * 2;
        if (value === 0) {
          return 30;
        }
        let result = 30 + (Math.round(blue2) << 2 | Math.round(green2) << 1 | Math.round(red2));
        if (value === 2) {
          result += 60;
        }
        return result;
      },
      enumerable: false
    },
    rgbToAnsi: {
      value: (red2, green2, blue2) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red2, green2, blue2)),
      enumerable: false
    },
    hexToAnsi: {
      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
      enumerable: false
    }
  });
  return styles;
}
__name(assembleStyles, "assembleStyles");
var ansiStyles = assembleStyles();
var ansi_styles_default = ansiStyles;

// ../../node_modules/.pnpm/wrap-ansi@8.1.0/node_modules/wrap-ansi/index.js
var ESCAPES = /* @__PURE__ */ new Set([
  "\x1B",
  "\x9B"
]);
var END_CODE = 39;
var ANSI_ESCAPE_BELL = "\x07";
var ANSI_CSI = "[";
var ANSI_OSC = "]";
var ANSI_SGR_TERMINATOR = "m";
var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
var wrapAnsiCode = /* @__PURE__ */ __name((code) => `${ESCAPES.values().next().value}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`, "wrapAnsiCode");
var wrapAnsiHyperlink = /* @__PURE__ */ __name((uri) => `${ESCAPES.values().next().value}${ANSI_ESCAPE_LINK}${uri}${ANSI_ESCAPE_BELL}`, "wrapAnsiHyperlink");
var wordLengths = /* @__PURE__ */ __name((string) => string.split(" ").map((character) => stringWidth(character)), "wordLengths");
var wrapWord = /* @__PURE__ */ __name((rows, word, columns) => {
  const characters = [...word];
  let isInsideEscape = false;
  let isInsideLinkEscape = false;
  let visible = stringWidth(stripAnsi2(rows[rows.length - 1]));
  for (const [index, character] of characters.entries()) {
    const characterLength = stringWidth(character);
    if (visible + characterLength <= columns) {
      rows[rows.length - 1] += character;
    } else {
      rows.push(character);
      visible = 0;
    }
    if (ESCAPES.has(character)) {
      isInsideEscape = true;
      isInsideLinkEscape = characters.slice(index + 1).join("").startsWith(ANSI_ESCAPE_LINK);
    }
    if (isInsideEscape) {
      if (isInsideLinkEscape) {
        if (character === ANSI_ESCAPE_BELL) {
          isInsideEscape = false;
          isInsideLinkEscape = false;
        }
      } else if (character === ANSI_SGR_TERMINATOR) {
        isInsideEscape = false;
      }
      continue;
    }
    visible += characterLength;
    if (visible === columns && index < characters.length - 1) {
      rows.push("");
      visible = 0;
    }
  }
  if (!visible && rows[rows.length - 1].length > 0 && rows.length > 1) {
    rows[rows.length - 2] += rows.pop();
  }
}, "wrapWord");
var stringVisibleTrimSpacesRight = /* @__PURE__ */ __name((string) => {
  const words = string.split(" ");
  let last = words.length;
  while (last > 0) {
    if (stringWidth(words[last - 1]) > 0) {
      break;
    }
    last--;
  }
  if (last === words.length) {
    return string;
  }
  return words.slice(0, last).join(" ") + words.slice(last).join("");
}, "stringVisibleTrimSpacesRight");
var exec = /* @__PURE__ */ __name((string, columns, options29 = {}) => {
  if (options29.trim !== false && string.trim() === "") {
    return "";
  }
  let returnValue = "";
  let escapeCode;
  let escapeUrl;
  const lengths = wordLengths(string);
  let rows = [""];
  for (const [index, word] of string.split(" ").entries()) {
    if (options29.trim !== false) {
      rows[rows.length - 1] = rows[rows.length - 1].trimStart();
    }
    let rowLength = stringWidth(rows[rows.length - 1]);
    if (index !== 0) {
      if (rowLength >= columns && (options29.wordWrap === false || options29.trim === false)) {
        rows.push("");
        rowLength = 0;
      }
      if (rowLength > 0 || options29.trim === false) {
        rows[rows.length - 1] += " ";
        rowLength++;
      }
    }
    if (options29.hard && lengths[index] > columns) {
      const remainingColumns = columns - rowLength;
      const breaksStartingThisLine = 1 + Math.floor((lengths[index] - remainingColumns - 1) / columns);
      const breaksStartingNextLine = Math.floor((lengths[index] - 1) / columns);
      if (breaksStartingNextLine < breaksStartingThisLine) {
        rows.push("");
      }
      wrapWord(rows, word, columns);
      continue;
    }
    if (rowLength + lengths[index] > columns && rowLength > 0 && lengths[index] > 0) {
      if (options29.wordWrap === false && rowLength < columns) {
        wrapWord(rows, word, columns);
        continue;
      }
      rows.push("");
    }
    if (rowLength + lengths[index] > columns && options29.wordWrap === false) {
      wrapWord(rows, word, columns);
      continue;
    }
    rows[rows.length - 1] += word;
  }
  if (options29.trim !== false) {
    rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
  }
  const pre = [...rows.join("\n")];
  for (const [index, character] of pre.entries()) {
    returnValue += character;
    if (ESCAPES.has(character)) {
      const { groups } = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`).exec(pre.slice(index).join("")) || { groups: {} };
      if (groups.code !== void 0) {
        const code2 = Number.parseFloat(groups.code);
        escapeCode = code2 === END_CODE ? void 0 : code2;
      } else if (groups.uri !== void 0) {
        escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
      }
    }
    const code = ansi_styles_default.codes.get(Number(escapeCode));
    if (pre[index + 1] === "\n") {
      if (escapeUrl) {
        returnValue += wrapAnsiHyperlink("");
      }
      if (escapeCode && code) {
        returnValue += wrapAnsiCode(code);
      }
    } else if (character === "\n") {
      if (escapeCode && code) {
        returnValue += wrapAnsiCode(escapeCode);
      }
      if (escapeUrl) {
        returnValue += wrapAnsiHyperlink(escapeUrl);
      }
    }
  }
  return returnValue;
}, "exec");
function wrapAnsi(string, columns, options29) {
  return String(string).normalize().replace(/\r\n/g, "\n").split("\n").map((line) => exec(line, columns, options29)).join("\n");
}
__name(wrapAnsi, "wrapAnsi");

// ../../node_modules/.pnpm/slice-ansi@5.0.0/node_modules/slice-ansi/index.js
init_import_meta_url();

// ../../node_modules/.pnpm/is-fullwidth-code-point@4.0.0/node_modules/is-fullwidth-code-point/index.js
init_import_meta_url();
function isFullwidthCodePoint(codePoint) {
  if (!Number.isInteger(codePoint)) {
    return false;
  }
  return codePoint >= 4352 && (codePoint <= 4447 || // Hangul Jamo
  codePoint === 9001 || // LEFT-POINTING ANGLE BRACKET
  codePoint === 9002 || // RIGHT-POINTING ANGLE BRACKET
  // CJK Radicals Supplement .. Enclosed CJK Letters and Months
  11904 <= codePoint && codePoint <= 12871 && codePoint !== 12351 || // Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A
  12880 <= codePoint && codePoint <= 19903 || // CJK Unified Ideographs .. Yi Radicals
  19968 <= codePoint && codePoint <= 42182 || // Hangul Jamo Extended-A
  43360 <= codePoint && codePoint <= 43388 || // Hangul Syllables
  44032 <= codePoint && codePoint <= 55203 || // CJK Compatibility Ideographs
  63744 <= codePoint && codePoint <= 64255 || // Vertical Forms
  65040 <= codePoint && codePoint <= 65049 || // CJK Compatibility Forms .. Small Form Variants
  65072 <= codePoint && codePoint <= 65131 || // Halfwidth and Fullwidth Forms
  65281 <= codePoint && codePoint <= 65376 || 65504 <= codePoint && codePoint <= 65510 || // Kana Supplement
  110592 <= codePoint && codePoint <= 110593 || // Enclosed Ideographic Supplement
  127488 <= codePoint && codePoint <= 127569 || // CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane
  131072 <= codePoint && codePoint <= 262141);
}
__name(isFullwidthCodePoint, "isFullwidthCodePoint");

// ../../node_modules/.pnpm/slice-ansi@5.0.0/node_modules/slice-ansi/index.js
var astralRegex = /^[\uD800-\uDBFF][\uDC00-\uDFFF]$/;
var ESCAPES2 = [
  "\x1B",
  "\x9B"
];
var wrapAnsi2 = /* @__PURE__ */ __name((code) => `${ESCAPES2[0]}[${code}m`, "wrapAnsi");
var checkAnsi = /* @__PURE__ */ __name((ansiCodes, isEscapes, endAnsiCode) => {
  let output = [];
  ansiCodes = [...ansiCodes];
  for (let ansiCode of ansiCodes) {
    const ansiCodeOrigin = ansiCode;
    if (ansiCode.includes(";")) {
      ansiCode = ansiCode.split(";")[0][0] + "0";
    }
    const item = ansi_styles_default.codes.get(Number.parseInt(ansiCode, 10));
    if (item) {
      const indexEscape = ansiCodes.indexOf(item.toString());
      if (indexEscape === -1) {
        output.push(wrapAnsi2(isEscapes ? item : ansiCodeOrigin));
      } else {
        ansiCodes.splice(indexEscape, 1);
      }
    } else if (isEscapes) {
      output.push(wrapAnsi2(0));
      break;
    } else {
      output.push(wrapAnsi2(ansiCodeOrigin));
    }
  }
  if (isEscapes) {
    output = output.filter((element, index) => output.indexOf(element) === index);
    if (endAnsiCode !== void 0) {
      const fistEscapeCode = wrapAnsi2(ansi_styles_default.codes.get(Number.parseInt(endAnsiCode, 10)));
      output = output.reduce((current, next) => next === fistEscapeCode ? [next, ...current] : [...current, next], []);
    }
  }
  return output.join("");
}, "checkAnsi");
function sliceAnsi(string, begin, end) {
  const characters = [...string];
  const ansiCodes = [];
  let stringEnd = typeof end === "number" ? end : characters.length;
  let isInsideEscape = false;
  let ansiCode;
  let visible = 0;
  let output = "";
  for (const [index, character] of characters.entries()) {
    let leftEscape = false;
    if (ESCAPES2.includes(character)) {
      const code = /\d[^m]*/.exec(string.slice(index, index + 18));
      ansiCode = code && code.length > 0 ? code[0] : void 0;
      if (visible < stringEnd) {
        isInsideEscape = true;
        if (ansiCode !== void 0) {
          ansiCodes.push(ansiCode);
        }
      }
    } else if (isInsideEscape && character === "m") {
      isInsideEscape = false;
      leftEscape = true;
    }
    if (!isInsideEscape && !leftEscape) {
      visible++;
    }
    if (!astralRegex.test(character) && isFullwidthCodePoint(character.codePointAt())) {
      visible++;
      if (typeof end !== "number") {
        stringEnd++;
      }
    }
    if (visible > begin && visible <= stringEnd) {
      output += character;
    } else if (visible === begin && !isInsideEscape && ansiCode !== void 0) {
      output = checkAnsi(ansiCodes);
    } else if (visible >= stringEnd) {
      output += checkAnsi(ansiCodes, true, ansiCode);
      break;
    }
  }
  return output;
}
__name(sliceAnsi, "sliceAnsi");

// ../../node_modules/.pnpm/log-update@5.0.1/node_modules/log-update/index.js
var defaultTerminalHeight = 24;
var getWidth = /* @__PURE__ */ __name((stream2) => {
  const { columns } = stream2;
  if (!columns) {
    return 80;
  }
  return columns;
}, "getWidth");
var fitToTerminalHeight = /* @__PURE__ */ __name((stream2, text) => {
  const terminalHeight = stream2.rows || defaultTerminalHeight;
  const lines = text.split("\n");
  const toRemove = lines.length - terminalHeight;
  if (toRemove <= 0) {
    return text;
  }
  return sliceAnsi(
    text,
    stripAnsi2(lines.slice(0, toRemove).join("\n")).length + 1
  );
}, "fitToTerminalHeight");
function createLogUpdate(stream2, { showCursor = false } = {}) {
  let previousLineCount = 0;
  let previousWidth = getWidth(stream2);
  let previousOutput = "";
  const render7 = /* @__PURE__ */ __name((...arguments_) => {
    if (!showCursor) {
      cli_cursor_default.hide();
    }
    let output = arguments_.join(" ") + "\n";
    output = fitToTerminalHeight(stream2, output);
    const width = getWidth(stream2);
    if (output === previousOutput && previousWidth === width) {
      return;
    }
    previousOutput = output;
    previousWidth = width;
    output = wrapAnsi(output, width, {
      trim: false,
      hard: true,
      wordWrap: false
    });
    stream2.write(ansi_escapes_default.eraseLines(previousLineCount) + output);
    previousLineCount = output.split("\n").length;
  }, "render");
  render7.clear = () => {
    stream2.write(ansi_escapes_default.eraseLines(previousLineCount));
    previousOutput = "";
    previousWidth = getWidth(stream2);
    previousLineCount = 0;
  };
  render7.done = () => {
    previousOutput = "";
    previousWidth = getWidth(stream2);
    previousLineCount = 0;
    if (!showCursor) {
      cli_cursor_default.show();
    }
  };
  return render7;
}
__name(createLogUpdate, "createLogUpdate");
var logUpdate = createLogUpdate(import_node_process10.default.stdout);
var logUpdateStderr = createLogUpdate(import_node_process10.default.stderr);

// ../cli/select-list.ts
init_import_meta_url();
var SelectRefreshablePrompt = class extends h {
  options;
  cursor = 0;
  get _value() {
    return this.options[this.cursor];
  }
  changeValue() {
    this.value = this._value.value;
  }
  constructor(opts) {
    super(opts, false);
    this.options = opts.options;
    this.cursor = this.options.findIndex(
      ({ value }) => value === opts.initialValue
    );
    if (this.cursor === -1)
      this.cursor = 0;
    this.changeValue();
    this.on("key", (c2) => {
      if (c2 !== "r")
        return;
      void opts.onRefresh().then((newOptions) => {
        this.options = [...newOptions];
        this.cursor = 0;
        this.changeValue();
        const that = this;
        if ("render" in that && typeof that.render === "function") {
          that.render();
        }
      }).catch(() => {
      });
    });
    this.on("cursor", (key) => {
      switch (key) {
        case "left":
        case "up":
          this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
          break;
        case "down":
        case "right":
          this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
          break;
      }
      this.changeValue();
    });
  }
};
__name(SelectRefreshablePrompt, "SelectRefreshablePrompt");

// ../cli/interactive.ts
var logUpdate2 = createLogUpdate(stdout);
var grayBar = gray(shapes.bar);
var blCorner = gray(shapes.corners.bl);
var leftT = gray(shapes.leftT);
function acceptDefault(promptConfig, renderers, initialValue) {
  const error2 = promptConfig.validate?.(initialValue);
  if (error2) {
    crash(error2);
  }
  const lines = renderers.submit({ value: initialValue });
  logRaw(lines.join("\n"));
  return initialValue;
}
__name(acceptDefault, "acceptDefault");
var inputPrompt = /* @__PURE__ */ __name(async (promptConfig) => {
  const renderers = {
    ...getRenderers(promptConfig),
    ...promptConfig.renderers
  };
  let prompt2;
  const dispatchRender = /* @__PURE__ */ __name((props, p2) => {
    const renderedLines = renderers[props.state](props, p2);
    return renderedLines.join("\n");
  }, "dispatchRender");
  if (promptConfig.type === "select") {
    const initialValue = String(promptConfig.defaultValue);
    if (promptConfig.acceptDefault) {
      return acceptDefault(promptConfig, renderers, initialValue);
    }
    prompt2 = new ED({
      ...promptConfig,
      options: promptConfig.options.filter((o2) => !o2.hidden),
      initialValue,
      render() {
        return dispatchRender(this, prompt2);
      }
    });
  } else if (promptConfig.type === "confirm") {
    const initialValue = Boolean(promptConfig.defaultValue);
    if (promptConfig.acceptDefault) {
      return acceptDefault(promptConfig, renderers, initialValue);
    }
    prompt2 = new sD({
      ...promptConfig,
      initialValue,
      active: promptConfig.activeText || "",
      inactive: promptConfig.inactiveText || "",
      render() {
        return dispatchRender(this, prompt2);
      }
    });
  } else if (promptConfig.type == "multiselect") {
    let initialValues;
    if (Array.isArray(promptConfig.defaultValue)) {
      initialValues = promptConfig.defaultValue;
    } else if (promptConfig.defaultValue !== void 0) {
      initialValues = [String(promptConfig.defaultValue)];
    }
    if (promptConfig.acceptDefault) {
      return acceptDefault(promptConfig, renderers, initialValues);
    }
    prompt2 = new iD({
      ...promptConfig,
      options: promptConfig.options,
      initialValues,
      render() {
        return dispatchRender(this, prompt2);
      }
    });
  } else if (promptConfig.type === "list") {
    const initialValue = String(promptConfig.defaultValue);
    if (promptConfig.acceptDefault) {
      return acceptDefault(promptConfig, renderers, initialValue);
    }
    prompt2 = new SelectRefreshablePrompt({
      ...promptConfig,
      onRefresh: promptConfig.onRefresh ?? (() => Promise.resolve(promptConfig.options)),
      initialValue,
      render() {
        return dispatchRender(this, prompt2);
      }
    });
  } else {
    const initialValue = promptConfig.initialValue ?? String(promptConfig.defaultValue ?? "");
    if (promptConfig.acceptDefault) {
      return acceptDefault(promptConfig, renderers, initialValue);
    }
    prompt2 = new oD({
      ...promptConfig,
      initialValue: promptConfig.initialValue,
      defaultValue: String(promptConfig.defaultValue ?? ""),
      render() {
        return dispatchRender(this, prompt2);
      }
    });
  }
  const input = await prompt2.prompt();
  if (eD(input)) {
    cancel("Operation cancelled.");
    process.exit(0);
  }
  return input;
}, "inputPrompt");
var renderSubmit = /* @__PURE__ */ __name((config, value) => {
  const { question, label } = config;
  if (config.type !== "confirm" && value.length === 0) {
    return [`${leftT} ${question} ${dim("(skipped)")}`, `${grayBar}`];
  }
  const content = config.type === "confirm" ? `${grayBar} ${brandColor(value)} ${dim(label)}` : `${grayBar} ${brandColor(label)} ${dim(value)}`;
  return [`${leftT} ${question}`, content, `${grayBar}`];
}, "renderSubmit");
var handleCancel = /* @__PURE__ */ __name(() => {
  cancel("Operation cancelled.");
  process.exit(0);
}, "handleCancel");
var getRenderers = /* @__PURE__ */ __name((config) => {
  switch (config.type) {
    case "select":
      return getSelectRenderers(config);
    case "confirm":
      return getConfirmRenderers(config);
    case "text":
      return getTextRenderers(config);
    case "multiselect":
      return getSelectRenderers(config);
    case "list":
      return getSelectListRenderers(config);
  }
}, "getRenderers");
var getTextRenderers = /* @__PURE__ */ __name((config) => {
  const { question } = config;
  const helpText = config.helpText ?? "";
  const format10 = config.format ?? ((val) => String(val));
  const defaultValue = config.defaultValue?.toString() ?? "";
  return {
    initial: () => [
      `${blCorner} ${bold(question)} ${dim(helpText)}`,
      `${space(2)}${gray(format10(defaultValue))}`,
      ``
      // extra line for readability
    ],
    active: ({ value }) => [
      `${blCorner} ${bold(question)} ${dim(helpText)}`,
      `${space(2)}${format10(value || dim(defaultValue))}`,
      ``
      // extra line for readability
    ],
    error: ({ value, error: error2 }) => [
      `${leftT} ${status.error} ${dim(error2)}`,
      `${grayBar}`,
      `${blCorner} ${question} ${dim(helpText)}`,
      `${space(2)}${format10(value)}`,
      ``
      // extra line for readability
    ],
    submit: ({ value }) => renderSubmit(config, format10(value ?? "")),
    cancel: handleCancel
  };
}, "getTextRenderers");
var getSelectRenderers = /* @__PURE__ */ __name((config) => {
  const { options: options29, question, helpText: _helpText } = config;
  const helpText = _helpText ?? "";
  const maxItemsPerPage = config.maxItemsPerPage ?? 32;
  const defaultRenderer = /* @__PURE__ */ __name(({ cursor, value }) => {
    cursor = cursor ?? 0;
    const renderOption = /* @__PURE__ */ __name((opt, i) => {
      const { label: optionLabel, value: optionValue } = opt;
      const active2 = i === cursor;
      const isInListOfValues = Array.isArray(value) && value.includes(optionValue);
      const color = isInListOfValues || active2 ? blue : white;
      const text = active2 ? color.underline(optionLabel) : color(optionLabel);
      const sublabel = opt.sublabel ? color.grey(opt.sublabel) : "";
      const indicator = isInListOfValues || active2 && !Array.isArray(value) ? color(shapes.radioActive) : color(shapes.radioInactive);
      return `${space(2)}${indicator} ${text} ${sublabel}`;
    }, "renderOption");
    const renderOptionCondition = /* @__PURE__ */ __name((_3, i) => {
      if (options29.length <= maxItemsPerPage) {
        return true;
      }
      cursor = cursor ?? 0;
      if (i < cursor) {
        return options29.length - i <= maxItemsPerPage;
      }
      return cursor + maxItemsPerPage > i;
    }, "renderOptionCondition");
    return [
      `${blCorner} ${bold(question)} ${dim(helpText)}`,
      `${cursor > 0 && options29.length > maxItemsPerPage ? `${space(2)}${dim("...")}
` : ""}${options29.filter((o2) => !o2.hidden).map(renderOption).filter(renderOptionCondition).join(`
`)}${cursor + maxItemsPerPage < options29.length && options29.length > maxItemsPerPage ? `
${space(2)}${dim("...")}` : ""}`,
      ``
      // extra line for readability
    ];
  }, "defaultRenderer");
  return {
    initial: defaultRenderer,
    active: defaultRenderer,
    confirm: defaultRenderer,
    error: (opts, prompt2) => {
      return [
        `${leftT} ${status.error} ${dim(opts.error)}`,
        `${grayBar}`,
        ...defaultRenderer(opts, prompt2)
      ];
    },
    submit: ({ value }) => {
      if (Array.isArray(value)) {
        return renderSubmit(
          config,
          options29.filter((o2) => value.includes(o2.value)).map((o2) => o2.label).join(", ")
        );
      }
      return renderSubmit(
        config,
        options29.find((o2) => o2.value === value)?.label
      );
    },
    cancel: handleCancel
  };
}, "getSelectRenderers");
var getSelectListRenderers = /* @__PURE__ */ __name((config) => {
  const { question, helpText: _helpText } = config;
  let options29 = config.options;
  const helpText = _helpText ?? "";
  const { rows } = stdout;
  const defaultRenderer = /* @__PURE__ */ __name(({ cursor, value }, prompt2) => {
    if (prompt2 instanceof SelectRefreshablePrompt) {
      options29 = prompt2.options;
    }
    cursor = cursor ?? 0;
    let smallCursor = 0;
    const renderOption = /* @__PURE__ */ __name((opt, i) => {
      const { label: optionLabel, value: optionValueAny } = opt;
      const optionValue = optionValueAny.toString();
      const active2 = i === smallCursor;
      const isInListOfValues = Array.isArray(value) && value.includes(optionValue);
      const color = isInListOfValues || active2 ? blue : white;
      const text = active2 ? color.underline(optionLabel) : color(optionLabel);
      const indicator = isInListOfValues || active2 && !Array.isArray(value) ? color(shapes.radioActive) : color(shapes.radioInactive);
      const indicatorMargin = 2;
      const detailBulletpointMargin = indicatorMargin + 4;
      return [
        `${space(indicatorMargin)}${indicator} ${text}`,
        ...opt.details.map(
          (detail, j2) => `${space(detailBulletpointMargin)}${j2 === opt.details.length - 1 ? gray(shapes.corners.bl) : grayBar} ${detail}`
        )
      ];
    }, "renderOption");
    const pages2 = [];
    let current = {
      size: 0,
      options: []
    };
    const VERTICAL_MARGIN = 6;
    for (const option of options29) {
      const optionHeight = option.details.length + 1;
      if (current.size + optionHeight > rows - VERTICAL_MARGIN) {
        pages2.push(current.options);
        current = { size: optionHeight, options: [option] };
        continue;
      }
      current.size += optionHeight;
      current.options.push(option);
    }
    if (current.size !== 0) {
      pages2.push(current.options);
    }
    let isFirstPage = true;
    let isLastPage = false;
    let page = [];
    let len = 0;
    for (let i = 0; i < pages2.length; i++) {
      const pageIter = pages2[i];
      if (cursor >= len && pageIter.length + len > cursor) {
        isFirstPage = i === 0;
        isLastPage = i === pages2.length - 1;
        page = pageIter;
        smallCursor = cursor - len;
        break;
      }
      len += pageIter.length;
    }
    return [
      `${blCorner} ${bold(question)} ${dim(helpText)}`,
      ...!isFirstPage ? [`${space(2)}${dim("...")}`] : [],
      ...page.map(renderOption).reduce((prev, now) => [...prev, ...now], []),
      ...!isLastPage ? [`${space(2)}${dim("...")}`] : []
    ];
  }, "defaultRenderer");
  return {
    initial: defaultRenderer,
    active: defaultRenderer,
    confirm: defaultRenderer,
    error: (opts, prompt2) => {
      return [
        `${leftT} ${status.error} ${dim(opts.error)}`,
        `${grayBar}`,
        ...defaultRenderer(opts, prompt2)
      ];
    },
    submit: ({ value }) => {
      if (Array.isArray(value)) {
        return renderSubmit(
          config,
          options29.filter((o2) => value.includes(o2.value)).map((o2) => o2.value).join(", ")
        );
      }
      return renderSubmit(
        config,
        options29.find((o2) => o2.value === value)?.value
      );
    },
    cancel: handleCancel
  };
}, "getSelectListRenderers");
var getConfirmRenderers = /* @__PURE__ */ __name((config) => {
  const { activeText, inactiveText, question, helpText: _helpText } = config;
  const helpText = _helpText ?? "";
  const active2 = activeText || "Yes";
  const inactive = inactiveText || "No";
  const defaultRenderer = /* @__PURE__ */ __name(({ value }) => {
    const yesColor = value ? blue.underline : dim;
    const noColor = value ? dim : blue.underline;
    return [
      `${blCorner} ${bold(question)} ${dim(helpText)}`,
      `${space(2)}${yesColor(active2)} / ${noColor(inactive)}`
    ];
  }, "defaultRenderer");
  return {
    initial: defaultRenderer,
    active: defaultRenderer,
    confirm: defaultRenderer,
    error: defaultRenderer,
    submit: ({ value }) => renderSubmit(config, value ? "yes" : "no"),
    cancel: handleCancel
  };
}, "getConfirmRenderers");
var spinnerFrames = {
  clockwise: ["\u2524", "\u2518", "\u2534", "\u2514", "\u251C", "\u250C", "\u252C", "\u2510"],
  vertical: ["\u2581", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2586", "\u2585", "\u2584", "\u2583"]
};
var ellipsisFrames = ["", ".", "..", "...", " ..", "  .", ""];
var spinner = /* @__PURE__ */ __name((frames = spinnerFrames.clockwise, color = brandColor) => {
  const frameRate = 120;
  let loop = null;
  let startMsg;
  let currentMsg;
  function clearLoop() {
    if (loop) {
      clearTimeout(loop);
    }
    loop = null;
  }
  __name(clearLoop, "clearLoop");
  return {
    start(msg, helpText) {
      helpText ||= ``;
      currentMsg = msg;
      startMsg = `${currentMsg} ${dim(helpText)}`;
      if (isInteractive2()) {
        let index = 0;
        clearLoop();
        loop = setInterval(() => {
          index++;
          const spinnerFrame = frames[index % frames.length];
          const ellipsisFrame = ellipsisFrames[index % ellipsisFrames.length];
          if (msg) {
            logUpdate2(`${color(spinnerFrame)} ${currentMsg} ${ellipsisFrame}`);
          }
        }, frameRate);
      } else {
        logUpdate2(`${leftT} ${startMsg}`);
      }
    },
    update(msg) {
      currentMsg = msg;
    },
    stop(msg) {
      if (isInteractive2()) {
        logUpdate2.clear();
        if (msg) {
          logUpdate2(`${leftT} ${startMsg}
${grayBar} ${msg}`);
          logUpdate2.done();
          newline();
        }
        clearLoop();
      } else {
        if (msg !== void 0) {
          logUpdate2(`
${grayBar} ${msg}`);
        }
        newline();
      }
    }
  };
}, "spinner");
var unwrapFactory = /* @__PURE__ */ __name((input) => {
  const output = typeof input === "function" ? input() : input;
  return output;
}, "unwrapFactory");
var spinnerWhile = /* @__PURE__ */ __name(async (opts) => {
  const s = opts.spinner ?? spinner();
  s.start(unwrapFactory(opts.startMessage));
  try {
    const result = await unwrapFactory(opts.promise);
    return result;
  } finally {
    s.stop(unwrapFactory(opts.endMessage));
  }
}, "spinnerWhile");
var isInteractive2 = /* @__PURE__ */ __name(() => {
  return process.stdin.isTTY;
}, "isInteractive");

// src/cloudchamber/client/index.ts
init_import_meta_url();

// src/cloudchamber/client/core/ApiError.ts
init_import_meta_url();
var ApiError = class extends Error {
  url;
  status;
  statusText;
  body;
  request;
  constructor(request3, response, message) {
    super(message);
    this.name = "ApiError";
    this.url = response.url;
    this.status = response.status;
    this.statusText = response.statusText;
    this.body = response.body;
    this.request = request3;
  }
};
__name(ApiError, "ApiError");

// src/cloudchamber/client/core/CancelablePromise.ts
init_import_meta_url();
var CancelError = class extends Error {
  constructor(message) {
    super(message);
    this.name = "CancelError";
  }
  get isCancelled() {
    return true;
  }
};
__name(CancelError, "CancelError");
var CancelablePromise = class {
  #isResolved;
  #isRejected;
  #isCancelled;
  #cancelHandlers;
  #promise;
  #resolve;
  #reject;
  constructor(executor) {
    this.#isResolved = false;
    this.#isRejected = false;
    this.#isCancelled = false;
    this.#cancelHandlers = [];
    this.#promise = new Promise((resolve19, reject) => {
      this.#resolve = resolve19;
      this.#reject = reject;
      const onResolve = /* @__PURE__ */ __name((value) => {
        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
          return;
        }
        this.#isResolved = true;
        this.#resolve?.(value);
      }, "onResolve");
      const onReject = /* @__PURE__ */ __name((reason) => {
        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
          return;
        }
        this.#isRejected = true;
        this.#reject?.(reason);
      }, "onReject");
      const onCancel = /* @__PURE__ */ __name((cancelHandler) => {
        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
          return;
        }
        this.#cancelHandlers.push(cancelHandler);
      }, "onCancel");
      Object.defineProperty(onCancel, "isResolved", {
        get: () => this.#isResolved
      });
      Object.defineProperty(onCancel, "isRejected", {
        get: () => this.#isRejected
      });
      Object.defineProperty(onCancel, "isCancelled", {
        get: () => this.#isCancelled
      });
      return executor(onResolve, onReject, onCancel);
    });
  }
  get [Symbol.toStringTag]() {
    return "Cancellable Promise";
  }
  then(onFulfilled, onRejected) {
    return this.#promise.then(onFulfilled, onRejected);
  }
  catch(onRejected) {
    return this.#promise.catch(onRejected);
  }
  finally(onFinally) {
    return this.#promise.finally(onFinally);
  }
  cancel() {
    if (this.#isResolved || this.#isRejected || this.#isCancelled) {
      return;
    }
    this.#isCancelled = true;
    if (this.#cancelHandlers.length) {
      try {
        for (const cancelHandler of this.#cancelHandlers) {
          cancelHandler();
        }
      } catch (error2) {
        console.warn("Cancellation threw an error", error2);
        return;
      }
    }
    this.#cancelHandlers.length = 0;
    this.#reject?.(new CancelError("Request aborted"));
  }
  get isCancelled() {
    return this.#isCancelled;
  }
};
__name(CancelablePromise, "CancelablePromise");

// src/cloudchamber/client/core/OpenAPI.ts
init_import_meta_url();
var OpenAPI = {
  BASE: "",
  VERSION: "1.0.0",
  WITH_CREDENTIALS: false,
  CREDENTIALS: "include",
  TOKEN: void 0,
  USERNAME: void 0,
  PASSWORD: void 0,
  HEADERS: void 0,
  ENCODE_PATH: void 0
};

// src/cloudchamber/client/models/ApplicationMutationError.ts
init_import_meta_url();

// src/cloudchamber/client/models/AssignIPv4.ts
init_import_meta_url();

// src/cloudchamber/client/models/BadRequestWithCodeError.ts
init_import_meta_url();
var BadRequestWithCodeError;
((BadRequestWithCodeError2) => {
  let error2;
  ((error3) => {
    error3["VALIDATE_INPUT"] = "VALIDATE_INPUT";
  })(error2 = BadRequestWithCodeError2.error || (BadRequestWithCodeError2.error = {}));
})(BadRequestWithCodeError || (BadRequestWithCodeError = {}));

// src/cloudchamber/client/models/DeploymentMutationError.ts
init_import_meta_url();
var DeploymentMutationError = /* @__PURE__ */ ((DeploymentMutationError2) => {
  DeploymentMutationError2["VALIDATE_INPUT"] = "VALIDATE_INPUT";
  DeploymentMutationError2["SURPASSED_BASE_LIMITS"] = "SURPASSED_BASE_LIMITS";
  DeploymentMutationError2["SURPASSED_TOTAL_LIMITS"] = "SURPASSED_TOTAL_LIMITS";
  DeploymentMutationError2["LOCATION_NOT_ALLOWED"] = "LOCATION_NOT_ALLOWED";
  DeploymentMutationError2["LOCATION_SURPASSED_BASE_LIMITS"] = "LOCATION_SURPASSED_BASE_LIMITS";
  DeploymentMutationError2["IMAGE_REGISTRY_NOT_CONFIGURED"] = "IMAGE_REGISTRY_NOT_CONFIGURED";
  return DeploymentMutationError2;
})(DeploymentMutationError || {});

// src/cloudchamber/client/models/DeploymentQueuedReason.ts
init_import_meta_url();

// src/cloudchamber/client/models/DeploymentSchedulingState.ts
init_import_meta_url();

// src/cloudchamber/client/models/DeploymentType.ts
init_import_meta_url();

// src/cloudchamber/client/models/ImageRegistryAlreadyExistsError.ts
init_import_meta_url();
var ImageRegistryAlreadyExistsError;
((ImageRegistryAlreadyExistsError2) => {
  let error2;
  ((error3) => {
    error3["IMAGE_REGISTRY_ALREADY_EXISTS"] = "IMAGE_REGISTRY_ALREADY_EXISTS";
  })(error2 = ImageRegistryAlreadyExistsError2.error || (ImageRegistryAlreadyExistsError2.error = {}));
})(ImageRegistryAlreadyExistsError || (ImageRegistryAlreadyExistsError = {}));

// src/cloudchamber/client/models/ImageRegistryIsPublic.ts
init_import_meta_url();
var ImageRegistryIsPublic;
((ImageRegistryIsPublic2) => {
  let error2;
  ((error3) => {
    error3["IMAGE_REGISTRY_IS_PUBLIC"] = "IMAGE_REGISTRY_IS_PUBLIC";
  })(error2 = ImageRegistryIsPublic2.error || (ImageRegistryIsPublic2.error = {}));
})(ImageRegistryIsPublic || (ImageRegistryIsPublic = {}));

// src/cloudchamber/client/models/ImageRegistryNotAllowedError.ts
init_import_meta_url();
var ImageRegistryNotAllowedError;
((ImageRegistryNotAllowedError2) => {
  let error2;
  ((error3) => {
    error3["IMAGE_REGISTRY_NOT_ALLOWED"] = "IMAGE_REGISTRY_NOT_ALLOWED";
  })(error2 = ImageRegistryNotAllowedError2.error || (ImageRegistryNotAllowedError2.error = {}));
})(ImageRegistryNotAllowedError || (ImageRegistryNotAllowedError = {}));

// src/cloudchamber/client/models/ImageRegistryNotFoundError.ts
init_import_meta_url();
var ImageRegistryNotFoundError;
((ImageRegistryNotFoundError2) => {
  let error2;
  ((error3) => {
    error3["IMAGE_REGISTRY_NOT_FOUND"] = "IMAGE_REGISTRY_NOT_FOUND";
  })(error2 = ImageRegistryNotFoundError2.error || (ImageRegistryNotFoundError2.error = {}));
})(ImageRegistryNotFoundError || (ImageRegistryNotFoundError = {}));

// src/cloudchamber/client/models/ImageRegistryPermissions.ts
init_import_meta_url();

// src/cloudchamber/client/models/IPType.ts
init_import_meta_url();

// src/cloudchamber/client/models/NetworkMode.ts
init_import_meta_url();

// src/cloudchamber/client/models/NodeGroup.ts
init_import_meta_url();

// src/cloudchamber/client/models/SchedulingPolicy.ts
init_import_meta_url();

// src/cloudchamber/client/models/State.ts
init_import_meta_url();

// src/cloudchamber/client/services/AccountService.ts
init_import_meta_url();

// src/cloudchamber/client/core/request.ts
init_import_meta_url();
var import_undici8 = __toESM(require_undici());
var isDefined = /* @__PURE__ */ __name((value) => {
  return value !== void 0 && value !== null;
}, "isDefined");
var isString2 = /* @__PURE__ */ __name((value) => {
  return typeof value === "string";
}, "isString");
var isStringWithValue = /* @__PURE__ */ __name((value) => {
  return isString2(value) && value !== "";
}, "isStringWithValue");
var isBlob = /* @__PURE__ */ __name((value) => {
  return typeof value === "object" && typeof value.type === "string" && typeof value.stream === "function" && typeof value.arrayBuffer === "function" && typeof value.constructor === "function" && typeof value.constructor.name === "string" && /^(Blob|File)$/.test(value.constructor.name) && /^(Blob|File)$/.test(value[Symbol.toStringTag]);
}, "isBlob");
var base64 = /* @__PURE__ */ __name((str) => {
  try {
    return btoa(str);
  } catch (err) {
    return Buffer.from(str).toString("base64");
  }
}, "base64");
var getQueryString = /* @__PURE__ */ __name((params) => {
  const qs = [];
  const append = /* @__PURE__ */ __name((key, value) => {
    qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
  }, "append");
  const process11 = /* @__PURE__ */ __name((key, value) => {
    if (isDefined(value)) {
      if (Array.isArray(value)) {
        value.forEach((v2) => {
          process11(key, v2);
        });
      } else if (typeof value === "object") {
        Object.entries(value).forEach(([k2, v2]) => {
          process11(`${key}[${k2}]`, v2);
        });
      } else {
        append(key, value);
      }
    }
  }, "process");
  Object.entries(params).forEach(([key, value]) => {
    process11(key, value);
  });
  if (qs.length > 0) {
    return `?${qs.join("&")}`;
  }
  return "";
}, "getQueryString");
var getUrl = /* @__PURE__ */ __name((config, options29) => {
  const encoder = config.ENCODE_PATH || encodeURI;
  const path67 = options29.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
    if (options29.path?.hasOwnProperty(group)) {
      return encoder(String(options29.path[group]));
    }
    return substring;
  });
  const url4 = `${config.BASE}${path67}`;
  if (options29.query) {
    return `${url4}${getQueryString(options29.query)}`;
  }
  return url4;
}, "getUrl");
var getFormData = /* @__PURE__ */ __name((options29) => {
  if (options29.formData) {
    const formData = new import_undici8.FormData();
    const process11 = /* @__PURE__ */ __name((key, value) => {
      if (isString2(value) || isBlob(value)) {
        formData.append(key, value);
      } else {
        formData.append(key, JSON.stringify(value));
      }
    }, "process");
    Object.entries(options29.formData).filter(([_3, value]) => isDefined(value)).forEach(([key, value]) => {
      if (Array.isArray(value)) {
        value.forEach((v2) => process11(key, v2));
      } else {
        process11(key, value);
      }
    });
    return formData;
  }
  return void 0;
}, "getFormData");
var resolve10 = /* @__PURE__ */ __name(async (options29, resolver) => {
  if (typeof resolver === "function") {
    return resolver(options29);
  }
  return resolver;
}, "resolve");
var getHeaders = /* @__PURE__ */ __name(async (config, options29) => {
  const token = await resolve10(options29, config.TOKEN);
  const username = await resolve10(options29, config.USERNAME);
  const password = await resolve10(options29, config.PASSWORD);
  const additionalHeaders = await resolve10(options29, config.HEADERS);
  const headers = Object.entries({
    Accept: "application/json",
    ...additionalHeaders,
    ...options29.headers
  }).filter(([_3, value]) => isDefined(value)).reduce(
    (headers2, [key, value]) => ({
      ...headers2,
      [key]: String(value)
    }),
    {}
  );
  if (isStringWithValue(token)) {
    headers["Authorization"] = `Bearer ${token}`;
  }
  if (isStringWithValue(username) && isStringWithValue(password)) {
    const credentials = base64(`${username}:${password}`);
    headers["Authorization"] = `Basic ${credentials}`;
  }
  if (options29.body) {
    if (options29.mediaType) {
      headers["Content-Type"] = options29.mediaType;
    } else if (isBlob(options29.body)) {
      headers["Content-Type"] = options29.body.type || "application/octet-stream";
    } else if (isString2(options29.body)) {
      headers["Content-Type"] = "text/plain";
    } else {
      headers["Content-Type"] = "application/json";
    }
  }
  return new import_undici8.Headers(headers);
}, "getHeaders");
var getRequestBody = /* @__PURE__ */ __name((options29) => {
  if (options29.body !== void 0) {
    if (options29.mediaType?.includes("/json")) {
      return JSON.stringify(options29.body);
    } else if (isString2(options29.body) || isBlob(options29.body)) {
      return options29.body;
    } else {
      return JSON.stringify(options29.body);
    }
  }
  return void 0;
}, "getRequestBody");
var sendRequest = /* @__PURE__ */ __name(async (config, options29, url4, body, formData, headers, onCancel) => {
  const controller = new AbortController();
  const request3 = {
    headers,
    body: body ?? formData,
    method: options29.method,
    signal: controller.signal,
    dispatcher: config.AGENT ?? void 0
  };
  if (config.WITH_CREDENTIALS) {
    request3.credentials = config.CREDENTIALS;
  }
  onCancel(() => controller.abort());
  return await (0, import_undici8.fetch)(url4, request3);
}, "sendRequest");
var getResponseHeader = /* @__PURE__ */ __name((response, responseHeader) => {
  if (responseHeader) {
    const content = response.headers.get(responseHeader);
    if (isString2(content)) {
      return content;
    }
  }
  return void 0;
}, "getResponseHeader");
var getResponseBody = /* @__PURE__ */ __name(async (response) => {
  if (response.status !== 204) {
    try {
      const contentType = response.headers.get("Content-Type");
      if (contentType) {
        const jsonTypes = ["application/json", "application/problem+json"];
        const isJSON = jsonTypes.some(
          (type) => contentType.toLowerCase().startsWith(type)
        );
        if (isJSON) {
          return await response.json();
        } else {
          return await response.text();
        }
      }
    } catch (error2) {
      console.error(error2);
    }
  }
  return void 0;
}, "getResponseBody");
var catchErrorCodes = /* @__PURE__ */ __name((options29, result) => {
  const errors = {
    400: "Bad Request",
    401: "Unauthorized",
    403: "Forbidden",
    404: "Not Found",
    500: "Internal Server Error",
    502: "Bad Gateway",
    503: "Service Unavailable",
    ...options29.errors
  };
  const error2 = errors[result.status];
  if (error2) {
    throw new ApiError(options29, result, error2);
  }
  if (!result.ok) {
    throw new ApiError(options29, result, "Generic Error");
  }
}, "catchErrorCodes");
var request = /* @__PURE__ */ __name((config, options29) => {
  return new CancelablePromise(async (resolve19, reject, onCancel) => {
    try {
      const url4 = getUrl(config, options29);
      const formData = getFormData(options29);
      const body = getRequestBody(options29);
      const headers = await getHeaders(config, options29);
      if (!onCancel.isCancelled) {
        const response = await sendRequest(
          config,
          options29,
          url4,
          body,
          formData,
          headers,
          onCancel
        );
        const responseBody = await getResponseBody(response);
        const responseHeader = getResponseHeader(
          response,
          options29.responseHeader
        );
        const result = {
          url: url4,
          ok: response.ok,
          status: response.status,
          statusText: response.statusText,
          body: responseHeader ?? responseBody
        };
        catchErrorCodes(options29, result);
        resolve19(result.body);
      }
    } catch (error2) {
      reject(error2);
    }
  });
}, "request");

// src/cloudchamber/client/services/AccountService.ts
var AccountService = class {
  /**
   * Get complete account details related to Cloudchamber
   * Get complete account details related to Cloudchamber, like limits and available locations
   * @returns CompleteAccountCustomer Complete account for the user
   * @throws ApiError
   */
  static getMe() {
    return request(OpenAPI, {
      method: "GET",
      url: "/me",
      errors: {
        401: `Unauthorized`,
        500: `There has been an internal error`
      }
    });
  }
  /**
   * Modify account details like defaults
   * Modify account details like defaults
   * @param requestBody
   * @returns CompleteAccountCustomer Complete account for the user
   * @throws ApiError
   */
  static modifyMe(requestBody) {
    return request(OpenAPI, {
      method: "PATCH",
      url: "/me",
      body: requestBody,
      mediaType: "application/json",
      errors: {
        400: `Bad Request that contains a specific constant code and details object about the error.`,
        401: `Unauthorized`,
        500: `There has been an internal error`
      }
    });
  }
};
__name(AccountService, "AccountService");

// src/cloudchamber/client/services/ApplicationsService.ts
init_import_meta_url();

// src/cloudchamber/client/services/DeploymentsService.ts
init_import_meta_url();
var DeploymentsService = class {
  /**
   * Create a new deployment
   * Creates a new deployment. A Deployment represents an intent to run one container, with image, in a particular location
   * @param requestBody
   * @returns DeploymentV2 Deployment created
   * @throws ApiError
   */
  static createDeploymentV2(requestBody) {
    return request(OpenAPI, {
      method: "POST",
      url: "/deployments/v2",
      body: requestBody,
      mediaType: "application/json",
      errors: {
        400: `Could not create the deployment because of input/limits reasons, more details in the error code`,
        401: `Unauthorized`,
        409: `Deployment already exists`,
        500: `Deployment Creation Error`
      }
    });
  }
  /**
   * List deployments
   * List all deployments in the current account. Optionally filter them
   * @param appId Filter deployments by application id
   * @param location Filter deployments by location
   * @param image Filter deployments by image
   * @param state Filter deployments by deployment state
   * @param ipv4 Filter deployments by ipv4 address
   * @param label Filter deployments by label
   * @returns ListDeploymentsV2 List of deployments with their corresponding placements
   * @throws ApiError
   */
  static listDeploymentsV2(appId, location, image, state, ipv4, label) {
    return request(OpenAPI, {
      method: "GET",
      url: "/deployments/v2",
      query: {
        appId,
        location,
        image,
        state,
        ipv4,
        label
      },
      errors: {
        400: `Unknown account`,
        401: `Unauthorized`,
        500: `Deployment List Error`
      }
    });
  }
  /**
   * Get a specific deployment
   * Get a deployment by its deployment
   * @param deploymentId
   * @returns DeploymentV2 Get a specific deployment along with its respective placements
   * @throws ApiError
   */
  static getDeploymentV2(deploymentId) {
    return request(OpenAPI, {
      method: "GET",
      url: "/deployments/{deploymentID}/v2",
      path: {
        deploymentID: deploymentId
      },
      errors: {
        400: `Unknown account`,
        401: `Unauthorized`,
        404: `Deployment not found`,
        500: `Deployment Get Error`
      }
    });
  }
  /**
   * Modify an existing deployment
   * Change specific properties in an existing deployment
   * @param deploymentId
   * @param requestBody
   * @returns DeploymentV2 Deployment modified
   * @throws ApiError
   */
  static modifyDeploymentV2(deploymentId, requestBody) {
    return request(OpenAPI, {
      method: "PATCH",
      url: "/deployments/{deploymentID}/v2",
      path: {
        deploymentID: deploymentId
      },
      body: requestBody,
      mediaType: "application/json",
      errors: {
        400: `Can't modify the deployment because it surpasses limits or it has bad input`,
        401: `Unauthorized`,
        404: `Deployment not found`,
        500: `Deployment Modification Error`
      }
    });
  }
  /**
   * Delete a specific deployment
   * Delete a deployment by its deployment ID
   * @param deploymentId
   * @returns EmptyResponse Delete a specific deployment along with its respective placements
   * @throws ApiError
   */
  static deleteDeploymentV2(deploymentId) {
    return request(OpenAPI, {
      method: "DELETE",
      url: "/deployments/{deploymentID}/v2",
      path: {
        deploymentID: deploymentId
      },
      errors: {
        400: `Unknown account`,
        401: `Unauthorized`,
        404: `Deployment not found`,
        500: `Deployment Delete Error`
      }
    });
  }
  /**
   * Replace a deployment
   * You can stop the current placement and create a new one. The new one will have the same durable properties of the deployment, but will otherwise be like new
   * @param placementId
   * @param requestBody
   * @returns DeploymentV2 Deployment replaced
   * @throws ApiError
   */
  static replaceDeployment(placementId, requestBody) {
    return request(OpenAPI, {
      method: "POST",
      url: "/placements/{placementID}",
      path: {
        placementID: placementId
      },
      body: requestBody,
      mediaType: "application/json",
      errors: {
        400: `Responses with 400 status code`,
        401: `Unauthorized`,
        404: `Placement not found`,
        500: `Deployment Replacement Error`
      }
    });
  }
};
__name(DeploymentsService, "DeploymentsService");

// src/cloudchamber/client/services/ImageRegistriesService.ts
init_import_meta_url();
var ImageRegistriesService = class {
  /**
   * Get a JWT to pull from the image registry
   * Get a JWT to pull from the image registry specifying its domain
   * @param domain
   * @param requestBody
   * @returns AccountRegistryToken Response that contains the credentials with 'pull' or 'push' permissions to access the registry
   * @throws ApiError
   */
  static generateImageRegistryCredentials(domain2, requestBody) {
    return request(OpenAPI, {
      method: "POST",
      url: "/registries/{domain}/credentials",
      path: {
        domain: domain2
      },
      body: requestBody,
      mediaType: "application/json",
      errors: {
        400: `Bad Request that contains a specific constant code and details object about the error.`,
        404: `The response body when the registry that is trying to be found does not exist`,
        409: `Response that contains the error ImageRegistryIsPublic`,
        500: `There has been an internal error`
      }
    });
  }
  /**
   * Delete a registry from the account
   * Delete a registry from the account, this will make Cloudchamber unable to pull images from the registry
   * @param domain
   * @returns EmptyResponse The image registry is deleted
   * @throws ApiError
   */
  static deleteImageRegistry(domain2) {
    return request(OpenAPI, {
      method: "DELETE",
      url: "/registries/{domain}",
      path: {
        domain: domain2
      },
      errors: {
        404: `The response body when the registry that is trying to be found does not exist`,
        500: `There has been an internal error`
      }
    });
  }
  /**
   * Get the list of configured registries in the account
   * Get the list of configured registries in the account
   * @returns CustomerImageRegistry The list of registries that are added in the account
   * @throws ApiError
   */
  static listImageRegistries() {
    return request(OpenAPI, {
      method: "GET",
      url: "/registries",
      errors: {
        500: `There has been an internal error`
      }
    });
  }
  /**
   * Add a new image registry configuration
   * Add a new image registry into your account, so then Cloudflare can pull docker images with public key JWT authentication
   * @param requestBody
   * @returns CustomerImageRegistry The response body when you create a new image registry in an account
   * @throws ApiError
   */
  static createImageRegistry(requestBody) {
    return request(OpenAPI, {
      method: "POST",
      url: "/registries",
      body: requestBody,
      mediaType: "application/json",
      errors: {
        400: `The response body when the input to create a new image registry is malformed`,
        403: `The response body when the registry that is being added is not allowed`,
        409: `The response body when the image registry already exists in the account`,
        500: `There has been an internal error`
      }
    });
  }
};
__name(ImageRegistriesService, "ImageRegistriesService");

// src/cloudchamber/client/services/IPsService.ts
init_import_meta_url();

// src/cloudchamber/client/services/PlacementsService.ts
init_import_meta_url();
var PlacementsService = class {
  /**
   * List placements
   * List all placements under a given deploymentID with all its events
   * @param deploymentId
   * @returns ListPlacements A list of placements along with its events under a deployment
   * @throws ApiError
   */
  static listPlacements(deploymentId) {
    return request(OpenAPI, {
      method: "GET",
      url: "/deployments/{deploymentID}/placements",
      path: {
        deploymentID: deploymentId
      },
      errors: {
        400: `Unknown account`,
        401: `Unauthorized`,
        404: `Deployment not found`,
        500: `List Placements Error`
      }
    });
  }
  /**
   * Get placement
   * A Placement represents the lifetime of a single instance of a Deployment
   * @param placementId
   * @returns PlacementWithEvents A specific placement along with its events
   * @throws ApiError
   */
  static getPlacement(placementId) {
    return request(OpenAPI, {
      method: "GET",
      url: "/placements/{placementID}",
      path: {
        placementID: placementId
      },
      errors: {
        400: `Unknown account`,
        401: `Unauthorized`,
        404: `Placement not found`,
        500: `Get Placement Error`
      }
    });
  }
  /**
   * Replace a deployment
   * You can stop the current placement and create a new one. The new one will have the same durable properties of the deployment, but will otherwise be like new
   * @param placementId
   * @param requestBody
   * @returns DeploymentV2 Deployment replaced
   * @throws ApiError
   */
  static replaceDeployment(placementId, requestBody) {
    return request(OpenAPI, {
      method: "POST",
      url: "/placements/{placementID}",
      path: {
        placementID: placementId
      },
      body: requestBody,
      mediaType: "application/json",
      errors: {
        400: `Responses with 400 status code`,
        401: `Unauthorized`,
        404: `Placement not found`,
        500: `Deployment Replacement Error`
      }
    });
  }
};
__name(PlacementsService, "PlacementsService");

// src/cloudchamber/client/services/SshPublicKeysService.ts
init_import_meta_url();
var SshPublicKeysService = class {
  /**
   * Add SSH public key
   * Adds a new ssh public key to an account. This can then be associated with a specific deployment during its creation or modification.
   * @param requestBody
   * @returns SSHPublicKeyItem SSH Public key added successfully
   * @throws ApiError
   */
  static createSshPublicKey(requestBody) {
    return request(OpenAPI, {
      method: "POST",
      url: "/ssh-public-keys",
      body: requestBody,
      mediaType: "application/json",
      errors: {
        401: `Unauthorized`,
        500: `Create SSH Public key error`
      }
    });
  }
  /**
   * List SSH Public keys
   * List all SSH Public keys in an account
   * @returns ListSSHPublicKeys List SSH Public keys response
   * @throws ApiError
   */
  static listSshPublicKeys() {
    return request(OpenAPI, {
      method: "GET",
      url: "/ssh-public-keys",
      errors: {
        401: `Unauthorized`,
        500: `List SSH Public keys error`
      }
    });
  }
};
__name(SshPublicKeysService, "SshPublicKeysService");

// src/cloudchamber/helpers/wrap.ts
init_import_meta_url();
async function wrap2(fn2) {
  return fn2.then((data) => [data, null]).catch((err) => [null, err]);
}
__name(wrap2, "wrap");

// src/cloudchamber/locations.ts
init_import_meta_url();
var cachedAccount;
async function loadAccount() {
  if (cachedAccount !== void 0) {
    return cachedAccount;
  }
  const account = await AccountService.getMe();
  cachedAccount = account;
  return cachedAccount;
}
__name(loadAccount, "loadAccount");
async function getLocations() {
  return (await loadAccount()).locations;
}
__name(getLocations, "getLocations");
function idToLocationName(locationId) {
  if (!cachedAccount)
    throw new Error("Needs a call to loadAccount beforehand");
  const locations = cachedAccount.locations;
  for (const location of locations) {
    if (location.location === locationId) {
      return location.name;
    }
  }
  return `Other (${locationId})`;
}
__name(idToLocationName, "idToLocationName");

// src/cloudchamber/common.ts
function handleFailure(cb) {
  return async (t3) => {
    try {
      const config = readConfig(
        t3.config,
        t3
      );
      await fillOpenAPIConfiguration(config, t3.json);
      await cb(t3, config);
    } catch (err) {
      if (!t3.json) {
        throw err;
      }
      if (err instanceof ApiError) {
        logger.log(JSON.stringify(err.body));
        return;
      }
      if (err instanceof Error) {
        logger.log(
          `${{ error: err.message, name: err.name, stack: err.stack }}`
        );
        return;
      }
      logger.log(JSON.stringify(err));
    }
  };
}
__name(handleFailure, "handleFailure");
async function loadAccountSpinner({ json }) {
  await promiseSpinner(loadAccount(), { message: "Loading account", json });
}
__name(loadAccountSpinner, "loadAccountSpinner");
async function getAPIUrl(config) {
  const api = getCloudflareApiBaseUrl();
  const accountId = config.account_id || await getAccountId();
  return `${api}/accounts/${accountId}/cloudchamber`;
}
__name(getAPIUrl, "getAPIUrl");
async function promiseSpinner(promise, {
  json = false,
  message = "Loading"
} = {
  json: false,
  message: "Loading"
}) {
  if (json)
    return promise;
  const { start, stop } = spinner();
  start(message);
  const t3 = await promise.catch((err) => {
    stop();
    throw err;
  });
  stop();
  return t3;
}
__name(promiseSpinner, "promiseSpinner");
async function fillOpenAPIConfiguration(config, json) {
  const headers = OpenAPI.HEADERS !== void 0 ? { ...OpenAPI.HEADERS } : {};
  if (Object.keys(getConfigCache("wrangler-account.json")).length === 0) {
    await wrap2((0, import_promises4.mkdir)("node_modules", {}));
    purgeConfigCaches();
  }
  const scopes = getScopes();
  const needsCloudchamberToken = !scopes?.find(
    (scope) => scope === "cloudchamber:write"
  );
  if (getAuthFromEnv()) {
    setLoginScopeKeys(["cloudchamber:write", "user:read", "account:read"]);
    reinitialiseAuthTokens({
      expiration_time: "2300-01-01:00:00:00+00:00",
      oauth_token: "_"
    });
  } else {
    if (needsCloudchamberToken && scopes) {
      logRaw(
        status.warning + " We need to re-authenticate with a cloudchamber token..."
      );
      await getAccountId();
      const account = getAccountFromCache();
      config.account_id = account?.id ?? config.account_id;
      await promiseSpinner(logout(), { json, message: "Revoking token" });
      purgeConfigCaches();
      reinitialiseAuthTokens({});
    }
    setLoginScopeKeys(["cloudchamber:write", "user:read", "account:read"]);
    const [, err2] = await wrap2(requireAuth(config));
    if (err2) {
      crash("authenticating with the Cloudflare API:", err2.message);
      return;
    }
  }
  const token = getAPIToken();
  if (!token) {
    crash("unexpected apiToken not existing in credentials");
    (0, import_process2.exit)(1);
  }
  const val = "apiToken" in token ? token.apiToken : null;
  if (!val) {
    crash(
      "we don't allow for authKey/email credentials, use `wrangler login` or CLOUDFLARE_API_TOKEN env variable to authenticate"
    );
  }
  headers["Authorization"] = `Bearer ${val}`;
  headers["User-Agent"] = `wrangler/${version}`;
  OpenAPI.CREDENTIALS = "omit";
  if (OpenAPI.BASE.length === 0) {
    const [base, errApiURL] = await wrap2(getAPIUrl(config));
    if (errApiURL) {
      crash("getting the API url:" + errApiURL.message);
    }
    OpenAPI.BASE = base;
  }
  OpenAPI.HEADERS = headers;
  const [, err] = await wrap2(loadAccountSpinner({ json }));
  if (err) {
    let message = err.message;
    if (json && err instanceof ApiError) {
      message = JSON.stringify(err);
    }
    crash("loading Cloudchamber account failed:" + message);
  }
}
__name(fillOpenAPIConfiguration, "fillOpenAPIConfiguration");
function interactWithUser(config) {
  return !config.json && isInteractive() && !CI.isCI();
}
__name(interactWithUser, "interactWithUser");
function checkEverythingIsSet(object, keys) {
  keys.forEach((key) => {
    if (object[key] === void 0) {
      throw new Error(
        `${key} is required but it's not passed as an argument`
      );
    }
  });
  return object;
}
__name(checkEverythingIsSet, "checkEverythingIsSet");
function renderDeploymentConfiguration(action, {
  image,
  location,
  vcpu,
  memory,
  environmentVariables,
  labels,
  env: env5,
  network
}) {
  let environmentVariablesText = "[]";
  if (environmentVariables !== void 0) {
    if (environmentVariables.length !== 0) {
      environmentVariablesText = "\n" + environmentVariables.map((ev) => "- " + dim(ev.name + ":" + ev.value)).join("\n").trim();
    }
  } else if (action === "create") {
    environmentVariablesText = `
No environment variables added! You can set some under [${env5 ? "env." + env5 + "." : ""}vars] and via command line`;
  }
  let labelsText = "[]";
  if (labels !== void 0 && labels.length !== 0) {
    labelsText = "\n" + labels.map((ev) => "- " + dim(ev.name + ":" + ev.value)).join("\n").trim();
  }
  const containerInformation = [
    ["Image", image],
    ["Location", idToLocationName(location)],
    ["VCPU", `${vcpu}`],
    ["Memory", memory],
    ["Environment variables", environmentVariablesText],
    ["Labels", labelsText],
    ...network === void 0 ? [] : [
      ["Include IPv4", network.assign_ipv4 === "predefined" ? "yes" : "no"]
    ]
  ];
  updateStatus(
    `You're about to ${action} a container with the following configuration
` + containerInformation.map(([key, text]) => `${brandColor(key)} ${dim(text)}`).join("\n")
  );
}
__name(renderDeploymentConfiguration, "renderDeploymentConfiguration");
function renderDeploymentMutationError(account, err) {
  if (!(err instanceof ApiError)) {
    crash(err.message);
    return;
  }
  if (typeof err.body === "string") {
    crash("There has been an internal error, please try again!");
    return;
  }
  if (!("error" in err.body)) {
    crash(err.message);
    return;
  }
  const errorMessage = err.body.error;
  if (!(errorMessage in DeploymentMutationError)) {
    crash(err.message);
    return;
  }
  const details = err.body.details ?? {};
  function renderAccountLimits() {
    return `${space(2)}${brandColor("Maximum VCPU per deployment")} ${account.limits.vcpu_per_deployment}
${space(2)}${brandColor("Maximum total VCPU in your account")} ${account.limits.total_vcpu}
${space(2)}${brandColor("Maximum memory per deployment")} ${account.limits.memory_per_deployment}
${space(2)}${brandColor("Maximum total memory in your account")} ${account.limits.total_memory}`;
  }
  __name(renderAccountLimits, "renderAccountLimits");
  function renderInvalidInputDetails(inputDetails) {
    return `${Object.keys(inputDetails).map((key) => `${space(2)}- ${key}: ${inputDetails[key]}`).join("\n")}`;
  }
  __name(renderInvalidInputDetails, "renderInvalidInputDetails");
  const errorEnum = errorMessage;
  const errorEnumToErrorMessage = {
    ["LOCATION_NOT_ALLOWED" /* LOCATION_NOT_ALLOWED */]: () => "The location you have chosen is not allowed, try with another one",
    ["LOCATION_SURPASSED_BASE_LIMITS" /* LOCATION_SURPASSED_BASE_LIMITS */]: () => "The location you have chosen doesn't allow that deployment configuration due to its limits",
    ["SURPASSED_BASE_LIMITS" /* SURPASSED_BASE_LIMITS */]: () => "You deployment surpasses the base limits of your account\n" + renderAccountLimits(),
    ["VALIDATE_INPUT" /* VALIDATE_INPUT */]: () => "Your deployment configuration has invalid inputs\n" + renderInvalidInputDetails(err.body.details),
    ["SURPASSED_TOTAL_LIMITS" /* SURPASSED_TOTAL_LIMITS */]: () => "You have surpassed the limits of your account\n" + renderAccountLimits(),
    ["IMAGE_REGISTRY_NOT_CONFIGURED" /* IMAGE_REGISTRY_NOT_CONFIGURED */]: () => "You have to configure the domain of the image you're trying to set\n"
  };
  crash(details["reason"] ?? errorEnumToErrorMessage[errorEnum]());
}
__name(renderDeploymentMutationError, "renderDeploymentMutationError");
function sortEnvironmentVariables(environmentVariables) {
  environmentVariables.sort((a, b2) => a.name.localeCompare(b2.name));
}
__name(sortEnvironmentVariables, "sortEnvironmentVariables");
function collectEnvironmentVariables(deploymentEnv, config, envArgs) {
  const envMap = /* @__PURE__ */ new Map();
  if (deploymentEnv !== void 0) {
    deploymentEnv.forEach((ev) => envMap.set(ev.name, ev.value));
  }
  Object.entries(config.vars).forEach(
    ([name, value]) => envMap.set(name, value?.toString() ?? "")
  );
  if (envArgs !== void 0) {
    envArgs.forEach((v2) => {
      const [name, ...value] = v2.split(":");
      envMap.set(name, value.join(":"));
    });
  }
  if (envMap.size === 0) {
    return void 0;
  }
  const env5 = Array.from(envMap).map(
    ([name, value]) => ({ name, value })
  );
  sortEnvironmentVariables(env5);
  return env5;
}
__name(collectEnvironmentVariables, "collectEnvironmentVariables");
async function promptForEnvironmentVariables(environmentVariables, initiallySelected, allowSkipping) {
  if (environmentVariables === void 0 || environmentVariables.length == 0) {
    return void 0;
  }
  let options29 = [
    { label: "Use all of them", value: "all" },
    { label: "Use some", value: "select" },
    { label: "Do not use any", value: "none" }
  ];
  if (allowSkipping) {
    options29 = [{ label: "Do not modify", value: "skip" }].concat(options29);
  }
  const action = await inputPrompt({
    question: "You have environment variables defined, what do you want to do for this deployment?",
    label: "",
    defaultValue: false,
    helpText: "",
    type: "select",
    options: options29
  });
  if (action === "skip") {
    return void 0;
  }
  if (action === "all") {
    return environmentVariables;
  }
  if (action === "select") {
    const selectedNames = await inputPrompt({
      question: "Select the environment variables you want to use",
      label: "",
      defaultValue: initiallySelected,
      helpText: "Use the 'space' key to select. Submit with 'enter'",
      type: "multiselect",
      options: environmentVariables.map((ev) => ({
        label: ev.name,
        value: ev.name
      })),
      validate: (values) => {
        if (!Array.isArray(values))
          return "unknown error";
      }
    });
    const selectedNamesSet = new Set(selectedNames);
    const selectedEnvironmentVariables = [];
    for (const ev of environmentVariables) {
      if (selectedNamesSet.has(ev.name))
        selectedEnvironmentVariables.push(ev);
    }
    return selectedEnvironmentVariables;
  }
  return [];
}
__name(promptForEnvironmentVariables, "promptForEnvironmentVariables");
function sortLabels(labels) {
  labels.sort((a, b2) => a.name.localeCompare(b2.name));
}
__name(sortLabels, "sortLabels");
function collectLabels(labelArgs) {
  const labelMap = /* @__PURE__ */ new Map();
  if (labelArgs !== void 0) {
    labelArgs.forEach((v2) => {
      const [name, ...value] = v2.split(":");
      labelMap.set(name, value.join(":"));
    });
  }
  if (labelMap.size === 0) {
    return void 0;
  }
  const labels = Array.from(labelMap).map(([name, value]) => ({
    name,
    value
  }));
  sortLabels(labels);
  return labels;
}
__name(collectLabels, "collectLabels");
async function promptForLabels(labels, initiallySelected, allowSkipping) {
  if (labels === void 0 || labels.length == 0) {
    return void 0;
  }
  let options29 = [
    { label: "Use all of them", value: "all" },
    { label: "Use some", value: "select" },
    { label: "Do not use any", value: "none" }
  ];
  if (allowSkipping) {
    options29 = [{ label: "Do not modify", value: "skip" }].concat(options29);
  }
  const action = await inputPrompt({
    question: "You have labels defined, what do you want to do for this deployment?",
    label: "",
    defaultValue: false,
    helpText: "",
    type: "select",
    options: options29
  });
  if (action === "skip") {
    return void 0;
  }
  if (action === "all") {
    return labels;
  }
  if (action === "select") {
    const selectedNames = await inputPrompt({
      question: "Select the labels you want to use",
      label: "",
      defaultValue: initiallySelected,
      helpText: "Use the 'space' key to select. Submit with 'enter'",
      type: "multiselect",
      options: labels.map((label) => ({
        label: label.name,
        value: label.name
      })),
      validate: (values) => {
        if (!Array.isArray(values))
          return "unknown error";
      }
    });
    const selectedNamesSet = new Set(selectedNames);
    const selectedLabels = [];
    for (const ev of labels) {
      if (selectedNamesSet.has(ev.name))
        selectedLabels.push(ev);
    }
    return selectedLabels;
  }
  return [];
}
__name(promptForLabels, "promptForLabels");

// src/cloudchamber/create.ts
init_import_meta_url();

// ../cli/args.ts
init_import_meta_url();
var processArgument = /* @__PURE__ */ __name(async (args, name, promptConfig) => {
  let value = args[name];
  const renderSubmitted = getRenderers(promptConfig).submit;
  if (value !== void 0) {
    const error2 = promptConfig.validate?.(value);
    if (error2) {
      crash(error2);
    }
    const lines = renderSubmitted({ value });
    logRaw(lines.join("\n"));
    return value;
  }
  value = await inputPrompt(promptConfig);
  return value;
}, "processArgument");

// src/cloudchamber/cli/index.ts
init_import_meta_url();
function pollSSHKeysUntilCondition(onSSHKeys) {
  return new Promise((res, rej) => {
    let errCount = 0;
    const poll = /* @__PURE__ */ __name(() => {
      SshPublicKeysService.listSshPublicKeys().then((sshKeys) => {
        try {
          if (!onSSHKeys(sshKeys))
            setTimeout(() => poll(), 500);
          else
            res(sshKeys);
        } catch (err) {
          rej(err);
        }
      }).catch((err) => {
        errCount++;
        if (errCount > 3) {
          rej(err);
          return;
        }
        poll();
      });
    }, "poll");
    poll();
  });
}
__name(pollSSHKeysUntilCondition, "pollSSHKeysUntilCondition");
async function pollDeploymentUntilCondition(deploymentId, onDeployment) {
  return new Promise((res, rej) => {
    let errCount = 0;
    const poll = /* @__PURE__ */ __name(() => {
      DeploymentsService.getDeploymentV2(deploymentId).then((deployment) => {
        errCount = 0;
        try {
          if (!onDeployment(deployment))
            setTimeout(() => poll(), 500);
          else
            res(deployment);
        } catch (err) {
          rej(err);
        }
      }).catch((err) => {
        errCount++;
        if (errCount > 3) {
          rej(err);
        }
      });
    }, "poll");
    poll();
  });
}
__name(pollDeploymentUntilCondition, "pollDeploymentUntilCondition");
async function pollDeploymentUntilConditionWithPlacement(placementId, onPlacement) {
  return new Promise((res, rej) => {
    let errCount = 0;
    const poll = /* @__PURE__ */ __name(() => {
      PlacementsService.getPlacement(placementId).then((placement) => {
        errCount = 0;
        if (!onPlacement(placement))
          setTimeout(() => poll(), 500);
        else
          res(placement);
      }).catch((err) => {
        errCount++;
        if (errCount > 3) {
          rej(err);
        }
      });
    }, "poll");
    poll();
  });
}
__name(pollDeploymentUntilConditionWithPlacement, "pollDeploymentUntilConditionWithPlacement");
function unexpectedLastEvent(placement) {
  throw new WaitForAnotherPlacement(
    `There has been an unknown error creating the container. (${placement.events[placement.events.length - 1].name})`
  );
}
__name(unexpectedLastEvent, "unexpectedLastEvent");
var WaitForAnotherPlacement = class extends Error {
  constructor(message) {
    super(message);
  }
};
__name(WaitForAnotherPlacement, "WaitForAnotherPlacement");
async function waitForEvent(deployment, ...eventName) {
  if (!deployment.current_placement)
    throw new Error("unexpected null current placement");
  let foundEvent;
  const placement = await pollDeploymentUntilConditionWithPlacement(
    deployment.current_placement.id,
    (p2) => {
      const event = p2.events.find(
        (e3) => eventName.includes(e3.name)
      );
      if (!event) {
        if (p2.status["health"] === "failed") {
          return true;
        }
        if (p2.status["health"] == "stopped") {
          return true;
        }
        return false;
      }
      foundEvent = event;
      return true;
    }
  );
  return { event: foundEvent, placement };
}
__name(waitForEvent, "waitForEvent");
async function waitForImagePull(deployment) {
  const s = spinner();
  s.start("Pulling your image");
  const [eventPlacement, err] = await wrap2(
    waitForEvent(deployment, "ImagePulled", "ImagePullError")
  );
  s.stop();
  if (err) {
    crash(err.message);
    return;
  }
  if (eventPlacement.event == void 0 || eventPlacement.event.name === "ImagePullError" && eventPlacement.event.type !== "UserError") {
    checkPlacementStatus(eventPlacement.placement);
    return;
  }
  if (eventPlacement.event.name == "ImagePullError") {
    crash(
      "Your container image couldn't be pulled, (404 not found). Did you specify the correct URL?",
      `Run ${brandColor(
        process.argv0 + " cloudchamber modify " + deployment.id
      )} to change the deployment image`
    );
    return;
  }
  updateStatus("Pulled your image");
  log(
    `${brandColor("pulled image")} ${dim(
      `in ${eventPlacement.event.details["duration"]}`
    )}
`
  );
}
__name(waitForImagePull, "waitForImagePull");
function checkPlacementStatus(placement) {
  if (placement.status["health"] === "stopped") {
    throw new WaitForAnotherPlacement(
      `The container stopped while waiting for the deployment to be created.
Either the deployment has been modified, changed location, or your container is in a reboot loop!`
    );
  }
  unexpectedLastEvent(placement);
}
__name(checkPlacementStatus, "checkPlacementStatus");
async function waitForVMToStart(deployment) {
  const s = spinner();
  s.start("Creating your container");
  const [eventPlacement, err] = await wrap2(
    waitForEvent(deployment, "VMStarted")
  );
  s.stop();
  if (err) {
    crash(err.message);
    return;
  }
  if (!eventPlacement.event) {
    checkPlacementStatus(eventPlacement.placement);
  }
  updateStatus(status.success + " Created your container");
  log(
    `${brandColor("assigned ipv6 address")} ${dim(
      eventPlacement.placement.status["ipv6Address"]
    )}
`
  );
  endSection("Your container is up and running");
  logRaw(
    `Run ${brandColor(
      `wrangler cloudchamber list ${deployment.id.slice(0, 6)}`
    )} to check its status`
  );
}
__name(waitForVMToStart, "waitForVMToStart");
async function waitForPlacementInstance(deployment) {
  const s = spinner();
  s.start(
    "Assigning a placement in " + idToLocationName(deployment.location.name)
  );
  const [d2, err] = await wrap2(
    pollDeploymentUntilCondition(deployment.id, (newDeployment) => {
      if (newDeployment.current_placement && !deployment.current_placement) {
        return true;
      }
      if (!newDeployment.current_placement)
        return false;
      if (newDeployment.version > deployment.version) {
        s.stop();
        throw new WaitForAnotherPlacement(
          `There is a new version of the deployment modified in another wrangler session, new version is ${newDeployment.version}`
        );
      }
      if (newDeployment.current_placement.deployment_version < deployment.version) {
        return false;
      }
      return newDeployment.current_placement.id !== deployment.current_placement?.id;
    })
  );
  s.stop();
  if (err instanceof WaitForAnotherPlacement) {
    throw err;
  }
  if (err) {
    crash(err.message);
    return;
  }
  updateStatus(
    "Assigned placement in " + idToLocationName(deployment.location.name)
  );
  if (d2.current_placement?.deployment_version) {
    log(
      `${brandColor("assigned placement")} ${dim(
        `version ${d2.current_placement.deployment_version}`
      )}
`
    );
  }
  deployment.current_placement = d2.current_placement;
}
__name(waitForPlacementInstance, "waitForPlacementInstance");
async function waitForPlacement(deployment) {
  let currentDeployment = { ...deployment };
  let keepIterating = true;
  while (keepIterating) {
    try {
      await waitForPlacementInstance(currentDeployment);
      await waitForImagePull(currentDeployment);
      await waitForVMToStart(currentDeployment);
      keepIterating = false;
    } catch (err) {
      if (err instanceof WaitForAnotherPlacement) {
        updateStatus(status.error + " " + err.message);
        log(
          "We will retry by waiting for another placement. You can see more details about your deployment with \n" + brandColor("wrangler cloudchamber list " + currentDeployment.id) + "\n"
        );
        const [newDeployment, getDeploymentError] = await wrap2(
          DeploymentsService.getDeploymentV2(deployment.id)
        );
        if (getDeploymentError) {
          crash(
            "Couldn't retrieve a new deployment: " + getDeploymentError.message
          );
          return;
        }
        currentDeployment = newDeployment;
        continue;
      }
      throw err;
    }
  }
}
__name(waitForPlacement, "waitForPlacement");

// src/cloudchamber/cli/locations.ts
init_import_meta_url();
var whichLocationQuestion = "Choose where you want to deploy your container";
var whichRegionQuestion = "Choose which region you want to deploy your container in";
function plural(word, size) {
  if (size > 1) {
    return `${word}s`;
  }
  return word;
}
__name(plural, "plural");
async function getLocation2(args, options29 = {}) {
  const locations = await getLocations();
  if (args.location !== void 0 && !locations.find((location2) => location2.location === args.location)) {
    locations.push({
      name: `Other (${args.location})`,
      location: args.location,
      region: ""
    });
  }
  if (args.location !== void 0) {
    const location2 = await processArgument(args, "location", {
      question: whichLocationQuestion,
      label: "location",
      defaultValue: args.location ?? "",
      type: "select",
      maxItemsPerPage: 6,
      options: locations.map((locationOption) => ({
        label: locationOption.name,
        value: locationOption.location
      }))
    });
    return location2;
  }
  const regionsToLocation = {};
  for (const location2 of locations) {
    regionsToLocation[location2.region] ??= [];
    regionsToLocation[location2.region].push(location2);
  }
  if (options29.skipLocation) {
    regionsToLocation["Skip"] = [];
  }
  const region = await inputPrompt({
    question: whichRegionQuestion,
    label: "region",
    defaultValue: args.location ?? "",
    type: "select",
    maxItemsPerPage: 4,
    options: Object.keys(regionsToLocation).map((r3) => ({
      value: r3,
      label: `${r3} ${r3 === "Skip" ? "" : `(${regionsToLocation[r3].length} ${plural(
        "location",
        regionsToLocation[r3].length
      )})`}`
    }))
  });
  if (region === "Skip") {
    return "Skip";
  }
  const locationsToChoose = regionsToLocation[region];
  const locationToPops = {};
  for (const location2 of locationsToChoose) {
    locationToPops[location2.name] ??= [];
    locationToPops[location2.name].push(location2);
  }
  const location = await inputPrompt({
    question: whichLocationQuestion,
    label: "location",
    defaultValue: args.location ?? "",
    type: "select",
    maxItemsPerPage: 6,
    options: Object.keys(locationToPops).map((locationOption) => ({
      value: locationOption,
      label: locationOption
    }))
  });
  const pops = locationToPops[location];
  if (pops.length === 1) {
    return pops.pop().location;
  }
  const chosenPop = await inputPrompt({
    question: `There is multiple points of presence in ${location}, which one do you want to be in?`,
    label: "location",
    defaultValue: args.location ?? "",
    type: "select",
    maxItemsPerPage: 6,
    options: pops.map((locationOpt) => ({
      label: `${locationOpt.name} (${locationOpt.location})`,
      value: locationOpt.location
    }))
  });
  return chosenPop;
}
__name(getLocation2, "getLocation");

// src/cloudchamber/network/network.ts
init_import_meta_url();
async function getNetworkInput(args) {
  const ipv4 = await processArgument(args, "ipv4", {
    question: "Add an IPv4 to the deployment?",
    helpText: "Your deployment will have IPv4 network connectivity if you select yes. Your deployment will always have an IPv6",
    label: "Include IPv4",
    type: "confirm"
  });
  return ipv4 === true ? { assign_ipv4: "predefined" /* PREDEFINED */ } : void 0;
}
__name(getNetworkInput, "getNetworkInput");

// src/cloudchamber/ssh/ssh.ts
init_import_meta_url();
var import_promises5 = require("fs/promises");
var import_os3 = require("os");
var import_process4 = require("process");

// src/cloudchamber/ssh/validate.ts
init_import_meta_url();
var import_process3 = require("process");
function validateSSHKey(line) {
  const supportedSyntaxInfo = "Syntax is space-separated: keytype, base64-encoded key, comment(optional). Example: 'ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIC0chNcjRotdsxXTwPPNoqVCGn4EcEWdUkkBPNm/v4gm cool-public-key'";
  const supportedKeyTypes = ["ssh-ed25519"];
  const syntaxError = `Invalid Authorized Key format.`;
  const keyTypeError = `Invalid key type. Supported key types are: ${supportedKeyTypes.join(
    ","
  )}. ${supportedSyntaxInfo}`;
  const invalidKey = `Invalid public key. ${supportedSyntaxInfo}`;
  const parts = line.split(" ");
  if (![2, 3].includes(parts.length)) {
    throw new Error(syntaxError);
  }
  const keyType = parts[0];
  if (!supportedKeyTypes.includes(keyType)) {
    throw new Error(keyTypeError);
  }
  const base64Key = parts[1];
  try {
    atob(base64Key);
  } catch {
    throw new Error(invalidKey);
  }
}
__name(validateSSHKey, "validateSSHKey");
function validatePublicSSHKeyCLI(line, { json }) {
  const bail = /* @__PURE__ */ __name((reason) => {
    if (!json)
      crash(reason);
    else {
      logger.log(JSON.stringify({ error: reason }, null, 4));
      (0, import_process3.exit)(1);
    }
  }, "bail");
  try {
    validateSSHKey(line);
  } catch (err) {
    if (err instanceof Error) {
      bail(err.message);
    }
    bail("unknown error validating ssh key");
  }
}
__name(validatePublicSSHKeyCLI, "validatePublicSSHKeyCLI");

// src/cloudchamber/ssh/ssh.ts
function createSSHPublicKeyOptionalYargs(yargs) {
  return yargs.option("name", {
    type: "string",
    describe: "The alias to your ssh key, you can put a recognisable name for you here"
  }).option("public-key", {
    type: "string",
    describe: "An SSH public key, you can specify either a path or the ssh key directly here"
  });
}
__name(createSSHPublicKeyOptionalYargs, "createSSHPublicKeyOptionalYargs");
async function retrieveSSHKey(sshKeyPath, { json } = { json: false }) {
  try {
    const file = (await (0, import_promises5.readFile)(sshKeyPath)).toString();
    validatePublicSSHKeyCLI(file, { json });
    return file;
  } catch (err) {
    if (!json)
      logger.debug("couldn't read the file, assuming input is an ssh key");
    validatePublicSSHKeyCLI(sshKeyPath, { json });
    return sshKeyPath;
  }
}
__name(retrieveSSHKey, "retrieveSSHKey");
async function sshPrompts(args, keys = void 0) {
  const [key, prompt2] = await shouldPromptForNewSSHKeyAppear(keys);
  if (prompt2) {
    const yes = await inputPrompt({
      question: "You didn't add any public keys from your .ssh folder, do you want to add one?",
      label: "",
      defaultValue: false,
      helpText: "If you don't add a public ssh key, you won't be able to ssh into your container unless you set it up",
      type: "confirm"
    });
    if (yes) {
      const sshKey = await promptForSSHKey({
        ...args,
        name: void 0,
        publicKey: void 0
      });
      updateStatus(
        "You will be able to ssh into containers where you add this ssh key from now on!"
      );
      return sshKey.id;
    }
    return key || void 0;
  }
  return key || void 0;
}
__name(sshPrompts, "sshPrompts");
var sshCommand = /* @__PURE__ */ __name((yargs) => {
  return yargs.command(
    "list",
    "list the ssh keys added to your account",
    (args) => args,
    (args) => handleFailure(async (sshArgs, config) => {
      if (!interactWithUser(sshArgs)) {
        const sshKeys = await SshPublicKeysService.listSshPublicKeys();
        console.log(JSON.stringify(sshKeys, null, 4));
        return;
      }
      await handleListSSHKeysCommand(sshArgs, config);
    })(args)
  ).command(
    "create",
    "create an ssh key",
    (args) => createSSHPublicKeyOptionalYargs(args),
    (args) => handleFailure(
      async (sshArgs, _config) => {
        if (!interactWithUser(sshArgs)) {
          const body = checkEverythingIsSet(sshArgs, ["publicKey", "name"]);
          const sshKey = await retrieveSSHKey(body.publicKey, {
            json: true
          });
          const addedSSHKey = await SshPublicKeysService.createSshPublicKey(
            {
              ...body,
              public_key: sshKey.trim()
            }
          );
          console.log(JSON.stringify(addedSSHKey, null, 4));
          return;
        }
        await handleCreateSSHPublicKeyCommand(sshArgs);
      }
    )(args)
  );
}, "sshCommand");
async function tryToRetrieveAllDefaultSSHKeyPaths() {
  const HOME = (0, import_os3.homedir)();
  const path67 = `${HOME}/.ssh`;
  const paths = [];
  try {
    const dirList = await (0, import_promises5.readdir)(path67);
    for (const file of dirList) {
      if (file.endsWith(".pub")) {
        const s = await (0, import_promises5.stat)(`${path67}/${file}`);
        if (s.isFile()) {
          paths.push(`${path67}/${file}`);
        }
      }
    }
  } catch (err) {
    return [];
  }
  return paths;
}
__name(tryToRetrieveAllDefaultSSHKeyPaths, "tryToRetrieveAllDefaultSSHKeyPaths");
async function tryToRetrieveADefaultPath() {
  const paths = await tryToRetrieveAllDefaultSSHKeyPaths();
  const path67 = paths.pop();
  return path67 ?? "";
}
__name(tryToRetrieveADefaultPath, "tryToRetrieveADefaultPath");
function clipPublicSSHKey(value) {
  return value.split(" ").slice(1).map(
    (val, i) => dim(val.length >= 10 && i === 0 ? val.slice(0, 10) + "..." : val)
  ).join(" ");
}
__name(clipPublicSSHKey, "clipPublicSSHKey");
async function shouldPromptForNewSSHKeyAppear(keys = void 0) {
  try {
    const { start, stop } = spinner();
    start("Loading");
    const [sshKeys, err] = keys !== void 0 ? [keys, null] : await wrap2(pollSSHKeysUntilCondition(() => true));
    stop();
    if (err !== null) {
      log(
        "\n" + status.warning + " We couldn't load the ssh public keys of the account, so Wrangler doesn't know if you have your SSH keys configured right. Try again?\n"
      );
      return [void 0, false];
    }
    const defaultSSHKeyPaths = await tryToRetrieveAllDefaultSSHKeyPaths();
    if (defaultSSHKeyPaths.length === 0) {
      return [void 0, false];
    }
    let foundValidSSHKeyThatDontExist = false;
    for (const defaultSSHKeyPath of defaultSSHKeyPaths) {
      const file = (await (0, import_promises5.readFile)(defaultSSHKeyPath)).toString().trim();
      try {
        validateSSHKey(file);
      } catch {
        continue;
      }
      const key = sshKeys.find((k2) => k2.public_key?.includes(file));
      if (key) {
        return [key.id, false];
      }
      foundValidSSHKeyThatDontExist = true;
    }
    return [void 0, foundValidSSHKeyThatDontExist];
  } catch (err) {
    return [void 0, false];
  }
}
__name(shouldPromptForNewSSHKeyAppear, "shouldPromptForNewSSHKeyAppear");
async function handleListSSHKeysCommand(_args, _config) {
  startSection("SSH Keys", "", false);
  const { start, stop } = spinner();
  start("Loading your ssh keys");
  const [sshKeys, err] = await wrap2(pollSSHKeysUntilCondition(() => true));
  stop();
  if (err)
    throw err;
  if (sshKeys.length === 0) {
    endSection(
      "No ssh keys added to your account!",
      "You can add one with\n" + brandColor("wrangler cloudchamber ssh create")
    );
    return;
  }
  for (const sshKey of sshKeys) {
    newline();
    updateStatus(
      `${sshKey.name}
ID: ${dim(sshKey.id)}
Key: ${dim(
        (sshKey.public_key ?? "").trim()
      )}`,
      false
    );
  }
  endSection("");
}
__name(handleListSSHKeysCommand, "handleListSSHKeysCommand");
async function handleCreateSSHPublicKeyCommand(args) {
  startSection(
    "Choose an ssh key to add",
    "It will allow you to ssh into new containers"
  );
  await promptForSSHKey(args);
  success("You are now able to ssh into your containers");
  logRaw(
    dim(
      "\nRemember that you will have to wait for a container restart until you're able to ssh into it"
    )
  );
}
__name(handleCreateSSHPublicKeyCommand, "handleCreateSSHPublicKeyCommand");
async function promptForSSHKey(args) {
  const { username } = (0, import_os3.userInfo)();
  const name = await inputPrompt({
    question: "Name your ssh key in a recognisable format for later",
    label: "name",
    validate: (value) => {
      if (typeof value !== "string")
        return "unknown error";
      if (value.length === 0)
        return "you should fill this input";
    },
    defaultValue: args.name ?? "",
    initialValue: args.name ?? "",
    helpText: `for example: 'ssh-key-${username || "me"}'`,
    type: "text"
  });
  const defaultSSHKeyPath = await tryToRetrieveADefaultPath();
  const sshKeyPath = await inputPrompt({
    question: "Insert the path to your public ssh key",
    label: "ssh_key",
    validate: (value) => {
      if (typeof value !== "string")
        return "unknown error";
      if (value.length === 0)
        return "you should fill this input";
    },
    defaultValue: args.publicKey ?? defaultSSHKeyPath,
    initialValue: args.publicKey ?? defaultSSHKeyPath,
    helpText: "Or insert the key directly",
    type: "text"
  });
  const sshKey = await retrieveSSHKey(sshKeyPath);
  log(
    `${brandColor("Verified")} public key successfully!
` + brandColor(sshKey.split(" ").slice(0, 1).join(" ")) + " " + clipPublicSSHKey(sshKey)
  );
  const { start, stop } = spinner();
  start("Adding your ssh key");
  const [res, err] = await wrap2(
    SshPublicKeysService.createSshPublicKey({
      public_key: sshKey.trim(),
      name
    })
  );
  stop();
  if (err != null) {
    crash("Error adding your public ssh key: " + err.message);
    (0, import_process4.exit)(1);
  }
  return res;
}
__name(promptForSSHKey, "promptForSSHKey");

// src/cloudchamber/create.ts
function createCommandOptionalYargs(yargs) {
  return yargs.option("image", {
    requiresArg: true,
    type: "string",
    demandOption: false,
    describe: "Image to use for your deployment"
  }).option("location", {
    requiresArg: true,
    type: "string",
    demandOption: false,
    describe: "Location on Cloudflare's network where your deployment will run"
  }).option("var", {
    requiresArg: true,
    type: "string",
    array: true,
    demandOption: false,
    describe: "Container environment variables",
    coerce: (arg) => arg.map((a) => a?.toString() ?? "")
  }).option("label", {
    requiresArg: true,
    type: "array",
    demandOption: false,
    describe: "Deployment labels",
    coerce: (arg) => arg.map((a) => a?.toString() ?? "")
  }).option("all-ssh-keys", {
    requiresArg: false,
    type: "boolean",
    demandOption: false,
    describe: "To add all SSH keys configured on your account to be added to this deployment, set this option to true"
  }).option("ssh-key-id", {
    requiresArg: false,
    type: "string",
    array: true,
    demandOption: false,
    describe: "ID of the SSH key to add to the deployment"
  }).option("vcpu", {
    requiresArg: true,
    type: "number",
    demandOption: false,
    describe: "Number of vCPUs to allocate to this deployment."
  }).option("memory", {
    requiresArg: true,
    type: "string",
    demandOption: false,
    describe: "Amount of memory (GB, MB...) to allocate to this deployment. Ex: 4GB."
  }).option("ipv4", {
    requiresArg: false,
    type: "boolean",
    demandOption: false,
    describe: "Include an IPv4 in the deployment"
  });
}
__name(createCommandOptionalYargs, "createCommandOptionalYargs");
async function createCommand(args, config) {
  await loadAccountSpinner(args);
  const environmentVariables = collectEnvironmentVariables(
    [],
    config,
    args.var
  );
  const labels = collectLabels(args.label);
  if (!interactWithUser(args)) {
    const body = checkEverythingIsSet(args, ["image", "location"]);
    const keysToAdd = args.allSshKeys ? (await pollSSHKeysUntilCondition(() => true)).map((key) => key.id) : [];
    const network = args.ipv4 === true ? { assign_ipv4: "predefined" /* PREDEFINED */ } : void 0;
    const deployment = await DeploymentsService.createDeploymentV2({
      image: body.image,
      location: body.location,
      ssh_public_key_ids: keysToAdd,
      environment_variables: environmentVariables,
      labels,
      vcpu: args.vcpu ?? config.cloudchamber.vcpu,
      memory: args.memory ?? config.cloudchamber.memory,
      network
    });
    console.log(JSON.stringify(deployment, null, 4));
    return;
  }
  await handleCreateCommand(args, config, environmentVariables, labels);
}
__name(createCommand, "createCommand");
async function askWhichSSHKeysDoTheyWantToAdd(args, key) {
  const keyItems = await pollSSHKeysUntilCondition(() => true);
  const keys = keyItems.map((keyItem) => keyItem.id);
  if (args.allSshKeys === true) {
    return keys;
  }
  if (args.sshKeyId && args.sshKeyId.length) {
    return key ? [...args.sshKeyId, key] : args.sshKeyId;
  }
  if (keys.length === 1) {
    const yes = await inputPrompt({
      question: `Do you want to add the ssh key ${keyItems[0].name}?`,
      type: "confirm",
      helpText: "You need this to ssh into the VM",
      defaultValue: false,
      label: ""
    });
    if (yes) {
      return keys;
    }
    return [];
  }
  if (keys.length <= 1) {
    return [];
  }
  const res = await inputPrompt({
    question: "You have multiple ssh keys in your account, what do you want to do for this new deployment?",
    label: "",
    defaultValue: false,
    helpText: "",
    type: "select",
    options: [
      { label: "Add all of them", value: "all" },
      { label: "Select the keys", value: "select" },
      { label: "Don't add any ssh keys", value: "none" }
    ]
  });
  if (res === "all") {
    return keys;
  }
  if (res === "select") {
    const resKeys = await inputPrompt({
      question: "Select the keys you want to add",
      label: "",
      defaultValue: [],
      helpText: "Select one key with the 'space' key. Submit with 'enter'",
      type: "multiselect",
      options: keyItems.map((keyOpt) => ({
        label: keyOpt.name,
        value: keyOpt.id
      })),
      validate: (values) => {
        if (!Array.isArray(values))
          return "unknown error";
        if (values.length === 0) {
          return "Select atleast one ssh key!";
        }
        return;
      }
    });
    return resKeys;
  }
  return [];
}
__name(askWhichSSHKeysDoTheyWantToAdd, "askWhichSSHKeysDoTheyWantToAdd");
async function handleCreateCommand(args, config, environmentVariables, labels) {
  startSection("Create a Cloudflare container", "Step 1 of 2");
  const sshKeyID = await sshPrompts(args);
  const image = await processArgument({ image: args.image }, "image", {
    question: whichImageQuestion,
    label: "image",
    validate: (value) => {
      if (typeof value !== "string")
        return "unknown error";
      if (value.length === 0)
        return "you should fill this input";
      if (value.endsWith(":latest"))
        return "we don't allow :latest tags";
    },
    defaultValue: args.image ?? "",
    initialValue: args.image ?? "",
    helpText: ":latest tags are not allowed!",
    type: "text"
  });
  const location = await getLocation2(args);
  const keys = await askWhichSSHKeysDoTheyWantToAdd(args, sshKeyID);
  const network = await getNetworkInput(args);
  const selectedEnvironmentVariables = await promptForEnvironmentVariables(
    environmentVariables,
    [],
    false
  );
  const selectedLabels = await promptForLabels(labels, [], false);
  const account = await loadAccount();
  renderDeploymentConfiguration("create", {
    image,
    location,
    network,
    vcpu: args.vcpu ?? config.cloudchamber.vcpu ?? account.defaults.vcpus,
    memory: args.memory ?? config.cloudchamber.memory ?? account.defaults.memory,
    environmentVariables: selectedEnvironmentVariables,
    labels: selectedLabels,
    env: args.env
  });
  const yes = await inputPrompt({
    type: "confirm",
    question: "Do you want to go ahead and create your container?",
    label: ""
  });
  if (!yes) {
    cancel("Not creating the container");
    return;
  }
  const { start, stop } = spinner();
  start("Creating your container", "shortly your container will be created");
  const [deployment, err] = await wrap2(
    DeploymentsService.createDeploymentV2({
      image,
      location,
      ssh_public_key_ids: keys,
      environment_variables: environmentVariables,
      labels,
      vcpu: args.vcpu ?? config.cloudchamber.vcpu,
      memory: args.memory ?? config.cloudchamber.memory,
      network
    })
  );
  if (err) {
    stop();
    renderDeploymentMutationError(account, err);
    return;
  }
  stop();
  updateStatus(`${status.success} Created deployment!`);
  if (deployment.network?.ipv4)
    log(`${deployment.id}
IP: ${deployment.network.ipv4}`);
  endSection("Creating a placement for your container");
  startSection("Create a Cloudflare container", "Step 2 of 2");
  await waitForPlacement(deployment);
}
__name(handleCreateCommand, "handleCreateCommand");
var whichImageQuestion = "Which image url should we use for your container?";

// src/cloudchamber/delete.ts
init_import_meta_url();

// src/cloudchamber/cli/deployments.ts
init_import_meta_url();
var import_process5 = require("process");

// src/cloudchamber/cli/util.ts
init_import_meta_url();
function statusToColored(status2) {
  if (!status2) {
    return bgYellow("PLACING");
  }
  const mappings = {
    placing: bgYellow,
    placed: bgYellow,
    running: bgGreen,
    stopped: bgYellow,
    stopping: bgYellow,
    failed: bgRed
  };
  return mappings[status2](status2.toUpperCase());
}
__name(statusToColored, "statusToColored");

// src/cloudchamber/cli/deployments.ts
function ipv6(placement) {
  if (!placement)
    return yellow("no ipv6 yet");
  if (!placement.status["ipv6Address"])
    return yellow("no ipv6 yet");
  return placement.status["ipv6Address"];
}
__name(ipv6, "ipv6");
function uptime(placement) {
  if (!placement)
    return yellow("inactive");
  const ms = Date.now() - new Date(placement.created_at).getTime();
  const days = Math.floor(ms / 864e5);
  const hours = new Date(ms).getUTCHours();
  const minutes = new Date(ms).getUTCMinutes();
  const seconds = new Date(ms).getUTCSeconds();
  const uptimeString = `${days ? days + "d " : ""}${hours ? hours + "h " : ""}${minutes ? minutes + "m " : ""}${seconds}s`;
  return uptimeString;
}
__name(uptime, "uptime");
function version2(deployment) {
  if (!deployment.current_placement) {
    return "";
  }
  if (deployment.current_placement.deployment_version !== deployment.version) {
    return ` (${yellow(
      `version ${deployment.current_placement.deployment_version}`
    )})`;
  }
  return ` (version ${deployment.version})`;
}
__name(version2, "version");
function health(placement) {
  if (!placement)
    return statusToColored("placing");
  if (!placement.status["health"])
    return statusToColored("placing");
  return statusToColored(placement.status["health"]);
}
__name(health, "health");
async function loadDeployments(deploymentIdPrefix, deploymentsParams) {
  const { start, stop } = spinner();
  start("Loading deployments");
  const [deploymentsResponse, err] = await wrap2(
    DeploymentsService.listDeploymentsV2(
      void 0,
      deploymentsParams?.location,
      deploymentsParams?.image,
      deploymentsParams?.state,
      deploymentsParams?.state
    )
  );
  stop();
  if (err) {
    crash(
      "There has been an error while loading your deployments: \n " + err.message
    );
    return [];
  }
  const deployments2 = deploymentsResponse.filter(
    (d2) => d2.id.startsWith(deploymentIdPrefix ?? "")
  );
  if (deployments2.length === 0 && !deploymentIdPrefix) {
    endSection(
      "you don't have any deployments in your account",
      "You can create one with\n	" + brandColor("wrangler cloudchamber create")
    );
    (0, import_process5.exit)(0);
  }
  if (deployments2.length === 0 && deploymentIdPrefix) {
    endSection(
      "you don't have any deployments that match the id " + deploymentIdPrefix
    );
    (0, import_process5.exit)(0);
  }
  return deployments2;
}
__name(loadDeployments, "loadDeployments");
async function listDeploymentsAndChoose(deployments2, args = {}) {
  const ips = /* @__PURE__ */ __name((d2) => {
    const ipsList = [];
    if (d2.network?.ipv4 !== void 0) {
      ipsList.push(`IPV4: ${dim(d2.network.ipv4)}`);
    }
    ipsList.push(`IPV6: ${dim(ipv6(d2.current_placement))}`);
    return ipsList;
  }, "ips");
  const deployment = await processArgument(args, "deploymentId", {
    type: "list",
    question: "Deployments",
    helpText: "Choose one by pressing the enter/return key",
    options: deployments2.map((d2) => ({
      label: "Deployment " + d2.id,
      value: d2.id,
      details: [
        `ID: ${dim(`${d2.id}`)}`,
        `Uptime: ${dim(`${uptime(d2.current_placement)}`)}`,
        `Version: ${dim(`${d2.version}`)}`,
        `Location: ${dim(`${idToLocationName(d2.location.name)}`)}`,
        `Image: ${dim(d2.image)}`,
        ...ips(d2),
        `Current Placement${version2(d2)}: ${health(d2.current_placement)}`
      ]
    })),
    label: "deployment"
  });
  return deployments2.find((d2) => d2.id === deployment);
}
__name(listDeploymentsAndChoose, "listDeploymentsAndChoose");
async function pickDeployment(deploymentIdPrefix) {
  const deployments2 = await loadDeployments(deploymentIdPrefix);
  const deploymentId = deployments2.length === 1 ? deployments2[0].id : void 0;
  const deployment = await listDeploymentsAndChoose(deployments2, {
    deploymentId
  });
  if (!deployment) {
    cancel("Cancelling deployment selection");
    (0, import_process5.exit)(0);
  }
  return deployment;
}
__name(pickDeployment, "pickDeployment");
function logDeployment(deployment) {
  log(
    `${brandColor("Image")} ${dim(deployment.image)}
${brandColor(
      "Location"
    )} ${dim(idToLocationName(deployment.location.name))}
${brandColor(
      "Version"
    )} ${dim(`${deployment.version}`)}
`
  );
}
__name(logDeployment, "logDeployment");

// src/cloudchamber/delete.ts
function deleteCommandOptionalYargs(yargs) {
  return yargs.positional("deploymentId", {
    type: "string",
    demandOption: false,
    describe: "deployment you want to delete"
  });
}
__name(deleteCommandOptionalYargs, "deleteCommandOptionalYargs");
async function deleteCommand(deleteArgs, config) {
  await loadAccountSpinner(deleteArgs);
  if (!interactWithUser(deleteArgs)) {
    if (!deleteArgs.deploymentId) {
      throw new Error(
        "there needs to be a deploymentId when you can't interact with the wrangler cli"
      );
    }
    const deployment = await DeploymentsService.deleteDeploymentV2(
      deleteArgs.deploymentId
    );
    console.log(JSON.stringify(deployment), null, 4);
    return;
  }
  await handleDeleteCommand(deleteArgs, config);
}
__name(deleteCommand, "deleteCommand");
async function handleDeleteCommand(args, _config) {
  startSection("Delete your deployment");
  const deployment = await pickDeployment(args.deploymentId);
  logDeployment(deployment);
  const yes = await inputPrompt({
    question: "Are you sure that you want to delete this deployment?",
    type: "confirm",
    label: ""
  });
  if (!yes) {
    cancel("The operation has been cancelled");
    return;
  }
  const [, err] = await wrap2(
    DeploymentsService.deleteDeploymentV2(deployment.id)
  );
  if (err) {
    crash(
      `There has been an internal error deleting your deployment.
 ${err.message}`
    );
    return;
  }
  endSection("Your container has been deleted");
}
__name(handleDeleteCommand, "handleDeleteCommand");

// src/cloudchamber/images/images.ts
init_import_meta_url();
function configureImageRegistryOptionalYargs(yargs) {
  return yargs.option("domain", {
    description: "Domain of your registry. Don't include the proto part of the URL, like 'http://'",
    type: "string"
  }).option("public", {
    description: "If the registry is public and you don't want credentials configured, set this to true",
    type: "boolean"
  });
}
__name(configureImageRegistryOptionalYargs, "configureImageRegistryOptionalYargs");
var registriesCommand = /* @__PURE__ */ __name((yargs) => {
  return yargs.command(
    "configure",
    "Configure Cloudchamber to pull from specific registries",
    (args) => configureImageRegistryOptionalYargs(args),
    (args) => handleFailure(
      async (imageArgs, config) => {
        if (!interactWithUser(args)) {
          const body = checkEverythingIsSet(imageArgs, [
            "domain",
            "public"
          ]);
          const registry = await ImageRegistriesService.createImageRegistry(
            {
              domain: body.domain,
              is_public: body.public
            }
          );
          console.log(JSON.stringify(registry, null, 4));
          return;
        }
        await handleConfigureImageRegistryCommand(args, config);
      }
    )(args)
  ).command(
    "credentials [domain]",
    "get a temporary password for a specific domain",
    (args) => args.positional("domain", { type: "string", demandOption: true }).option("expiration-minutes", {
      type: "number",
      default: 15
    }).option("push", {
      type: "boolean",
      description: "If you want these credentials to be able to push"
    }).option("pull", {
      type: "boolean",
      description: "If you want these credentials to be able to pull"
    }),
    (args) => {
      args.json = true;
      return handleFailure(
        async (imageArgs, _config) => {
          if (!imageArgs.pull && !imageArgs.push) {
            crash(
              "You have to specify either --push or --pull in the command."
            );
            process.exit(1);
          }
          const credentials = await ImageRegistriesService.generateImageRegistryCredentials(
            imageArgs.domain,
            {
              expiration_minutes: imageArgs.expirationMinutes,
              permissions: [
                ...imageArgs.push ? ["push"] : [],
                ...imageArgs.pull ? ["pull"] : []
              ]
            }
          );
          console.log(credentials.password);
        }
      )(args);
    }
  );
}, "registriesCommand");
async function handleConfigureImageRegistryCommand(args, _config) {
  startSection("Configure a Docker registry in Cloudflare");
  const domain2 = await processArgument({ domain: args.domain }, "domain", {
    type: "text",
    question: "What is the domain of your registry?",
    validate: (text) => {
      const t3 = text?.toString();
      if (t3?.includes("://")) {
        return "a proto like https:// shouldn't be included";
      }
    },
    label: "domain",
    defaultValue: "",
    helpText: "example.com, example-with-port:8080. Remember to not include https!"
  });
  const isPublic = await processArgument({ public: args.public }, "public", {
    type: "confirm",
    question: "Is the domain public?",
    label: "is public",
    helpText: "if the domain is not owned by you or you want it to be public, mark as yes"
  });
  const [registry, err] = await wrap2(
    promiseSpinner(
      ImageRegistriesService.createImageRegistry({
        domain: domain2,
        is_public: isPublic
      })
    )
  );
  if (err instanceof ApiError) {
    const { error: errString } = err.body;
    switch (errString) {
      case ImageRegistryAlreadyExistsError.error.IMAGE_REGISTRY_ALREADY_EXISTS:
        crash("The domain already exists!");
        break;
      case ImageRegistryNotAllowedError.error.IMAGE_REGISTRY_NOT_ALLOWED:
        crash("This domain is not allowed!");
        break;
      default:
        crash(
          "An unexpected error happened, please try again or send us the error for troubleshooting\n" + errString
        );
    }
    return;
  }
  if (err) {
    crash("There has been an internal error:", `${JSON.stringify(err)}`);
    return;
  }
  endSection(
    `Docker registry configured`,
    registry?.public_key && "set the following public key in the registry if necessary:\n" + registry?.public_key
  );
}
__name(handleConfigureImageRegistryCommand, "handleConfigureImageRegistryCommand");

// src/cloudchamber/list.ts
init_import_meta_url();
function listDeploymentsYargs(args) {
  return args.option("location", {
    requiresArg: true,
    type: "string",
    demandOption: false,
    describe: "Filter deployments by location"
  }).option("image", {
    requiresArg: true,
    type: "string",
    demandOption: false,
    describe: "Filter deployments by image"
  }).option("state", {
    requiresArg: true,
    type: "string",
    demandOption: false,
    describe: "Filter deployments by deployment state"
  }).option("ipv4", {
    requiresArg: true,
    type: "string",
    demandOption: false,
    describe: "Filter deployments by ipv4 address"
  }).option("label", {
    requiresArg: true,
    type: "array",
    demandOption: false,
    describe: "Filter deployments by labels",
    coerce: (arg) => arg.map((a) => a?.toString() ?? "")
  }).positional("deploymentIdPrefix", {
    describe: "Optional deploymentId to filter deployments\nThis means that 'list' will only showcase deployments that contain this ID prefix",
    type: "string"
  });
}
__name(listDeploymentsYargs, "listDeploymentsYargs");
async function listCommand(deploymentArgs, config) {
  await loadAccountSpinner(deploymentArgs);
  const prefix = deploymentArgs.deploymentIdPrefix ?? "";
  if (deploymentArgs.json || !isInteractive()) {
    const deployments2 = (await DeploymentsService.listDeploymentsV2(
      void 0,
      deploymentArgs.location,
      deploymentArgs.image,
      deploymentArgs.state,
      deploymentArgs.ipv4,
      deploymentArgs.label
    )).filter((deployment) => deployment.id.startsWith(prefix));
    if (deployments2.length === 1) {
      const placements = await PlacementsService.listPlacements(
        deployments2[0].id
      );
      console.log(
        JSON.stringify(
          {
            ...deployments2[0],
            placements
          },
          null,
          4
        )
      );
      return;
    }
    console.log(JSON.stringify(deployments2, null, 4));
    return;
  }
  await listCommandHandle(prefix, deploymentArgs, config);
}
__name(listCommand, "listCommand");
function eventMessage(event, lastEvent) {
  let { message } = event;
  const name = event.name;
  const health2 = event.statusChange["health"];
  if (health2 === "failed") {
    message = `${bgRed(" X ")} ${dim(message)}`;
  } else if (lastEvent && name === "VMStopped") {
    message = `${yellow(message)}`;
  } else if (lastEvent && name === "VMStarted" || name === "SSHStarted") {
    message = `${green(message)}`;
  } else if (lastEvent) {
    message = `${brandColor(message)}`;
  } else {
    message = dim(message);
  }
  return `${message} (${event.time})`;
}
__name(eventMessage, "eventMessage");
var listCommandHandle = /* @__PURE__ */ __name(async (deploymentIdPrefix, args, _config) => {
  const keepListIter = true;
  while (keepListIter) {
    logRaw(gray(shapes.bar));
    const deployments2 = await loadDeployments(deploymentIdPrefix, args);
    const deployment = await listDeploymentsAndChoose(deployments2);
    const placementToOptions = /* @__PURE__ */ __name((p2) => {
      return {
        label: `Placement ${p2.id.slice(0, 6)} (${p2.created_at})`,
        details: [
          `ID: ${dim(p2.id)}`,
          `Version: ${dim(`${p2.deployment_version}`)}`,
          `Status: ${statusToColored(p2.status["health"])}`,
          `${bgCyan(white(`Events`))}`,
          ...p2.events.map(
            (event, i) => space(1) + eventMessage(event, i === p2.events.length - 1)
          )
        ],
        value: p2.id
      };
    }, "placementToOptions");
    const loadPlacements = /* @__PURE__ */ __name(() => {
      return PlacementsService.listPlacements(deployment.id);
    }, "loadPlacements");
    const placements = await promiseSpinner(loadPlacements(), {
      message: "Loading placements"
    });
    const { start, stop } = spinner();
    let refresh = false;
    await inputPrompt({
      type: "list",
      question: "Placements",
      helpText: "Hint: Press R to refresh! Or press return to go back",
      options: placements.map(placementToOptions),
      label: "going back",
      onRefresh: async () => {
        start("Refreshing placements");
        const options29 = (await loadPlacements()).map(placementToOptions);
        if (refresh)
          return [];
        stop();
        if (options29.length)
          options29[0].label += ", last refresh: " + (/* @__PURE__ */ new Date()).toLocaleString();
        return options29;
      }
    });
    refresh = true;
    stop();
  }
}, "listCommandHandle");

// src/cloudchamber/modify.ts
init_import_meta_url();
function modifyCommandOptionalYargs(yargs) {
  return yargs.positional("deploymentId", {
    type: "string",
    demandOption: false,
    describe: "The deployment you want to modify"
  }).option("var", {
    requiresArg: true,
    type: "array",
    demandOption: false,
    describe: "Container environment variables",
    coerce: (arg) => arg.map((a) => a?.toString() ?? "")
  }).option("label", {
    requiresArg: true,
    type: "array",
    demandOption: false,
    describe: "Deployment labels",
    coerce: (arg) => arg.map((a) => a?.toString() ?? "")
  }).option("ssh-public-key-id", {
    requiresArg: true,
    type: "string",
    array: true,
    demandOption: false,
    describe: "Public SSH key IDs to include in this container. You can add one to your account with `wrangler cloudchamber ssh create"
  }).option("image", {
    requiresArg: true,
    type: "string",
    demandOption: false,
    describe: "The new image that the deployment will have from now on"
  }).option("location", {
    requiresArg: true,
    type: "string",
    demandOption: false,
    describe: "The new location that the deployment will have from now on"
  }).option("vcpu", {
    requiresArg: true,
    type: "number",
    demandOption: false,
    describe: "The new vcpu that the deployment will have from now on"
  }).option("memory", {
    requiresArg: true,
    type: "string",
    demandOption: false,
    describe: "The new memory that the deployment will have from now on"
  });
}
__name(modifyCommandOptionalYargs, "modifyCommandOptionalYargs");
async function modifyCommand(modifyArgs, config) {
  await loadAccountSpinner(modifyArgs);
  if (!interactWithUser(modifyArgs)) {
    if (!modifyArgs.deploymentId) {
      throw new Error(
        "there needs to be a deploymentId when you can't interact with the wrangler cli"
      );
    }
    const environmentVariables = collectEnvironmentVariables(
      [],
      config,
      modifyArgs.var
    );
    const labels = collectLabels(modifyArgs.label);
    const deployment = await DeploymentsService.modifyDeploymentV2(
      modifyArgs.deploymentId,
      {
        image: modifyArgs.image,
        location: modifyArgs.location,
        environment_variables: environmentVariables,
        labels,
        ssh_public_key_ids: modifyArgs.sshPublicKeyId,
        vcpu: modifyArgs.vcpu ?? config.cloudchamber.vcpu,
        memory: modifyArgs.memory ?? config.cloudchamber.memory
      }
    );
    console.log(JSON.stringify(deployment, null, 4));
    return;
  }
  await handleModifyCommand(modifyArgs, config);
}
__name(modifyCommand, "modifyCommand");
async function handleSSH(args, config, deployment) {
  if (args.sshPublicKeyId !== void 0) {
    return args.sshPublicKeyId;
  }
  await sshPrompts(args);
  const keys = await pollSSHKeysUntilCondition(() => true);
  let keysToAdd = [...deployment.ssh_public_key_ids ?? []];
  const yes = await inputPrompt({
    type: "confirm",
    question: "Do you want to modify existing ssh keys from the deployment?",
    label: "",
    defaultValue: false
  });
  if (!yes) {
    return void 0;
  }
  if ((deployment.ssh_public_key_ids?.length || 0) > 0) {
    const keysSelected = await inputPrompt({
      type: "multiselect",
      question: "Select the keys you want to remove from the deployment",
      helpText: "You can select pressing 'space'. Submit with 'enter'",
      options: keys.filter((k2) => deployment.ssh_public_key_ids?.includes(k2.id)).map((key) => ({ label: key.name, value: key.id })),
      label: "removing"
    });
    keysToAdd = keys.filter((key) => deployment.ssh_public_key_ids?.includes(key.id)).filter((key) => !keysSelected.includes(key.id)).map((k2) => k2.id);
  }
  const addKeysOptions = keys.filter((k2) => !deployment.ssh_public_key_ids?.includes(k2.id)).map((key) => ({ label: key.name, value: key.id }));
  if (addKeysOptions.length > 0) {
    const newKeys = await inputPrompt({
      type: "multiselect",
      question: "Select the keys you want to add to the deployment",
      options: addKeysOptions,
      label: "adding",
      defaultValue: []
    });
    keysToAdd = [...newKeys, ...keysToAdd];
  }
  return keysToAdd;
}
__name(handleSSH, "handleSSH");
async function handleModifyCommand(args, config) {
  startSection("Modify deployment");
  const deployment = await pickDeployment(args.deploymentId);
  const keys = await handleSSH(args, config, deployment);
  const imagePrompt = await processArgument(
    { image: args.image },
    "image",
    {
      question: modifyImageQuestion,
      label: "",
      validate: (value) => {
        if (typeof value !== "string")
          return "unknown error";
        if (value.endsWith(":latest"))
          return "we don't allow :latest tags";
      },
      defaultValue: args.image ?? "",
      initialValue: args.image ?? "",
      helpText: "if you don't want to modify the image, press return",
      type: "text"
    }
  );
  const image = !imagePrompt ? void 0 : imagePrompt;
  const locationPick = await getLocation2(args, { skipLocation: true });
  const location = locationPick === "Skip" ? void 0 : locationPick;
  const environmentVariables = collectEnvironmentVariables(
    deployment.environment_variables,
    config,
    args.var
  );
  const selectedEnvironmentVariables = await promptForEnvironmentVariables(
    environmentVariables,
    (deployment.environment_variables ?? []).map((v2) => v2.name),
    true
  );
  const labels = collectLabels(args.label);
  const selectedLabels = await promptForLabels(
    labels,
    (deployment.labels ?? []).map((v2) => v2.name),
    true
  );
  renderDeploymentConfiguration("modify", {
    image: image ?? deployment.image,
    location: location ?? deployment.location.name,
    vcpu: args.vcpu ?? config.cloudchamber.vcpu ?? deployment.vcpu,
    memory: args.memory ?? config.cloudchamber.memory ?? deployment.memory,
    env: args.env,
    environmentVariables: selectedEnvironmentVariables !== void 0 ? selectedEnvironmentVariables : deployment.environment_variables,
    // show the existing environment variables if any
    labels: selectedLabels !== void 0 ? selectedLabels : deployment.labels
    // show the existing labels if any
  });
  const yesOrNo = await inputPrompt({
    question: "Want to go ahead and modify the deployment?",
    label: "",
    type: "confirm"
  });
  if (!yesOrNo) {
    cancel("Not modifying the deployment");
    return;
  }
  const { start, stop } = spinner();
  start(
    "Modifying your container",
    "shortly your container will be modified to a new version"
  );
  const [newDeployment, err] = await wrap2(
    DeploymentsService.modifyDeploymentV2(deployment.id, {
      image,
      location,
      ssh_public_key_ids: keys,
      environment_variables: selectedEnvironmentVariables,
      vcpu: args.vcpu ?? config.cloudchamber.vcpu,
      memory: args.memory ?? config.cloudchamber.memory
    })
  );
  stop();
  if (err) {
    renderDeploymentMutationError(await loadAccount(), err);
    return;
  }
  await waitForPlacement(newDeployment);
}
__name(handleModifyCommand, "handleModifyCommand");
var modifyImageQuestion = "Insert the image url you want to change your deployment to";

// src/cloudchamber/index.ts
function internalCommands(args) {
  try {
    const cloudchamberInternalRequireEntry = require("./internal/index");
    return cloudchamberInternalRequireEntry.internalCommands(args);
  } catch {
    return args;
  }
}
__name(internalCommands, "internalCommands");
var cloudchamber = /* @__PURE__ */ __name((yargs, subHelp) => {
  yargs = internalCommands(yargs);
  return yargs.command(
    "delete [deploymentId]",
    "Delete an existing deployment that is running in the Cloudflare edge",
    (args) => deleteCommandOptionalYargs(args),
    (args) => handleFailure(deleteCommand)(args)
  ).command(
    "create",
    "Create a new deployment",
    (args) => createCommandOptionalYargs(args),
    (args) => handleFailure(createCommand)(args)
  ).command(
    "list [deploymentIdPrefix]",
    "List and view status of deployments",
    (args) => listDeploymentsYargs(args),
    (args) => handleFailure(listCommand)(args)
  ).command(
    "modify [deploymentId]",
    "Modify an existing deployment",
    (args) => modifyCommandOptionalYargs(args),
    (args) => handleFailure(modifyCommand)(args)
  ).command(
    "ssh",
    "Manage the ssh keys of your account",
    (args) => sshCommand(args).command(subHelp)
  ).command(
    "registries",
    "Configure registries via Cloudchamber",
    (args) => registriesCommand(args).command(subHelp)
  );
}, "cloudchamber");

// src/constellation/index.ts
init_import_meta_url();

// src/constellation/createProject.tsx
init_import_meta_url();

// src/constellation/options.ts
init_import_meta_url();
function takeName(yargs) {
  return yargs.positional("name", {
    describe: "The name of the project",
    type: "string",
    demandOption: true
  });
}
__name(takeName, "takeName");

// src/constellation/createProject.tsx
function options4(yargs) {
  return takeName(yargs).positional("runtime", {
    describe: "The name of the runtime to use",
    type: "string",
    demandOption: true
  }).epilogue(constellationBetaWarning);
}
__name(options4, "options");
var handler5 = withConfig(
  async ({ name, runtime, config }) => {
    const accountId = await requireAuth(config);
    logger.log(constellationBetaWarning);
    let proj;
    try {
      proj = await fetchResult(`/accounts/${accountId}/constellation/project`, {
        method: "POST",
        headers: {
          "Content-Type": "application/json"
        },
        body: JSON.stringify({
          name,
          runtime
        })
      });
    } catch (e3) {
      if (e3.code === 7409) {
        throw new UserError("A project with that name already exists");
      }
      throw e3;
    }
    logger.log(`\u2705 Successfully created Project "${proj.name}"!`);
  }
);

// src/constellation/deleteProject.ts
init_import_meta_url();
function options5(yargs) {
  return takeName(yargs).option("force", {
    describe: "Skip confirmation",
    type: "boolean",
    alias: "f",
    default: false
  }).epilogue(constellationBetaWarning);
}
__name(options5, "options");
var handler6 = withConfig(
  async ({ name, force, config }) => {
    const accountId = await requireAuth(config);
    logger.log(constellationBetaWarning);
    const proj = await getProjectByName(config, accountId, name);
    logger.log(`About to delete Project '${name}' (${proj.id}).`);
    if (!force) {
      const response = await confirm(`Ok to proceed?`);
      if (!response) {
        logger.log(`Not deleting.`);
        return;
      }
      logger.log("Deleting...");
    }
    await fetchResult(
      `/accounts/${accountId}/constellation/project/${proj.id}`,
      {
        method: "DELETE"
      }
    );
    logger.log(`Deleted '${name}' successfully.`);
  }
);

// src/constellation/deleteProjectModel.ts
init_import_meta_url();
function options6(yargs) {
  return yargs.positional("projectName", {
    describe: "The name of the project",
    type: "string",
    demandOption: true
  }).positional("modelName", {
    describe: "The name of the uploaded model",
    type: "string",
    demandOption: true
  }).option("force", {
    describe: "Skip confirmation",
    type: "boolean",
    alias: "f",
    default: false
  }).epilogue(constellationBetaWarning);
}
__name(options6, "options");
var handler7 = withConfig(
  async ({ projectName, modelName, force, config }) => {
    const accountId = await requireAuth(config);
    logger.log(constellationBetaWarning);
    const proj = await getProjectByName(
      config,
      accountId,
      projectName
    );
    const model = await getProjectModelByName(
      config,
      accountId,
      proj,
      modelName
    );
    logger.log(`About to delete Model '${modelName}' (${model.id}).`);
    if (!force) {
      const response = await confirm(`Ok to proceed?`);
      if (!response) {
        logger.log(`Not deleting.`);
        return;
      }
      logger.log("Deleting...");
    }
    await fetchResult(
      `/accounts/${accountId}/constellation/project/${proj.id}/model/${model.id}`,
      {
        method: "DELETE"
      }
    );
    logger.log(`Deleted '${modelName}' successfully.`);
  }
);

// src/constellation/listCatalog.tsx
init_import_meta_url();
function options7(yargs) {
  return asJson(yargs).epilogue(constellationBetaWarning);
}
__name(options7, "options");
var handler8 = withConfig(
  async ({ json, config }) => {
    const accountId = await requireAuth(config);
    const entries = await listCatalogEntries(accountId);
    if (json) {
      logger.log(JSON.stringify(entries, null, 2));
    } else {
      logger.log(constellationBetaWarning);
      logger.table(
        entries.map((entry) => ({
          project_id: entry.project.id,
          project_name: entry.project.name,
          project_runtime: entry.project.runtime,
          models: entry.models.map((model) => model.name).join(",")
        }))
      );
    }
  }
);

// src/constellation/listModel.tsx
init_import_meta_url();
function options8(yargs) {
  return yargs.positional("projectName", {
    describe: "The name of the project",
    type: "string",
    demandOption: true
  }).option("json", {
    describe: "return output as clean JSON",
    type: "boolean",
    default: false
  }).epilogue(constellationBetaWarning);
}
__name(options8, "options");
var handler9 = withConfig(
  async ({ projectName, json, config }) => {
    const accountId = await requireAuth(config);
    const proj = await getProjectByName(
      config,
      accountId,
      projectName
    );
    const models = await listModels(accountId, proj);
    if (json) {
      logger.log(JSON.stringify(models, null, 2));
    } else {
      logger.log(constellationBetaWarning);
      logger.table(models);
    }
  }
);

// src/constellation/listProject.tsx
init_import_meta_url();
function options9(yargs) {
  return asJson(yargs).epilogue(constellationBetaWarning);
}
__name(options9, "options");
var handler10 = withConfig(
  async ({ json, config }) => {
    const accountId = await requireAuth(config);
    const projs = await listProjects(accountId);
    if (json) {
      logger.log(JSON.stringify(projs, null, 2));
    } else {
      logger.log(constellationBetaWarning);
      logger.table(projs);
    }
  }
);

// src/constellation/listRuntime.tsx
init_import_meta_url();
function options10(yargs) {
  return asJson(yargs).epilogue(constellationBetaWarning);
}
__name(options10, "options");
var handler11 = withConfig(
  async ({ json, config }) => {
    const accountId = await requireAuth(config);
    const runtimes = await listRuntimes(accountId);
    if (json) {
      logger.log(JSON.stringify(runtimes, null, 2));
    } else {
      logger.log(constellationBetaWarning);
      logger.table(runtimes.map((runtime) => ({ name: runtime })));
    }
  }
);

// src/constellation/uploadModel.tsx
init_import_meta_url();
var import_node_fs19 = require("node:fs");
var import_undici9 = __toESM(require_undici());
function options11(yargs) {
  return yargs.positional("projectName", {
    describe: "The name of the project",
    type: "string",
    demandOption: true
  }).positional("modelName", {
    describe: "The name of the uploaded model",
    type: "string",
    demandOption: true
  }).positional("modelFile", {
    describe: "The name of the local file with the model contents",
    type: "string",
    demandOption: true
  }).option("description", {
    describe: "include a description of the model",
    type: "string",
    demandOption: false,
    alias: "d"
  }).epilogue(constellationBetaWarning);
}
__name(options11, "options");
var handler12 = withConfig(
  async ({
    projectName,
    modelName,
    modelFile,
    description,
    config
  }) => {
    const accountId = await requireAuth(config);
    logger.log(constellationBetaWarning);
    const proj = await getProjectByName(config, accountId, projectName);
    const formData = new import_undici9.FormData();
    formData.set(
      "file",
      new import_undici9.File([(0, import_node_fs19.readFileSync)(modelFile)], modelFile, {
        type: "application/octet-stream"
      })
    );
    formData.set("name", modelName);
    if (description !== void 0) {
      formData.set("description", description);
    }
    let model;
    try {
      model = await fetchResult(
        `/accounts/${accountId}/constellation/project/${proj.id}/model`,
        {
          method: "POST",
          body: formData
        }
      );
    } catch (e3) {
      if (e3.code === 7408) {
        throw new UserError("A model with that name already exists");
      }
      throw e3;
    }
    logger.log(`\u2705 Successfully uploaded Model "${model.name}"!`);
  }
);

// src/constellation/index.ts
function constellation(yargs) {
  logger.warn(
    "`wrangler constellation` is deprecated and will be removed in the next major version.\nPlease migrate to Workers AI, learn more here https://developers.cloudflare.com/workers-ai/."
  );
  return yargs.command("project", "Manage your projects", (constProjYargs) => {
    return constProjYargs.command(
      "list",
      "List your projects",
      options9,
      handler10
    ).command(
      "create <name> <runtime>",
      "Create project",
      options4,
      handler5
    ).command(
      "delete <name>",
      "Delete project",
      options5,
      handler6
    );
  }).command("model", "Manage your models", (constModelYargs) => {
    return constModelYargs.command(
      "upload <projectName> <modelName> <modelFile>",
      "Upload a model for an existing project",
      options11,
      handler12
    ).command(
      "list <projectName>",
      "List models of a project",
      options8,
      handler9
    ).command(
      "delete <projectName> <modelName>",
      "Delete a model of a project",
      options6,
      handler7
    );
  }).command(
    "catalog",
    "Check the curated model catalog",
    (constCatalogYargs) => {
      return constCatalogYargs.command(
        "list",
        "List catalog models",
        options7,
        handler8
      );
    }
  ).command("runtime", "Check the suported runtimes", (constRuntimeYargs) => {
    return constRuntimeYargs.command(
      "list",
      "List suported runtimes",
      options10,
      handler11
    );
  });
}
__name(constellation, "constellation");

// src/d1/index.ts
init_import_meta_url();

// src/d1/backups.tsx
init_import_meta_url();
var import_promises6 = __toESM(require("node:fs/promises"));
var path29 = __toESM(require("path"));
var import_ink_table2 = __toESM(require_dist4());
var import_react3 = __toESM(require_react());

// src/utils/render.ts
init_import_meta_url();
var import_events = require("events");
var import_ink = __toESM(require_build2());
function renderToString(tree) {
  const { output, cleanup } = render(tree);
  cleanup();
  return output;
}
__name(renderToString, "renderToString");
var LASTFRAME_UNDEFINED = "value of stdout.lastframe() is undefined";
var OutputStream = class extends import_events.EventEmitter {
  constructor(_originalStream) {
    super();
    this._originalStream = _originalStream;
  }
  frames = [];
  _lastFrame;
  get columns() {
    return this._originalStream.columns;
  }
  get rows() {
    return this._originalStream.rows;
  }
  write = (frame) => {
    this.frames.push(frame);
    this._lastFrame = frame;
  };
  lastFrame = () => {
    return this._lastFrame;
  };
};
__name(OutputStream, "OutputStream");
var render = /* @__PURE__ */ __name((tree) => {
  const stdout2 = new OutputStream(process.stdout);
  const stderr2 = new OutputStream(process.stderr);
  const instance = (0, import_ink.render)(tree, {
    stdout: stdout2,
    stderr: stderr2,
    debug: true,
    exitOnCtrlC: false,
    patchConsole: false
  });
  return {
    output: stdout2.lastFrame() ?? LASTFRAME_UNDEFINED,
    stdout: stdout2,
    stderr: stderr2,
    cleanup: instance.cleanup,
    unmount: instance.unmount,
    frames: stdout2.frames
  };
}, "render");

// src/d1/formatTimeAgo.ts
init_import_meta_url();

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/index.js
init_import_meta_url();

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/TimeAgo.js
init_import_meta_url();

// ../../node_modules/.pnpm/relative-time-format@1.1.4/node_modules/relative-time-format/index.js
init_import_meta_url();

// ../../node_modules/.pnpm/relative-time-format@1.1.4/node_modules/relative-time-format/modules/RelativeTimeFormat.js
init_import_meta_url();

// ../../node_modules/.pnpm/relative-time-format@1.1.4/node_modules/relative-time-format/modules/LocaleDataStore.js
init_import_meta_url();
var defaultLocale = "en";
var localesData = {};
var lowercaseLocaleLookup = {};
function getDefaultLocale() {
  return defaultLocale;
}
__name(getDefaultLocale, "getDefaultLocale");
function setDefaultLocale(locale) {
  defaultLocale = locale;
}
__name(setDefaultLocale, "setDefaultLocale");
function getLocaleData(locale) {
  return localesData[locale];
}
__name(getLocaleData, "getLocaleData");
function addLocaleData(localeData) {
  if (!localeData) {
    throw new Error("No locale data passed");
  }
  localesData[localeData.locale] = localeData;
  lowercaseLocaleLookup[localeData.locale.toLowerCase()] = localeData.locale;
}
__name(addLocaleData, "addLocaleData");
function resolveLocale(locale) {
  if (localesData[locale]) {
    return locale;
  }
  if (lowercaseLocaleLookup[locale.toLowerCase()]) {
    return lowercaseLocaleLookup[locale.toLowerCase()];
  }
}
__name(resolveLocale, "resolveLocale");

// ../../node_modules/.pnpm/relative-time-format@1.1.4/node_modules/relative-time-format/modules/resolveLocale.js
init_import_meta_url();
function resolveLocale2(locale) {
  var options29 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
  var localeMatcher = options29.localeMatcher || "lookup";
  switch (localeMatcher) {
    case "lookup":
      return resolveLocaleLookup(locale);
    case "best fit":
      return resolveLocaleLookup(locale);
    default:
      throw new RangeError('Invalid "localeMatcher" option: '.concat(localeMatcher));
  }
}
__name(resolveLocale2, "resolveLocale");
function resolveLocaleLookup(locale) {
  var resolvedLocale = resolveLocale(locale);
  if (resolvedLocale) {
    return resolvedLocale;
  }
  var parts = locale.split("-");
  while (locale.length > 1) {
    parts.pop();
    locale = parts.join("-");
    var _resolvedLocale = resolveLocale(locale);
    if (_resolvedLocale) {
      return _resolvedLocale;
    }
  }
}
__name(resolveLocaleLookup, "resolveLocaleLookup");

// ../../node_modules/.pnpm/relative-time-format@1.1.4/node_modules/relative-time-format/modules/PluralRules.js
init_import_meta_url();

// ../../node_modules/.pnpm/relative-time-format@1.1.4/node_modules/relative-time-format/modules/PluralRuleFunctions.js
init_import_meta_url();
var $2 = {
  af: /* @__PURE__ */ __name(function af(n2) {
    return n2 == 1 ? "one" : "other";
  }, "af"),
  am: /* @__PURE__ */ __name(function am(n2) {
    return n2 >= 0 && n2 <= 1 ? "one" : "other";
  }, "am"),
  ar: /* @__PURE__ */ __name(function ar(n2) {
    var s = String(n2).split("."), t0 = Number(s[0]) == n2, n100 = t0 && s[0].slice(-2);
    return n2 == 0 ? "zero" : n2 == 1 ? "one" : n2 == 2 ? "two" : n100 >= 3 && n100 <= 10 ? "few" : n100 >= 11 && n100 <= 99 ? "many" : "other";
  }, "ar"),
  ast: /* @__PURE__ */ __name(function ast(n2) {
    var s = String(n2).split("."), v0 = !s[1];
    return n2 == 1 && v0 ? "one" : "other";
  }, "ast"),
  be: /* @__PURE__ */ __name(function be(n2) {
    var s = String(n2).split("."), t0 = Number(s[0]) == n2, n10 = t0 && s[0].slice(-1), n100 = t0 && s[0].slice(-2);
    return n10 == 1 && n100 != 11 ? "one" : n10 >= 2 && n10 <= 4 && (n100 < 12 || n100 > 14) ? "few" : t0 && n10 == 0 || n10 >= 5 && n10 <= 9 || n100 >= 11 && n100 <= 14 ? "many" : "other";
  }, "be"),
  br: /* @__PURE__ */ __name(function br(n2) {
    var s = String(n2).split("."), t0 = Number(s[0]) == n2, n10 = t0 && s[0].slice(-1), n100 = t0 && s[0].slice(-2), n1000000 = t0 && s[0].slice(-6);
    return n10 == 1 && n100 != 11 && n100 != 71 && n100 != 91 ? "one" : n10 == 2 && n100 != 12 && n100 != 72 && n100 != 92 ? "two" : (n10 == 3 || n10 == 4 || n10 == 9) && (n100 < 10 || n100 > 19) && (n100 < 70 || n100 > 79) && (n100 < 90 || n100 > 99) ? "few" : n2 != 0 && t0 && n1000000 == 0 ? "many" : "other";
  }, "br"),
  bs: /* @__PURE__ */ __name(function bs(n2) {
    var s = String(n2).split("."), i = s[0], f = s[1] || "", v0 = !s[1], i10 = i.slice(-1), i100 = i.slice(-2), f10 = f.slice(-1), f100 = f.slice(-2);
    return v0 && i10 == 1 && i100 != 11 || f10 == 1 && f100 != 11 ? "one" : v0 && i10 >= 2 && i10 <= 4 && (i100 < 12 || i100 > 14) || f10 >= 2 && f10 <= 4 && (f100 < 12 || f100 > 14) ? "few" : "other";
  }, "bs"),
  ceb: /* @__PURE__ */ __name(function ceb(n2) {
    var s = String(n2).split("."), i = s[0], f = s[1] || "", v0 = !s[1], i10 = i.slice(-1), f10 = f.slice(-1);
    return v0 && (i == 1 || i == 2 || i == 3) || v0 && i10 != 4 && i10 != 6 && i10 != 9 || !v0 && f10 != 4 && f10 != 6 && f10 != 9 ? "one" : "other";
  }, "ceb"),
  cs: /* @__PURE__ */ __name(function cs(n2) {
    var s = String(n2).split("."), i = s[0], v0 = !s[1];
    return n2 == 1 && v0 ? "one" : i >= 2 && i <= 4 && v0 ? "few" : !v0 ? "many" : "other";
  }, "cs"),
  cy: /* @__PURE__ */ __name(function cy(n2) {
    return n2 == 0 ? "zero" : n2 == 1 ? "one" : n2 == 2 ? "two" : n2 == 3 ? "few" : n2 == 6 ? "many" : "other";
  }, "cy"),
  da: /* @__PURE__ */ __name(function da(n2) {
    var s = String(n2).split("."), i = s[0], t0 = Number(s[0]) == n2;
    return n2 == 1 || !t0 && (i == 0 || i == 1) ? "one" : "other";
  }, "da"),
  dsb: /* @__PURE__ */ __name(function dsb(n2) {
    var s = String(n2).split("."), i = s[0], f = s[1] || "", v0 = !s[1], i100 = i.slice(-2), f100 = f.slice(-2);
    return v0 && i100 == 1 || f100 == 1 ? "one" : v0 && i100 == 2 || f100 == 2 ? "two" : v0 && (i100 == 3 || i100 == 4) || f100 == 3 || f100 == 4 ? "few" : "other";
  }, "dsb"),
  dz: /* @__PURE__ */ __name(function dz(n2) {
    return "other";
  }, "dz"),
  es: /* @__PURE__ */ __name(function es(n2) {
    var s = String(n2).split("."), i = s[0], v0 = !s[1], i1000000 = i.slice(-6);
    return n2 == 1 ? "one" : i != 0 && i1000000 == 0 && v0 ? "many" : "other";
  }, "es"),
  ff: /* @__PURE__ */ __name(function ff(n2) {
    return n2 >= 0 && n2 < 2 ? "one" : "other";
  }, "ff"),
  fr: /* @__PURE__ */ __name(function fr(n2) {
    var s = String(n2).split("."), i = s[0], v0 = !s[1], i1000000 = i.slice(-6);
    return n2 >= 0 && n2 < 2 ? "one" : i != 0 && i1000000 == 0 && v0 ? "many" : "other";
  }, "fr"),
  ga: /* @__PURE__ */ __name(function ga(n2) {
    var s = String(n2).split("."), t0 = Number(s[0]) == n2;
    return n2 == 1 ? "one" : n2 == 2 ? "two" : t0 && n2 >= 3 && n2 <= 6 ? "few" : t0 && n2 >= 7 && n2 <= 10 ? "many" : "other";
  }, "ga"),
  gd: /* @__PURE__ */ __name(function gd(n2) {
    var s = String(n2).split("."), t0 = Number(s[0]) == n2;
    return n2 == 1 || n2 == 11 ? "one" : n2 == 2 || n2 == 12 ? "two" : t0 && n2 >= 3 && n2 <= 10 || t0 && n2 >= 13 && n2 <= 19 ? "few" : "other";
  }, "gd"),
  he: /* @__PURE__ */ __name(function he(n2) {
    var s = String(n2).split("."), i = s[0], v0 = !s[1], t0 = Number(s[0]) == n2, n10 = t0 && s[0].slice(-1);
    return n2 == 1 && v0 ? "one" : i == 2 && v0 ? "two" : v0 && (n2 < 0 || n2 > 10) && t0 && n10 == 0 ? "many" : "other";
  }, "he"),
  is: /* @__PURE__ */ __name(function is(n2) {
    var s = String(n2).split("."), i = s[0], t0 = Number(s[0]) == n2, i10 = i.slice(-1), i100 = i.slice(-2);
    return t0 && i10 == 1 && i100 != 11 || !t0 ? "one" : "other";
  }, "is"),
  it: /* @__PURE__ */ __name(function it(n2) {
    var s = String(n2).split("."), i = s[0], v0 = !s[1], i1000000 = i.slice(-6);
    return n2 == 1 && v0 ? "one" : i != 0 && i1000000 == 0 && v0 ? "many" : "other";
  }, "it"),
  ksh: /* @__PURE__ */ __name(function ksh(n2) {
    return n2 == 0 ? "zero" : n2 == 1 ? "one" : "other";
  }, "ksh"),
  lt: /* @__PURE__ */ __name(function lt(n2) {
    var s = String(n2).split("."), f = s[1] || "", t0 = Number(s[0]) == n2, n10 = t0 && s[0].slice(-1), n100 = t0 && s[0].slice(-2);
    return n10 == 1 && (n100 < 11 || n100 > 19) ? "one" : n10 >= 2 && n10 <= 9 && (n100 < 11 || n100 > 19) ? "few" : f != 0 ? "many" : "other";
  }, "lt"),
  lv: /* @__PURE__ */ __name(function lv(n2) {
    var s = String(n2).split("."), f = s[1] || "", v2 = f.length, t0 = Number(s[0]) == n2, n10 = t0 && s[0].slice(-1), n100 = t0 && s[0].slice(-2), f100 = f.slice(-2), f10 = f.slice(-1);
    return t0 && n10 == 0 || n100 >= 11 && n100 <= 19 || v2 == 2 && f100 >= 11 && f100 <= 19 ? "zero" : n10 == 1 && n100 != 11 || v2 == 2 && f10 == 1 && f100 != 11 || v2 != 2 && f10 == 1 ? "one" : "other";
  }, "lv"),
  mk: /* @__PURE__ */ __name(function mk(n2) {
    var s = String(n2).split("."), i = s[0], f = s[1] || "", v0 = !s[1], i10 = i.slice(-1), i100 = i.slice(-2), f10 = f.slice(-1), f100 = f.slice(-2);
    return v0 && i10 == 1 && i100 != 11 || f10 == 1 && f100 != 11 ? "one" : "other";
  }, "mk"),
  mt: /* @__PURE__ */ __name(function mt(n2) {
    var s = String(n2).split("."), t0 = Number(s[0]) == n2, n100 = t0 && s[0].slice(-2);
    return n2 == 1 ? "one" : n2 == 0 || n100 >= 2 && n100 <= 10 ? "few" : n100 >= 11 && n100 <= 19 ? "many" : "other";
  }, "mt"),
  pa: /* @__PURE__ */ __name(function pa(n2) {
    return n2 == 0 || n2 == 1 ? "one" : "other";
  }, "pa"),
  pl: /* @__PURE__ */ __name(function pl(n2) {
    var s = String(n2).split("."), i = s[0], v0 = !s[1], i10 = i.slice(-1), i100 = i.slice(-2);
    return n2 == 1 && v0 ? "one" : v0 && i10 >= 2 && i10 <= 4 && (i100 < 12 || i100 > 14) ? "few" : v0 && i != 1 && (i10 == 0 || i10 == 1) || v0 && i10 >= 5 && i10 <= 9 || v0 && i100 >= 12 && i100 <= 14 ? "many" : "other";
  }, "pl"),
  pt: /* @__PURE__ */ __name(function pt(n2) {
    var s = String(n2).split("."), i = s[0], v0 = !s[1], i1000000 = i.slice(-6);
    return i == 0 || i == 1 ? "one" : i != 0 && i1000000 == 0 && v0 ? "many" : "other";
  }, "pt"),
  ro: /* @__PURE__ */ __name(function ro(n2) {
    var s = String(n2).split("."), v0 = !s[1], t0 = Number(s[0]) == n2, n100 = t0 && s[0].slice(-2);
    return n2 == 1 && v0 ? "one" : !v0 || n2 == 0 || n100 >= 2 && n100 <= 19 ? "few" : "other";
  }, "ro"),
  ru: /* @__PURE__ */ __name(function ru(n2) {
    var s = String(n2).split("."), i = s[0], v0 = !s[1], i10 = i.slice(-1), i100 = i.slice(-2);
    return v0 && i10 == 1 && i100 != 11 ? "one" : v0 && i10 >= 2 && i10 <= 4 && (i100 < 12 || i100 > 14) ? "few" : v0 && i10 == 0 || v0 && i10 >= 5 && i10 <= 9 || v0 && i100 >= 11 && i100 <= 14 ? "many" : "other";
  }, "ru"),
  se: /* @__PURE__ */ __name(function se(n2) {
    return n2 == 1 ? "one" : n2 == 2 ? "two" : "other";
  }, "se"),
  si: /* @__PURE__ */ __name(function si(n2) {
    var s = String(n2).split("."), i = s[0], f = s[1] || "";
    return n2 == 0 || n2 == 1 || i == 0 && f == 1 ? "one" : "other";
  }, "si"),
  sl: /* @__PURE__ */ __name(function sl(n2) {
    var s = String(n2).split("."), i = s[0], v0 = !s[1], i100 = i.slice(-2);
    return v0 && i100 == 1 ? "one" : v0 && i100 == 2 ? "two" : v0 && (i100 == 3 || i100 == 4) || !v0 ? "few" : "other";
  }, "sl")
};
$2.as = $2.am;
$2.az = $2.af;
$2.bg = $2.af;
$2.bn = $2.am;
$2.brx = $2.af;
$2.ca = $2.ast;
$2.ce = $2.af;
$2.chr = $2.af;
$2.de = $2.ast;
$2.ee = $2.af;
$2.el = $2.af;
$2.en = $2.ast;
$2.et = $2.ast;
$2.eu = $2.af;
$2.fa = $2.am;
$2.fi = $2.ast;
$2.fil = $2.ceb;
$2.fo = $2.af;
$2.fur = $2.af;
$2.fy = $2.ast;
$2.gl = $2.ast;
$2.gu = $2.am;
$2.ha = $2.af;
$2.hi = $2.am;
$2.hr = $2.bs;
$2.hsb = $2.dsb;
$2.hu = $2.af;
$2.hy = $2.ff;
$2.ia = $2.ast;
$2.id = $2.dz;
$2.ig = $2.dz;
$2.ja = $2.dz;
$2.jgo = $2.af;
$2.jv = $2.dz;
$2.ka = $2.af;
$2.kea = $2.dz;
$2.kk = $2.af;
$2.kl = $2.af;
$2.km = $2.dz;
$2.kn = $2.am;
$2.ko = $2.dz;
$2.ku = $2.af;
$2.ky = $2.af;
$2.lb = $2.af;
$2.lkt = $2.dz;
$2.lo = $2.dz;
$2.ml = $2.af;
$2.mn = $2.af;
$2.mr = $2.af;
$2.ms = $2.dz;
$2.my = $2.dz;
$2.nb = $2.af;
$2.ne = $2.af;
$2.nl = $2.ast;
$2.nn = $2.af;
$2.no = $2.af;
$2.or = $2.af;
$2.pcm = $2.am;
$2.ps = $2.af;
$2.rm = $2.af;
$2.sah = $2.dz;
$2.sc = $2.ast;
$2.sd = $2.af;
$2.sk = $2.cs;
$2.so = $2.af;
$2.sq = $2.af;
$2.sr = $2.bs;
$2.su = $2.dz;
$2.sv = $2.ast;
$2.sw = $2.ast;
$2.ta = $2.af;
$2.te = $2.af;
$2.th = $2.dz;
$2.ti = $2.pa;
$2.tk = $2.af;
$2.to = $2.dz;
$2.tr = $2.af;
$2.ug = $2.af;
$2.uk = $2.ru;
$2.ur = $2.ast;
$2.uz = $2.af;
$2.vi = $2.dz;
$2.wae = $2.af;
$2.wo = $2.dz;
$2.yi = $2.ast;
$2.yo = $2.dz;
$2.yue = $2.dz;
$2.zh = $2.dz;
$2.zu = $2.am;
var PluralRuleFunctions_default = $2;

// ../../node_modules/.pnpm/relative-time-format@1.1.4/node_modules/relative-time-format/modules/getPluralRulesLocale.js
init_import_meta_url();
function getPluralRulesLocale(locale) {
  if (locale === "pt-PT") {
    return locale;
  }
  return getLanguageFromLanguageTag(locale);
}
__name(getPluralRulesLocale, "getPluralRulesLocale");
var LANGUAGE_REG_EXP = /^([a-z0-9]+)/i;
function getLanguageFromLanguageTag(languageTag) {
  var match = languageTag.match(LANGUAGE_REG_EXP);
  if (!match) {
    throw new TypeError("Invalid locale: ".concat(languageTag));
  }
  return match[1];
}
__name(getLanguageFromLanguageTag, "getLanguageFromLanguageTag");

// ../../node_modules/.pnpm/relative-time-format@1.1.4/node_modules/relative-time-format/modules/PluralRules.js
function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}
__name(_classCallCheck, "_classCallCheck");
function _defineProperties(target, props) {
  for (var i = 0; i < props.length; i++) {
    var descriptor2 = props[i];
    descriptor2.enumerable = descriptor2.enumerable || false;
    descriptor2.configurable = true;
    if ("value" in descriptor2)
      descriptor2.writable = true;
    Object.defineProperty(target, descriptor2.key, descriptor2);
  }
}
__name(_defineProperties, "_defineProperties");
function _createClass(Constructor, protoProps, staticProps) {
  if (protoProps)
    _defineProperties(Constructor.prototype, protoProps);
  if (staticProps)
    _defineProperties(Constructor, staticProps);
  Object.defineProperty(Constructor, "prototype", { writable: false });
  return Constructor;
}
__name(_createClass, "_createClass");
var PluralRules = /* @__PURE__ */ function() {
  function PluralRules2(locale, options29) {
    _classCallCheck(this, PluralRules2);
    var locales = PluralRules2.supportedLocalesOf(locale);
    if (locales.length === 0) {
      throw new RangeError("Unsupported locale: " + locale);
    }
    if (options29 && options29.type !== "cardinal") {
      throw new RangeError('Only "cardinal" "type" is supported');
    }
    this.$ = PluralRuleFunctions_default[getPluralRulesLocale(locales[0])];
  }
  __name(PluralRules2, "PluralRules");
  _createClass(PluralRules2, [{
    key: "select",
    value: /* @__PURE__ */ __name(function select2(number) {
      return this.$(number);
    }, "select")
  }], [{
    key: "supportedLocalesOf",
    value: /* @__PURE__ */ __name(function supportedLocalesOf(locales) {
      if (typeof locales === "string") {
        locales = [locales];
      }
      return locales.filter(function(locale) {
        return PluralRuleFunctions_default[getPluralRulesLocale(locale)];
      });
    }, "supportedLocalesOf")
  }]);
  return PluralRules2;
}();

// ../../node_modules/.pnpm/relative-time-format@1.1.4/node_modules/relative-time-format/modules/RelativeTimeFormat.js
function _typeof(obj) {
  "@babel/helpers - typeof";
  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
    return typeof obj2;
  } : function(obj2) {
    return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
  }, _typeof(obj);
}
__name(_typeof, "_typeof");
function ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object);
  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    enumerableOnly && (symbols = symbols.filter(function(sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    })), keys.push.apply(keys, symbols);
  }
  return keys;
}
__name(ownKeys, "ownKeys");
function _objectSpread(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = null != arguments[i] ? arguments[i] : {};
    i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
      _defineProperty(target, key, source[key]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
    });
  }
  return target;
}
__name(_objectSpread, "_objectSpread");
function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
  } else {
    obj[key] = value;
  }
  return obj;
}
__name(_defineProperty, "_defineProperty");
function _slicedToArray(arr, i) {
  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
}
__name(_slicedToArray, "_slicedToArray");
function _nonIterableRest() {
  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
__name(_nonIterableRest, "_nonIterableRest");
function _unsupportedIterableToArray(o2, minLen) {
  if (!o2)
    return;
  if (typeof o2 === "string")
    return _arrayLikeToArray(o2, minLen);
  var n2 = Object.prototype.toString.call(o2).slice(8, -1);
  if (n2 === "Object" && o2.constructor)
    n2 = o2.constructor.name;
  if (n2 === "Map" || n2 === "Set")
    return Array.from(o2);
  if (n2 === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n2))
    return _arrayLikeToArray(o2, minLen);
}
__name(_unsupportedIterableToArray, "_unsupportedIterableToArray");
function _arrayLikeToArray(arr, len) {
  if (len == null || len > arr.length)
    len = arr.length;
  for (var i = 0, arr2 = new Array(len); i < len; i++) {
    arr2[i] = arr[i];
  }
  return arr2;
}
__name(_arrayLikeToArray, "_arrayLikeToArray");
function _iterableToArrayLimit(arr, i) {
  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
  if (_i == null)
    return;
  var _arr = [];
  var _n = true;
  var _d = false;
  var _s, _e;
  try {
    for (_i = _i.call(arr); !(_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"] != null)
        _i["return"]();
    } finally {
      if (_d)
        throw _e;
    }
  }
  return _arr;
}
__name(_iterableToArrayLimit, "_iterableToArrayLimit");
function _arrayWithHoles(arr) {
  if (Array.isArray(arr))
    return arr;
}
__name(_arrayWithHoles, "_arrayWithHoles");
function _classCallCheck2(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}
__name(_classCallCheck2, "_classCallCheck");
function _defineProperties2(target, props) {
  for (var i = 0; i < props.length; i++) {
    var descriptor2 = props[i];
    descriptor2.enumerable = descriptor2.enumerable || false;
    descriptor2.configurable = true;
    if ("value" in descriptor2)
      descriptor2.writable = true;
    Object.defineProperty(target, descriptor2.key, descriptor2);
  }
}
__name(_defineProperties2, "_defineProperties");
function _createClass2(Constructor, protoProps, staticProps) {
  if (protoProps)
    _defineProperties2(Constructor.prototype, protoProps);
  if (staticProps)
    _defineProperties2(Constructor, staticProps);
  Object.defineProperty(Constructor, "prototype", { writable: false });
  return Constructor;
}
__name(_createClass2, "_createClass");
var UNITS = ["second", "minute", "hour", "day", "week", "month", "quarter", "year"];
var NUMERIC_VALUES = ["auto", "always"];
var STYLE_VALUES = ["long", "short", "narrow"];
var LOCALE_MATCHER_VALUES = ["lookup", "best fit"];
var RelativeTimeFormat = /* @__PURE__ */ function() {
  function RelativeTimeFormat2() {
    var locales = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
    var options29 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
    _classCallCheck2(this, RelativeTimeFormat2);
    var numeric = options29.numeric, style = options29.style, localeMatcher = options29.localeMatcher;
    this.numeric = "always";
    this.style = "long";
    this.localeMatcher = "lookup";
    if (numeric !== void 0) {
      if (NUMERIC_VALUES.indexOf(numeric) < 0) {
        throw new RangeError('Invalid "numeric" option: '.concat(numeric));
      }
      this.numeric = numeric;
    }
    if (style !== void 0) {
      if (STYLE_VALUES.indexOf(style) < 0) {
        throw new RangeError('Invalid "style" option: '.concat(style));
      }
      this.style = style;
    }
    if (localeMatcher !== void 0) {
      if (LOCALE_MATCHER_VALUES.indexOf(localeMatcher) < 0) {
        throw new RangeError('Invalid "localeMatcher" option: '.concat(localeMatcher));
      }
      this.localeMatcher = localeMatcher;
    }
    if (typeof locales === "string") {
      locales = [locales];
    }
    locales.push(getDefaultLocale());
    this.locale = RelativeTimeFormat2.supportedLocalesOf(locales, {
      localeMatcher: this.localeMatcher
    })[0];
    if (!this.locale) {
      throw new Error("No supported locale was found");
    }
    if (PluralRules.supportedLocalesOf(this.locale).length > 0) {
      this.pluralRules = new PluralRules(this.locale);
    } else {
      console.warn('"'.concat(this.locale, '" locale is not supported'));
    }
    if (typeof Intl !== "undefined" && Intl.NumberFormat) {
      this.numberFormat = new Intl.NumberFormat(this.locale);
      this.numberingSystem = this.numberFormat.resolvedOptions().numberingSystem;
    } else {
      this.numberingSystem = "latn";
    }
    this.locale = resolveLocale2(this.locale, {
      localeMatcher: this.localeMatcher
    });
  }
  __name(RelativeTimeFormat2, "RelativeTimeFormat");
  _createClass2(RelativeTimeFormat2, [{
    key: "format",
    value: /* @__PURE__ */ __name(function format10() {
      var _parseFormatArgs = parseFormatArgs(arguments), _parseFormatArgs2 = _slicedToArray(_parseFormatArgs, 2), number = _parseFormatArgs2[0], unit = _parseFormatArgs2[1];
      return this.getRule(number, unit).replace("{0}", this.formatNumber(Math.abs(number)));
    }, "format")
    /**
     * Formats time `number` in `units` (either in past or in future).
     * @param {number} number - Time interval value.
     * @param {string} unit - Time interval measurement unit.
     * @return {Object[]} The parts (`{ type, value, unit? }`).
     * @throws {RangeError} If unit is not one of "second", "minute", "hour", "day", "week", "month", "quarter".
     * @example
     * // Version 1 (deprecated).
     * // Returns [
     * //   { type: "literal", value: "in " },
     * //   { type: "day", value: "100" },
     * //   { type: "literal", value: " days" }
     * // ]
     * rtf.formatToParts(100, "day")
     * //
     * // Version 2.
     * // Returns [
     * //   { type: "literal", value: "in " },
     * //   { type: "integer", value: "100", unit: "day" },
     * //   { type: "literal", value: " days" }
     * // ]
     * rtf.formatToParts(100, "day")
     */
  }, {
    key: "formatToParts",
    value: /* @__PURE__ */ __name(function formatToParts() {
      var _parseFormatArgs3 = parseFormatArgs(arguments), _parseFormatArgs4 = _slicedToArray(_parseFormatArgs3, 2), number = _parseFormatArgs4[0], unit = _parseFormatArgs4[1];
      var rule = this.getRule(number, unit);
      var valueIndex = rule.indexOf("{0}");
      if (valueIndex < 0) {
        return [{
          type: "literal",
          value: rule
        }];
      }
      var parts = [];
      if (valueIndex > 0) {
        parts.push({
          type: "literal",
          value: rule.slice(0, valueIndex)
        });
      }
      parts = parts.concat(this.formatNumberToParts(Math.abs(number)).map(function(part) {
        return _objectSpread(_objectSpread({}, part), {}, {
          unit
        });
      }));
      if (valueIndex + "{0}".length < rule.length - 1) {
        parts.push({
          type: "literal",
          value: rule.slice(valueIndex + "{0}".length)
        });
      }
      return parts;
    }, "formatToParts")
    /**
     * Returns formatting rule for `value` in `units` (either in past or in future).
     * @param {number} value - Time interval value.
     * @param {string} unit - Time interval measurement unit.
     * @return {string}
     * @throws {RangeError} If unit is not one of "second", "minute", "hour", "day", "week", "month", "quarter".
     * @example
     * // Returns "{0} days ago"
     * getRule(-2, "day")
     */
  }, {
    key: "getRule",
    value: /* @__PURE__ */ __name(function getRule(value, unit) {
      var unitMessages = getLocaleData(this.locale)[this.style][unit];
      if (typeof unitMessages === "string") {
        return unitMessages;
      }
      if (this.numeric === "auto") {
        if (value === -2 || value === -1) {
          var message = unitMessages["previous".concat(value === -1 ? "" : "-" + Math.abs(value))];
          if (message) {
            return message;
          }
        } else if (value === 1 || value === 2) {
          var _message = unitMessages["next".concat(value === 1 ? "" : "-" + Math.abs(value))];
          if (_message) {
            return _message;
          }
        } else if (value === 0) {
          if (unitMessages.current) {
            return unitMessages.current;
          }
        }
      }
      var pluralizedMessages = unitMessages[isNegative(value) ? "past" : "future"];
      if (typeof pluralizedMessages === "string") {
        return pluralizedMessages;
      }
      var quantifier = this.pluralRules && this.pluralRules.select(Math.abs(value)) || "other";
      return pluralizedMessages[quantifier] || pluralizedMessages.other;
    }, "getRule")
    /**
     * Formats a number into a string.
     * Uses `Intl.NumberFormat` when available.
     * @param  {number} number
     * @return {string}
     */
  }, {
    key: "formatNumber",
    value: /* @__PURE__ */ __name(function formatNumber2(number) {
      return this.numberFormat ? this.numberFormat.format(number) : String(number);
    }, "formatNumber")
    /**
     * Formats a number into a list of parts.
     * Uses `Intl.NumberFormat` when available.
     * @param  {number} number
     * @return {object[]}
     */
  }, {
    key: "formatNumberToParts",
    value: /* @__PURE__ */ __name(function formatNumberToParts(number) {
      return this.numberFormat && this.numberFormat.formatToParts ? this.numberFormat.formatToParts(number) : [{
        type: "integer",
        value: this.formatNumber(number)
      }];
    }, "formatNumberToParts")
    /**
     * Returns a new object with properties reflecting the locale and date and time formatting options computed during initialization of this DateTimeFormat object.
     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat/resolvedOptions
     * @return {Object}
     */
  }, {
    key: "resolvedOptions",
    value: /* @__PURE__ */ __name(function resolvedOptions() {
      return {
        locale: this.locale,
        style: this.style,
        numeric: this.numeric,
        numberingSystem: this.numberingSystem
      };
    }, "resolvedOptions")
  }]);
  return RelativeTimeFormat2;
}();
RelativeTimeFormat.supportedLocalesOf = function(locales) {
  var options29 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
  if (typeof locales === "string") {
    locales = [locales];
  } else if (!Array.isArray(locales)) {
    throw new TypeError('Invalid "locales" argument');
  }
  return locales.filter(function(locale) {
    return resolveLocale2(locale, options29);
  });
};
RelativeTimeFormat.addLocale = addLocaleData;
RelativeTimeFormat.setDefaultLocale = setDefaultLocale;
RelativeTimeFormat.getDefaultLocale = getDefaultLocale;
RelativeTimeFormat.PluralRules = PluralRules;
var UNIT_ERROR = 'Invalid "unit" argument';
function parseUnit(unit) {
  if (_typeof(unit) === "symbol") {
    throw new TypeError(UNIT_ERROR);
  }
  if (typeof unit !== "string") {
    throw new RangeError("".concat(UNIT_ERROR, ": ").concat(unit));
  }
  if (unit[unit.length - 1] === "s") {
    unit = unit.slice(0, unit.length - 1);
  }
  if (UNITS.indexOf(unit) < 0) {
    throw new RangeError("".concat(UNIT_ERROR, ": ").concat(unit));
  }
  return unit;
}
__name(parseUnit, "parseUnit");
var NUMBER_ERROR = 'Invalid "number" argument';
function parseNumber(value) {
  value = Number(value);
  if (Number.isFinite) {
    if (!Number.isFinite(value)) {
      throw new RangeError("".concat(NUMBER_ERROR, ": ").concat(value));
    }
  }
  return value;
}
__name(parseNumber, "parseNumber");
function isNegativeZero(number) {
  return 1 / number === -Infinity;
}
__name(isNegativeZero, "isNegativeZero");
function isNegative(number) {
  return number < 0 || number === 0 && isNegativeZero(number);
}
__name(isNegative, "isNegative");
function parseFormatArgs(args) {
  if (args.length < 2) {
    throw new TypeError('"unit" argument is required');
  }
  return [parseNumber(args[0]), parseUnit(args[1])];
}
__name(parseFormatArgs, "parseFormatArgs");

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/cache.js
init_import_meta_url();
function _typeof2(obj) {
  "@babel/helpers - typeof";
  return _typeof2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
    return typeof obj2;
  } : function(obj2) {
    return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
  }, _typeof2(obj);
}
__name(_typeof2, "_typeof");
function _classCallCheck3(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}
__name(_classCallCheck3, "_classCallCheck");
function _defineProperties3(target, props) {
  for (var i = 0; i < props.length; i++) {
    var descriptor2 = props[i];
    descriptor2.enumerable = descriptor2.enumerable || false;
    descriptor2.configurable = true;
    if ("value" in descriptor2)
      descriptor2.writable = true;
    Object.defineProperty(target, descriptor2.key, descriptor2);
  }
}
__name(_defineProperties3, "_defineProperties");
function _createClass3(Constructor, protoProps, staticProps) {
  if (protoProps)
    _defineProperties3(Constructor.prototype, protoProps);
  if (staticProps)
    _defineProperties3(Constructor, staticProps);
  Object.defineProperty(Constructor, "prototype", { writable: false });
  return Constructor;
}
__name(_createClass3, "_createClass");
var Cache = /* @__PURE__ */ function() {
  function Cache3() {
    _classCallCheck3(this, Cache3);
    this.cache = {};
  }
  __name(Cache3, "Cache");
  _createClass3(Cache3, [{
    key: "get",
    value: /* @__PURE__ */ __name(function get() {
      var cache2 = this.cache;
      for (var _len = arguments.length, keys = new Array(_len), _key = 0; _key < _len; _key++) {
        keys[_key] = arguments[_key];
      }
      for (var _i = 0, _keys = keys; _i < _keys.length; _i++) {
        var key = _keys[_i];
        if (_typeof2(cache2) !== "object") {
          return;
        }
        cache2 = cache2[key];
      }
      return cache2;
    }, "get")
  }, {
    key: "put",
    value: /* @__PURE__ */ __name(function put() {
      for (var _len2 = arguments.length, keys = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        keys[_key2] = arguments[_key2];
      }
      var value = keys.pop();
      var lastKey = keys.pop();
      var cache2 = this.cache;
      for (var _i2 = 0, _keys2 = keys; _i2 < _keys2.length; _i2++) {
        var key = _keys2[_i2];
        if (_typeof2(cache2[key]) !== "object") {
          cache2[key] = {};
        }
        cache2 = cache2[key];
      }
      return cache2[lastKey] = value;
    }, "put")
  }]);
  return Cache3;
}();

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/locale.js
init_import_meta_url();
function _typeof3(obj) {
  "@babel/helpers - typeof";
  return _typeof3 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
    return typeof obj2;
  } : function(obj2) {
    return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
  }, _typeof3(obj);
}
__name(_typeof3, "_typeof");
function _createForOfIteratorHelperLoose(o2, allowArrayLike) {
  var it2 = typeof Symbol !== "undefined" && o2[Symbol.iterator] || o2["@@iterator"];
  if (it2)
    return (it2 = it2.call(o2)).next.bind(it2);
  if (Array.isArray(o2) || (it2 = _unsupportedIterableToArray2(o2)) || allowArrayLike && o2 && typeof o2.length === "number") {
    if (it2)
      o2 = it2;
    var i = 0;
    return function() {
      if (i >= o2.length)
        return { done: true };
      return { done: false, value: o2[i++] };
    };
  }
  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
__name(_createForOfIteratorHelperLoose, "_createForOfIteratorHelperLoose");
function _unsupportedIterableToArray2(o2, minLen) {
  if (!o2)
    return;
  if (typeof o2 === "string")
    return _arrayLikeToArray2(o2, minLen);
  var n2 = Object.prototype.toString.call(o2).slice(8, -1);
  if (n2 === "Object" && o2.constructor)
    n2 = o2.constructor.name;
  if (n2 === "Map" || n2 === "Set")
    return Array.from(o2);
  if (n2 === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n2))
    return _arrayLikeToArray2(o2, minLen);
}
__name(_unsupportedIterableToArray2, "_unsupportedIterableToArray");
function _arrayLikeToArray2(arr, len) {
  if (len == null || len > arr.length)
    len = arr.length;
  for (var i = 0, arr2 = new Array(len); i < len; i++) {
    arr2[i] = arr[i];
  }
  return arr2;
}
__name(_arrayLikeToArray2, "_arrayLikeToArray");
function chooseLocale(locales, isLocaleDataAvailable) {
  for (var _iterator = _createForOfIteratorHelperLoose(locales), _step; !(_step = _iterator()).done; ) {
    var locale = _step.value;
    if (isLocaleDataAvailable(locale)) {
      return locale;
    }
    var parts = locale.split("-");
    while (parts.length > 1) {
      parts.pop();
      locale = parts.join("-");
      if (isLocaleDataAvailable(locale)) {
        return locale;
      }
    }
  }
  throw new Error("No locale data has been registered for any of the locales: ".concat(locales.join(", ")));
}
__name(chooseLocale, "chooseLocale");
function intlDateTimeFormatSupported() {
  var isIntlAvailable = (typeof Intl === "undefined" ? "undefined" : _typeof3(Intl)) === "object";
  return isIntlAvailable && typeof Intl.DateTimeFormat === "function";
}
__name(intlDateTimeFormatSupported, "intlDateTimeFormatSupported");

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/isStyleObject.js
init_import_meta_url();
function _typeof4(obj) {
  "@babel/helpers - typeof";
  return _typeof4 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
    return typeof obj2;
  } : function(obj2) {
    return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
  }, _typeof4(obj);
}
__name(_typeof4, "_typeof");
function isStyleObject(object) {
  return isObject(object) && (Array.isArray(object.steps) || // `gradation` property is deprecated: it has been renamed to `steps`.
  Array.isArray(object.gradation) || // `flavour` property is deprecated: it has been renamed to `labels`.
  Array.isArray(object.flavour) || typeof object.flavour === "string" || Array.isArray(object.labels) || typeof object.labels === "string" || // `units` property is deprecated.
  Array.isArray(object.units) || // `custom` property is deprecated.
  typeof object.custom === "function");
}
__name(isStyleObject, "isStyleObject");
var OBJECT_CONSTRUCTOR = {}.constructor;
function isObject(object) {
  return _typeof4(object) !== void 0 && object !== null && object.constructor === OBJECT_CONSTRUCTOR;
}
__name(isObject, "isObject");

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/steps/getStep.js
init_import_meta_url();

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/steps/getStepDenominator.js
init_import_meta_url();

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/steps/units.js
init_import_meta_url();
var minute = 60;
var hour = 60 * minute;
var day = 24 * hour;
var week = 7 * day;
var month = 30.44 * day;
var year = 146097 / 400 * day;
function getSecondsInUnit(unit) {
  switch (unit) {
    case "second":
      return 1;
    case "minute":
      return minute;
    case "hour":
      return hour;
    case "day":
      return day;
    case "week":
      return week;
    case "month":
      return month;
    case "year":
      return year;
  }
}
__name(getSecondsInUnit, "getSecondsInUnit");

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/steps/getStepDenominator.js
function getStepDenominator(step) {
  if (step.factor !== void 0) {
    return step.factor;
  }
  return getSecondsInUnit(step.unit || step.formatAs) || 1;
}
__name(getStepDenominator, "getStepDenominator");

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/steps/getStepMinTime.js
init_import_meta_url();

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/round.js
init_import_meta_url();
function getRoundFunction(round) {
  switch (round) {
    case "floor":
      return Math.floor;
    default:
      return Math.round;
  }
}
__name(getRoundFunction, "getRoundFunction");
function getDiffRatioToNextRoundedNumber(round) {
  switch (round) {
    case "floor":
      return 1;
    default:
      return 0.5;
  }
}
__name(getDiffRatioToNextRoundedNumber, "getDiffRatioToNextRoundedNumber");

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/steps/getStepMinTime.js
function _typeof5(obj) {
  "@babel/helpers - typeof";
  return _typeof5 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
    return typeof obj2;
  } : function(obj2) {
    return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
  }, _typeof5(obj);
}
__name(_typeof5, "_typeof");
function getStepMinTime(step, _ref) {
  var prevStep = _ref.prevStep, timestamp = _ref.timestamp, now = _ref.now, future = _ref.future, round = _ref.round;
  var minTime3;
  if (prevStep) {
    if (prevStep.id || prevStep.unit) {
      minTime3 = step["threshold_for_".concat(prevStep.id || prevStep.unit)];
    }
  }
  if (minTime3 === void 0) {
    if (step.threshold !== void 0) {
      minTime3 = step.threshold;
      if (typeof minTime3 === "function") {
        minTime3 = minTime3(now, future);
      }
    }
  }
  if (minTime3 === void 0) {
    minTime3 = step.minTime;
  }
  if (_typeof5(minTime3) === "object") {
    if (prevStep && prevStep.id && minTime3[prevStep.id] !== void 0) {
      minTime3 = minTime3[prevStep.id];
    } else {
      minTime3 = minTime3["default"];
    }
  }
  if (typeof minTime3 === "function") {
    minTime3 = minTime3(timestamp, {
      future,
      getMinTimeForUnit: /* @__PURE__ */ __name(function getMinTimeForUnit(toUnit, fromUnit) {
        return _getMinTimeForUnit(toUnit, fromUnit || prevStep && prevStep.formatAs, {
          round
        });
      }, "getMinTimeForUnit")
    });
  }
  if (minTime3 === void 0) {
    if (step.test) {
      if (step.test(timestamp, {
        now,
        future
      })) {
        minTime3 = 0;
      } else {
        minTime3 = 9007199254740991;
      }
    }
  }
  if (minTime3 === void 0) {
    if (prevStep) {
      if (step.formatAs && prevStep.formatAs) {
        minTime3 = _getMinTimeForUnit(step.formatAs, prevStep.formatAs, {
          round
        });
      }
    } else {
      minTime3 = 0;
    }
  }
  if (minTime3 === void 0) {
    console.warn("[javascript-time-ago] A step should specify `minTime`:\n" + JSON.stringify(step, null, 2));
  }
  return minTime3;
}
__name(getStepMinTime, "getStepMinTime");
function _getMinTimeForUnit(toUnit, fromUnit, _ref2) {
  var round = _ref2.round;
  var toUnitAmount = getSecondsInUnit(toUnit);
  var fromUnitAmount;
  if (fromUnit === "now") {
    fromUnitAmount = getSecondsInUnit(toUnit);
  } else {
    fromUnitAmount = getSecondsInUnit(fromUnit);
  }
  if (toUnitAmount !== void 0 && fromUnitAmount !== void 0) {
    return toUnitAmount - fromUnitAmount * (1 - getDiffRatioToNextRoundedNumber(round));
  }
}
__name(_getMinTimeForUnit, "_getMinTimeForUnit");

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/steps/getStep.js
function ownKeys2(object, enumerableOnly) {
  var keys = Object.keys(object);
  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    enumerableOnly && (symbols = symbols.filter(function(sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    })), keys.push.apply(keys, symbols);
  }
  return keys;
}
__name(ownKeys2, "ownKeys");
function _objectSpread2(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = null != arguments[i] ? arguments[i] : {};
    i % 2 ? ownKeys2(Object(source), true).forEach(function(key) {
      _defineProperty2(target, key, source[key]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys2(Object(source)).forEach(function(key) {
      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
    });
  }
  return target;
}
__name(_objectSpread2, "_objectSpread");
function _defineProperty2(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
  } else {
    obj[key] = value;
  }
  return obj;
}
__name(_defineProperty2, "_defineProperty");
function getStep(steps2, secondsPassed, _ref) {
  var now = _ref.now, future = _ref.future, round = _ref.round, units2 = _ref.units, getNextStep = _ref.getNextStep;
  steps2 = filterStepsByUnits(steps2, units2);
  var step = _getStep(steps2, secondsPassed, {
    now,
    future,
    round
  });
  if (getNextStep) {
    if (step) {
      var prevStep = steps2[steps2.indexOf(step) - 1];
      var nextStep = steps2[steps2.indexOf(step) + 1];
      return [prevStep, step, nextStep];
    }
    return [void 0, void 0, steps2[0]];
  }
  return step;
}
__name(getStep, "getStep");
function _getStep(steps2, secondsPassed, _ref2) {
  var now = _ref2.now, future = _ref2.future, round = _ref2.round;
  if (steps2.length === 0) {
    return;
  }
  var i = getStepIndex(steps2, secondsPassed, {
    now,
    future: future || secondsPassed < 0,
    round
  });
  if (i === -1) {
    return;
  }
  var step = steps2[i];
  if (step.granularity) {
    var secondsPassedGranular = getRoundFunction(round)(Math.abs(secondsPassed) / getStepDenominator(step) / step.granularity) * step.granularity;
    if (secondsPassedGranular === 0 && i > 0) {
      return steps2[i - 1];
    }
  }
  return step;
}
__name(_getStep, "_getStep");
function getStepIndex(steps2, secondsPassed, options29) {
  var i = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0;
  var minTime3 = getStepMinTime(steps2[i], _objectSpread2({
    prevStep: steps2[i - 1],
    timestamp: options29.now - secondsPassed * 1e3
  }, options29));
  if (minTime3 === void 0) {
    return i - 1;
  }
  if (Math.abs(secondsPassed) < minTime3) {
    return i - 1;
  }
  if (i === steps2.length - 1) {
    return i;
  }
  return getStepIndex(steps2, secondsPassed, options29, i + 1);
}
__name(getStepIndex, "getStepIndex");
function filterStepsByUnits(steps2, units2) {
  return steps2.filter(function(_ref3) {
    var unit = _ref3.unit, formatAs = _ref3.formatAs;
    unit = unit || formatAs;
    if (unit) {
      return units2.indexOf(unit) >= 0;
    }
    return true;
  });
}
__name(filterStepsByUnits, "filterStepsByUnits");

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/steps/getTimeToNextUpdate.js
init_import_meta_url();

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/steps/getTimeToNextUpdateForUnit.js
init_import_meta_url();
function getTimeToNextUpdateForUnit(unit, timestamp, _ref) {
  var now = _ref.now, round = _ref.round;
  if (!getSecondsInUnit(unit)) {
    return;
  }
  var unitDenominator = getSecondsInUnit(unit) * 1e3;
  var future = timestamp > now;
  var preciseAmount = Math.abs(timestamp - now);
  var roundedAmount = getRoundFunction(round)(preciseAmount / unitDenominator) * unitDenominator;
  if (future) {
    if (roundedAmount > 0) {
      return preciseAmount - roundedAmount + getDiffToPreviousRoundedNumber(round, unitDenominator);
    } else {
      return preciseAmount - roundedAmount + 1;
    }
  }
  return -(preciseAmount - roundedAmount) + getDiffToNextRoundedNumber(round, unitDenominator);
}
__name(getTimeToNextUpdateForUnit, "getTimeToNextUpdateForUnit");
function getDiffToNextRoundedNumber(round, unitDenominator) {
  return getDiffRatioToNextRoundedNumber(round) * unitDenominator;
}
__name(getDiffToNextRoundedNumber, "getDiffToNextRoundedNumber");
function getDiffToPreviousRoundedNumber(round, unitDenominator) {
  return (1 - getDiffRatioToNextRoundedNumber(round)) * unitDenominator + 1;
}
__name(getDiffToPreviousRoundedNumber, "getDiffToPreviousRoundedNumber");

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/steps/getTimeToNextUpdate.js
var YEAR = 365 * 24 * 60 * 60 * 1e3;
var INFINITY = 1e3 * YEAR;
function getTimeToNextUpdate(date, step, _ref) {
  var prevStep = _ref.prevStep, nextStep = _ref.nextStep, now = _ref.now, future = _ref.future, round = _ref.round;
  var timestamp = date.getTime ? date.getTime() : date;
  var getTimeToNextUpdateForUnit2 = /* @__PURE__ */ __name(function getTimeToNextUpdateForUnit3(unit2) {
    return getTimeToNextUpdateForUnit(unit2, timestamp, {
      now,
      round
    });
  }, "getTimeToNextUpdateForUnit");
  var timeToStepChange = getTimeToStepChange(future ? step : nextStep, timestamp, {
    future,
    now,
    round,
    prevStep: future ? prevStep : step
    // isFirstStep: future && isFirstStep
  });
  if (timeToStepChange === void 0) {
    return;
  }
  var timeToNextUpdate;
  if (step) {
    if (step.getTimeToNextUpdate) {
      timeToNextUpdate = step.getTimeToNextUpdate(timestamp, {
        getTimeToNextUpdateForUnit: getTimeToNextUpdateForUnit2,
        getRoundFunction,
        now,
        future,
        round
      });
    }
    if (timeToNextUpdate === void 0) {
      var unit = step.unit || step.formatAs;
      if (unit) {
        timeToNextUpdate = getTimeToNextUpdateForUnit2(unit);
      }
    }
  }
  if (timeToNextUpdate === void 0) {
    return timeToStepChange;
  }
  return Math.min(timeToNextUpdate, timeToStepChange);
}
__name(getTimeToNextUpdate, "getTimeToNextUpdate");
function getStepChangesAt(currentOrNextStep, timestamp, _ref2) {
  var now = _ref2.now, future = _ref2.future, round = _ref2.round, prevStep = _ref2.prevStep;
  var minTime3 = getStepMinTime(currentOrNextStep, {
    timestamp,
    now,
    future,
    round,
    prevStep
  });
  if (minTime3 === void 0) {
    return;
  }
  if (future) {
    return timestamp - minTime3 * 1e3 + 1;
  } else {
    if (minTime3 === 0 && timestamp === now) {
      return INFINITY;
    }
    return timestamp + minTime3 * 1e3;
  }
}
__name(getStepChangesAt, "getStepChangesAt");
function getTimeToStepChange(step, timestamp, _ref3) {
  var now = _ref3.now, future = _ref3.future, round = _ref3.round, prevStep = _ref3.prevStep;
  if (step) {
    var stepChangesAt = getStepChangesAt(step, timestamp, {
      now,
      future,
      round,
      prevStep
    });
    if (stepChangesAt === void 0) {
      return;
    }
    return stepChangesAt - now;
  } else {
    if (future) {
      return timestamp - now + 1;
    } else {
      return INFINITY;
    }
  }
}
__name(getTimeToStepChange, "getTimeToStepChange");

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/LocaleDataStore.js
init_import_meta_url();
var localesData2 = {};
function getLocaleData2(locale) {
  return localesData2[locale];
}
__name(getLocaleData2, "getLocaleData");
function addLocaleData2(localeData) {
  if (!localeData) {
    throw new Error("[javascript-time-ago] No locale data passed.");
  }
  localesData2[localeData.locale] = localeData;
}
__name(addLocaleData2, "addLocaleData");

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/style/roundMinute.js
init_import_meta_url();

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/style/round.js
init_import_meta_url();

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/steps/round.js
init_import_meta_url();
var round_default = [{
  formatAs: "now"
}, {
  formatAs: "second"
}, {
  formatAs: "minute"
}, {
  formatAs: "hour"
}, {
  formatAs: "day"
}, {
  formatAs: "week"
}, {
  formatAs: "month"
}, {
  formatAs: "year"
}];

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/style/round.js
var round_default2 = {
  steps: round_default,
  labels: "long"
};

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/style/roundMinute.js
function ownKeys3(object, enumerableOnly) {
  var keys = Object.keys(object);
  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    enumerableOnly && (symbols = symbols.filter(function(sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    })), keys.push.apply(keys, symbols);
  }
  return keys;
}
__name(ownKeys3, "ownKeys");
function _objectSpread3(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = null != arguments[i] ? arguments[i] : {};
    i % 2 ? ownKeys3(Object(source), true).forEach(function(key) {
      _defineProperty3(target, key, source[key]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys3(Object(source)).forEach(function(key) {
      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
    });
  }
  return target;
}
__name(_objectSpread3, "_objectSpread");
function _defineProperty3(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
  } else {
    obj[key] = value;
  }
  return obj;
}
__name(_defineProperty3, "_defineProperty");
var roundMinute_default = _objectSpread3(_objectSpread3({}, round_default2), {}, {
  // Skip "seconds".
  steps: round_default2.steps.filter(function(step) {
    return step.formatAs !== "second";
  })
});

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/style/getStyleByName.js
init_import_meta_url();

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/style/approximate.js
init_import_meta_url();

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/steps/approximate.js
init_import_meta_url();
var approximate_default = [{
  // This step returns the amount of seconds
  // by dividing the amount of seconds by `1`.
  factor: 1,
  // "now" labels are used for formatting the output.
  unit: "now"
}, {
  // When the language doesn't support `now` unit,
  // the first step is ignored, and it uses this `second` unit.
  threshold: 1,
  // `threshold_for_now` should be the same as `threshold` on minutes.
  threshold_for_now: 45.5,
  // This step returns the amount of seconds
  // by dividing the amount of seconds by `1`.
  factor: 1,
  // "second" labels are used for formatting the output.
  unit: "second"
}, {
  // `threshold` should be the same as `threshold_for_now` on seconds.
  threshold: 45.5,
  // Return the amount of minutes by dividing the amount
  // of seconds by the amount of seconds in a minute.
  factor: minute,
  // "minute" labels are used for formatting the output.
  unit: "minute"
}, {
  // This step is effective starting from 2.5 minutes.
  threshold: 2.5 * minute,
  // Allow only 5-minute increments of minutes starting from 2.5 minutes.
  // `granularity` — (advanced) Time interval value "granularity".
  // For example, it could be set to `5` for minutes to allow only 5-minute increments
  // when formatting time intervals: `0 minutes`, `5 minutes`, `10 minutes`, etc.
  // Perhaps this feature will be removed because there seem to be no use cases
  // of it in the real world.
  granularity: 5,
  // Return the amount of minutes by dividing the amount
  // of seconds by the amount of seconds in a minute.
  factor: minute,
  // "minute" labels are used for formatting the output.
  unit: "minute"
}, {
  // This step is effective starting from 22.5 minutes.
  threshold: 22.5 * minute,
  // Return the amount of minutes by dividing the amount
  // of seconds by the amount of seconds in  half-an-hour.
  factor: 0.5 * hour,
  // "half-hour" labels are used for formatting the output.
  // (if available, which is no longer the case)
  unit: "half-hour"
}, {
  // This step is effective starting from 42.5 minutes.
  threshold: 42.5 * minute,
  threshold_for_minute: 52.5 * minute,
  // Return the amount of minutes by dividing the amount
  // of seconds by the amount of seconds in an hour.
  factor: hour,
  // "hour" labels are used for formatting the output.
  unit: "hour"
}, {
  // This step is effective starting from 20.5 hours.
  threshold: 20.5 / 24 * day,
  // Return the amount of minutes by dividing the amount
  // of seconds by the amount of seconds in a day.
  factor: day,
  // "day" labels are used for formatting the output.
  unit: "day"
}, {
  // This step is effective starting from 5.5 days.
  threshold: 5.5 * day,
  // Return the amount of minutes by dividing the amount
  // of seconds by the amount of seconds in a week.
  factor: week,
  // "week" labels are used for formatting the output.
  unit: "week"
}, {
  // This step is effective starting from 3.5 weeks.
  threshold: 3.5 * week,
  // Return the amount of minutes by dividing the amount
  // of seconds by the amount of seconds in a month.
  factor: month,
  // "month" labels are used for formatting the output.
  unit: "month"
}, {
  // This step is effective starting from 10.5 months.
  threshold: 10.5 * month,
  // Return the amount of minutes by dividing the amount
  // of seconds by the amount of seconds in a year.
  factor: year,
  // "year" labels are used for formatting the output.
  unit: "year"
}];

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/style/approximate.js
var approximate_default2 = {
  gradation: approximate_default,
  flavour: "long",
  units: ["now", "minute", "hour", "day", "week", "month", "year"]
};

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/style/approximateTime.js
init_import_meta_url();
var approximateTime_default = {
  gradation: approximate_default,
  flavour: "long-time",
  units: ["now", "minute", "hour", "day", "week", "month", "year"]
};

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/style/twitter.js
init_import_meta_url();

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/steps/index.js
init_import_meta_url();

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/steps/helpers.js
init_import_meta_url();
function getDate(value) {
  return value instanceof Date ? value : new Date(value);
}
__name(getDate, "getDate");

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/style/twitter.js
var steps = [{
  formatAs: "second"
}, {
  formatAs: "minute"
}, {
  formatAs: "hour"
}];
var formatters = {};
var monthAndDay = {
  minTime: /* @__PURE__ */ __name(function minTime(timestamp, _ref) {
    var future = _ref.future, getMinTimeForUnit = _ref.getMinTimeForUnit;
    return getMinTimeForUnit("day");
  }, "minTime"),
  format: /* @__PURE__ */ __name(function format6(value, locale) {
    if (!formatters[locale]) {
      formatters[locale] = {};
    }
    if (!formatters[locale].dayMonth) {
      formatters[locale].dayMonth = new Intl.DateTimeFormat(locale, {
        month: "short",
        day: "numeric"
      });
    }
    return formatters[locale].dayMonth.format(getDate(value));
  }, "format")
};
var yearMonthAndDay = {
  minTime: /* @__PURE__ */ __name(function minTime2(timestamp, _ref2) {
    var future = _ref2.future;
    if (future) {
      var maxFittingNow = new Date(new Date(timestamp).getFullYear(), 0).getTime() - 1;
      return (timestamp - maxFittingNow) / 1e3;
    } else {
      var minFittingNow = new Date(new Date(timestamp).getFullYear() + 1, 0).getTime();
      return (minFittingNow - timestamp) / 1e3;
    }
  }, "minTime"),
  format: /* @__PURE__ */ __name(function format7(value, locale) {
    if (!formatters[locale]) {
      formatters[locale] = {};
    }
    if (!formatters[locale].dayMonthYear) {
      formatters[locale].dayMonthYear = new Intl.DateTimeFormat(locale, {
        year: "numeric",
        month: "short",
        day: "numeric"
      });
    }
    return formatters[locale].dayMonthYear.format(getDate(value));
  }, "format")
};
if (intlDateTimeFormatSupported()) {
  steps.push(monthAndDay, yearMonthAndDay);
} else {
  steps.push({
    formatAs: "day"
  }, {
    formatAs: "week"
  }, {
    formatAs: "month"
  }, {
    formatAs: "year"
  });
}
var twitter_default = {
  steps,
  labels: [
    // "mini" labels are only defined for a few languages.
    "mini",
    // "short-time" labels are only defined for a few languages.
    "short-time",
    // "narrow" and "short" labels are defined for all languages.
    // "narrow" labels can sometimes be weird (like "+5d."),
    // but "short" labels have the " ago" part, so "narrow" seem
    // more appropriate.
    // "short" labels would have been more appropriate if they
    // didn't have the " ago" part, hence the "short-time" above.
    "narrow",
    // Since "narrow" labels are always present, "short" element
    // of this array can be removed.
    "short"
  ]
};

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/style/twitterNow.js
init_import_meta_url();
function ownKeys4(object, enumerableOnly) {
  var keys = Object.keys(object);
  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    enumerableOnly && (symbols = symbols.filter(function(sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    })), keys.push.apply(keys, symbols);
  }
  return keys;
}
__name(ownKeys4, "ownKeys");
function _objectSpread4(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = null != arguments[i] ? arguments[i] : {};
    i % 2 ? ownKeys4(Object(source), true).forEach(function(key) {
      _defineProperty4(target, key, source[key]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys4(Object(source)).forEach(function(key) {
      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
    });
  }
  return target;
}
__name(_objectSpread4, "_objectSpread");
function _defineProperty4(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
  } else {
    obj[key] = value;
  }
  return obj;
}
__name(_defineProperty4, "_defineProperty");
var twitterNow_default = _objectSpread4(_objectSpread4({}, twitter_default), {}, {
  // Add "now".
  steps: [{
    formatAs: "now"
  }].concat(twitter_default.steps)
});

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/style/twitterMinute.js
init_import_meta_url();
function ownKeys5(object, enumerableOnly) {
  var keys = Object.keys(object);
  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    enumerableOnly && (symbols = symbols.filter(function(sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    })), keys.push.apply(keys, symbols);
  }
  return keys;
}
__name(ownKeys5, "ownKeys");
function _objectSpread5(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = null != arguments[i] ? arguments[i] : {};
    i % 2 ? ownKeys5(Object(source), true).forEach(function(key) {
      _defineProperty5(target, key, source[key]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys5(Object(source)).forEach(function(key) {
      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
    });
  }
  return target;
}
__name(_objectSpread5, "_objectSpread");
function _defineProperty5(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
  } else {
    obj[key] = value;
  }
  return obj;
}
__name(_defineProperty5, "_defineProperty");
var twitterMinute_default = _objectSpread5(_objectSpread5({}, twitter_default), {}, {
  // Skip "seconds".
  steps: twitter_default.steps.filter(function(step) {
    return step.formatAs !== "second";
  })
});

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/style/twitterMinuteNow.js
init_import_meta_url();
function ownKeys6(object, enumerableOnly) {
  var keys = Object.keys(object);
  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    enumerableOnly && (symbols = symbols.filter(function(sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    })), keys.push.apply(keys, symbols);
  }
  return keys;
}
__name(ownKeys6, "ownKeys");
function _objectSpread6(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = null != arguments[i] ? arguments[i] : {};
    i % 2 ? ownKeys6(Object(source), true).forEach(function(key) {
      _defineProperty6(target, key, source[key]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys6(Object(source)).forEach(function(key) {
      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
    });
  }
  return target;
}
__name(_objectSpread6, "_objectSpread");
function _defineProperty6(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
  } else {
    obj[key] = value;
  }
  return obj;
}
__name(_defineProperty6, "_defineProperty");
var twitterMinuteNow_default = _objectSpread6(_objectSpread6({}, twitterMinute_default), {}, {
  // Add "now".
  steps: [{
    formatAs: "now"
  }].concat(twitterMinute_default.steps)
});

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/style/twitterFirstMinute.js
init_import_meta_url();
function ownKeys7(object, enumerableOnly) {
  var keys = Object.keys(object);
  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    enumerableOnly && (symbols = symbols.filter(function(sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    })), keys.push.apply(keys, symbols);
  }
  return keys;
}
__name(ownKeys7, "ownKeys");
function _objectSpread7(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = null != arguments[i] ? arguments[i] : {};
    i % 2 ? ownKeys7(Object(source), true).forEach(function(key) {
      _defineProperty7(target, key, source[key]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys7(Object(source)).forEach(function(key) {
      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
    });
  }
  return target;
}
__name(_objectSpread7, "_objectSpread");
function _defineProperty7(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
  } else {
    obj[key] = value;
  }
  return obj;
}
__name(_defineProperty7, "_defineProperty");
var twitterFirstMinute_default = _objectSpread7(_objectSpread7({}, twitter_default), {}, {
  // Skip "seconds".
  steps: twitter_default.steps.filter(function(step) {
    return step.formatAs !== "second";
  }).map(function(step) {
    return step.formatAs === "minute" ? _objectSpread7(_objectSpread7({}, step), {}, {
      minTime: minute
    }) : step;
  })
});

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/style/mini.js
init_import_meta_url();
var mini_default = {
  steps: [{
    formatAs: "second"
  }, {
    formatAs: "minute"
  }, {
    formatAs: "hour"
  }, {
    formatAs: "day"
  }, {
    formatAs: "month"
  }, {
    formatAs: "year"
  }],
  labels: [
    // "mini" labels are only defined for a few languages.
    "mini",
    // "short-time" labels are only defined for a few languages.
    "short-time",
    // "narrow" and "short" labels are defined for all languages.
    // "narrow" labels can sometimes be weird (like "+5d."),
    // but "short" labels have the " ago" part, so "narrow" seem
    // more appropriate.
    // "short" labels would have been more appropriate if they
    // didn't have the " ago" part, hence the "short-time" above.
    "narrow",
    // Since "narrow" labels are always present, "short" element
    // of this array can be removed.
    "short"
  ]
};

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/style/miniNow.js
init_import_meta_url();
function ownKeys8(object, enumerableOnly) {
  var keys = Object.keys(object);
  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    enumerableOnly && (symbols = symbols.filter(function(sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    })), keys.push.apply(keys, symbols);
  }
  return keys;
}
__name(ownKeys8, "ownKeys");
function _objectSpread8(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = null != arguments[i] ? arguments[i] : {};
    i % 2 ? ownKeys8(Object(source), true).forEach(function(key) {
      _defineProperty8(target, key, source[key]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys8(Object(source)).forEach(function(key) {
      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
    });
  }
  return target;
}
__name(_objectSpread8, "_objectSpread");
function _defineProperty8(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
  } else {
    obj[key] = value;
  }
  return obj;
}
__name(_defineProperty8, "_defineProperty");
var miniNow_default = _objectSpread8(_objectSpread8({}, mini_default), {}, {
  // Add "now".
  steps: [{
    formatAs: "now"
  }].concat(mini_default.steps)
});

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/style/miniMinute.js
init_import_meta_url();
function ownKeys9(object, enumerableOnly) {
  var keys = Object.keys(object);
  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    enumerableOnly && (symbols = symbols.filter(function(sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    })), keys.push.apply(keys, symbols);
  }
  return keys;
}
__name(ownKeys9, "ownKeys");
function _objectSpread9(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = null != arguments[i] ? arguments[i] : {};
    i % 2 ? ownKeys9(Object(source), true).forEach(function(key) {
      _defineProperty9(target, key, source[key]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys9(Object(source)).forEach(function(key) {
      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
    });
  }
  return target;
}
__name(_objectSpread9, "_objectSpread");
function _defineProperty9(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
  } else {
    obj[key] = value;
  }
  return obj;
}
__name(_defineProperty9, "_defineProperty");
var miniMinute_default = _objectSpread9(_objectSpread9({}, mini_default), {}, {
  // Skip "seconds".
  steps: mini_default.steps.filter(function(step) {
    return step.formatAs !== "second";
  })
});

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/style/miniMinuteNow.js
init_import_meta_url();
function ownKeys10(object, enumerableOnly) {
  var keys = Object.keys(object);
  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    enumerableOnly && (symbols = symbols.filter(function(sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    })), keys.push.apply(keys, symbols);
  }
  return keys;
}
__name(ownKeys10, "ownKeys");
function _objectSpread10(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = null != arguments[i] ? arguments[i] : {};
    i % 2 ? ownKeys10(Object(source), true).forEach(function(key) {
      _defineProperty10(target, key, source[key]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys10(Object(source)).forEach(function(key) {
      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
    });
  }
  return target;
}
__name(_objectSpread10, "_objectSpread");
function _defineProperty10(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
  } else {
    obj[key] = value;
  }
  return obj;
}
__name(_defineProperty10, "_defineProperty");
var miniMinuteNow_default = _objectSpread10(_objectSpread10({}, miniMinute_default), {}, {
  // Add "now".
  steps: [{
    formatAs: "now"
  }].concat(miniMinute_default.steps)
});

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/style/getStyleByName.js
function getStyleByName(style) {
  switch (style) {
    case "default":
    case "round":
      return round_default2;
    case "round-minute":
      return roundMinute_default;
    case "approximate":
      return approximate_default2;
    case "time":
    case "approximate-time":
      return approximateTime_default;
    case "mini":
      return mini_default;
    case "mini-now":
      return miniNow_default;
    case "mini-minute":
      return miniMinute_default;
    case "mini-minute-now":
      return miniMinuteNow_default;
    case "twitter":
      return twitter_default;
    case "twitter-now":
      return twitterNow_default;
    case "twitter-minute":
      return twitterMinute_default;
    case "twitter-minute-now":
      return twitterMinuteNow_default;
    case "twitter-first-minute":
      return twitterFirstMinute_default;
    default:
      return approximate_default2;
  }
}
__name(getStyleByName, "getStyleByName");

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/modules/TimeAgo.js
function _typeof6(obj) {
  "@babel/helpers - typeof";
  return _typeof6 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
    return typeof obj2;
  } : function(obj2) {
    return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
  }, _typeof6(obj);
}
__name(_typeof6, "_typeof");
function _createForOfIteratorHelperLoose2(o2, allowArrayLike) {
  var it2 = typeof Symbol !== "undefined" && o2[Symbol.iterator] || o2["@@iterator"];
  if (it2)
    return (it2 = it2.call(o2)).next.bind(it2);
  if (Array.isArray(o2) || (it2 = _unsupportedIterableToArray3(o2)) || allowArrayLike && o2 && typeof o2.length === "number") {
    if (it2)
      o2 = it2;
    var i = 0;
    return function() {
      if (i >= o2.length)
        return { done: true };
      return { done: false, value: o2[i++] };
    };
  }
  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
__name(_createForOfIteratorHelperLoose2, "_createForOfIteratorHelperLoose");
function _slicedToArray2(arr, i) {
  return _arrayWithHoles2(arr) || _iterableToArrayLimit2(arr, i) || _unsupportedIterableToArray3(arr, i) || _nonIterableRest2();
}
__name(_slicedToArray2, "_slicedToArray");
function _nonIterableRest2() {
  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
__name(_nonIterableRest2, "_nonIterableRest");
function _unsupportedIterableToArray3(o2, minLen) {
  if (!o2)
    return;
  if (typeof o2 === "string")
    return _arrayLikeToArray3(o2, minLen);
  var n2 = Object.prototype.toString.call(o2).slice(8, -1);
  if (n2 === "Object" && o2.constructor)
    n2 = o2.constructor.name;
  if (n2 === "Map" || n2 === "Set")
    return Array.from(o2);
  if (n2 === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n2))
    return _arrayLikeToArray3(o2, minLen);
}
__name(_unsupportedIterableToArray3, "_unsupportedIterableToArray");
function _arrayLikeToArray3(arr, len) {
  if (len == null || len > arr.length)
    len = arr.length;
  for (var i = 0, arr2 = new Array(len); i < len; i++) {
    arr2[i] = arr[i];
  }
  return arr2;
}
__name(_arrayLikeToArray3, "_arrayLikeToArray");
function _iterableToArrayLimit2(arr, i) {
  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
  if (_i == null)
    return;
  var _arr = [];
  var _n = true;
  var _d = false;
  var _s, _e;
  try {
    for (_i = _i.call(arr); !(_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"] != null)
        _i["return"]();
    } finally {
      if (_d)
        throw _e;
    }
  }
  return _arr;
}
__name(_iterableToArrayLimit2, "_iterableToArrayLimit");
function _arrayWithHoles2(arr) {
  if (Array.isArray(arr))
    return arr;
}
__name(_arrayWithHoles2, "_arrayWithHoles");
function _classCallCheck4(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}
__name(_classCallCheck4, "_classCallCheck");
function _defineProperties4(target, props) {
  for (var i = 0; i < props.length; i++) {
    var descriptor2 = props[i];
    descriptor2.enumerable = descriptor2.enumerable || false;
    descriptor2.configurable = true;
    if ("value" in descriptor2)
      descriptor2.writable = true;
    Object.defineProperty(target, descriptor2.key, descriptor2);
  }
}
__name(_defineProperties4, "_defineProperties");
function _createClass4(Constructor, protoProps, staticProps) {
  if (protoProps)
    _defineProperties4(Constructor.prototype, protoProps);
  if (staticProps)
    _defineProperties4(Constructor, staticProps);
  Object.defineProperty(Constructor, "prototype", { writable: false });
  return Constructor;
}
__name(_createClass4, "_createClass");
var TimeAgo = /* @__PURE__ */ function() {
  function TimeAgo2() {
    var locales = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
    var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, polyfill2 = _ref.polyfill;
    _classCallCheck4(this, TimeAgo2);
    if (typeof locales === "string") {
      locales = [locales];
    }
    this.locale = chooseLocale(locales.concat(TimeAgo2.getDefaultLocale()), getLocaleData2);
    if (typeof Intl !== "undefined") {
      if (Intl.NumberFormat) {
        this.numberFormat = new Intl.NumberFormat(this.locale);
      }
    }
    if (polyfill2 === false) {
      this.IntlRelativeTimeFormat = Intl.RelativeTimeFormat;
      this.IntlPluralRules = Intl.PluralRules;
    } else {
      this.IntlRelativeTimeFormat = RelativeTimeFormat;
      this.IntlPluralRules = RelativeTimeFormat.PluralRules;
    }
    this.relativeTimeFormatCache = new Cache();
    this.pluralRulesCache = new Cache();
  }
  __name(TimeAgo2, "TimeAgo");
  _createClass4(TimeAgo2, [{
    key: "format",
    value: /* @__PURE__ */ __name(function format10(input, style, options29) {
      if (!options29) {
        if (style && !isStyle(style)) {
          options29 = style;
          style = void 0;
        } else {
          options29 = {};
        }
      }
      if (!style) {
        style = roundMinute_default;
      }
      if (typeof style === "string") {
        style = getStyleByName(style);
      }
      var timestamp = getTimestamp(input);
      var _this$getLabels = this.getLabels(style.flavour || style.labels), labels = _this$getLabels.labels, labelsType = _this$getLabels.labelsType;
      var now;
      if (style.now !== void 0) {
        now = style.now;
      }
      if (now === void 0 && options29.now !== void 0) {
        now = options29.now;
      }
      if (now === void 0) {
        now = Date.now();
      }
      var secondsPassed = (now - timestamp) / 1e3;
      var future = options29.future || secondsPassed < 0;
      var nowLabel = getNowLabel(labels, getLocaleData2(this.locale).now, getLocaleData2(this.locale)["long"], future);
      if (style.custom) {
        var custom = style.custom({
          now,
          date: new Date(timestamp),
          time: timestamp,
          elapsed: secondsPassed,
          locale: this.locale
        });
        if (custom !== void 0) {
          return custom;
        }
      }
      var units2 = getTimeIntervalMeasurementUnits(
        // Controlling `style.steps` through `style.units` seems to be deprecated:
        // create a new custom `style` instead.
        style.units,
        labels,
        nowLabel
      );
      var round = options29.round || style.round;
      var _getStep2 = getStep(
        // "gradation" is a legacy name for "steps".
        // For historical reasons, "approximate" steps are used by default.
        // In the next major version, there'll be no default for `steps`.
        style.gradation || style.steps || roundMinute_default.steps,
        secondsPassed,
        {
          now,
          units: units2,
          round,
          future,
          getNextStep: true
        }
      ), _getStep22 = _slicedToArray2(_getStep2, 3), prevStep = _getStep22[0], step = _getStep22[1], nextStep = _getStep22[2];
      var formattedDate = this.formatDateForStep(timestamp, step, secondsPassed, {
        labels,
        labelsType,
        nowLabel,
        now,
        future,
        round
      }) || "";
      if (options29.getTimeToNextUpdate) {
        var timeToNextUpdate = getTimeToNextUpdate(timestamp, step, {
          nextStep,
          prevStep,
          now,
          future,
          round
        });
        return [formattedDate, timeToNextUpdate];
      }
      return formattedDate;
    }, "format")
  }, {
    key: "formatDateForStep",
    value: /* @__PURE__ */ __name(function formatDateForStep(timestamp, step, secondsPassed, _ref2) {
      var _this = this;
      var labels = _ref2.labels, labelsType = _ref2.labelsType, nowLabel = _ref2.nowLabel, now = _ref2.now, future = _ref2.future, round = _ref2.round;
      if (!step) {
        return;
      }
      if (step.format) {
        return step.format(timestamp, this.locale, {
          formatAs: /* @__PURE__ */ __name(function formatAs(unit2, value) {
            return _this.formatValue(value, unit2, {
              labels,
              future
            });
          }, "formatAs"),
          now,
          future
        });
      }
      var unit = step.unit || step.formatAs;
      if (!unit) {
        throw new Error("[javascript-time-ago] Each step must define either `formatAs` or `format()`. Step: ".concat(JSON.stringify(step)));
      }
      if (unit === "now") {
        return nowLabel;
      }
      var amount = Math.abs(secondsPassed) / getStepDenominator(step);
      if (step.granularity) {
        amount = getRoundFunction(round)(amount / step.granularity) * step.granularity;
      }
      var valueForFormatting = -1 * Math.sign(secondsPassed) * getRoundFunction(round)(amount);
      if (valueForFormatting === 0) {
        if (future) {
          valueForFormatting = 0;
        } else {
          valueForFormatting = -0;
        }
      }
      switch (labelsType) {
        case "long":
        case "short":
        case "narrow":
          return this.getFormatter(labelsType).format(valueForFormatting, unit);
        default:
          return this.formatValue(valueForFormatting, unit, {
            labels,
            future
          });
      }
    }, "formatDateForStep")
    /**
     * Mimicks what `Intl.RelativeTimeFormat` does for additional locale styles.
     * @param  {number} value
     * @param  {string} unit
     * @param  {object} options.labels — Relative time labels.
     * @param  {boolean} [options.future] — Tells how to format value `0`: as "future" (`true`) or "past" (`false`). Is `false` by default, but should have been `true` actually.
     * @return {string}
     */
  }, {
    key: "formatValue",
    value: /* @__PURE__ */ __name(function formatValue(value, unit, _ref3) {
      var labels = _ref3.labels, future = _ref3.future;
      return this.getFormattingRule(labels, unit, value, {
        future
      }).replace("{0}", this.formatNumber(Math.abs(value)));
    }, "formatValue")
    /**
     * Returns formatting rule for `value` in `units` (either in past or in future).
     * @param {object} formattingRules — Relative time labels for different units.
     * @param {string} unit - Time interval measurement unit.
     * @param {number} value - Time interval value.
     * @param  {boolean} [options.future] — Tells how to format value `0`: as "future" (`true`) or "past" (`false`). Is `false` by default.
     * @return {string}
     * @example
     * // Returns "{0} days ago"
     * getFormattingRule(en.long, "day", -2, 'en')
     */
  }, {
    key: "getFormattingRule",
    value: /* @__PURE__ */ __name(function getFormattingRule(formattingRules, unit, value, _ref4) {
      var future = _ref4.future;
      var locale = this.locale;
      formattingRules = formattingRules[unit];
      if (typeof formattingRules === "string") {
        return formattingRules;
      }
      var pastOrFuture = value === 0 ? future ? "future" : "past" : value < 0 ? "past" : "future";
      var quantifierRules = formattingRules[pastOrFuture] || formattingRules;
      if (typeof quantifierRules === "string") {
        return quantifierRules;
      }
      var quantifier = this.getPluralRules().select(Math.abs(value));
      return quantifierRules[quantifier] || quantifierRules.other;
    }, "getFormattingRule")
    /**
     * Formats a number into a string.
     * Uses `Intl.NumberFormat` when available.
     * @param  {number} number
     * @return {string}
     */
  }, {
    key: "formatNumber",
    value: /* @__PURE__ */ __name(function formatNumber2(number) {
      return this.numberFormat ? this.numberFormat.format(number) : String(number);
    }, "formatNumber")
    /**
     * Returns an `Intl.RelativeTimeFormat` for a given `labelsType`.
     * @param {string} labelsType
     * @return {object} `Intl.RelativeTimeFormat` instance
     */
  }, {
    key: "getFormatter",
    value: /* @__PURE__ */ __name(function getFormatter(labelsType) {
      return this.relativeTimeFormatCache.get(this.locale, labelsType) || this.relativeTimeFormatCache.put(this.locale, labelsType, new this.IntlRelativeTimeFormat(this.locale, {
        style: labelsType
      }));
    }, "getFormatter")
    /**
     * Returns an `Intl.PluralRules` instance.
     * @return {object} `Intl.PluralRules` instance
     */
  }, {
    key: "getPluralRules",
    value: /* @__PURE__ */ __name(function getPluralRules() {
      return this.pluralRulesCache.get(this.locale) || this.pluralRulesCache.put(this.locale, new this.IntlPluralRules(this.locale));
    }, "getPluralRules")
    /**
     * Gets localized labels for this type of labels.
     *
     * @param {(string|string[])} labelsType - Relative date/time labels type.
     *                                     If it's an array then all label types are tried
     *                                     until a suitable one is found.
     *
     * @returns {Object} Returns an object of shape { labelsType, labels }
     */
  }, {
    key: "getLabels",
    value: /* @__PURE__ */ __name(function getLabels() {
      var labelsType = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
      if (typeof labelsType === "string") {
        labelsType = [labelsType];
      }
      labelsType = labelsType.map(function(labelsType2) {
        switch (labelsType2) {
          case "tiny":
          case "mini-time":
            return "mini";
          default:
            return labelsType2;
        }
      });
      labelsType = labelsType.concat("long");
      var localeData = getLocaleData2(this.locale);
      for (var _iterator = _createForOfIteratorHelperLoose2(labelsType), _step; !(_step = _iterator()).done; ) {
        var _labelsType = _step.value;
        if (localeData[_labelsType]) {
          return {
            labelsType: _labelsType,
            labels: localeData[_labelsType]
          };
        }
      }
    }, "getLabels")
  }]);
  return TimeAgo2;
}();
var defaultLocale2 = "en";
TimeAgo.getDefaultLocale = function() {
  return defaultLocale2;
};
TimeAgo.setDefaultLocale = function(locale) {
  return defaultLocale2 = locale;
};
TimeAgo.addDefaultLocale = function(localeData) {
  if (defaultLocaleHasBeenSpecified) {
    return console.error("[javascript-time-ago] `TimeAgo.addDefaultLocale()` can only be called once. To add other locales, use `TimeAgo.addLocale()`.");
  }
  defaultLocaleHasBeenSpecified = true;
  TimeAgo.setDefaultLocale(localeData.locale);
  TimeAgo.addLocale(localeData);
};
var defaultLocaleHasBeenSpecified;
TimeAgo.addLocale = function(localeData) {
  addLocaleData2(localeData);
  RelativeTimeFormat.addLocale(localeData);
};
TimeAgo.locale = TimeAgo.addLocale;
TimeAgo.addLabels = function(locale, name, labels) {
  var localeData = getLocaleData2(locale);
  if (!localeData) {
    addLocaleData2({
      locale
    });
    localeData = getLocaleData2(locale);
  }
  localeData[name] = labels;
};
function getTimestamp(input) {
  if (input.constructor === Date || isMockedDate(input)) {
    return input.getTime();
  }
  if (typeof input === "number") {
    return input;
  }
  throw new Error("Unsupported relative time formatter input: ".concat(_typeof6(input), ", ").concat(input));
}
__name(getTimestamp, "getTimestamp");
function isMockedDate(object) {
  return _typeof6(object) === "object" && typeof object.getTime === "function";
}
__name(isMockedDate, "isMockedDate");
function getTimeIntervalMeasurementUnits(allowedUnits, labels, nowLabel) {
  var units2 = Object.keys(labels);
  if (nowLabel) {
    units2.push("now");
  }
  if (allowedUnits) {
    units2 = allowedUnits.filter(function(unit) {
      return unit === "now" || units2.indexOf(unit) >= 0;
    });
  }
  return units2;
}
__name(getTimeIntervalMeasurementUnits, "getTimeIntervalMeasurementUnits");
function getNowLabel(labels, nowLabels, longLabels, future) {
  var nowLabel = labels.now || nowLabels && nowLabels.now;
  if (nowLabel) {
    if (typeof nowLabel === "string") {
      return nowLabel;
    }
    if (future) {
      return nowLabel.future;
    } else {
      return nowLabel.past;
    }
  }
  if (longLabels && longLabels.second && longLabels.second.current) {
    return longLabels.second.current;
  }
}
__name(getNowLabel, "getNowLabel");
function isStyle(variable) {
  return typeof variable === "string" || isStyleObject(variable);
}
__name(isStyle, "isStyle");

// ../../node_modules/.pnpm/javascript-time-ago@2.5.7/node_modules/javascript-time-ago/locale/en.json.js
init_import_meta_url();
var en_json_default = {
  "locale": "en",
  "long": {
    "year": {
      "previous": "last year",
      "current": "this year",
      "next": "next year",
      "past": {
        "one": "{0} year ago",
        "other": "{0} years ago"
      },
      "future": {
        "one": "in {0} year",
        "other": "in {0} years"
      }
    },
    "quarter": {
      "previous": "last quarter",
      "current": "this quarter",
      "next": "next quarter",
      "past": {
        "one": "{0} quarter ago",
        "other": "{0} quarters ago"
      },
      "future": {
        "one": "in {0} quarter",
        "other": "in {0} quarters"
      }
    },
    "month": {
      "previous": "last month",
      "current": "this month",
      "next": "next month",
      "past": {
        "one": "{0} month ago",
        "other": "{0} months ago"
      },
      "future": {
        "one": "in {0} month",
        "other": "in {0} months"
      }
    },
    "week": {
      "previous": "last week",
      "current": "this week",
      "next": "next week",
      "past": {
        "one": "{0} week ago",
        "other": "{0} weeks ago"
      },
      "future": {
        "one": "in {0} week",
        "other": "in {0} weeks"
      }
    },
    "day": {
      "previous": "yesterday",
      "current": "today",
      "next": "tomorrow",
      "past": {
        "one": "{0} day ago",
        "other": "{0} days ago"
      },
      "future": {
        "one": "in {0} day",
        "other": "in {0} days"
      }
    },
    "hour": {
      "current": "this hour",
      "past": {
        "one": "{0} hour ago",
        "other": "{0} hours ago"
      },
      "future": {
        "one": "in {0} hour",
        "other": "in {0} hours"
      }
    },
    "minute": {
      "current": "this minute",
      "past": {
        "one": "{0} minute ago",
        "other": "{0} minutes ago"
      },
      "future": {
        "one": "in {0} minute",
        "other": "in {0} minutes"
      }
    },
    "second": {
      "current": "now",
      "past": {
        "one": "{0} second ago",
        "other": "{0} seconds ago"
      },
      "future": {
        "one": "in {0} second",
        "other": "in {0} seconds"
      }
    }
  },
  "short": {
    "year": {
      "previous": "last yr.",
      "current": "this yr.",
      "next": "next yr.",
      "past": "{0} yr. ago",
      "future": "in {0} yr."
    },
    "quarter": {
      "previous": "last qtr.",
      "current": "this qtr.",
      "next": "next qtr.",
      "past": {
        "one": "{0} qtr. ago",
        "other": "{0} qtrs. ago"
      },
      "future": {
        "one": "in {0} qtr.",
        "other": "in {0} qtrs."
      }
    },
    "month": {
      "previous": "last mo.",
      "current": "this mo.",
      "next": "next mo.",
      "past": "{0} mo. ago",
      "future": "in {0} mo."
    },
    "week": {
      "previous": "last wk.",
      "current": "this wk.",
      "next": "next wk.",
      "past": "{0} wk. ago",
      "future": "in {0} wk."
    },
    "day": {
      "previous": "yesterday",
      "current": "today",
      "next": "tomorrow",
      "past": {
        "one": "{0} day ago",
        "other": "{0} days ago"
      },
      "future": {
        "one": "in {0} day",
        "other": "in {0} days"
      }
    },
    "hour": {
      "current": "this hour",
      "past": "{0} hr. ago",
      "future": "in {0} hr."
    },
    "minute": {
      "current": "this minute",
      "past": "{0} min. ago",
      "future": "in {0} min."
    },
    "second": {
      "current": "now",
      "past": "{0} sec. ago",
      "future": "in {0} sec."
    }
  },
  "narrow": {
    "year": {
      "previous": "last yr.",
      "current": "this yr.",
      "next": "next yr.",
      "past": "{0} yr. ago",
      "future": "in {0} yr."
    },
    "quarter": {
      "previous": "last qtr.",
      "current": "this qtr.",
      "next": "next qtr.",
      "past": {
        "one": "{0} qtr. ago",
        "other": "{0} qtrs. ago"
      },
      "future": {
        "one": "in {0} qtr.",
        "other": "in {0} qtrs."
      }
    },
    "month": {
      "previous": "last mo.",
      "current": "this mo.",
      "next": "next mo.",
      "past": "{0} mo. ago",
      "future": "in {0} mo."
    },
    "week": {
      "previous": "last wk.",
      "current": "this wk.",
      "next": "next wk.",
      "past": "{0} wk. ago",
      "future": "in {0} wk."
    },
    "day": {
      "previous": "yesterday",
      "current": "today",
      "next": "tomorrow",
      "past": {
        "one": "{0} day ago",
        "other": "{0} days ago"
      },
      "future": {
        "one": "in {0} day",
        "other": "in {0} days"
      }
    },
    "hour": {
      "current": "this hour",
      "past": "{0} hr. ago",
      "future": "in {0} hr."
    },
    "minute": {
      "current": "this minute",
      "past": "{0} min. ago",
      "future": "in {0} min."
    },
    "second": {
      "current": "now",
      "past": "{0} sec. ago",
      "future": "in {0} sec."
    }
  },
  "now": {
    "now": {
      "current": "now",
      "future": "in a moment",
      "past": "just now"
    }
  },
  "mini": {
    "year": "{0}yr",
    "month": "{0}mo",
    "week": "{0}wk",
    "day": "{0}d",
    "hour": "{0}h",
    "minute": "{0}m",
    "second": "{0}s",
    "now": "now"
  },
  "short-time": {
    "year": "{0} yr.",
    "month": "{0} mo.",
    "week": "{0} wk.",
    "day": {
      "one": "{0} day",
      "other": "{0} days"
    },
    "hour": "{0} hr.",
    "minute": "{0} min.",
    "second": "{0} sec."
  },
  "long-time": {
    "year": {
      "one": "{0} year",
      "other": "{0} years"
    },
    "month": {
      "one": "{0} month",
      "other": "{0} months"
    },
    "week": {
      "one": "{0} week",
      "other": "{0} weeks"
    },
    "day": {
      "one": "{0} day",
      "other": "{0} days"
    },
    "hour": {
      "one": "{0} hour",
      "other": "{0} hours"
    },
    "minute": {
      "one": "{0} minute",
      "other": "{0} minutes"
    },
    "second": {
      "one": "{0} second",
      "other": "{0} seconds"
    }
  }
};

// ../../node_modules/.pnpm/pretty-bytes@6.0.0/node_modules/pretty-bytes/index.js
init_import_meta_url();
var BYTE_UNITS = [
  "B",
  "kB",
  "MB",
  "GB",
  "TB",
  "PB",
  "EB",
  "ZB",
  "YB"
];
var BIBYTE_UNITS = [
  "B",
  "kiB",
  "MiB",
  "GiB",
  "TiB",
  "PiB",
  "EiB",
  "ZiB",
  "YiB"
];
var BIT_UNITS = [
  "b",
  "kbit",
  "Mbit",
  "Gbit",
  "Tbit",
  "Pbit",
  "Ebit",
  "Zbit",
  "Ybit"
];
var BIBIT_UNITS = [
  "b",
  "kibit",
  "Mibit",
  "Gibit",
  "Tibit",
  "Pibit",
  "Eibit",
  "Zibit",
  "Yibit"
];
var toLocaleString = /* @__PURE__ */ __name((number, locale, options29) => {
  let result = number;
  if (typeof locale === "string" || Array.isArray(locale)) {
    result = number.toLocaleString(locale, options29);
  } else if (locale === true || options29 !== void 0) {
    result = number.toLocaleString(void 0, options29);
  }
  return result;
}, "toLocaleString");
function prettyBytes(number, options29) {
  if (!Number.isFinite(number)) {
    throw new TypeError(`Expected a finite number, got ${typeof number}: ${number}`);
  }
  options29 = {
    bits: false,
    binary: false,
    ...options29
  };
  const UNITS2 = options29.bits ? options29.binary ? BIBIT_UNITS : BIT_UNITS : options29.binary ? BIBYTE_UNITS : BYTE_UNITS;
  if (options29.signed && number === 0) {
    return ` 0 ${UNITS2[0]}`;
  }
  const isNegative2 = number < 0;
  const prefix = isNegative2 ? "-" : options29.signed ? "+" : "";
  if (isNegative2) {
    number = -number;
  }
  let localeOptions;
  if (options29.minimumFractionDigits !== void 0) {
    localeOptions = { minimumFractionDigits: options29.minimumFractionDigits };
  }
  if (options29.maximumFractionDigits !== void 0) {
    localeOptions = { maximumFractionDigits: options29.maximumFractionDigits, ...localeOptions };
  }
  if (number < 1) {
    const numberString2 = toLocaleString(number, options29.locale, localeOptions);
    return prefix + numberString2 + " " + UNITS2[0];
  }
  const exponent = Math.min(Math.floor(options29.binary ? Math.log(number) / Math.log(1024) : Math.log10(number) / 3), UNITS2.length - 1);
  number /= (options29.binary ? 1024 : 1e3) ** exponent;
  if (!localeOptions) {
    number = number.toPrecision(3);
  }
  const numberString = toLocaleString(Number(number), options29.locale, localeOptions);
  const unit = UNITS2[exponent];
  return prefix + numberString + " " + unit;
}
__name(prettyBytes, "prettyBytes");

// src/d1/formatTimeAgo.ts
TimeAgo.addDefaultLocale(en_json_default);
var timeAgo = new TimeAgo("en-US");
var formatTimeAgo = /* @__PURE__ */ __name((date) => {
  const result = timeAgo.format(date);
  return Array.isArray(result) ? result[0] : result;
}, "formatTimeAgo");
var formatBytes = /* @__PURE__ */ __name((bytes) => {
  return prettyBytes(bytes);
}, "formatBytes");

// src/d1/options.ts
init_import_meta_url();
function Name(yargs) {
  return yargs.positional("name", {
    describe: "The name or binding of the DB",
    type: "string",
    demandOption: true
  });
}
__name(Name, "Name");
function Database(yargs) {
  return yargs.positional("database", {
    describe: "The name or binding of the DB",
    type: "string",
    demandOption: true
  });
}
__name(Database, "Database");

// src/d1/utils.ts
init_import_meta_url();

// src/d1/constants.ts
init_import_meta_url();
var DEFAULT_MIGRATION_PATH = "./migrations";
var DEFAULT_MIGRATION_TABLE = "d1_migrations";
var LOCATION_CHOICES = ["weur", "eeur", "apac", "oc", "wnam", "enam"];
var DEFAULT_BATCH_SIZE = 1e4;

// src/d1/list.tsx
init_import_meta_url();
var import_ink_table = __toESM(require_dist4());
var import_react2 = __toESM(require_react());
function Options(d1ListYargs) {
  return d1ListYargs.option("json", {
    describe: "return output as clean JSON",
    type: "boolean",
    default: false
  });
}
__name(Options, "Options");
var Handler = withConfig(
  async ({ json, config }) => {
    const accountId = await requireAuth(config);
    const dbs = await listDatabases(accountId);
    if (json) {
      logger.log(JSON.stringify(dbs, null, 2));
    } else {
      await printWranglerBanner();
      logger.log(renderToString(/* @__PURE__ */ import_react2.default.createElement(import_ink_table.default, { data: dbs })));
    }
  }
);
var listDatabases = /* @__PURE__ */ __name(async (accountId) => {
  const pageSize = 10;
  let page = 1;
  const results = [];
  while (results.length % pageSize === 0) {
    const json = await fetchResult(
      `/accounts/${accountId}/d1/database`,
      {},
      new URLSearchParams({
        per_page: pageSize.toString(),
        page: page.toString()
      })
    );
    page++;
    results.push(...json);
    if (json.length < pageSize) {
      break;
    }
  }
  return results;
}, "listDatabases");

// src/d1/utils.ts
function getDatabaseInfoFromConfig(config, name) {
  for (const d1Database of config.d1_databases) {
    if (d1Database.database_id && (name === d1Database.database_name || name === d1Database.binding)) {
      return {
        uuid: d1Database.database_id,
        previewDatabaseUuid: d1Database.preview_database_id,
        binding: d1Database.binding,
        name: d1Database.database_name,
        migrationsTableName: d1Database.migrations_table || DEFAULT_MIGRATION_TABLE,
        migrationsFolderPath: d1Database.migrations_dir || DEFAULT_MIGRATION_PATH,
        internal_env: d1Database.database_internal_env
      };
    }
  }
  return null;
}
__name(getDatabaseInfoFromConfig, "getDatabaseInfoFromConfig");
var getDatabaseByNameOrBinding = /* @__PURE__ */ __name(async (config, accountId, name) => {
  const dbFromConfig = getDatabaseInfoFromConfig(config, name);
  if (dbFromConfig)
    return dbFromConfig;
  const allDBs = await listDatabases(accountId);
  const matchingDB = allDBs.find((db) => db.name === name);
  if (!matchingDB) {
    throw new UserError(`Couldn't find DB with name '${name}'`);
  }
  return matchingDB;
}, "getDatabaseByNameOrBinding");
var getDatabaseInfoFromId = /* @__PURE__ */ __name(async (accountId, databaseId) => {
  return await fetchResult(
    `/accounts/${accountId}/d1/database/${databaseId}`,
    {
      headers: {
        "Content-Type": "application/json"
      }
    }
  );
}, "getDatabaseInfoFromId");

// src/d1/backups.tsx
function ListOptions(yargs) {
  return Name(yargs);
}
__name(ListOptions, "ListOptions");
var ListHandler = withConfig(
  async ({ config, name }) => {
    const accountId = await requireAuth(config);
    const db = await getDatabaseByNameOrBinding(
      config,
      accountId,
      name
    );
    const backups = await listBackups(accountId, db.uuid);
    logger.log(
      renderToString(
        /* @__PURE__ */ import_react3.default.createElement(
          import_ink_table2.default,
          {
            data: backups,
            columns: ["created_at", "id", "num_tables", "size"]
          }
        )
      )
    );
  }
);
var listBackups = /* @__PURE__ */ __name(async (accountId, uuid) => {
  const json = await fetchResult(
    `/accounts/${accountId}/d1/database/${uuid}/backup`,
    {}
  );
  const results = {};
  json.map((backup) => ({
    ...backup,
    created_at: new Date(backup.created_at)
  })).sort((a, b2) => +b2.created_at - +a.created_at).forEach((backup) => {
    const timeAgo2 = formatTimeAgo(backup.created_at);
    if (!results[timeAgo2]) {
      results[timeAgo2] = {
        ...backup,
        created_at: timeAgo2,
        size: formatBytes(backup.file_size)
      };
    }
  });
  return Object.values(results);
}, "listBackups");
function CreateOptions(yargs) {
  return ListOptions(yargs);
}
__name(CreateOptions, "CreateOptions");
var CreateHandler = withConfig(
  async ({ config, name }) => {
    const accountId = await requireAuth(config);
    const db = await getDatabaseByNameOrBinding(
      config,
      accountId,
      name
    );
    const backup = await createBackup(accountId, db.uuid);
    logger.log(
      renderToString(
        /* @__PURE__ */ import_react3.default.createElement(
          import_ink_table2.default,
          {
            data: [backup],
            columns: ["created_at", "id", "num_tables", "size", "state"]
          }
        )
      )
    );
  }
);
var createBackup = /* @__PURE__ */ __name(async (accountId, uuid) => {
  const backup = await fetchResult(
    `/accounts/${accountId}/d1/database/${uuid}/backup`,
    {
      method: "POST"
    }
  );
  return {
    ...backup,
    size: formatBytes(backup.file_size)
  };
}, "createBackup");
function RestoreOptions(yargs) {
  return ListOptions(yargs).positional("backup-id", {
    describe: "The Backup ID to restore",
    type: "string",
    demandOption: true
  });
}
__name(RestoreOptions, "RestoreOptions");
var RestoreHandler = withConfig(
  async ({ config, name, backupId }) => {
    const accountId = await requireAuth(config);
    const db = await getDatabaseByNameOrBinding(
      config,
      accountId,
      name
    );
    logger.log(`Restoring ${name} from backup ${backupId}....`);
    await restoreBackup(accountId, db.uuid, backupId);
    logger.log(`Done!`);
  }
);
var restoreBackup = /* @__PURE__ */ __name(async (accountId, uuid, backupId) => {
  await fetchResult(
    `/accounts/${accountId}/d1/database/${uuid}/backup/${backupId}/restore`,
    {
      method: "POST",
      headers: {
        "Content-Type": "application/json"
      }
    }
  );
}, "restoreBackup");
function DownloadOptions(yargs) {
  return ListOptions(yargs).positional("backup-id", {
    describe: "The Backup ID to download",
    type: "string",
    demandOption: true
  }).option("output", {
    describe: "The .sqlite3 file to write to (defaults to '<db-name>.<short-backup-id>.sqlite3'",
    type: "string"
  });
}
__name(DownloadOptions, "DownloadOptions");
var DownloadHandler = withConfig(
  async ({ name, backupId, output, config }) => {
    const accountId = await requireAuth(config);
    const db = await getDatabaseByNameOrBinding(
      config,
      accountId,
      name
    );
    const filename = output || path29.resolve(`${name}.${backupId.slice(0, 8)}.sqlite3`);
    logger.log(`\u{1F300} Downloading backup ${backupId} from '${name}'`);
    const response = await getBackupResponse(accountId, db.uuid, backupId);
    if (!response.ok) {
      throw new Error(
        `Failed to download backup ${backupId} from '${name}' - got ${response.status} from the API`
      );
    }
    logger.log(`\u{1F300} Saving to ${filename}`);
    const buffer = await response.arrayBuffer();
    await import_promises6.default.writeFile(filename, new Buffer(buffer));
    logger.log(`\u{1F300} Done!`);
  }
);
var getBackupResponse = /* @__PURE__ */ __name(async (accountId, uuid, backupId) => {
  return await performApiFetch(
    `/accounts/${accountId}/d1/database/${uuid}/backup/${backupId}/download`
  );
}, "getBackupResponse");

// src/d1/create.tsx
init_import_meta_url();
var import_ink2 = __toESM(require_build2());
var import_react4 = __toESM(require_react());
function Options2(yargs) {
  return yargs.positional("name", {
    describe: "The name of the new DB",
    type: "string",
    demandOption: true
  }).option("location", {
    describe: "A hint for the primary location of the new DB. Options:\nweur: Western Europe\neeur: Eastern Europe\napac: Asia Pacific\noc: Oceania\nwnam: Western North America\nenam: Eastern North America \n",
    type: "string"
  });
}
__name(Options2, "Options");
var Handler2 = withConfig(
  async ({ name, config, location }) => {
    await printWranglerBanner();
    const accountId = await requireAuth(config);
    if (location) {
      if (LOCATION_CHOICES.indexOf(location.toLowerCase()) === -1) {
        throw new UserError(
          `Location '${location}' invalid. Valid values are ${LOCATION_CHOICES.join(
            ","
          )}`
        );
      }
    }
    let db;
    try {
      db = await fetchResult(`/accounts/${accountId}/d1/database`, {
        method: "POST",
        headers: {
          "Content-Type": "application/json"
        },
        body: JSON.stringify({
          name,
          ...location && { primary_location_hint: location }
        })
      });
    } catch (e3) {
      if (e3.code === 7502) {
        throw new UserError("A database with that name already exists");
      }
      throw e3;
    }
    logger.log(
      renderToString(
        /* @__PURE__ */ import_react4.default.createElement(import_ink2.Box, { flexDirection: "column" }, /* @__PURE__ */ import_react4.default.createElement(import_ink2.Text, null, "\u2705 Successfully created DB '", db.name, "'", db.created_in_region ? ` in region ${db.created_in_region}` : location ? ` using primary location hint ${location}` : ``), /* @__PURE__ */ import_react4.default.createElement(import_ink2.Text, null, "Created your new D1 database."), /* @__PURE__ */ import_react4.default.createElement(import_ink2.Text, null, "\xA0"), /* @__PURE__ */ import_react4.default.createElement(import_ink2.Text, null, "[[d1_databases]]"), /* @__PURE__ */ import_react4.default.createElement(import_ink2.Text, null, 'binding = "DB" # i.e. available in your Worker on env.DB'), /* @__PURE__ */ import_react4.default.createElement(import_ink2.Text, null, 'database_name = "', db.name, '"'), /* @__PURE__ */ import_react4.default.createElement(import_ink2.Text, null, 'database_id = "', db.uuid, '"'))
      )
    );
  }
);

// src/d1/delete.ts
init_import_meta_url();
function Options3(d1ListYargs) {
  return Name(d1ListYargs).option("skip-confirmation", {
    describe: "Skip confirmation",
    type: "boolean",
    alias: "y",
    default: false
  });
}
__name(Options3, "Options");
var Handler3 = withConfig(
  async ({ name, skipConfirmation, config }) => {
    await printWranglerBanner();
    const accountId = await requireAuth(config);
    const db = await getDatabaseByNameOrBinding(
      config,
      accountId,
      name
    );
    logger.log(`About to delete DB '${name}' (${db.uuid}).`);
    if (!skipConfirmation) {
      const response = await confirm(`Ok to proceed?`);
      if (!response) {
        logger.log(`Not deleting.`);
        return;
      }
    }
    logger.log("Deleting...");
    await fetchResult(`/accounts/${accountId}/d1/database/${db.uuid}`, {
      method: "DELETE"
    });
    logger.log(`Deleted '${name}' successfully.`);
  }
);

// src/d1/execute.tsx
init_import_meta_url();
var import_node_assert12 = __toESM(require("node:assert"));
var import_node_path29 = __toESM(require("node:path"));
var import_chalk9 = __toESM(require_chalk());
var import_ink3 = __toESM(require_build2());
var import_ink_table3 = __toESM(require_dist4());
var import_miniflare8 = require("miniflare");
var import_react5 = __toESM(require_react());

// src/dev/get-local-persistence-path.ts
init_import_meta_url();
var import_node_path28 = __toESM(require("node:path"));
function getLocalPersistencePath(persistTo, configPath) {
  return persistTo ? (
    // If path specified, always treat it as relative to cwd()
    import_node_path28.default.resolve(process.cwd(), persistTo)
  ) : (
    // Otherwise, treat it as relative to wrangler.toml,
    // if one can be found, otherwise cwd()
    import_node_path28.default.resolve(
      configPath ? import_node_path28.default.dirname(configPath) : process.cwd(),
      ".wrangler/state"
    )
  );
}
__name(getLocalPersistencePath, "getLocalPersistencePath");

// src/d1/splitter.ts
init_import_meta_url();

// src/d1/trimmer.ts
init_import_meta_url();
function trimSqlQuery(sql) {
  if (!mayContainTransaction(sql))
    return sql;
  const trimmedSql = sql.replace("BEGIN TRANSACTION;", "").replace("COMMIT;", "");
  if (mayContainTransaction(trimmedSql)) {
    throw new UserError(
      "Wrangler could not process the provided SQL file, as it contains several transactions.\nD1 runs your SQL in a transaction for you.\nPlease export an SQL file from your SQLite database and try again."
    );
  }
  return trimmedSql;
}
__name(trimSqlQuery, "trimSqlQuery");
function mayContainTransaction(sql) {
  return sql.includes("BEGIN TRANSACTION");
}
__name(mayContainTransaction, "mayContainTransaction");

// src/d1/splitter.ts
function mayContainMultipleStatements(sql) {
  const trimmed = sql.trimEnd();
  const semiColonIndex = trimmed.indexOf(";");
  return semiColonIndex !== -1 && semiColonIndex !== trimmed.length - 1;
}
__name(mayContainMultipleStatements, "mayContainMultipleStatements");
function splitSqlQuery(sql) {
  const trimmedSql = trimSqlQuery(sql);
  if (!mayContainMultipleStatements(trimmedSql))
    return [trimmedSql];
  const split = splitSqlIntoStatements(trimmedSql);
  if (split.length === 0) {
    return [trimmedSql];
  } else {
    return split;
  }
}
__name(splitSqlQuery, "splitSqlQuery");
function splitSqlIntoStatements(sql) {
  const statements = [];
  let str = "";
  const compoundStatementStack = [];
  const iterator = sql[Symbol.iterator]();
  let next = iterator.next();
  while (!next.done) {
    const char = next.value;
    if (compoundStatementStack[0]?.(str + char)) {
      compoundStatementStack.shift();
    }
    switch (char) {
      case `'`:
      case `"`:
      case "`":
        str += char + consumeUntilMarker(iterator, char);
        break;
      case `$`: {
        const dollarQuote = "$" + consumeWhile(iterator, isDollarQuoteIdentifier);
        str += dollarQuote;
        if (dollarQuote.endsWith("$")) {
          str += consumeUntilMarker(iterator, dollarQuote);
        }
        break;
      }
      case `-`:
        str += char;
        next = iterator.next();
        if (!next.done && next.value === "-") {
          str += next.value + consumeUntilMarker(iterator, "\n");
          break;
        } else {
          continue;
        }
      case `/`:
        str += char;
        next = iterator.next();
        if (!next.done && next.value === "*") {
          str += next.value + consumeUntilMarker(iterator, "*/");
          break;
        } else {
          continue;
        }
      case `;`:
        if (compoundStatementStack.length === 0) {
          statements.push(str);
          str = "";
        } else {
          str += char;
        }
        break;
      default:
        str += char;
        break;
    }
    if (isCompoundStatementStart(str)) {
      compoundStatementStack.unshift(isCompoundStatementEnd);
    }
    next = iterator.next();
  }
  statements.push(str);
  return statements.map((statement) => statement.trim()).filter((statement) => statement.length > 0);
}
__name(splitSqlIntoStatements, "splitSqlIntoStatements");
function consumeWhile(iterator, predicate) {
  let next = iterator.next();
  let str = "";
  while (!next.done) {
    str += next.value;
    if (!predicate(str)) {
      break;
    }
    next = iterator.next();
  }
  return str;
}
__name(consumeWhile, "consumeWhile");
function consumeUntilMarker(iterator, endMarker) {
  return consumeWhile(iterator, (str) => !str.endsWith(endMarker));
}
__name(consumeUntilMarker, "consumeUntilMarker");
function isDollarQuoteIdentifier(str) {
  const lastChar = str.slice(-1);
  return (
    // The $ marks the end of the identifier
    lastChar !== "$" && // we allow numbers, underscore and letters with diacritical marks
    (/[0-9_]/i.test(lastChar) || lastChar.toLowerCase() !== lastChar.toUpperCase())
  );
}
__name(isDollarQuoteIdentifier, "isDollarQuoteIdentifier");
function isCompoundStatementStart(str) {
  return /\s(BEGIN|CASE)\s$/.test(str);
}
__name(isCompoundStatementStart, "isCompoundStatementStart");
function isCompoundStatementEnd(str) {
  return /\sEND[;\s]$/.test(str);
}
__name(isCompoundStatementEnd, "isCompoundStatementEnd");

// src/d1/execute.tsx
function Options4(yargs) {
  return Database(yargs).option("yes", {
    describe: 'Answer "yes" to any prompts',
    type: "boolean",
    alias: "y"
  }).option("local", {
    describe: "Execute commands/files against a local DB for use with wrangler dev",
    type: "boolean"
  }).option("remote", {
    describe: "Execute commands/files against a remote DB for use with wrangler dev",
    type: "boolean"
  }).option("file", {
    describe: "A .sql file to ingest",
    type: "string"
  }).option("command", {
    describe: "A single SQL statement to execute",
    type: "string"
  }).option("persist-to", {
    describe: "Specify directory to use for local persistence (for --local)",
    type: "string",
    requiresArg: true
  }).option("json", {
    describe: "Return output as clean JSON",
    type: "boolean",
    default: false
  }).option("preview", {
    describe: "Execute commands/files against a preview D1 DB",
    type: "boolean",
    default: false
  }).option("batch-size", {
    describe: "Number of queries to send in a single batch",
    type: "number",
    default: DEFAULT_BATCH_SIZE
  });
}
__name(Options4, "Options");
var Handler4 = /* @__PURE__ */ __name(async (args) => {
  const {
    local,
    remote,
    database,
    yes,
    persistTo,
    file,
    command: command2,
    json,
    preview,
    batchSize
  } = args;
  const existingLogLevel = logger.loggerLevel;
  if (json) {
    logger.loggerLevel = "error";
  }
  await printWranglerBanner();
  const config = readConfig(args.config, args);
  if (file && command2)
    return logger.error(`Error: can't provide both --command and --file.`);
  const isInteractive3 = process.stdout.isTTY;
  try {
    const response = await executeSql({
      local,
      remote,
      config,
      name: database,
      shouldPrompt: isInteractive3 && !yes,
      persistTo,
      file,
      command: command2,
      json,
      preview,
      batchSize
    });
    if (!response)
      return;
    if (isInteractive3 && !json) {
      logger.log(
        renderToString(
          /* @__PURE__ */ import_react5.default.createElement(import_ink3.Static, { items: response }, (result) => {
            if (!Array.isArray(result)) {
              const { results, query } = result;
              if (Array.isArray(results) && results.length > 0) {
                const shortQuery = shorten(query, 48);
                return /* @__PURE__ */ import_react5.default.createElement(import_react5.default.Fragment, null, shortQuery ? /* @__PURE__ */ import_react5.default.createElement(import_ink3.Text, { dimColor: true }, shortQuery) : null, /* @__PURE__ */ import_react5.default.createElement(import_ink_table3.default, { data: results }));
              }
            }
          })
        )
      );
    } else {
      logger.loggerLevel = existingLogLevel;
      logger.log(JSON.stringify(response, null, 2));
    }
  } catch (error2) {
    if (json && error2 instanceof Error) {
      logger.loggerLevel = existingLogLevel;
      const messageToDisplay = error2.name === "APIError" ? error2 : { text: error2.message };
      throw new JsonFriendlyFatalError(
        JSON.stringify({ error: messageToDisplay }, null, 2)
      );
    } else {
      throw error2;
    }
  }
}, "Handler");
async function executeSql({
  local,
  remote,
  config,
  name,
  shouldPrompt,
  persistTo,
  file,
  command: command2,
  json,
  preview,
  batchSize
}) {
  const existingLogLevel = logger.loggerLevel;
  if (json) {
    logger.loggerLevel = "error";
  }
  const sql = file ? readFileSync5(file) : command2;
  if (!sql)
    throw new UserError(`Error: must provide --command or --file.`);
  if (local && remote) {
    throw new UserError(
      `Error: can't use --local and --remote at the same time`
    );
  }
  if (preview && !remote)
    throw new UserError(`Error: can't use --preview without --remote`);
  if (persistTo && !local)
    throw new UserError(`Error: can't use --persist-to without --local`);
  logger.log(`\u{1F300} Mapping SQL input into an array of statements`);
  const queries = splitSqlQuery(sql);
  if (file && sql) {
    if (queries[0].startsWith("SQLite format 3")) {
      throw new UserError(
        "Provided file is a binary SQLite database file instead of an SQL text file.\nThe execute command can only process SQL text files.\nPlease export an SQL file from your SQLite database and try again."
      );
    }
  }
  const result = remote || preview ? await executeRemotely({
    config,
    name,
    shouldPrompt,
    batches: batchSplit(queries, batchSize),
    json,
    preview
  }) : await executeLocally({
    config,
    name,
    queries,
    persistTo
  });
  if (json)
    logger.loggerLevel = existingLogLevel;
  return result;
}
__name(executeSql, "executeSql");
async function executeLocally({
  config,
  name,
  queries,
  persistTo
}) {
  const localDB = getDatabaseInfoFromConfig(config, name);
  if (!localDB) {
    throw new UserError(
      `Couldn't find a D1 DB with the name or binding '${name}' in wrangler.toml.`
    );
  }
  const id = localDB.previewDatabaseUuid ?? localDB.uuid;
  const persistencePath = getLocalPersistencePath(persistTo, config.configPath);
  const d1Persist = import_node_path29.default.join(persistencePath, "v3", "d1");
  logger.log(
    `\u{1F300} Executing on local database ${name} (${id}) from ${readableRelative(
      d1Persist
    )}:`
  );
  logger.log(
    "\u{1F300} To execute on your remote database, add a --remote flag to your wrangler command."
  );
  const mf = new import_miniflare8.Miniflare({
    modules: true,
    script: "",
    d1Persist,
    d1Databases: { DATABASE: id }
  });
  const db = await mf.getD1Database("DATABASE");
  let results;
  try {
    results = await db.batch(queries.map((query) => db.prepare(query)));
  } catch (e3) {
    throw e3?.cause ?? e3;
  } finally {
    await mf.dispose();
  }
  (0, import_node_assert12.default)(Array.isArray(results));
  return results.map((result) => ({
    results: (result.results ?? []).map(
      (row) => Object.fromEntries(
        Object.entries(row).map(([key, value]) => {
          if (Array.isArray(value))
            value = `[${value.join(", ")}]`;
          if (value === null)
            value = "null";
          return [key, value];
        })
      )
    ),
    success: result.success,
    meta: { duration: result.meta?.duration }
  }));
}
__name(executeLocally, "executeLocally");
async function executeRemotely({
  config,
  name,
  shouldPrompt,
  batches,
  json,
  preview
}) {
  const multiple_batches = batches.length > 1;
  if (multiple_batches && !json) {
    const warning = `\u26A0\uFE0F  Too much SQL to send at once, this execution will be sent as ${batches.length} batches.`;
    if (shouldPrompt) {
      const ok = await confirm(
        `${warning}
\u2139\uFE0F  Each batch is sent individually and may leave your DB in an unexpected state if a later batch fails.
\u26A0\uFE0F  Make sure you have a recent backup. Ok to proceed?`
      );
      if (!ok)
        return null;
      logger.log(`\u{1F300} Let's go`);
    } else {
      logger.error(warning);
    }
  }
  const accountId = await requireAuth(config);
  const db = await getDatabaseByNameOrBinding(
    config,
    accountId,
    name
  );
  if (preview && !db.previewDatabaseUuid) {
    const error2 = new UserError(
      "Please define a `preview_database_id` in your wrangler.toml to execute your queries against a preview database"
    );
    logger.error(error2.message);
    throw error2;
  }
  const dbUuid = preview ? db.previewDatabaseUuid : db.uuid;
  logger.log(`\u{1F300} Executing on remote database ${name} (${dbUuid}):`);
  logger.log(
    "\u{1F300} To execute on your local development database, remove the --remote flag from your wrangler command."
  );
  const results = [];
  for (const sql of batches) {
    if (multiple_batches)
      logger.log(
        import_chalk9.default.gray(`  ${sql.slice(0, 70)}${sql.length > 70 ? "..." : ""}`)
      );
    const result = await fetchResult(
      `/accounts/${accountId}/d1/database/${dbUuid}/query`,
      {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          ...db.internal_env ? { "x-d1-internal-env": db.internal_env } : {}
        },
        body: JSON.stringify({ sql })
      }
    );
    logResult(result);
    results.push(...result);
  }
  return results;
}
__name(executeRemotely, "executeRemotely");
function logResult(r3) {
  logger.log(
    `\u{1F6A3} Executed ${Array.isArray(r3) ? `${r3.length} commands` : "1 command"} in ${Array.isArray(r3) ? r3.map((d2) => d2.meta?.duration || 0).reduce((a, b2) => a + b2, 0) : r3.meta?.duration}ms`
  );
}
__name(logResult, "logResult");
function batchSplit(queries, batchSize) {
  logger.log(`\u{1F300} Parsing ${queries.length} statements`);
  const num_batches = Math.ceil(queries.length / batchSize);
  const batches = [];
  for (let i = 0; i < num_batches; i++) {
    batches.push(queries.slice(i * batchSize, (i + 1) * batchSize).join("; "));
  }
  if (num_batches > 1) {
    logger.log(
      `\u{1F300} We are sending ${num_batches} batch(es) to D1 (limited to ${batchSize} statements per batch. Use --batch-size to override.)`
    );
  }
  return batches;
}
__name(batchSplit, "batchSplit");
function shorten(query, length) {
  return query && query.length > length ? query.slice(0, length) + "..." : query;
}
__name(shorten, "shorten");

// src/d1/export.ts
init_import_meta_url();
var import_promises7 = __toESM(require("node:fs/promises"));
var import_chalk10 = __toESM(require_chalk());
var import_undici10 = __toESM(require_undici());
function Options5(yargs) {
  return Name(yargs).option("local", {
    type: "boolean",
    describe: "Export from your local DB you use with wrangler dev",
    conflicts: "remote"
  }).option("remote", {
    type: "boolean",
    describe: "Export from your live D1",
    conflicts: "local"
  }).option("no-schema", {
    type: "boolean",
    describe: "Only output table contents, not the DB schema",
    conflicts: "no-data"
  }).option("no-data", {
    type: "boolean",
    describe: "Only output table schema, not the contents of the DBs themselves",
    conflicts: "no-schema"
  }).option("table", {
    type: "string",
    describe: "Specify which tables to include in export"
  }).option("output", {
    type: "string",
    describe: "Which .sql file to output to",
    demandOption: true
  });
}
__name(Options5, "Options");
var Handler5 = /* @__PURE__ */ __name(async (args) => {
  const { local, remote, name, output, noSchema, noData, table } = args;
  await printWranglerBanner();
  const config = readConfig(args.config, args);
  if (local)
    throw new UserError(
      `Local imports/exports will be coming in a future version of Wrangler.`
    );
  if (!remote)
    throw new UserError(`You must specify either --local or --remote`);
  const tables = table ? Array.isArray(table) ? table : [table] : [];
  const result = await exportRemotely(
    config,
    name,
    output,
    tables,
    noSchema,
    noData
  );
  return result;
}, "Handler");
async function exportRemotely(config, name, output, tables, noSchema, noData) {
  const accountId = await requireAuth(config);
  const db = await getDatabaseByNameOrBinding(
    config,
    accountId,
    name
  );
  logger.log(`\u{1F300} Executing on remote database ${name} (${db.uuid}):`);
  logger.log(`\u{1F300} Creating export...`);
  const dumpOptions = {
    noSchema,
    noData,
    tables
  };
  const finalResponse = await pollExport(accountId, db, dumpOptions, void 0);
  if (finalResponse.status !== "complete")
    throw new APIError({ text: `D1 reset before export completed!` });
  logger.log(`\u{1F300} Downloading SQL to ${output}...`);
  logger.log(
    import_chalk10.default.gray(
      `You can also download your export from the following URL manually. This link will be valid for one hour: ${finalResponse.result.signedUrl}`
    )
  );
  const contents = await (0, import_undici10.fetch)(finalResponse.result.signedUrl);
  await import_promises7.default.writeFile(output, contents.body || "");
  logger.log(`Done!`);
}
__name(exportRemotely, "exportRemotely");
async function pollExport(accountId, db, dumpOptions, currentBookmark, num_parts_uploaded = 0) {
  const response = await fetchResult(`/accounts/${accountId}/d1/database/${db.uuid}/export`, {
    method: "POST",
    body: JSON.stringify({
      outputFormat: "polling",
      dumpOptions,
      currentBookmark
    })
  });
  if (!response.success)
    throw new Error(response.error);
  response.messages.forEach((line) => {
    if (line.startsWith(`Uploaded part`)) {
      logger.log(`\u{1F300} Uploaded part ${++num_parts_uploaded}`);
    } else {
      logger.log(`\u{1F300} ${line}`);
    }
  });
  if (response.status === "complete") {
    return response;
  } else if (response.status === "error") {
    throw new APIError({
      text: response.errors.join("\n"),
      notes: response.messages.map((text) => ({ text }))
    });
  } else {
    return await pollExport(
      accountId,
      db,
      dumpOptions,
      response.at_bookmark,
      num_parts_uploaded
    );
  }
}
__name(pollExport, "pollExport");

// src/d1/info.tsx
init_import_meta_url();
var import_ink_table4 = __toESM(require_dist4());
var import_react6 = __toESM(require_react());
function Options6(d1ListYargs) {
  return d1ListYargs.positional("name", {
    describe: "The name of the DB",
    type: "string",
    demandOption: true
  }).option("json", {
    describe: "return output as clean JSON",
    type: "boolean",
    default: false
  });
}
__name(Options6, "Options");
var Handler6 = withConfig(
  async ({ name, config, json }) => {
    const accountId = await requireAuth(config);
    const db = await getDatabaseByNameOrBinding(
      config,
      accountId,
      name
    );
    const result = await getDatabaseInfoFromId(accountId, db.uuid);
    const output = { ...result };
    if (output["file_size"]) {
      output["database_size"] = output["file_size"];
      delete output["file_size"];
    }
    if (output["version"] !== "alpha") {
      delete output["version"];
    }
    if (result.version !== "alpha") {
      const today = /* @__PURE__ */ new Date();
      const yesterday = new Date(new Date(today).setDate(today.getDate() - 1));
      const graphqlResult = await fetchGraphqlResult({
        method: "POST",
        body: JSON.stringify({
          query: `query getD1MetricsOverviewQuery($accountTag: string, $filter: ZoneWorkersRequestsFilter_InputObject) {
								viewer {
									accounts(filter: {accountTag: $accountTag}) {
										d1AnalyticsAdaptiveGroups(limit: 10000, filter: $filter) {
											sum {
												readQueries
												writeQueries
												rowsRead
												rowsWritten
										}
										dimensions {
												datetimeHour
										}
									}
								}
							}
						}`,
          operationName: "getD1MetricsOverviewQuery",
          variables: {
            accountTag: accountId,
            filter: {
              AND: [
                {
                  datetimeHour_geq: yesterday.toISOString(),
                  datetimeHour_leq: today.toISOString(),
                  databaseId: db.uuid
                }
              ]
            }
          }
        }),
        headers: {
          "Content-Type": "application/json"
        }
      });
      const metrics = {
        readQueries: 0,
        writeQueries: 0,
        rowsRead: 0,
        rowsWritten: 0
      };
      if (graphqlResult) {
        graphqlResult.data?.viewer?.accounts[0]?.d1AnalyticsAdaptiveGroups?.forEach(
          (row) => {
            metrics.readQueries += row?.sum?.readQueries ?? 0;
            metrics.writeQueries += row?.sum?.writeQueries ?? 0;
            metrics.rowsRead += row?.sum?.rowsRead ?? 0;
            metrics.rowsWritten += row?.sum?.rowsWritten ?? 0;
          }
        );
        output.read_queries_24h = metrics.readQueries;
        output.write_queries_24h = metrics.writeQueries;
        output.rows_read_24h = metrics.rowsRead;
        output.rows_written_24h = metrics.rowsWritten;
      }
    }
    if (json) {
      logger.log(JSON.stringify(output, null, 2));
    } else {
      const entries = Object.entries(output).filter(
        // also remove any version that isn't "alpha"
        ([k2, v2]) => k2 !== "uuid" && !(k2 === "version" && v2 !== "alpha")
      );
      const data = entries.map(([k2, v2]) => {
        let value;
        if (k2 === "database_size") {
          value = prettyBytes(Number(v2));
        } else if (k2 === "read_queries_24h" || k2 === "write_queries_24h" || k2 === "rows_read_24h" || k2 === "rows_written_24h") {
          value = v2.toLocaleString();
        } else {
          value = v2;
        }
        return {
          [db.binding || ""]: k2,
          [db.uuid]: value
        };
      });
      await printWranglerBanner();
      logger.log(renderToString(/* @__PURE__ */ import_react6.default.createElement(import_ink_table4.default, { data })));
    }
  }
);

// src/d1/insights.ts
init_import_meta_url();
function Options7(d1ListYargs) {
  return d1ListYargs.positional("name", {
    describe: "The name of the DB",
    type: "string",
    demandOption: true
  }).option("timePeriod", {
    choices: ["1d", "7d", "31d"],
    describe: "Fetch data from now to the provided time period",
    default: "1d"
  }).option("sort-type", {
    choices: ["sum", "avg"],
    describe: "Choose the operation you want to sort insights by",
    default: "sum"
  }).option("sort-by", {
    choices: ["time", "reads", "writes", "count"],
    describe: "Choose the field you want to sort insights by",
    default: "time"
  }).option("sort-direction", {
    choices: ["ASC", "DESC"],
    describe: "Choose a sort direction",
    default: "DESC"
  }).option("count", {
    describe: "fetch insights about the first X queries",
    type: "number",
    default: 5
  }).option("json", {
    describe: "return output as clean JSON",
    type: "boolean",
    default: false
  });
}
__name(Options7, "Options");
var cliOptionToGraphQLOption = {
  time: "queryDurationMs",
  reads: "rowsRead",
  writes: "rowsWritten",
  count: "count"
};
var Handler7 = withConfig(
  async ({
    name,
    config,
    json,
    count,
    timePeriod,
    sortType,
    sortBy,
    sortDirection
  }) => {
    const accountId = await requireAuth(config);
    const db = await getDatabaseByNameOrBinding(
      config,
      accountId,
      name
    );
    const result = await getDatabaseInfoFromId(accountId, db.uuid);
    const output = [];
    if (result.version !== "alpha") {
      const convertedTimePeriod = Number(timePeriod.replace("d", ""));
      const endDate = /* @__PURE__ */ new Date();
      const startDate = new Date(
        new Date(endDate).setDate(endDate.getDate() - convertedTimePeriod)
      );
      const parsedSortBy = cliOptionToGraphQLOption[sortBy];
      const orderByClause = parsedSortBy === "count" ? `${parsedSortBy}_${sortDirection}` : `${sortType}_${parsedSortBy}_${sortDirection}`;
      const graphqlQueriesResult = await fetchGraphqlResult({
        method: "POST",
        body: JSON.stringify({
          query: `query getD1QueriesOverviewQuery($accountTag: string, $filter: ZoneWorkersRequestsFilter_InputObject) {
								viewer {
									accounts(filter: {accountTag: $accountTag}) {
										d1QueriesAdaptiveGroups(limit: ${count}, filter: $filter, orderBy: [${orderByClause}]) {
											sum {
												queryDurationMs
												rowsRead
												rowsWritten
											}
											avg {
												queryDurationMs
												rowsRead
												rowsWritten
											}
											count
											dimensions {
													query
											}
										}
									}
								}
							}`,
          operationName: "getD1QueriesOverviewQuery",
          variables: {
            accountTag: accountId,
            filter: {
              AND: [
                {
                  datetimeHour_geq: startDate.toISOString(),
                  datetimeHour_leq: endDate.toISOString(),
                  databaseId: db.uuid
                }
              ]
            }
          }
        }),
        headers: {
          "Content-Type": "application/json"
        }
      });
      graphqlQueriesResult?.data?.viewer?.accounts[0]?.d1QueriesAdaptiveGroups?.forEach(
        (row) => {
          if (!row.dimensions.query)
            return;
          output.push({
            query: row.dimensions.query,
            avgRowsRead: row?.avg?.rowsRead ?? 0,
            totalRowsRead: row?.sum?.rowsRead ?? 0,
            avgRowsWritten: row?.avg?.rowsWritten ?? 0,
            totalRowsWritten: row?.sum?.rowsWritten ?? 0,
            avgDurationMs: row?.avg?.queryDurationMs ?? 0,
            totalDurationMs: row?.sum?.queryDurationMs ?? 0,
            numberOfTimesRun: row?.count ?? 0
          });
        }
      );
    }
    if (json) {
      logger.log(JSON.stringify(output, null, 2));
    } else {
      await printWranglerBanner();
      logger.log(
        "-------------------\n\u{1F6A7} `wrangler d1 insights` is an experimental command.\n\u{1F6A7} Flags for this command, their descriptions, and output may change between wrangler versions.\n-------------------\n"
      );
      logger.log(JSON.stringify(output, null, 2));
    }
  }
);

// src/d1/migrations/index.ts
init_import_meta_url();

// src/d1/migrations/apply.tsx
init_import_meta_url();
var import_node_assert13 = __toESM(require("node:assert"));
var import_node_fs21 = __toESM(require("node:fs"));
var import_path9 = __toESM(require("path"));
var import_ink4 = __toESM(require_build2());
var import_ink_table5 = __toESM(require_dist4());
var import_react7 = __toESM(require_react());

// src/d1/migrations/helpers.ts
init_import_meta_url();
var import_node_fs20 = __toESM(require("node:fs"));
var import_path8 = __toESM(require("path"));
async function getMigrationsPath({
  projectPath,
  migrationsFolderPath,
  createIfMissing
}) {
  const dir = import_path8.default.resolve(projectPath, migrationsFolderPath);
  if (import_node_fs20.default.existsSync(dir))
    return dir;
  const warning = `No migrations folder found.${migrationsFolderPath === DEFAULT_MIGRATION_PATH ? " Set `migrations_dir` in wrangler.toml to choose a different path." : ""}`;
  if (createIfMissing && await confirm(`${warning}
Ok to create ${dir}?`)) {
    import_node_fs20.default.mkdirSync(dir, { recursive: true });
    return dir;
  } else {
    logger.warn(warning);
  }
  throw new UserError(`No migrations present at ${dir}.`);
}
__name(getMigrationsPath, "getMigrationsPath");
async function getUnappliedMigrations({
  migrationsTableName,
  migrationsPath,
  local,
  remote,
  config,
  name,
  persistTo,
  preview
}) {
  const appliedMigrations = (await listAppliedMigrations({
    migrationsTableName,
    local,
    remote,
    config,
    name,
    persistTo,
    preview
  })).map((migration) => {
    return migration.name;
  });
  const projectMigrations = getMigrationNames(migrationsPath);
  const unappliedMigrations = [];
  for (const migration of projectMigrations) {
    if (!appliedMigrations.includes(migration)) {
      unappliedMigrations.push(migration);
    }
  }
  return unappliedMigrations;
}
__name(getUnappliedMigrations, "getUnappliedMigrations");
var listAppliedMigrations = /* @__PURE__ */ __name(async ({
  migrationsTableName,
  local,
  remote,
  config,
  name,
  persistTo,
  preview
}) => {
  const response = await executeSql({
    local,
    remote,
    config,
    name,
    shouldPrompt: isInteractive() && !CI.isCI(),
    persistTo,
    command: `SELECT *
		FROM ${migrationsTableName}
		ORDER BY id`,
    file: void 0,
    json: true,
    preview,
    batchSize: DEFAULT_BATCH_SIZE
  });
  if (!response || response[0].results.length === 0)
    return [];
  return response[0].results;
}, "listAppliedMigrations");
function getMigrationNames(migrationsPath) {
  const migrations = [];
  const dir = import_node_fs20.default.opendirSync(migrationsPath);
  let dirent;
  while ((dirent = dir.readSync()) !== null) {
    if (dirent.name.endsWith(".sql"))
      migrations.push(dirent.name);
  }
  dir.closeSync();
  return migrations;
}
__name(getMigrationNames, "getMigrationNames");
function getNextMigrationNumber(migrationsPath) {
  const migrationNumbers = getMigrationNames(migrationsPath).map(
    (migration) => parseInt(migration.split("_")[0])
  );
  const highestMigrationNumber = Math.max(...migrationNumbers, 0);
  return highestMigrationNumber + 1;
}
__name(getNextMigrationNumber, "getNextMigrationNumber");
var initMigrationsTable = /* @__PURE__ */ __name(async ({
  migrationsTableName,
  local,
  remote,
  config,
  name,
  persistTo,
  preview
}) => {
  return executeSql({
    local,
    remote,
    config,
    name,
    shouldPrompt: isInteractive() && !CI.isCI(),
    persistTo,
    command: `CREATE TABLE IF NOT EXISTS ${migrationsTableName}(
		id         INTEGER PRIMARY KEY AUTOINCREMENT,
		name       TEXT UNIQUE,
		applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL
);`,
    file: void 0,
    json: true,
    preview,
    batchSize: DEFAULT_BATCH_SIZE
  });
}, "initMigrationsTable");

// src/d1/migrations/options.ts
init_import_meta_url();
function MigrationOptions(yargs) {
  return Database(yargs).option("local", {
    describe: "Execute commands/files against a local DB for use with wrangler dev",
    type: "boolean"
  }).option("remote", {
    describe: "Execute commands/files against a remote DB for use with wrangler dev --remote",
    type: "boolean"
  }).option("preview", {
    describe: "Execute commands/files against a preview D1 DB",
    type: "boolean",
    default: false
  }).option("persist-to", {
    describe: "Specify directory to use for local persistence (you must use --local with this flag)",
    type: "string",
    requiresArg: true
  }).implies("persist-to", "local");
}
__name(MigrationOptions, "MigrationOptions");

// src/d1/migrations/apply.tsx
function ApplyOptions(yargs) {
  return MigrationOptions(yargs).option("batch-size", {
    describe: "Number of queries to send in a single batch",
    type: "number",
    default: DEFAULT_BATCH_SIZE
  });
}
__name(ApplyOptions, "ApplyOptions");
var ApplyHandler = withConfig(
  async ({
    config,
    database,
    local,
    remote,
    persistTo,
    preview,
    batchSize
  }) => {
    await printWranglerBanner();
    const databaseInfo = getDatabaseInfoFromConfig(config, database);
    if (!databaseInfo && remote) {
      throw new UserError(
        `Couldn't find a D1 DB with the name or binding '${database}' in wrangler.toml.`
      );
    }
    if (!config.configPath) {
      return;
    }
    const migrationsPath = await getMigrationsPath({
      projectPath: import_path9.default.dirname(config.configPath),
      migrationsFolderPath: databaseInfo?.migrationsFolderPath ?? DEFAULT_MIGRATION_PATH,
      createIfMissing: false
    });
    const migrationsTableName = databaseInfo?.migrationsTableName ?? DEFAULT_MIGRATION_TABLE;
    await initMigrationsTable({
      migrationsTableName,
      local,
      remote,
      config,
      name: database,
      persistTo,
      preview
    });
    const unappliedMigrations = (await getUnappliedMigrations({
      migrationsTableName,
      migrationsPath,
      local,
      remote,
      config,
      name: database,
      persistTo,
      preview
    })).map((migration) => {
      return {
        name: migration,
        status: "\u{1F552}\uFE0F"
      };
    }).sort((a, b2) => {
      const migrationNumberA = parseInt(a.name.split("_")[0]);
      const migrationNumberB = parseInt(b2.name.split("_")[0]);
      if (migrationNumberA < migrationNumberB) {
        return -1;
      }
      if (migrationNumberA > migrationNumberB) {
        return 1;
      }
      return 0;
    });
    if (unappliedMigrations.length === 0) {
      logger.log(renderToString(/* @__PURE__ */ import_react7.default.createElement(import_ink4.Text, null, "\u2705 No migrations to apply!")));
      return;
    }
    logger.log(
      renderToString(
        /* @__PURE__ */ import_react7.default.createElement(import_ink4.Box, { flexDirection: "column" }, /* @__PURE__ */ import_react7.default.createElement(import_ink4.Text, null, "Migrations to be applied:"), /* @__PURE__ */ import_react7.default.createElement(import_ink_table5.default, { data: unappliedMigrations, columns: ["name"] }))
      )
    );
    const ok = await confirm(
      `About to apply ${unappliedMigrations.length} migration(s)
Your database may not be available to serve requests during the migration, continue?`
    );
    if (!ok)
      return;
    if (!(local || preview)) {
      (0, import_node_assert13.default)(
        databaseInfo,
        "In non-local mode `databaseInfo` should be defined."
      );
      const accountId = await requireAuth(config);
      const dbInfo = await getDatabaseInfoFromId(accountId, databaseInfo?.uuid);
      if (dbInfo.version === "alpha") {
        logger.log(renderToString(/* @__PURE__ */ import_react7.default.createElement(import_ink4.Text, null, "\u{1F552} Creating backup...")));
        await createBackup(accountId, databaseInfo.uuid);
      }
    }
    for (const migration of unappliedMigrations) {
      let query = import_node_fs21.default.readFileSync(
        `${migrationsPath}/${migration.name}`,
        "utf8"
      );
      query += `
								INSERT INTO ${migrationsTableName} (name)
								values ('${migration.name}');
						`;
      let success2 = true;
      let errorNotes = [];
      try {
        const response = await executeSql({
          local,
          remote,
          config,
          name: database,
          shouldPrompt: isInteractive() && !CI.isCI(),
          persistTo,
          command: query,
          file: void 0,
          json: void 0,
          preview,
          batchSize
        });
        if (response === null) {
          return;
        }
        for (const result of response) {
          if (Array.isArray(result)) {
            for (const subResult of result) {
              if (!subResult.success) {
                success2 = false;
              }
            }
          } else {
            if (!result.success) {
              success2 = false;
            }
          }
        }
      } catch (e3) {
        const err = e3;
        const maybeCause = err.cause ?? err;
        success2 = false;
        errorNotes = err.notes?.map((msg) => msg.text) ?? [
          maybeCause?.message ?? maybeCause.toString()
        ];
      }
      migration.status = success2 ? "\u2705" : "\u274C";
      logger.log(
        renderToString(
          /* @__PURE__ */ import_react7.default.createElement(import_ink4.Box, { flexDirection: "column" }, /* @__PURE__ */ import_react7.default.createElement(import_ink_table5.default, { data: unappliedMigrations, columns: ["name", "status"] }), errorNotes.length > 0 && /* @__PURE__ */ import_react7.default.createElement(import_ink4.Box, { flexDirection: "column" }, /* @__PURE__ */ import_react7.default.createElement(import_ink4.Text, null, "\xA0"), /* @__PURE__ */ import_react7.default.createElement(import_ink4.Text, null, "\u274C Migration ", migration.name, " ", errorNotes.length > 0 ? "failed with the following errors:" : "")))
        )
      );
      if (errorNotes.length > 0) {
        throw new UserError(
          errorNotes.map((err) => {
            return err;
          }).join("\n")
        );
      }
    }
  }
);

// src/d1/migrations/create.tsx
init_import_meta_url();
var import_node_fs22 = __toESM(require("node:fs"));
var import_path10 = __toESM(require("path"));
var import_ink5 = __toESM(require_build2());
var import_react8 = __toESM(require_react());
function CreateOptions2(yargs) {
  return Database(yargs).positional("message", {
    describe: "The Migration message",
    type: "string",
    demandOption: true
  });
}
__name(CreateOptions2, "CreateOptions");
var CreateHandler2 = withConfig(
  async ({ config, database, message }) => {
    await printWranglerBanner();
    const databaseInfo = getDatabaseInfoFromConfig(config, database);
    if (!databaseInfo) {
      throw new UserError(
        `Couldn't find a D1 DB with the name or binding '${database}' in wrangler.toml.`
      );
    }
    if (!config.configPath) {
      return;
    }
    const migrationsPath = await getMigrationsPath({
      projectPath: import_path10.default.dirname(config.configPath),
      migrationsFolderPath: databaseInfo.migrationsFolderPath ?? DEFAULT_MIGRATION_PATH,
      createIfMissing: true
    });
    const nextMigrationNumber = pad(getNextMigrationNumber(migrationsPath), 4);
    const migrationName = message.replaceAll(" ", "_");
    const newMigrationName = `${nextMigrationNumber}_${migrationName}.sql`;
    import_node_fs22.default.writeFileSync(
      `${migrationsPath}/${newMigrationName}`,
      `-- Migration number: ${nextMigrationNumber} 	 ${(/* @__PURE__ */ new Date()).toISOString()}
`
    );
    logger.log(
      renderToString(
        /* @__PURE__ */ import_react8.default.createElement(import_ink5.Box, { flexDirection: "column" }, /* @__PURE__ */ import_react8.default.createElement(import_ink5.Text, null, "\u2705 Successfully created Migration '", newMigrationName, "'!"), /* @__PURE__ */ import_react8.default.createElement(import_ink5.Text, null, "\xA0"), /* @__PURE__ */ import_react8.default.createElement(import_ink5.Text, null, "The migration is available for editing here"), /* @__PURE__ */ import_react8.default.createElement(import_ink5.Text, null, migrationsPath, "/", newMigrationName))
      )
    );
  }
);
function pad(num, size) {
  let newNum = num.toString();
  while (newNum.length < size)
    newNum = "0" + newNum;
  return newNum;
}
__name(pad, "pad");

// src/d1/migrations/list.tsx
init_import_meta_url();
var import_path11 = __toESM(require("path"));
var import_ink6 = __toESM(require_build2());
var import_ink_table6 = __toESM(require_dist4());
var import_react9 = __toESM(require_react());
function ListOptions2(yargs) {
  return MigrationOptions(yargs);
}
__name(ListOptions2, "ListOptions");
var ListHandler2 = withConfig(
  async ({
    config,
    database,
    local,
    remote,
    persistTo,
    preview
  }) => {
    await printWranglerBanner();
    if (remote) {
      await requireAuth({});
    }
    const databaseInfo = getDatabaseInfoFromConfig(config, database);
    if (!databaseInfo && remote) {
      throw new UserError(
        `Couldn't find a D1 DB with the name or binding '${database}' in wrangler.toml.`
      );
    }
    if (!config.configPath) {
      return;
    }
    const migrationsPath = await getMigrationsPath({
      projectPath: import_path11.default.dirname(config.configPath),
      migrationsFolderPath: databaseInfo?.migrationsFolderPath ?? DEFAULT_MIGRATION_PATH,
      createIfMissing: false
    });
    const migrationsTableName = databaseInfo?.migrationsTableName ?? DEFAULT_MIGRATION_TABLE;
    await initMigrationsTable({
      migrationsTableName,
      local,
      remote,
      config,
      name: database,
      persistTo,
      preview
    });
    const unappliedMigrations = (await getUnappliedMigrations({
      migrationsTableName,
      migrationsPath,
      local,
      remote,
      config,
      name: database,
      persistTo,
      preview
    })).map((migration) => {
      return {
        Name: migration
      };
    });
    if (unappliedMigrations.length === 0) {
      logger.log(renderToString(/* @__PURE__ */ import_react9.default.createElement(import_ink6.Text, null, "\u2705 No migrations to apply!")));
      return;
    }
    logger.log(
      renderToString(
        /* @__PURE__ */ import_react9.default.createElement(import_ink6.Box, { flexDirection: "column" }, /* @__PURE__ */ import_react9.default.createElement(import_ink6.Text, null, "Migrations to be applied:"), /* @__PURE__ */ import_react9.default.createElement(import_ink_table6.default, { data: unappliedMigrations, columns: ["Name"] }))
      )
    );
  }
);

// src/d1/timeTravel/index.ts
init_import_meta_url();

// src/d1/timeTravel/info.ts
init_import_meta_url();

// src/d1/timeTravel/utils.ts
init_import_meta_url();
var getBookmarkIdFromTimestamp = /* @__PURE__ */ __name(async (accountId, databaseId, timestamp) => {
  const searchParams = new URLSearchParams();
  if (timestamp) {
    searchParams.append("timestamp", convertTimestampToISO(timestamp));
  }
  const bookmarkResult = await fetchResult(
    `/accounts/${accountId}/d1/database/${databaseId}/time_travel/bookmark?${searchParams.toString()}`,
    {
      headers: {
        "Content-Type": "application/json"
      }
    }
  );
  return bookmarkResult;
}, "getBookmarkIdFromTimestamp");
var throwIfDatabaseIsAlpha = /* @__PURE__ */ __name(async (accountId, databaseId) => {
  const dbInfo = await getDatabaseInfoFromId(accountId, databaseId);
  if (dbInfo.version === "alpha") {
    throw new UserError(
      "Time travel is not available for alpha D1 databases. You will need to migrate to a new database for access to this feature."
    );
  }
}, "throwIfDatabaseIsAlpha");
var ISO_DATE_REG_EXP = new RegExp(
  /(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))/
);
function isISODate(date) {
  return ISO_DATE_REG_EXP.test(date);
}
__name(isISODate, "isISODate");
function getLocalISOString(date) {
  const offset = date.getTimezoneOffset();
  const offsetAbs = Math.abs(offset);
  const isoString = new Date(date.getTime() - offset * 60 * 1e3).toISOString();
  return `${isoString.slice(0, -1)}${offset > 0 ? "-" : "+"}${String(
    Math.floor(offsetAbs / 60)
  ).padStart(2, "0")}:${String(offsetAbs % 60).padStart(2, "0")}`;
}
__name(getLocalISOString, "getLocalISOString");
var convertTimestampToISO = /* @__PURE__ */ __name((timestamp) => {
  const parsedTimestamp = isISODate(timestamp) ? new Date(timestamp) : new Date(Number(timestamp.length === 10 ? timestamp + "000" : timestamp));
  if (parsedTimestamp.toString() === "Invalid Date") {
    throw new UserError(
      `Invalid timestamp '${timestamp}'. Please provide a valid Unix timestamp or ISO string, for example: ${getLocalISOString(
        /* @__PURE__ */ new Date()
      )}
For accepted format, see: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date#date_time_string_format`
    );
  }
  const now = /* @__PURE__ */ new Date();
  const thirtyDaysAgo = /* @__PURE__ */ new Date();
  thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
  if (parsedTimestamp > now) {
    throw new UserError(
      `Invalid timestamp '${timestamp}'. Please provide a timestamp in the past`
    );
  }
  if (parsedTimestamp < thirtyDaysAgo) {
    throw new UserError(
      `Invalid timestamp '${timestamp}'. Please provide a timestamp within the last 30 days`
    );
  }
  return parsedTimestamp.toISOString();
}, "convertTimestampToISO");

// src/d1/timeTravel/info.ts
function InfoOptions(yargs) {
  return Database(yargs).option("timestamp", {
    describe: "accepts a Unix (seconds from epoch) or RFC3339 timestamp (e.g. 2023-07-13T08:46:42.228Z) to retrieve a bookmark for",
    type: "string"
  }).option("json", {
    describe: "return output as clean JSON",
    type: "boolean",
    default: false
  });
}
__name(InfoOptions, "InfoOptions");
var InfoHandler = withConfig(
  async ({ database, config, json, timestamp }) => {
    const accountId = await requireAuth(config);
    const db = await getDatabaseByNameOrBinding(config, accountId, database);
    await throwIfDatabaseIsAlpha(accountId, db.uuid);
    const result = await getBookmarkIdFromTimestamp(
      accountId,
      db.uuid,
      timestamp
    );
    if (json) {
      logger.log(JSON.stringify(result, null, 2));
    } else {
      await printWranglerBanner();
      logger.log("\u{1F6A7} Time Traveling...");
      logger.log(
        timestamp ? `\u26A0\uFE0F Timestamp '${timestamp}' corresponds with bookmark '${result.bookmark}'` : `\u26A0\uFE0F The current bookmark is '${result.bookmark}'`
      );
      logger.log(`\u26A1\uFE0F To restore to this specific bookmark, run:
 \`wrangler d1 time-travel restore ${database} --bookmark=${result.bookmark}\`
      `);
    }
  }
);

// src/d1/timeTravel/restore.ts
init_import_meta_url();
function RestoreOptions2(yargs) {
  return Database(yargs).option("bookmark", {
    describe: "Bookmark to use for time travel",
    type: "string"
  }).option("timestamp", {
    describe: "accepts a Unix (seconds from epoch) or RFC3339 timestamp (e.g. 2023-07-13T08:46:42.228Z) to retrieve a bookmark for",
    type: "string"
  }).option("json", {
    describe: "return output as clean JSON",
    type: "boolean",
    default: false
  }).check(function(argv) {
    if (argv.timestamp && !argv.bookmark || !argv.timestamp && argv.bookmark) {
      return true;
    } else if (argv.timestamp && argv.bookmark) {
      throw new UserError(
        "Provide either a timestamp, or a bookmark - not both."
      );
    } else {
      throw new UserError("Provide either a timestamp or a bookmark");
    }
  });
}
__name(RestoreOptions2, "RestoreOptions");
var RestoreHandler2 = withConfig(
  async ({ database, config, json, timestamp, bookmark }) => {
    const accountId = await requireAuth(config);
    const db = await getDatabaseByNameOrBinding(config, accountId, database);
    await throwIfDatabaseIsAlpha(accountId, db.uuid);
    const searchParams = new URLSearchParams();
    if (timestamp) {
      const bookmarkResult = await getBookmarkIdFromTimestamp(
        accountId,
        db.uuid,
        timestamp
      );
      searchParams.set("bookmark", bookmarkResult.bookmark);
    } else if (bookmark) {
      searchParams.set("bookmark", bookmark);
    }
    if (json) {
      const result = await handleRestore(accountId, db.uuid, searchParams);
      logger.log(JSON.stringify(result, null, 2));
    } else {
      await printWranglerBanner();
      logger.log(`\u{1F6A7} Restoring database ${database} from bookmark ${searchParams.get(
        "bookmark"
      )}
			`);
      logger.log(`\u26A0\uFE0F This will overwrite all data in database ${database}. 
In-flight queries and transactions will be cancelled.
			`);
      if (await confirm("OK to proceed (y/N)", { defaultValue: false })) {
        logger.log("\u26A1\uFE0F Time travel in progress...");
        const result = await handleRestore(accountId, db.uuid, searchParams);
        logger.log(`\u2705 Database ${database} restored back to bookmark ${result.bookmark}
				`);
        logger.log(
          `\u21A9\uFE0F To undo this operation, you can restore to the previous bookmark: ${result.previous_bookmark}`
        );
      }
    }
  }
);
var handleRestore = /* @__PURE__ */ __name(async (accountId, databaseId, searchParams) => {
  return await fetchResult(
    `/accounts/${accountId}/d1/database/${databaseId}/time_travel/restore?${searchParams.toString()}`,
    {
      headers: {
        "Content-Type": "application/json"
      },
      method: "POST"
    }
  );
}, "handleRestore");

// src/d1/index.ts
function d1(yargs) {
  return yargs.command("list", "List D1 databases", Options, Handler).command(
    "info <name>",
    "Get information about a D1 database, including the current database size and state.",
    Options6,
    Handler6
  ).command(
    "insights <name>",
    "Experimental command. Get information about the queries run on a D1 database.",
    Options7,
    Handler7
  ).command(
    "create <name>",
    "Create D1 database",
    Options2,
    Handler2
  ).command(
    "delete <name>",
    "Delete D1 database",
    Options3,
    Handler3
  ).command(
    "backup",
    "Interact with D1 Backups",
    (backupArgs) => backupArgs.demandCommand().command(
      "list <name>",
      "List your D1 backups",
      ListOptions,
      ListHandler
    ).command(
      "create <name>",
      "Create a new D1 backup",
      CreateOptions,
      CreateHandler
    ).command(
      "restore <name> <backup-id>",
      "Restore a DB backup",
      RestoreOptions,
      RestoreHandler
    ).command(
      "download <name> <backup-id>",
      "Download a DB backup",
      DownloadOptions,
      DownloadHandler
    )
  ).command(
    "execute <database>",
    "Executed command or SQL file",
    Options4,
    Handler4
  ).command(
    "export <name>",
    "Export the contents or schema of your database as a .sql file",
    Options5,
    Handler5
  ).command(
    "time-travel",
    "Use Time Travel to restore, fork or copy a database at a specific point-in-time.",
    (yargs2) => yargs2.demandCommand().command(
      "info <database>",
      "Retrieve information about a database at a specific point-in-time using Time Travel.",
      InfoOptions,
      InfoHandler
    ).command(
      "restore <database>",
      "Restore a database back to a specific point-in-time.",
      RestoreOptions2,
      RestoreHandler2
    )
  ).command(
    "migrations",
    "Interact with D1 Migrations",
    (yargs2) => yargs2.demandCommand().command(
      "list <database>",
      "List your D1 migrations",
      ListOptions2,
      ListHandler2
    ).command(
      "create <database> <message>",
      "Create a new Migration",
      CreateOptions2,
      CreateHandler2
    ).command(
      "apply <database>",
      "Apply D1 Migrations",
      ApplyOptions,
      ApplyHandler
    )
  );
}
__name(d1, "d1");

// src/delete.ts
init_import_meta_url();
var import_assert2 = __toESM(require("assert"));
var import_path12 = __toESM(require("path"));

// src/kv/helpers.ts
init_import_meta_url();
var import_node_buffer3 = require("node:buffer");
var import_node_url12 = require("node:url");
var import_miniflare9 = require("miniflare");
var import_undici11 = __toESM(require_undici());
var API_MAX = 1e4;
var BATCH_KEY_MAX = API_MAX / 2;
async function createKVNamespace(accountId, title) {
  const response = await fetchResult(
    `/accounts/${accountId}/storage/kv/namespaces`,
    {
      method: "POST",
      headers: {
        "Content-Type": "application/json"
      },
      body: JSON.stringify({
        title
      })
    }
  );
  return response.id;
}
__name(createKVNamespace, "createKVNamespace");
async function listKVNamespaces(accountId) {
  const pageSize = 100;
  let page = 1;
  const results = [];
  while (results.length % pageSize === 0) {
    const json = await fetchResult(
      `/accounts/${accountId}/storage/kv/namespaces`,
      {},
      new import_node_url12.URLSearchParams({
        per_page: pageSize.toString(),
        order: "title",
        direction: "asc",
        page: page.toString()
      })
    );
    page++;
    results.push(...json);
    if (json.length < pageSize) {
      break;
    }
  }
  return results;
}
__name(listKVNamespaces, "listKVNamespaces");
async function listKVNamespaceKeys(accountId, namespaceId, prefix = "") {
  return await fetchListResult(
    `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/keys`,
    {},
    new import_node_url12.URLSearchParams({ prefix })
  );
}
__name(listKVNamespaceKeys, "listKVNamespaceKeys");
async function deleteKVNamespace(accountId, namespaceId) {
  return await fetchResult(
    `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}`,
    { method: "DELETE" }
  );
}
__name(deleteKVNamespace, "deleteKVNamespace");
var KeyValueKeys = /* @__PURE__ */ new Set([
  "key",
  "value",
  "expiration",
  "expiration_ttl",
  "metadata",
  "base64"
]);
function hasProperty2(obj, property) {
  return property in obj;
}
__name(hasProperty2, "hasProperty");
function hasTypedProperty(obj, property, type) {
  return hasProperty2(obj, property) && typeof obj[property] === type;
}
__name(hasTypedProperty, "hasTypedProperty");
function hasOptionalTypedProperty(obj, property, type) {
  return !hasProperty2(obj, property) || typeof obj[property] === type;
}
__name(hasOptionalTypedProperty, "hasOptionalTypedProperty");
function isKVKeyValue(keyValue) {
  if (keyValue === null || typeof keyValue !== "object" || !hasTypedProperty(keyValue, "key", "string") || !hasTypedProperty(keyValue, "value", "string") || !hasOptionalTypedProperty(keyValue, "expiration", "number") || !hasOptionalTypedProperty(keyValue, "expiration_ttl", "number") || !hasOptionalTypedProperty(keyValue, "base64", "boolean") || !hasOptionalTypedProperty(keyValue, "metadata", "object")) {
    return false;
  }
  return true;
}
__name(isKVKeyValue, "isKVKeyValue");
function unexpectedKVKeyValueProps(keyValue) {
  const props = Object.keys(keyValue);
  return props.filter((prop) => !KeyValueKeys.has(prop));
}
__name(unexpectedKVKeyValueProps, "unexpectedKVKeyValueProps");
function asFormData(fields) {
  const formData = new import_undici11.FormData();
  for (const [name, value] of Object.entries(fields)) {
    formData.append(name, Buffer.isBuffer(value) ? new import_node_buffer3.Blob([value]) : value);
  }
  return formData;
}
__name(asFormData, "asFormData");
async function putKVKeyValue(accountId, namespaceId, keyValue) {
  let searchParams;
  if (keyValue.expiration || keyValue.expiration_ttl) {
    searchParams = new import_node_url12.URLSearchParams();
    if (keyValue.expiration) {
      searchParams.set("expiration", `${keyValue.expiration}`);
    }
    if (keyValue.expiration_ttl) {
      searchParams.set("expiration_ttl", `${keyValue.expiration_ttl}`);
    }
  }
  return await fetchResult(
    `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${encodeURIComponent(
      keyValue.key
    )}`,
    {
      method: "PUT",
      body: keyValue.metadata ? asFormData({
        value: keyValue.value,
        metadata: JSON.stringify(keyValue.metadata)
      }) : keyValue.value
    },
    searchParams
  );
}
__name(putKVKeyValue, "putKVKeyValue");
async function getKVKeyValue(accountId, namespaceId, key) {
  return await fetchKVGetValue(accountId, namespaceId, encodeURIComponent(key));
}
__name(getKVKeyValue, "getKVKeyValue");
async function deleteKVKeyValue(accountId, namespaceId, key) {
  return await fetchResult(
    `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${encodeURIComponent(
      key
    )}`,
    { method: "DELETE" }
  );
}
__name(deleteKVKeyValue, "deleteKVKeyValue");
var formatNumber = new Intl.NumberFormat("en-US", {
  notation: "standard"
}).format;
function logBulkProgress(operation, index, total) {
  logger.log(
    `${operation === "put" ? "Uploaded" : "Deleted"} ${Math.floor(
      100 * index / total
    )}% (${formatNumber(index)} out of ${formatNumber(total)})`
  );
}
__name(logBulkProgress, "logBulkProgress");
async function putKVBulkKeyValue(accountId, namespaceId, keyValues, quiet = false, abortSignal) {
  for (let index = 0; index < keyValues.length; index += BATCH_KEY_MAX) {
    if (!quiet && keyValues.length > BATCH_KEY_MAX) {
      logBulkProgress("put", index, keyValues.length);
    }
    await fetchResult(
      `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/bulk`,
      {
        method: "PUT",
        body: JSON.stringify(keyValues.slice(index, index + BATCH_KEY_MAX)),
        headers: { "Content-Type": "application/json" }
      },
      void 0,
      abortSignal
    );
  }
  if (!quiet && keyValues.length > BATCH_KEY_MAX) {
    logBulkProgress("put", keyValues.length, keyValues.length);
  }
}
__name(putKVBulkKeyValue, "putKVBulkKeyValue");
async function deleteKVBulkKeyValue(accountId, namespaceId, keys, quiet = false) {
  for (let index = 0; index < keys.length; index += BATCH_KEY_MAX) {
    if (!quiet && keys.length > BATCH_KEY_MAX) {
      logBulkProgress("delete", index, keys.length);
    }
    await fetchResult(
      `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/bulk`,
      {
        method: "DELETE",
        body: JSON.stringify(keys.slice(index, index + BATCH_KEY_MAX)),
        headers: { "Content-Type": "application/json" }
      }
    );
  }
  if (!quiet && keys.length > BATCH_KEY_MAX) {
    logBulkProgress("delete", keys.length, keys.length);
  }
}
__name(deleteKVBulkKeyValue, "deleteKVBulkKeyValue");
function getKVNamespaceId({ preview, binding, "namespace-id": namespaceId }, config) {
  if (namespaceId) {
    return namespaceId;
  }
  if (binding && !config) {
    throw new UserError("--binding specified, but no config file was found.");
  }
  if (!config) {
    throw new UserError(
      "Failed to find a config file.\nEither use --namespace-id to upload directly or create a configuration file with a binding."
    );
  }
  if (!config.kv_namespaces || config.kv_namespaces.length === 0) {
    throw new UserError(
      "No KV Namespaces configured! Either use --namespace-id to upload directly or add a KV namespace to your wrangler config file."
    );
  }
  const namespace = config.kv_namespaces.find((ns) => ns.binding === binding);
  if (!namespace) {
    throw new UserError(
      `A namespace with binding name "${binding}" was not found in the configured "kv_namespaces".`
    );
  }
  if (preview && namespace.preview_id) {
    namespaceId = namespace.preview_id;
    return namespaceId;
  } else if (preview) {
    throw new UserError(
      `No preview ID found for ${binding}. Add one to your wrangler config file to use a separate namespace for previewing your worker.`
    );
  }
  const previewIsDefined = typeof preview !== "undefined";
  if (previewIsDefined && namespace.id) {
    namespaceId = namespace.id;
    return namespaceId;
  } else if (previewIsDefined) {
    throw new UserError(
      `No namespace ID found for ${binding}. Add one to your wrangler config file to use a separate namespace for previewing your worker.`
    );
  }
  const bindingHasOnlyOneId = namespace.id && !namespace.preview_id || !namespace.id && namespace.preview_id;
  if (bindingHasOnlyOneId) {
    namespaceId = namespace.id || namespace.preview_id;
  } else {
    throw new UserError(
      `${binding} has both a namespace ID and a preview ID. Specify "--preview" or "--preview false" to avoid writing data to the wrong namespace.`
    );
  }
  if (!namespaceId) {
    throw new Error(
      "Something went wrong trying to determine which namespace to upload to.\nPlease create a github issue with the command you just ran along with your wrangler configuration."
    );
  }
  return namespaceId;
}
__name(getKVNamespaceId, "getKVNamespaceId");
async function usingLocalNamespace(persistTo, configPath, namespaceId, closure) {
  const persist = getLocalPersistencePath(persistTo, configPath);
  const persistOptions = buildPersistOptions(persist);
  const mf = new import_miniflare9.Miniflare({
    script: 'addEventListener("fetch", (e) => e.respondWith(new Response(null, { status: 404 })))',
    ...persistOptions,
    kvNamespaces: { NAMESPACE: namespaceId }
  });
  const namespace = await mf.getKVNamespace("NAMESPACE");
  try {
    return await closure(namespace);
  } finally {
    await mf.dispose();
  }
}
__name(usingLocalNamespace, "usingLocalNamespace");

// src/metrics/index.ts
init_import_meta_url();

// src/metrics/metrics-dispatcher.ts
init_import_meta_url();
var import_undici12 = __toESM(require_undici());

// src/metrics/metrics-config.ts
init_import_meta_url();
var import_node_crypto5 = require("node:crypto");
var import_node_fs23 = require("node:fs");
var import_node_path30 = __toESM(require("node:path"));
var CURRENT_METRICS_DATE = new Date(2022, 6, 4);
var USER_ID_CACHE_PATH = "user-id.json";
var getWranglerSendMetricsFromEnv2 = getEnvironmentVariableFactory({
  variableName: "WRANGLER_SEND_METRICS"
});
async function getMetricsConfig({
  sendMetrics,
  offline = false
}) {
  const config = readMetricsConfig();
  const deviceId = getDeviceId(config);
  const userId = await getUserId(offline);
  const sendMetricsEnv = getWranglerSendMetricsFromEnv2();
  if (sendMetricsEnv !== void 0) {
    return {
      enabled: sendMetricsEnv.toLowerCase() === "true",
      deviceId,
      userId
    };
  }
  if (sendMetrics !== void 0) {
    return { enabled: sendMetrics, deviceId, userId };
  }
  const permission = config.permission;
  if (permission !== void 0) {
    if (new Date(permission.date) >= CURRENT_METRICS_DATE) {
      return { enabled: permission.enabled, deviceId, userId };
    } else if (permission.enabled) {
      logger.log(
        "Usage metrics tracking has changed since you last granted permission."
      );
    }
  }
  if (!isInteractive() || CI.isCI()) {
    return { enabled: false, deviceId, userId };
  }
  const enabled = await confirm(
    "Would you like to help improve Wrangler by sending usage metrics to Cloudflare?"
  );
  logger.log(
    `Your choice has been saved in the following file: ${import_node_path30.default.relative(
      process.cwd(),
      getMetricsConfigPath()
    )}.

  You can override the user level setting for a project in \`wrangler.toml\`:

   - to disable sending metrics for a project: \`send_metrics = false\`
   - to enable sending metrics for a project: \`send_metrics = true\``
  );
  writeMetricsConfig({
    permission: {
      enabled,
      date: CURRENT_METRICS_DATE
    },
    deviceId
  });
  return { enabled, deviceId, userId };
}
__name(getMetricsConfig, "getMetricsConfig");
function writeMetricsConfig(config) {
  (0, import_node_fs23.mkdirSync)(import_node_path30.default.dirname(getMetricsConfigPath()), { recursive: true });
  (0, import_node_fs23.writeFileSync)(
    getMetricsConfigPath(),
    JSON.stringify(
      config,
      (_key, value) => value instanceof Date ? value.toISOString() : value,
      "	"
    )
  );
}
__name(writeMetricsConfig, "writeMetricsConfig");
function readMetricsConfig() {
  try {
    const config = (0, import_node_fs23.readFileSync)(getMetricsConfigPath(), "utf8");
    return JSON.parse(
      config,
      (key, value) => key === "date" ? new Date(value) : value
    );
  } catch {
    return {};
  }
}
__name(readMetricsConfig, "readMetricsConfig");
function getMetricsConfigPath() {
  return import_node_path30.default.resolve(getGlobalWranglerConfigPath(), "metrics.json");
}
__name(getMetricsConfigPath, "getMetricsConfigPath");
function getDeviceId(config) {
  const deviceId = config.deviceId ?? (0, import_node_crypto5.randomUUID)();
  if (config.deviceId === void 0) {
    writeMetricsConfig({ ...config, deviceId });
  }
  return deviceId;
}
__name(getDeviceId, "getDeviceId");
async function getUserId(offline) {
  let userId = getConfigCache(USER_ID_CACHE_PATH).userId;
  if (userId === void 0 && !offline) {
    userId = await fetchUserId();
    if (userId !== void 0) {
      saveToConfigCache(USER_ID_CACHE_PATH, { userId });
    }
  }
  return userId;
}
__name(getUserId, "getUserId");
async function fetchUserId() {
  try {
    return getAPIToken() ? (await fetchResult("/user")).id : void 0;
  } catch (e3) {
    return void 0;
  }
}
__name(fetchUserId, "fetchUserId");

// src/metrics/metrics-dispatcher.ts
var SPARROW_URL = "https://sparrow.cloudflare.com";
async function getMetricsDispatcher(options29) {
  return {
    /**
     * Dispatch a event to the analytics target.
     *
     * The event should follow these conventions
     *  - name is of the form `[action] [object]` (lower case)
     *  - additional properties are camelCased
     */
    async sendEvent(name, properties = {}) {
      await dispatch({ type: "event", name, properties });
    },
    /**
     * Dispatch a user profile information to the analytics target.
     *
     * This call can be used to inform the analytics target of relevant properties associated
     * with the current user.
     */
    async identify(properties) {
      await dispatch({ type: "identify", name: "identify", properties });
    }
  };
  async function dispatch(event) {
    if (false) {
      logger.debug(
        "Metrics dispatcher: Source Key not provided. Be sure to initialize before sending events.",
        event
      );
      return;
    }
    const metricsConfig = await getMetricsConfig(options29);
    if (!metricsConfig.enabled) {
      logger.debug(
        `Metrics dispatcher: Dispatching disabled - would have sent ${JSON.stringify(
          event
        )}.`
      );
      return;
    }
    logger.debug(`Metrics dispatcher: Posting data ${JSON.stringify(event)}`);
    const body = JSON.stringify({
      deviceId: metricsConfig.deviceId,
      userId: metricsConfig.userId,
      event: event.name,
      properties: {
        category: "Workers",
        wranglerVersion: version,
        os: process.platform + ":" + process.arch,
        ...event.properties
      }
    });
    (0, import_undici12.fetch)(`${SPARROW_URL}/api/v1/${event.type}`, {
      method: "POST",
      headers: {
        Accept: "*/*",
        "Content-Type": "application/json",
        "Sparrow-Source-Key": "50598e014ed44c739ec8074fdc16057c"
      },
      mode: "cors",
      keepalive: true,
      body
    }).catch((e3) => {
      logger.debug(
        "Metrics dispatcher: Failed to send request:",
        e3.message
      );
    });
  }
  __name(dispatch, "dispatch");
}
__name(getMetricsDispatcher, "getMetricsDispatcher");

// src/metrics/send-event.ts
init_import_meta_url();
async function sendMetricsEvent(event, ...args) {
  try {
    const options29 = args.pop() ?? {};
    const properties = args.pop() ?? {};
    const metricsDispatcher = await getMetricsDispatcher(options29);
    await metricsDispatcher.sendEvent(event, properties);
  } catch (err) {
    logger.debug("Error sending metrics event", err);
  }
}
__name(sendMetricsEvent, "sendMetricsEvent");

// src/metrics/metrics-usage-headers.ts
init_import_meta_url();
async function getMetricsUsageHeaders(sendMetrics) {
  const metricsEnabled = (await getMetricsConfig({
    sendMetrics
  })).enabled;
  if (metricsEnabled) {
    return {
      metricsEnabled: "true"
    };
  } else {
    return void 0;
  }
}
__name(getMetricsUsageHeaders, "getMetricsUsageHeaders");

// src/delete.ts
function deleteOptions(yargs) {
  return yargs.positional("script", {
    describe: "The path to an entry point for your worker",
    type: "string",
    requiresArg: true
  }).option("name", {
    describe: "Name of the worker",
    type: "string",
    requiresArg: true
  }).option("dry-run", {
    describe: "Don't actually delete",
    type: "boolean"
  }).option("force", {
    describe: "Delete even if doing so will break other Workers that depend on this one",
    type: "boolean"
  }).option("legacy-env", {
    type: "boolean",
    describe: "Use legacy environments",
    hidden: true
  });
}
__name(deleteOptions, "deleteOptions");
async function deleteHandler(args) {
  await printWranglerBanner();
  const configPath = args.config || args.script && findWranglerToml(import_path12.default.dirname(args.script));
  const config = readConfig(configPath, args);
  await sendMetricsEvent(
    "delete worker script",
    {},
    { sendMetrics: config.send_metrics }
  );
  const accountId = args.dryRun ? void 0 : await requireAuth(config);
  const scriptName = getScriptName(args, config);
  if (!scriptName) {
    throw new UserError(
      "A worker name must be defined, either via --name, or in wrangler.toml"
    );
  }
  if (args.dryRun) {
    logger.log(`--dry-run: exiting now.`);
    return;
  }
  (0, import_assert2.default)(accountId, "Missing accountId");
  const confirmed = args.force || await confirm(
    `Are you sure you want to delete ${scriptName}? This action cannot be undone.`
  );
  if (confirmed) {
    const needsForceDelete = args.force || await checkAndConfirmForceDeleteIfNecessary(scriptName, accountId);
    if (needsForceDelete === null) {
      return;
    }
    await fetchResult(
      `/accounts/${accountId}/workers/services/${scriptName}`,
      { method: "DELETE" },
      new URLSearchParams({ force: needsForceDelete.toString() })
    );
    await deleteSiteNamespaceIfExisting(scriptName, accountId);
    logger.log("Successfully deleted", scriptName);
  }
}
__name(deleteHandler, "deleteHandler");
async function deleteSiteNamespaceIfExisting(scriptName, accountId) {
  const title = `__${scriptName}-workers_sites_assets`;
  const previewTitle = `__${scriptName}-workers_sites_assets_preview`;
  const allNamespaces = await listKVNamespaces(accountId);
  const namespacesToDelete = allNamespaces.filter(
    (ns) => ns.title === title || ns.title === previewTitle
  );
  for (const ns of namespacesToDelete) {
    await deleteKVNamespace(accountId, ns.id);
    logger.log(`\u{1F300} Deleted asset namespace for Workers Site "${ns.title}"`);
  }
}
__name(deleteSiteNamespaceIfExisting, "deleteSiteNamespaceIfExisting");
function renderScriptName(details) {
  let service;
  let environment;
  if ("script" in details) {
    service = details.script;
  } else {
    service = details.service;
    environment = details.environment;
  }
  return environment ? `${service} (${environment})` : service;
}
__name(renderScriptName, "renderScriptName");
function isUsedAsServiceBinding(references) {
  return (references.services?.incoming.length || 0) > 0;
}
__name(isUsedAsServiceBinding, "isUsedAsServiceBinding");
function isUsedAsDurableObjectNamespace(references, scriptName) {
  return (references.durable_objects?.filter((ref) => ref.service !== scriptName)?.length || 0) > 0;
}
__name(isUsedAsDurableObjectNamespace, "isUsedAsDurableObjectNamespace");
function isUsedAsDispatchOutbound(references) {
  return references.dispatch_outbounds?.length || 0;
}
__name(isUsedAsDispatchOutbound, "isUsedAsDispatchOutbound");
function isUsedAsTailConsumer(tailProducers) {
  return tailProducers.length > 0;
}
__name(isUsedAsTailConsumer, "isUsedAsTailConsumer");
async function checkAndConfirmForceDeleteIfNecessary(scriptName, accountId) {
  const references = await fetchResult(
    `/accounts/${accountId}/workers/scripts/${scriptName}/references`
  );
  const tailProducers = await fetchResult(
    `/accounts/${accountId}/workers/tails/by-consumer/${scriptName}`
  );
  const isDependentService = isUsedAsServiceBinding(references) || isUsedAsDurableObjectNamespace(references, scriptName) || isUsedAsDispatchOutbound(references) || isUsedAsTailConsumer(tailProducers);
  if (!isDependentService)
    return false;
  const dependentMessages = [];
  for (const serviceBindingReference of references.services?.incoming || []) {
    const dependentScript = renderScriptName(serviceBindingReference);
    dependentMessages.push(
      `- Worker ${dependentScript} uses this Worker as a Service Binding`
    );
  }
  for (const implementedDOBindingReference of references.durable_objects || []) {
    if (implementedDOBindingReference.service === scriptName)
      continue;
    const dependentScript = renderScriptName(implementedDOBindingReference);
    dependentMessages.push(
      `- Worker ${dependentScript} has a binding to the Durable Object Namespace "${implementedDOBindingReference.durable_object_namespace_name}" implemented by this Worker`
    );
  }
  for (const dispatchNamespaceOutboundReference of references.dispatch_outbounds || []) {
    const dependentScript = renderScriptName(
      dispatchNamespaceOutboundReference
    );
    dependentMessages.push(
      `- Worker ${dependentScript} uses this Worker as an Outbound Worker for the Dynamic Dispatch Namespace "${dispatchNamespaceOutboundReference.namespace}"`
    );
  }
  for (const consumingTail of tailProducers) {
    const dependentScript = renderScriptName(consumingTail.producer);
    dependentMessages.push(
      `- Worker ${dependentScript} uses this Worker as a Tail Worker`
    );
  }
  const extraConfirmed = await confirm(`${scriptName} is currently in use by other Workers:

${dependentMessages.join("\n")}

You can still delete this Worker, but doing so WILL BREAK the Workers that depend on it. This will cause unexpected failures, and cannot be undone.
Are you sure you want to continue?`);
  return extraConfirmed ? true : null;
}
__name(checkAndConfirmForceDeleteIfNecessary, "checkAndConfirmForceDeleteIfNecessary");

// src/deploy/index.ts
init_import_meta_url();
var import_node_path31 = __toESM(require("node:path"));

// src/sites.ts
init_import_meta_url();
var import_node_assert14 = __toESM(require("node:assert"));
var import_promises8 = require("node:fs/promises");
var path38 = __toESM(require("node:path"));
var import_chalk11 = __toESM(require_chalk());
var import_ignore = __toESM(require_ignore());

// ../../node_modules/.pnpm/xxhash-wasm@1.0.1/node_modules/xxhash-wasm/esm/xxhash-wasm.js
init_import_meta_url();
var t2 = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 1, 48, 8, 96, 3, 127, 127, 127, 0, 96, 3, 127, 127, 127, 1, 127, 96, 2, 127, 127, 0, 96, 2, 127, 126, 0, 96, 1, 127, 1, 127, 96, 1, 127, 1, 126, 96, 3, 127, 127, 126, 1, 126, 96, 3, 126, 127, 127, 1, 126, 3, 11, 10, 1, 1, 2, 0, 4, 6, 7, 3, 0, 5, 5, 3, 1, 0, 1, 7, 85, 9, 3, 109, 101, 109, 2, 0, 5, 120, 120, 104, 51, 50, 0, 0, 6, 105, 110, 105, 116, 51, 50, 0, 2, 8, 117, 112, 100, 97, 116, 101, 51, 50, 0, 3, 8, 100, 105, 103, 101, 115, 116, 51, 50, 0, 4, 5, 120, 120, 104, 54, 52, 0, 5, 6, 105, 110, 105, 116, 54, 52, 0, 7, 8, 117, 112, 100, 97, 116, 101, 54, 52, 0, 8, 8, 100, 105, 103, 101, 115, 116, 54, 52, 0, 9, 10, 211, 23, 10, 242, 1, 1, 4, 127, 32, 0, 32, 1, 106, 33, 3, 32, 1, 65, 16, 79, 4, 127, 32, 3, 65, 16, 107, 33, 6, 32, 2, 65, 168, 136, 141, 161, 2, 106, 33, 3, 32, 2, 65, 247, 148, 175, 175, 120, 106, 33, 4, 32, 2, 65, 177, 243, 221, 241, 121, 107, 33, 5, 3, 64, 32, 0, 40, 2, 0, 65, 247, 148, 175, 175, 120, 108, 32, 3, 106, 65, 13, 119, 65, 177, 243, 221, 241, 121, 108, 33, 3, 32, 0, 65, 4, 106, 34, 0, 40, 2, 0, 65, 247, 148, 175, 175, 120, 108, 32, 4, 106, 65, 13, 119, 65, 177, 243, 221, 241, 121, 108, 33, 4, 32, 0, 65, 4, 106, 34, 0, 40, 2, 0, 65, 247, 148, 175, 175, 120, 108, 32, 2, 106, 65, 13, 119, 65, 177, 243, 221, 241, 121, 108, 33, 2, 32, 0, 65, 4, 106, 34, 0, 40, 2, 0, 65, 247, 148, 175, 175, 120, 108, 32, 5, 106, 65, 13, 119, 65, 177, 243, 221, 241, 121, 108, 33, 5, 32, 0, 65, 4, 106, 34, 0, 32, 6, 77, 13, 0, 11, 32, 2, 65, 12, 119, 32, 5, 65, 18, 119, 106, 32, 4, 65, 7, 119, 106, 32, 3, 65, 1, 119, 106, 5, 32, 2, 65, 177, 207, 217, 178, 1, 106, 11, 32, 1, 106, 32, 0, 32, 1, 65, 15, 113, 16, 1, 11, 146, 1, 0, 32, 1, 32, 2, 106, 33, 2, 3, 64, 32, 1, 65, 4, 106, 32, 2, 75, 69, 4, 64, 32, 1, 40, 2, 0, 65, 189, 220, 202, 149, 124, 108, 32, 0, 106, 65, 17, 119, 65, 175, 214, 211, 190, 2, 108, 33, 0, 32, 1, 65, 4, 106, 33, 1, 12, 1, 11, 11, 3, 64, 32, 1, 32, 2, 79, 69, 4, 64, 32, 1, 45, 0, 0, 65, 177, 207, 217, 178, 1, 108, 32, 0, 106, 65, 11, 119, 65, 177, 243, 221, 241, 121, 108, 33, 0, 32, 1, 65, 1, 106, 33, 1, 12, 1, 11, 11, 32, 0, 65, 15, 118, 32, 0, 115, 65, 247, 148, 175, 175, 120, 108, 34, 0, 32, 0, 65, 13, 118, 115, 65, 189, 220, 202, 149, 124, 108, 34, 0, 32, 0, 65, 16, 118, 115, 11, 63, 0, 32, 0, 65, 8, 106, 32, 1, 65, 168, 136, 141, 161, 2, 106, 54, 2, 0, 32, 0, 65, 12, 106, 32, 1, 65, 247, 148, 175, 175, 120, 106, 54, 2, 0, 32, 0, 65, 16, 106, 32, 1, 54, 2, 0, 32, 0, 65, 20, 106, 32, 1, 65, 177, 243, 221, 241, 121, 107, 54, 2, 0, 11, 211, 4, 1, 6, 127, 32, 1, 32, 2, 106, 33, 6, 32, 0, 65, 24, 106, 33, 5, 32, 0, 65, 40, 106, 40, 2, 0, 33, 3, 32, 0, 32, 0, 40, 2, 0, 32, 2, 106, 54, 2, 0, 32, 0, 65, 4, 106, 34, 4, 32, 4, 40, 2, 0, 32, 2, 65, 16, 79, 32, 0, 40, 2, 0, 65, 16, 79, 114, 114, 54, 2, 0, 32, 2, 32, 3, 106, 65, 16, 73, 4, 64, 32, 3, 32, 5, 106, 32, 1, 32, 2, 252, 10, 0, 0, 32, 0, 65, 40, 106, 32, 2, 32, 3, 106, 54, 2, 0, 15, 11, 32, 3, 4, 64, 32, 3, 32, 5, 106, 32, 1, 65, 16, 32, 3, 107, 34, 2, 252, 10, 0, 0, 32, 0, 65, 8, 106, 34, 3, 40, 2, 0, 32, 5, 40, 2, 0, 65, 247, 148, 175, 175, 120, 108, 106, 65, 13, 119, 65, 177, 243, 221, 241, 121, 108, 33, 4, 32, 3, 32, 4, 54, 2, 0, 32, 0, 65, 12, 106, 34, 3, 40, 2, 0, 32, 5, 65, 4, 106, 40, 2, 0, 65, 247, 148, 175, 175, 120, 108, 106, 65, 13, 119, 65, 177, 243, 221, 241, 121, 108, 33, 4, 32, 3, 32, 4, 54, 2, 0, 32, 0, 65, 16, 106, 34, 3, 40, 2, 0, 32, 5, 65, 8, 106, 40, 2, 0, 65, 247, 148, 175, 175, 120, 108, 106, 65, 13, 119, 65, 177, 243, 221, 241, 121, 108, 33, 4, 32, 3, 32, 4, 54, 2, 0, 32, 0, 65, 20, 106, 34, 3, 40, 2, 0, 32, 5, 65, 12, 106, 40, 2, 0, 65, 247, 148, 175, 175, 120, 108, 106, 65, 13, 119, 65, 177, 243, 221, 241, 121, 108, 33, 4, 32, 3, 32, 4, 54, 2, 0, 32, 0, 65, 40, 106, 65, 0, 54, 2, 0, 32, 1, 32, 2, 106, 33, 1, 11, 32, 1, 32, 6, 65, 16, 107, 77, 4, 64, 32, 6, 65, 16, 107, 33, 8, 32, 0, 65, 8, 106, 40, 2, 0, 33, 2, 32, 0, 65, 12, 106, 40, 2, 0, 33, 3, 32, 0, 65, 16, 106, 40, 2, 0, 33, 4, 32, 0, 65, 20, 106, 40, 2, 0, 33, 7, 3, 64, 32, 1, 40, 2, 0, 65, 247, 148, 175, 175, 120, 108, 32, 2, 106, 65, 13, 119, 65, 177, 243, 221, 241, 121, 108, 33, 2, 32, 1, 65, 4, 106, 34, 1, 40, 2, 0, 65, 247, 148, 175, 175, 120, 108, 32, 3, 106, 65, 13, 119, 65, 177, 243, 221, 241, 121, 108, 33, 3, 32, 1, 65, 4, 106, 34, 1, 40, 2, 0, 65, 247, 148, 175, 175, 120, 108, 32, 4, 106, 65, 13, 119, 65, 177, 243, 221, 241, 121, 108, 33, 4, 32, 1, 65, 4, 106, 34, 1, 40, 2, 0, 65, 247, 148, 175, 175, 120, 108, 32, 7, 106, 65, 13, 119, 65, 177, 243, 221, 241, 121, 108, 33, 7, 32, 1, 65, 4, 106, 34, 1, 32, 8, 77, 13, 0, 11, 32, 0, 65, 8, 106, 32, 2, 54, 2, 0, 32, 0, 65, 12, 106, 32, 3, 54, 2, 0, 32, 0, 65, 16, 106, 32, 4, 54, 2, 0, 32, 0, 65, 20, 106, 32, 7, 54, 2, 0, 11, 32, 1, 32, 6, 73, 4, 64, 32, 5, 32, 1, 32, 6, 32, 1, 107, 34, 1, 252, 10, 0, 0, 32, 0, 65, 40, 106, 32, 1, 54, 2, 0, 11, 11, 97, 1, 1, 127, 32, 0, 65, 16, 106, 40, 2, 0, 33, 1, 32, 0, 65, 4, 106, 40, 2, 0, 4, 127, 32, 1, 65, 12, 119, 32, 0, 65, 20, 106, 40, 2, 0, 65, 18, 119, 106, 32, 0, 65, 12, 106, 40, 2, 0, 65, 7, 119, 106, 32, 0, 65, 8, 106, 40, 2, 0, 65, 1, 119, 106, 5, 32, 1, 65, 177, 207, 217, 178, 1, 106, 11, 32, 0, 40, 2, 0, 106, 32, 0, 65, 24, 106, 32, 0, 65, 40, 106, 40, 2, 0, 16, 1, 11, 157, 4, 2, 1, 127, 3, 126, 32, 0, 32, 1, 106, 33, 3, 32, 1, 65, 32, 79, 4, 126, 32, 3, 65, 32, 107, 33, 3, 32, 2, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 124, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 124, 33, 4, 32, 2, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 124, 33, 5, 32, 2, 66, 0, 124, 33, 6, 32, 2, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 125, 33, 2, 3, 64, 32, 0, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 32, 4, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 33, 4, 32, 0, 65, 8, 106, 34, 0, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 32, 5, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 33, 5, 32, 0, 65, 8, 106, 34, 0, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 32, 6, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 33, 6, 32, 0, 65, 8, 106, 34, 0, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 32, 2, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 33, 2, 32, 0, 65, 8, 106, 34, 0, 32, 3, 77, 13, 0, 11, 32, 6, 66, 12, 137, 32, 2, 66, 18, 137, 124, 32, 5, 66, 7, 137, 124, 32, 4, 66, 1, 137, 124, 32, 4, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 66, 0, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 133, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 66, 227, 220, 202, 149, 252, 206, 242, 245, 133, 127, 124, 32, 5, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 66, 0, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 133, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 66, 227, 220, 202, 149, 252, 206, 242, 245, 133, 127, 124, 32, 6, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 66, 0, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 133, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 66, 227, 220, 202, 149, 252, 206, 242, 245, 133, 127, 124, 32, 2, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 66, 0, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 133, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 66, 227, 220, 202, 149, 252, 206, 242, 245, 133, 127, 124, 5, 32, 2, 66, 197, 207, 217, 178, 241, 229, 186, 234, 39, 124, 11, 32, 1, 173, 124, 32, 0, 32, 1, 65, 31, 113, 16, 6, 11, 137, 2, 0, 32, 1, 32, 2, 106, 33, 2, 3, 64, 32, 1, 65, 8, 106, 32, 2, 77, 4, 64, 32, 1, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 66, 0, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 32, 0, 133, 66, 27, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 66, 227, 220, 202, 149, 252, 206, 242, 245, 133, 127, 124, 33, 0, 32, 1, 65, 8, 106, 33, 1, 12, 1, 11, 11, 32, 1, 65, 4, 106, 32, 2, 77, 4, 64, 32, 1, 53, 2, 0, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 32, 0, 133, 66, 23, 137, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 66, 249, 243, 221, 241, 153, 246, 153, 171, 22, 124, 33, 0, 32, 1, 65, 4, 106, 33, 1, 11, 3, 64, 32, 1, 32, 2, 73, 4, 64, 32, 1, 49, 0, 0, 66, 197, 207, 217, 178, 241, 229, 186, 234, 39, 126, 32, 0, 133, 66, 11, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 33, 0, 32, 1, 65, 1, 106, 33, 1, 12, 1, 11, 11, 32, 0, 66, 33, 136, 32, 0, 133, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 34, 0, 32, 0, 66, 29, 136, 133, 66, 249, 243, 221, 241, 153, 246, 153, 171, 22, 126, 34, 0, 32, 0, 66, 32, 136, 133, 11, 88, 0, 32, 0, 65, 8, 106, 32, 1, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 124, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 124, 55, 3, 0, 32, 0, 65, 16, 106, 32, 1, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 124, 55, 3, 0, 32, 0, 65, 24, 106, 32, 1, 55, 3, 0, 32, 0, 65, 32, 106, 32, 1, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 125, 55, 3, 0, 11, 132, 5, 2, 3, 127, 4, 126, 32, 1, 32, 2, 106, 33, 5, 32, 0, 65, 40, 106, 33, 4, 32, 0, 65, 200, 0, 106, 40, 2, 0, 33, 3, 32, 0, 32, 0, 41, 3, 0, 32, 2, 173, 124, 55, 3, 0, 32, 2, 32, 3, 106, 65, 32, 73, 4, 64, 32, 3, 32, 4, 106, 32, 1, 32, 2, 252, 10, 0, 0, 32, 0, 65, 200, 0, 106, 32, 2, 32, 3, 106, 54, 2, 0, 15, 11, 32, 3, 4, 64, 32, 3, 32, 4, 106, 32, 1, 65, 32, 32, 3, 107, 34, 2, 252, 10, 0, 0, 32, 0, 65, 8, 106, 34, 3, 41, 3, 0, 32, 4, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 33, 6, 32, 3, 32, 6, 55, 3, 0, 32, 0, 65, 16, 106, 34, 3, 41, 3, 0, 32, 4, 65, 8, 106, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 33, 6, 32, 3, 32, 6, 55, 3, 0, 32, 0, 65, 24, 106, 34, 3, 41, 3, 0, 32, 4, 65, 16, 106, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 33, 6, 32, 3, 32, 6, 55, 3, 0, 32, 0, 65, 32, 106, 34, 3, 41, 3, 0, 32, 4, 65, 24, 106, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 33, 6, 32, 3, 32, 6, 55, 3, 0, 32, 0, 65, 200, 0, 106, 65, 0, 54, 2, 0, 32, 1, 32, 2, 106, 33, 1, 11, 32, 1, 65, 32, 106, 32, 5, 77, 4, 64, 32, 5, 65, 32, 107, 33, 2, 32, 0, 65, 8, 106, 41, 3, 0, 33, 6, 32, 0, 65, 16, 106, 41, 3, 0, 33, 7, 32, 0, 65, 24, 106, 41, 3, 0, 33, 8, 32, 0, 65, 32, 106, 41, 3, 0, 33, 9, 3, 64, 32, 1, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 32, 6, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 33, 6, 32, 1, 65, 8, 106, 34, 1, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 32, 7, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 33, 7, 32, 1, 65, 8, 106, 34, 1, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 32, 8, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 33, 8, 32, 1, 65, 8, 106, 34, 1, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 32, 9, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 33, 9, 32, 1, 65, 8, 106, 34, 1, 32, 2, 77, 13, 0, 11, 32, 0, 65, 8, 106, 32, 6, 55, 3, 0, 32, 0, 65, 16, 106, 32, 7, 55, 3, 0, 32, 0, 65, 24, 106, 32, 8, 55, 3, 0, 32, 0, 65, 32, 106, 32, 9, 55, 3, 0, 11, 32, 1, 32, 5, 73, 4, 64, 32, 4, 32, 1, 32, 5, 32, 1, 107, 34, 1, 252, 10, 0, 0, 32, 0, 65, 200, 0, 106, 32, 1, 54, 2, 0, 11, 11, 200, 2, 1, 5, 126, 32, 0, 65, 24, 106, 41, 3, 0, 33, 1, 32, 0, 41, 3, 0, 34, 2, 66, 32, 90, 4, 126, 32, 0, 65, 8, 106, 41, 3, 0, 34, 3, 66, 1, 137, 32, 0, 65, 16, 106, 41, 3, 0, 34, 4, 66, 7, 137, 124, 32, 1, 66, 12, 137, 32, 0, 65, 32, 106, 41, 3, 0, 34, 5, 66, 18, 137, 124, 124, 32, 3, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 66, 0, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 133, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 66, 227, 220, 202, 149, 252, 206, 242, 245, 133, 127, 124, 32, 4, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 66, 0, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 133, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 66, 227, 220, 202, 149, 252, 206, 242, 245, 133, 127, 124, 32, 1, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 66, 0, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 133, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 66, 227, 220, 202, 149, 252, 206, 242, 245, 133, 127, 124, 32, 5, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 66, 0, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 133, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 66, 227, 220, 202, 149, 252, 206, 242, 245, 133, 127, 124, 5, 32, 1, 66, 197, 207, 217, 178, 241, 229, 186, 234, 39, 124, 11, 32, 2, 124, 32, 0, 65, 40, 106, 32, 2, 66, 31, 131, 167, 16, 6, 11]);
async function e2() {
  const { instance: { exports: { mem: e3, xxh32: n2, xxh64: r3, init32: i, update32: o2, digest32: h2, init64: s, update64: u, digest64: g2 } } } = await WebAssembly.instantiate(t2);
  let a = new Uint8Array(e3.buffer);
  function c2(t3, n3) {
    if (e3.buffer.byteLength < t3 + n3) {
      const r4 = Math.ceil((t3 + n3 - e3.buffer.byteLength) / 65536);
      e3.grow(r4), a = new Uint8Array(e3.buffer);
    }
  }
  __name(c2, "c");
  function l2(t3, e4, n3, r4, i2, o3) {
    c2(t3);
    const h3 = new Uint8Array(t3);
    return a.set(h3), n3(0, e4), h3.set(a.slice(0, t3)), { update(e5) {
      let n4;
      return a.set(h3), "string" == typeof e5 ? (c2(3 * e5.length, t3), n4 = b2.encodeInto(e5, a.subarray(t3)).written) : (c2(e5.byteLength, t3), a.set(e5, t3), n4 = e5.byteLength), r4(0, t3, n4), h3.set(a.slice(0, t3)), this;
    }, digest: () => (a.set(h3), o3(i2(0))) };
  }
  __name(l2, "l");
  function d2(t3) {
    return t3 >>> 0;
  }
  __name(d2, "d");
  const f = 2n ** 64n - 1n;
  function y2(t3) {
    return t3 & f;
  }
  __name(y2, "y");
  const b2 = new TextEncoder(), w2 = 0n;
  function p2(t3) {
    let e4 = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : 0;
    return c2(3 * t3.length, 0), d2(n2(0, b2.encodeInto(t3, a).written, e4));
  }
  __name(p2, "p");
  function v2(t3) {
    let e4 = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : w2;
    return c2(3 * t3.length, 0), y2(r3(0, b2.encodeInto(t3, a).written, e4));
  }
  __name(v2, "v");
  return { h32: p2, h32ToString(t3) {
    return p2(t3, arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : 0).toString(16).padStart(8, "0");
  }, h32Raw(t3) {
    let e4 = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : 0;
    return c2(t3.byteLength, 0), a.set(t3), d2(n2(0, t3.byteLength, e4));
  }, create32() {
    return l2(48, arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : 0, i, o2, h2, d2);
  }, h64: v2, h64ToString(t3) {
    return v2(t3, arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : w2).toString(16).padStart(16, "0");
  }, h64Raw(t3) {
    let e4 = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : w2;
    return c2(t3.byteLength, 0), a.set(t3), y2(r3(0, t3.byteLength, e4));
  }, create64() {
    return l2(88, arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : w2, s, u, g2, y2);
  } };
}
__name(e2, "e");

// src/sites.ts
var ALWAYS_IGNORE = /* @__PURE__ */ new Set(["node_modules"]);
var HIDDEN_FILES_TO_INCLUDE = /* @__PURE__ */ new Set([
  ".well-known"
  // See https://datatracker.ietf.org/doc/html/rfc8615
]);
async function* getFilesInFolder(dirPath) {
  const files = await (0, import_promises8.readdir)(dirPath, { withFileTypes: true });
  for (const file of files) {
    if (ALWAYS_IGNORE.has(file.name)) {
      continue;
    }
    if (file.name.startsWith(".") && !HIDDEN_FILES_TO_INCLUDE.has(file.name)) {
      continue;
    }
    if (file.isDirectory()) {
      yield* await getFilesInFolder(path38.join(dirPath, file.name));
    } else {
      yield path38.join(dirPath, file.name);
    }
  }
}
__name(getFilesInFolder, "getFilesInFolder");
function hashFileContent(hasher, content) {
  return hasher.h64ToString(content).substring(0, 10);
}
__name(hashFileContent, "hashFileContent");
function hashAsset(hasher, filePath, content) {
  const extName = path38.extname(filePath) || "";
  const baseName = path38.basename(filePath, extName);
  const directory = path38.dirname(filePath);
  const hash = hashFileContent(hasher, content);
  return urlSafe(path38.join(directory, `${baseName}.${hash}${extName}`));
}
__name(hashAsset, "hashAsset");
async function createKVNamespaceIfNotAlreadyExisting(title, accountId) {
  const namespaces = await listKVNamespaces(accountId);
  const found = namespaces.find((ns) => ns.title === title);
  if (found) {
    return { created: false, id: found.id };
  }
  const id = await createKVNamespace(accountId, title);
  logger.log(`\u{1F300} Created namespace for Workers Site "${title}"`);
  return {
    created: true,
    id
  };
}
__name(createKVNamespaceIfNotAlreadyExisting, "createKVNamespaceIfNotAlreadyExisting");
var MAX_DIFF_LINES = 100;
var MAX_BUCKET_SIZE2 = 98 * 1e3 * 1e3;
var MAX_BUCKET_KEYS = BATCH_KEY_MAX;
var MAX_BATCH_OPERATIONS = 5;
function pluralise(count) {
  return count === 1 ? "" : "s";
}
__name(pluralise, "pluralise");
async function syncAssets(accountId, scriptName, siteAssets, preview, dryRun, oldAssetTTL) {
  if (siteAssets === void 0) {
    return { manifest: void 0, namespace: void 0 };
  }
  if (dryRun) {
    logger.log("(Note: doing a dry run, not uploading or deleting anything.)");
    return { manifest: void 0, namespace: void 0 };
  }
  (0, import_node_assert14.default)(accountId, "Missing accountId");
  const title = `__${scriptName}-workers_sites_assets${preview ? "_preview" : ""}`;
  const { id: namespace } = await createKVNamespaceIfNotAlreadyExisting(
    title,
    accountId
  );
  logger.info("Fetching list of already uploaded assets...");
  const namespaceKeysResponse = await listKVNamespaceKeys(accountId, namespace);
  const namespaceKeyInfoMap = new Map(
    namespaceKeysResponse.map((x2) => [x2.name, x2])
  );
  const namespaceKeys = new Set(namespaceKeysResponse.map((x2) => x2.name));
  const assetDirectory = path38.join(
    siteAssets.baseDirectory,
    siteAssets.assetDirectory
  );
  const include = createPatternMatcher(siteAssets.includePatterns, false);
  const exclude = createPatternMatcher(siteAssets.excludePatterns, true);
  const hasher = await e2();
  const manifest = {};
  const uploadBuckets = [];
  let uploadBucket = [];
  let uploadBucketSize = 0;
  let uploadCount = 0;
  let skipCount = 0;
  let diffCount = 0;
  function logDiff(line) {
    const level = logger.loggerLevel;
    if (LOGGER_LEVELS[level] >= LOGGER_LEVELS.debug) {
      logger.debug(line);
    } else if (diffCount < MAX_DIFF_LINES) {
      logger.info(line);
    } else if (diffCount === MAX_DIFF_LINES) {
      const msg = "   (truncating changed assets log, set `WRANGLER_LOG=debug` environment variable to see full diff)";
      logger.info(import_chalk11.default.dim(msg));
    }
    diffCount++;
  }
  __name(logDiff, "logDiff");
  logger.info("Building list of assets to upload...");
  for await (const absAssetFile of getFilesInFolder(assetDirectory)) {
    const assetFile = path38.relative(assetDirectory, absAssetFile);
    if (!include(assetFile) || exclude(assetFile))
      continue;
    const content = await (0, import_promises8.readFile)(absAssetFile, "base64");
    const assetSize = Buffer.byteLength(content);
    await validateAssetSize(absAssetFile, assetFile);
    const assetKey = hashAsset(hasher, assetFile, content);
    validateAssetKey(assetKey);
    if (!namespaceKeys.has(assetKey)) {
      logDiff(
        import_chalk11.default.green(` + ${assetKey} (uploading new version of ${assetFile})`)
      );
      if (uploadBucketSize + assetSize > MAX_BUCKET_SIZE2 || uploadBucket.length + 1 > MAX_BUCKET_KEYS) {
        uploadBuckets.push(uploadBucket);
        uploadBucketSize = 0;
        uploadBucket = [];
      }
      uploadBucketSize += assetSize;
      uploadBucket.push([absAssetFile, assetKey]);
      uploadCount++;
    } else {
      logDiff(import_chalk11.default.dim(` = ${assetKey} (already uploaded ${assetFile})`));
      skipCount++;
    }
    namespaceKeys.delete(assetKey);
    const manifestKey = urlSafe(path38.relative(assetDirectory, absAssetFile));
    manifest[manifestKey] = assetKey;
  }
  if (uploadBucket.length > 0)
    uploadBuckets.push(uploadBucket);
  for (const key of namespaceKeys) {
    logDiff(
      import_chalk11.default.red(` - ${key} (${oldAssetTTL ? "expiring" : "removing"} as stale)`)
    );
  }
  if (uploadCount > 0) {
    const s = pluralise(uploadCount);
    logger.info(`Uploading ${formatNumber(uploadCount)} new asset${s}...`);
  }
  if (skipCount > 0) {
    const s = pluralise(skipCount);
    logger.info(
      `Skipped uploading ${formatNumber(skipCount)} existing asset${s}.`
    );
  }
  let uploadedCount = 0;
  const controller = new AbortController();
  const uploaders = Array.from(Array(MAX_BATCH_OPERATIONS)).map(async () => {
    while (!controller.signal.aborted) {
      const nextBucket = uploadBuckets.shift();
      if (nextBucket === void 0)
        break;
      const bucket = [];
      for (const [absAssetFile, assetKey] of nextBucket) {
        bucket.push({
          key: assetKey,
          value: await (0, import_promises8.readFile)(absAssetFile, "base64"),
          base64: true
        });
        if (controller.signal.aborted)
          break;
      }
      try {
        await putKVBulkKeyValue(
          accountId,
          namespace,
          bucket,
          /* quiet */
          true,
          controller.signal
        );
      } catch (e3) {
        if (typeof e3 === "object" && e3 !== null && "name" in e3 && e3.name === "AbortError") {
          break;
        }
        throw e3;
      }
      uploadedCount += nextBucket.length;
      const percent = Math.floor(100 * uploadedCount / uploadCount);
      logger.info(
        `Uploaded ${percent}% [${formatNumber(
          uploadedCount
        )} out of ${formatNumber(uploadCount)}]`
      );
    }
  });
  try {
    await Promise.all(uploaders);
  } catch (e3) {
    logger.info(`Upload failed, aborting...`);
    controller.abort();
    throw e3;
  }
  const deleteCount = namespaceKeys.size;
  if (deleteCount > 0) {
    const s = pluralise(deleteCount);
    logger.info(
      `${oldAssetTTL ? "Expiring" : "Removing"} ${formatNumber(
        deleteCount
      )} stale asset${s}...`
    );
    if (!oldAssetTTL) {
      await deleteKVBulkKeyValue(
        accountId,
        namespace,
        Array.from(namespaceKeys)
      );
    } else {
      for (const namespaceKey of namespaceKeys) {
        const expiration = namespaceKeyInfoMap.get(namespaceKey)?.expiration;
        logger.info(
          ` - ${namespaceKey} ${expiration ? `(already expiring at ${expiration})` : ""}`
        );
        if (expiration) {
          continue;
        }
        const currentValue = await getKVKeyValue(
          accountId,
          namespace,
          namespaceKey
        );
        await putKVKeyValue(accountId, namespace, {
          key: namespaceKey,
          value: Buffer.from(currentValue),
          expiration_ttl: oldAssetTTL
        });
      }
    }
  }
  logger.log("\u2197\uFE0F  Done syncing assets");
  return { manifest, namespace };
}
__name(syncAssets, "syncAssets");
function createPatternMatcher(patterns, exclude) {
  if (patterns.length === 0) {
    return (_filePath) => !exclude;
  } else {
    const ignorer = (0, import_ignore.default)().add(patterns);
    return (filePath) => ignorer.test(filePath).ignored;
  }
}
__name(createPatternMatcher, "createPatternMatcher");
async function validateAssetSize(absFilePath, relativeFilePath) {
  const { size } = await (0, import_promises8.stat)(absFilePath);
  if (size > 25 * 1024 * 1024) {
    throw new UserError(
      `File ${relativeFilePath} is too big, it should be under 25 MiB. See https://developers.cloudflare.com/workers/platform/limits#kv-limits`
    );
  }
}
__name(validateAssetSize, "validateAssetSize");
function validateAssetKey(assetKey) {
  if (assetKey.length > 512) {
    throw new UserError(
      `The asset path key "${assetKey}" exceeds the maximum key size limit of 512. See https://developers.cloudflare.com/workers/platform/limits#kv-limits",`
    );
  }
}
__name(validateAssetKey, "validateAssetKey");
function urlSafe(filePath) {
  return filePath.replace(/\\/g, "/");
}
__name(urlSafe, "urlSafe");
function getAssetPaths(config, assetDirectory) {
  const baseDirectory = assetDirectory ? process.cwd() : path38.resolve(path38.dirname(config.configPath ?? "wrangler.toml"));
  assetDirectory ??= typeof config.assets === "string" ? config.assets : config.assets !== void 0 ? config.assets.bucket : void 0;
  const includePatterns = typeof config.assets !== "string" && config.assets?.include || [];
  const excludePatterns = typeof config.assets !== "string" && config.assets?.exclude || [];
  return assetDirectory ? {
    baseDirectory,
    assetDirectory,
    includePatterns,
    excludePatterns
  } : void 0;
}
__name(getAssetPaths, "getAssetPaths");
function getSiteAssetPaths(config, assetDirectory, includePatterns = config.site?.include ?? [], excludePatterns = config.site?.exclude ?? []) {
  const baseDirectory = assetDirectory ? process.cwd() : path38.resolve(path38.dirname(config.configPath ?? "wrangler.toml"));
  assetDirectory ??= config.site?.bucket;
  if (assetDirectory) {
    return {
      baseDirectory,
      assetDirectory,
      includePatterns,
      excludePatterns
    };
  } else {
    return void 0;
  }
}
__name(getSiteAssetPaths, "getSiteAssetPaths");

// src/utils/collectKeyValues.ts
init_import_meta_url();
function collectKeyValues(array) {
  return array?.reduce((recordsToCollect, v2) => {
    const [key, ...value] = v2.split(":");
    recordsToCollect[key] = value.join(":");
    return recordsToCollect;
  }, {}) || {};
}
__name(collectKeyValues, "collectKeyValues");

// src/deploy/index.ts
async function standardPricingWarning(config) {
  if (config.usage_model !== void 0) {
    logger.warn(
      "The `usage_model` defined in wrangler.toml is deprecated and no longer used. Visit our developer docs for details: https://developers.cloudflare.com/workers/wrangler/configuration/#usage-model"
    );
  }
}
__name(standardPricingWarning, "standardPricingWarning");
function deployOptions(yargs) {
  return yargs.positional("script", {
    describe: "The path to an entry point for your worker",
    type: "string",
    requiresArg: true
  }).option("name", {
    describe: "Name of the worker",
    type: "string",
    requiresArg: true
  }).option("bundle", {
    describe: "Run wrangler's compilation step before publishing",
    type: "boolean",
    hidden: true
  }).option("no-bundle", {
    describe: "Skip internal build steps and directly deploy Worker",
    type: "boolean",
    default: false
  }).option("outdir", {
    describe: "Output directory for the bundled worker",
    type: "string",
    requiresArg: true
  }).option("format", {
    choices: ["modules", "service-worker"],
    describe: "Choose an entry type",
    deprecated: true,
    hidden: true
  }).option("compatibility-date", {
    describe: "Date to use for compatibility checks",
    type: "string",
    requiresArg: true
  }).option("compatibility-flags", {
    describe: "Flags to use for compatibility checks",
    alias: "compatibility-flag",
    type: "string",
    requiresArg: true,
    array: true
  }).option("latest", {
    describe: "Use the latest version of the worker runtime",
    type: "boolean",
    default: false
  }).option("experimental-public", {
    describe: "Static assets to be served",
    type: "string",
    requiresArg: true,
    deprecated: true,
    hidden: true
  }).option("public", {
    describe: "Static assets to be served",
    type: "string",
    requiresArg: true,
    deprecated: true,
    hidden: true
  }).option("assets", {
    describe: "Static assets to be served",
    type: "string",
    requiresArg: true
  }).option("site", {
    describe: "Root folder of static assets for Workers Sites",
    type: "string",
    requiresArg: true
  }).option("site-include", {
    describe: "Array of .gitignore-style patterns that match file or directory names from the sites directory. Only matched items will be uploaded.",
    type: "string",
    requiresArg: true,
    array: true
  }).option("site-exclude", {
    describe: "Array of .gitignore-style patterns that match file or directory names from the sites directory. Matched items will not be uploaded.",
    type: "string",
    requiresArg: true,
    array: true
  }).option("var", {
    describe: "A key-value pair to be injected into the script as a variable",
    type: "string",
    requiresArg: true,
    array: true
  }).option("define", {
    describe: "A key-value pair to be substituted in the script",
    type: "string",
    requiresArg: true,
    array: true
  }).option("triggers", {
    describe: "cron schedules to attach",
    alias: ["schedule", "schedules"],
    type: "string",
    requiresArg: true,
    array: true
  }).option("routes", {
    describe: "Routes to upload",
    alias: "route",
    type: "string",
    requiresArg: true,
    array: true
  }).option("jsx-factory", {
    describe: "The function that is called for each JSX element",
    type: "string",
    requiresArg: true
  }).option("jsx-fragment", {
    describe: "The function that is called for each JSX fragment",
    type: "string",
    requiresArg: true
  }).option("tsconfig", {
    describe: "Path to a custom tsconfig.json file",
    type: "string",
    requiresArg: true
  }).option("minify", {
    describe: "Minify the Worker",
    type: "boolean"
  }).option("node-compat", {
    describe: "Enable Node.js compatibility",
    type: "boolean"
  }).option("dry-run", {
    describe: "Don't actually deploy",
    type: "boolean"
  }).option("keep-vars", {
    describe: "Stop wrangler from deleting vars that are not present in the wrangler.toml\nBy default Wrangler will remove all vars and replace them with those found in the wrangler.toml configuration.\nIf your development approach is to modify vars after deployment via the dashboard you may wish to set this flag.",
    default: false,
    type: "boolean"
  }).option("legacy-env", {
    type: "boolean",
    describe: "Use legacy environments",
    hidden: true
  }).option("logpush", {
    type: "boolean",
    describe: "Send Trace Events from this worker to Workers Logpush.\nThis will not configure a corresponding Logpush job automatically."
  }).option("upload-source-maps", {
    type: "boolean",
    describe: "Include source maps when uploading this worker."
  }).option("old-asset-ttl", {
    describe: "Expire old assets in given seconds rather than immediate deletion.",
    type: "number"
  }).option("dispatch-namespace", {
    describe: "Name of a dispatch namespace to deploy the Worker to (Workers for Platforms)",
    type: "string"
  });
}
__name(deployOptions, "deployOptions");
async function deployHandler(args) {
  await printWranglerBanner();
  if (args._[0] === "publish") {
    logger.warn(
      "`wrangler publish` is deprecated and will be removed in the next major version.\nPlease use `wrangler deploy` instead, which accepts exactly the same arguments."
    );
  }
  const configPath = args.config || args.script && findWranglerToml(import_node_path31.default.dirname(args.script));
  const projectRoot = configPath && import_node_path31.default.dirname(configPath);
  const config = readConfig(configPath, args);
  const entry = await getEntry(args, config, "deploy");
  await sendMetricsEvent(
    "deploy worker script",
    {
      usesTypeScript: /\.tsx?$/.test(entry.file)
    },
    {
      sendMetrics: config.send_metrics
    }
  );
  if (args.public) {
    throw new UserError("The --public field has been renamed to --assets");
  }
  if (args.experimentalPublic) {
    throw new UserError(
      "The --experimental-public field has been renamed to --assets"
    );
  }
  if ((args.assets || config.assets) && (args.site || config.site)) {
    throw new UserError(
      "Cannot use Assets and Workers Sites in the same Worker."
    );
  }
  if (args.assets) {
    logger.warn(
      "The --assets argument is experimental and may change or break at any time"
    );
  }
  if (args.latest) {
    logger.warn(
      "Using the latest version of the Workers runtime. To silence this warning, please choose a specific version of the runtime with --compatibility-date, or add a compatibility_date to your wrangler.toml.\n"
    );
  }
  const cliVars = collectKeyValues(args.var);
  const cliDefines = collectKeyValues(args.define);
  const accountId = args.dryRun ? void 0 : await requireAuth(config);
  const assetPaths = args.assets || config.assets ? getAssetPaths(config, args.assets) : getSiteAssetPaths(
    config,
    args.site,
    args.siteInclude,
    args.siteExclude
  );
  if (!args.dryRun)
    await standardPricingWarning(config);
  await deploy({
    config,
    accountId,
    name: getScriptName(args, config),
    rules: getRules(config),
    entry,
    env: args.env,
    compatibilityDate: args.latest ? (/* @__PURE__ */ new Date()).toISOString().substring(0, 10) : args.compatibilityDate,
    compatibilityFlags: args.compatibilityFlags,
    vars: cliVars,
    defines: cliDefines,
    triggers: args.triggers,
    jsxFactory: args.jsxFactory,
    jsxFragment: args.jsxFragment,
    tsconfig: args.tsconfig,
    routes: args.routes,
    assetPaths,
    legacyEnv: isLegacyEnv(config),
    minify: args.minify,
    nodeCompat: args.nodeCompat,
    isWorkersSite: Boolean(args.site || config.site),
    outDir: args.outdir,
    dryRun: args.dryRun,
    noBundle: !(args.bundle ?? !config.no_bundle),
    keepVars: args.keepVars,
    logpush: args.logpush,
    uploadSourceMaps: args.uploadSourceMaps,
    oldAssetTtl: args.oldAssetTtl,
    projectRoot,
    dispatchNamespace: args.dispatchNamespace,
    experimentalVersions: args.experimentalVersions
  });
}
__name(deployHandler, "deployHandler");

// src/deprecated/index.ts
init_import_meta_url();
function buildOptions(yargs) {
  return yargs;
}
__name(buildOptions, "buildOptions");
async function buildHandler(buildArgs) {
  const envFlag = buildArgs.env ? ` --env=${buildArgs.env}` : "";
  logger.log(
    formatMessage({
      kind: "warning",
      text: "Deprecation: `wrangler build` has been deprecated.",
      notes: [
        {
          text: "Please refer to https://developers.cloudflare.com/workers/wrangler/migration/deprecations/#build for more information."
        },
        {
          text: `Attempting to run \`wrangler deploy --dry-run --outdir=dist${envFlag}\` for you instead:`
        }
      ]
    })
  );
  await createCLIParser([
    "deploy",
    "--dry-run",
    "--outdir=dist",
    ...buildArgs.env ? ["--env", buildArgs.env] : [],
    ...buildArgs.config ? ["--config", buildArgs.config] : [],
    ...buildArgs.experimentalJsonConfig ? ["--experimental-json-config"] : [],
    ...buildArgs.experimentalVersions ? ["--experimental-versions"] : []
  ]).parse();
}
__name(buildHandler, "buildHandler");
var noOpOptions = /* @__PURE__ */ __name(() => {
}, "noOpOptions");
var configHandler = /* @__PURE__ */ __name(() => {
  throw new DeprecationError(
    "`wrangler config` has been deprecated, please refer to https://developers.cloudflare.com/workers/wrangler/migration/deprecations/#config for alternatives"
  );
}, "configHandler");
function previewOptions(yargs) {
  return yargs.positional("method", {
    type: "string",
    describe: "Type of request to preview your worker"
  }).positional("body", {
    type: "string",
    describe: "Body string to post to your preview worker request."
  }).option("watch", {
    default: true,
    describe: "Enable live preview",
    type: "boolean"
  });
}
__name(previewOptions, "previewOptions");
function previewHandler() {
  throw new DeprecationError(
    "The `wrangler preview` command has been deprecated.\nTry using `wrangler dev` to to try out a worker during development.\n"
  );
}
__name(previewHandler, "previewHandler");
var route = /* @__PURE__ */ __name((routeYargs) => {
  return routeYargs.command(
    "list",
    "List the routes associated with a zone",
    (yargs) => {
      return yargs.option("zone", {
        type: "string",
        requiresArg: true,
        describe: "Zone id"
      }).positional("zone", {
        describe: "Zone id",
        type: "string"
      });
    },
    () => {
      const deprecationNotice = "`wrangler route list` has been deprecated.";
      const futureRoutes = "Refer to wrangler.toml for a list of routes the worker will be deployed to upon publishing.";
      const presentRoutes = "Refer to the Cloudflare Dashboard to see the routes this worker is currently running on.";
      throw new DeprecationError(
        `${deprecationNotice}
${futureRoutes}
${presentRoutes}`
      );
    }
  ).command(
    "delete [id]",
    "Delete a route associated with a zone",
    (yargs) => {
      return yargs.positional("id", {
        describe: "The hash of the route ID to delete.",
        type: "string"
      }).option("zone", {
        type: "string",
        requiresArg: true,
        describe: "zone id"
      });
    },
    () => {
      const deprecationNotice = "`wrangler route delete` has been deprecated.";
      const shouldDo = "Remove the unwanted route(s) from wrangler.toml and run `wrangler deploy` to remove your worker from those routes.";
      throw new DeprecationError(`${deprecationNotice}
${shouldDo}`);
    }
  );
}, "route");
var routeHandler = /* @__PURE__ */ __name(() => {
  const deprecationNotice = "`wrangler route` has been deprecated.";
  const shouldDo = "Please use wrangler.toml and/or `wrangler deploy --routes` to modify routes";
  throw new DeprecationError(`${deprecationNotice}
${shouldDo}`);
}, "routeHandler");
var subdomainOptions = /* @__PURE__ */ __name((yargs) => {
  return yargs.positional("name", { type: "string" });
}, "subdomainOptions");
var subdomainHandler = /* @__PURE__ */ __name(() => {
  throw new DeprecationError(
    "`wrangler subdomain` has been deprecated, please refer to https://developers.cloudflare.com/workers/wrangler/migration/deprecations/#subdomain for alternatives"
  );
}, "subdomainHandler");

// src/dispatch-namespace.ts
init_import_meta_url();
async function createWorkerNamespace(accountId, name) {
  const namespace = await fetchResult(
    `/accounts/${accountId}/workers/dispatch/namespaces`,
    {
      method: "POST",
      headers: {
        "Content-Type": "application/json"
      },
      body: JSON.stringify({ name })
    }
  );
  logger.log(
    `Created dispatch namespace "${name}" with ID "${namespace.namespace_id}"`
  );
}
__name(createWorkerNamespace, "createWorkerNamespace");
async function deleteWorkerNamespace(accountId, name) {
  await fetchResult(
    `/accounts/${accountId}/workers/dispatch/namespaces/${name}`,
    { method: "DELETE" }
  );
  logger.log(`Deleted dispatch namespace "${name}"`);
}
__name(deleteWorkerNamespace, "deleteWorkerNamespace");
async function listWorkerNamespaces(accountId) {
  logger.log(
    await fetchResult(
      `/accounts/${accountId}/workers/dispatch/namespaces`,
      {
        headers: {
          "Content-Type": "application/json"
        }
      }
    )
  );
}
__name(listWorkerNamespaces, "listWorkerNamespaces");
async function getWorkerNamespaceInfo(accountId, name) {
  logger.log(
    await fetchResult(
      `/accounts/${accountId}/workers/dispatch/namespaces/${name}`,
      {
        headers: {
          "Content-Type": "application/json"
        }
      }
    )
  );
}
__name(getWorkerNamespaceInfo, "getWorkerNamespaceInfo");
async function renameWorkerNamespace(accountId, oldName, newName) {
  await fetchResult(
    `/accounts/${accountId}/workers/dispatch/namespaces/${oldName}`,
    {
      method: "PUT",
      headers: {
        "Content-Type": "application/json"
      },
      body: JSON.stringify({ name: newName })
    }
  );
  logger.log(`Renamed dispatch namespace "${oldName}" to "${newName}"`);
}
__name(renameWorkerNamespace, "renameWorkerNamespace");
function workerNamespaceCommands(workerNamespaceYargs, subHelp) {
  return workerNamespaceYargs.command(subHelp).command(
    "list",
    "List all dispatch namespaces",
    (args) => args,
    async (args) => {
      const config = readConfig(args.config, args);
      const accountId = await requireAuth(config);
      await listWorkerNamespaces(accountId);
      await sendMetricsEvent("list dispatch namespaces", {
        sendMetrics: config.send_metrics
      });
    }
  ).command(
    "get <name>",
    "Get information about a dispatch namespace",
    (yargs) => {
      return yargs.positional("name", {
        describe: "Name of the dispatch namespace",
        type: "string",
        demandOption: true
      });
    },
    async (args) => {
      const config = readConfig(args.config, args);
      const accountId = await requireAuth(config);
      await getWorkerNamespaceInfo(accountId, args.name);
      await sendMetricsEvent("view dispatch namespace", {
        sendMetrics: config.send_metrics
      });
    }
  ).command(
    "create <name>",
    "Create a dispatch namespace",
    (yargs) => {
      return yargs.positional("name", {
        describe: "Name of the dispatch namespace",
        type: "string",
        demandOption: true
      });
    },
    async (args) => {
      await printWranglerBanner();
      const config = readConfig(args.config, args);
      const accountId = await requireAuth(config);
      await createWorkerNamespace(accountId, args.name);
      await sendMetricsEvent("create dispatch namespace", {
        sendMetrics: config.send_metrics
      });
    }
  ).command(
    "delete <name>",
    "Delete a dispatch namespace",
    (yargs) => {
      return yargs.positional("name", {
        describe: "Name of the dispatch namespace",
        type: "string",
        demandOption: true
      });
    },
    async (args) => {
      await printWranglerBanner();
      const config = readConfig(args.config, args);
      const accountId = await requireAuth(config);
      await deleteWorkerNamespace(accountId, args.name);
      await sendMetricsEvent("delete dispatch namespace", {
        sendMetrics: config.send_metrics
      });
    }
  ).command(
    "rename <old-name> <new-name>",
    "Rename a dispatch namespace",
    (yargs) => {
      return yargs.positional("old-name", {
        describe: "Name of the dispatch namespace",
        type: "string",
        demandOption: true
      }).positional("new-name", {
        describe: "New name of the dispatch namespace",
        type: "string",
        demandOption: true
      });
    },
    async (args) => {
      await printWranglerBanner();
      const config = readConfig(args.config, args);
      const accountId = await requireAuth(config);
      await renameWorkerNamespace(accountId, args.oldName, args.newName);
      await sendMetricsEvent("rename dispatch namespace", {
        sendMetrics: config.send_metrics
      });
    }
  );
}
__name(workerNamespaceCommands, "workerNamespaceCommands");

// src/docs/index.ts
init_import_meta_url();

// src/docs/helpers.ts
init_import_meta_url();
var import_node_assert15 = __toESM(require("node:assert"));
var import_undici13 = __toESM(require_undici());
async function runSearch(searchTerm) {
  const id = "8MU1G3QO9P";
  const index = "developers-cloudflare2";
  const key = "045e8dbec8c137a52f0f56e196d7abe0";
  const params = new URLSearchParams({
    query: searchTerm,
    hitsPerPage: "1",
    getRankingInfo: "0"
  });
  (0, import_node_assert15.default)(id, "Missing Algolia App ID");
  (0, import_node_assert15.default)(key, "Missing Algolia Key");
  const searchResp = await (0, import_undici13.fetch)(
    `https://${id}-dsn.algolia.net/1/indexes/${index}/query`,
    {
      method: "POST",
      body: JSON.stringify({
        params: params.toString()
      }),
      headers: {
        "X-Algolia-API-Key": key,
        "X-Algolia-Application-Id": id
      }
    }
  );
  if (!searchResp.ok) {
    logger.error(`Could not search the docs. Please try again later.`);
    return;
  }
  const searchData = await searchResp.json();
  logger.debug("searchData: ", searchData);
  if (searchData.hits[0]) {
    return searchData.hits[0].url;
  } else {
    logger.error(
      `Could not find docs for: ${searchTerm}. Please try again with another search term.`
    );
    return;
  }
}
__name(runSearch, "runSearch");

// src/docs/index.ts
function docsOptions(yargs) {
  return yargs.positional("command", {
    describe: "Enter the wrangler command you want to know more about",
    type: "string",
    array: true
  }).option("yes", {
    alias: "y",
    type: "boolean",
    description: "Takes you to the docs, even if search fails"
  });
}
__name(docsOptions, "docsOptions");
async function docsHandler(args) {
  let urlToOpen = args.yes || !args.command || args.command.length === 0 ? "https://developers.cloudflare.com/workers/wrangler/commands/" : "";
  if (args.command && args.command.length > 0) {
    const searchTerm = args.command.join(" ");
    const searchResult = await runSearch(searchTerm);
    urlToOpen = searchResult ?? urlToOpen;
  }
  if (!urlToOpen) {
    return;
  }
  await printWranglerBanner();
  logger.log(`Opening a link in your default browser: ${urlToOpen}`);
  await openInBrowser(urlToOpen);
  const config = readConfig(void 0, args);
  await sendMetricsEvent("view docs", {
    sendMetrics: config.send_metrics
  });
}
__name(docsHandler, "docsHandler");

// src/generate/index.ts
init_import_meta_url();
var import_node_fs24 = __toESM(require("node:fs"));
var import_node_path32 = __toESM(require("node:path"));
function generateOptions(yargs) {
  return yargs.positional("name", {
    describe: "Name of the Workers project",
    type: "string",
    demandOption: true
  }).positional("template", {
    type: "string",
    describe: "The URL of a GitHub template"
  }).option("type", {
    alias: "t",
    type: "string",
    hidden: true,
    deprecated: true
  }).option("site", {
    alias: "s",
    type: "boolean",
    hidden: true,
    deprecated: true
  });
}
__name(generateOptions, "generateOptions");
async function generateHandler2(args) {
  if (args.template === void 0) {
    return initHandler({
      name: args.name,
      site: void 0,
      yes: void 0,
      fromDash: void 0,
      delegateC3: false,
      v: void 0,
      config: void 0,
      env: void 0,
      type: void 0,
      _: args._,
      $0: args.$0,
      experimentalJsonConfig: false,
      experimentalVersions: args.experimentalVersions
    });
  }
  await printWranglerBanner();
  logger.warn(
    `The \`generate\` command is no longer supported and will be removed in a future version.`
    // TODO: recommend replacement commands
  );
  if (args.type) {
    let message = "The --type option is no longer supported.";
    if (args.type === "webpack") {
      message += "\nIf you wish to use webpack then you will need to create a custom build.";
    }
    throw new CommandLineArgsError(message);
  }
  if (args.name && isRemote(args.name)) {
    [args.template, args.name] = [args.name, args.template];
  }
  const creationDirectory = generateWorkerDirectoryName(args.name);
  if (args.site) {
    const gitDirectory = creationDirectory !== process.cwd() ? import_node_path32.default.basename(creationDirectory) : "my-site";
    const message = `The --site option is no longer supported.
If you wish to create a brand new Worker Sites project then clone the \`worker-sites-template\` starter repository:

\`\`\`
git clone --depth=1 --branch=wrangler2 https://github.com/cloudflare/worker-sites-template ${gitDirectory}
cd ${gitDirectory}
\`\`\`

Find out more about how to create and maintain Sites projects at https://developers.cloudflare.com/workers/platform/sites.
Have you considered using Cloudflare Pages instead? See https://pages.cloudflare.com/.`;
    throw new CommandLineArgsError(message);
  }
  logger.log(
    `Creating a worker in ${import_node_path32.default.basename(creationDirectory)} from ${args.template}`
  );
  const { remote, subdirectory } = parseTemplatePath(args.template);
  await cloneIntoDirectory(remote, creationDirectory, subdirectory);
  await initializeGit(creationDirectory);
  logger.log("\u2728 Success!");
}
__name(generateHandler2, "generateHandler");
function generateWorkerDirectoryName(workerName) {
  let workerDirectoryPath = import_node_path32.default.resolve(process.cwd(), workerName);
  let i = 1;
  while (import_node_fs24.default.existsSync(workerDirectoryPath)) {
    workerDirectoryPath = import_node_path32.default.resolve(process.cwd(), `${workerName}-${i}`);
    i++;
  }
  return workerDirectoryPath;
}
__name(generateWorkerDirectoryName, "generateWorkerDirectoryName");
function isRemote(arg) {
  return /^(https?|ftps?|file|git|ssh):\/\//.test(arg) || arg.includes(":");
}
__name(isRemote, "isRemote");
var TEMPLATE_REGEX = /^(?:(?:https:\/\/)?(?<httpsUrl>[^:/]+\.[^:/]+)\/|git@(?<gitUrl>[^:/]+)[:/]|(?<shorthandUrl>[^/]+):)?(?<user>[^/\s]+)\/(?<repository>[^/\s#]+)(?:(?<subdirectoryPath>(?:\/[^/\s#]+)+))?(?:\/)?(?:#(?<tag>.+))?/;
function toUrlBase({ httpsUrl, gitUrl, shorthandUrl }) {
  if (httpsUrl !== void 0) {
    return `https://${httpsUrl}`;
  }
  if (gitUrl !== void 0) {
    return `git@${gitUrl}`;
  }
  if (shorthandUrl !== void 0) {
    switch (shorthandUrl) {
      case "github":
      case "gh":
        return "https://github.com";
      case "gitlab":
      case "gl":
        return "https://gitlab.com";
      case "bitbucket":
      case "bb":
        return "https://bitbucket.org";
      default:
        throw new UserError(
          `Unable to parse shorthand ${shorthandUrl}. Supported options are "bitbucket" ("bb"), "github" ("gh"), and "gitlab" ("gl")`
        );
    }
  }
  return "https://github.com";
}
__name(toUrlBase, "toUrlBase");
function parseTemplatePath(templatePath) {
  if (!templatePath.includes("/")) {
    return {
      remote: "https://github.com/cloudflare/workers-sdk.git",
      subdirectory: `templates/${templatePath}`
    };
  }
  const groups = TEMPLATE_REGEX.exec(templatePath)?.groups;
  if (!groups) {
    throw new UserError(`Unable to parse ${templatePath} as a template`);
  }
  const { user, repository, subdirectoryPath, tag, ...urlGroups } = groups;
  const urlBase = toUrlBase(urlGroups);
  const isHttp = urlBase.startsWith("http");
  const remote = `${urlBase}${isHttp ? "/" : ":"}${user}/${repository}.git${tag ? `#${tag}` : ""}`;
  const subdirectory = subdirectoryPath?.slice(1);
  return { remote, subdirectory };
}
__name(parseTemplatePath, "parseTemplatePath");

// src/hyperdrive/index.ts
init_import_meta_url();

// src/hyperdrive/create.ts
init_import_meta_url();

// src/hyperdrive/client.ts
init_import_meta_url();
async function createConfig(config, body) {
  const accountId = await requireAuth(config);
  return await fetchResult(`/accounts/${accountId}/hyperdrive/configs`, {
    method: "POST",
    body: JSON.stringify(body)
  });
}
__name(createConfig, "createConfig");
async function deleteConfig(config, id) {
  const accountId = await requireAuth(config);
  return await fetchResult(`/accounts/${accountId}/hyperdrive/configs/${id}`, {
    method: "DELETE"
  });
}
__name(deleteConfig, "deleteConfig");
async function getConfig(config, id) {
  const accountId = await requireAuth(config);
  return await fetchResult(`/accounts/${accountId}/hyperdrive/configs/${id}`, {
    method: "GET"
  });
}
__name(getConfig, "getConfig");
async function listConfigs(config) {
  const accountId = await requireAuth(config);
  return await fetchResult(`/accounts/${accountId}/hyperdrive/configs`, {
    method: "GET"
  });
}
__name(listConfigs, "listConfigs");
async function patchConfig(config, id, body) {
  const accountId = await requireAuth(config);
  return await fetchResult(`/accounts/${accountId}/hyperdrive/configs/${id}`, {
    method: "PATCH",
    body: JSON.stringify(body)
  });
}
__name(patchConfig, "patchConfig");

// src/hyperdrive/create.ts
function options12(yargs) {
  return yargs.positional("name", {
    type: "string",
    demandOption: true,
    description: "The name of the Hyperdrive config"
  }).options({
    "connection-string": {
      type: "string",
      demandOption: true,
      describe: "The connection string for the database you want Hyperdrive to connect to - ex: protocol://user:password@host:port/database"
    },
    "caching-disabled": {
      type: "boolean",
      describe: "Disables the caching of SQL responses",
      default: false
    },
    "max-age": {
      type: "number",
      describe: "Specifies max duration for which items should persist in the cache, cannot be set when caching is disabled"
    },
    swr: {
      type: "number",
      describe: "Indicates the number of seconds cache may serve the response after it becomes stale, cannot be set when caching is disabled"
    }
  });
}
__name(options12, "options");
async function handler13(args) {
  const config = readConfig(args.config, args);
  const url4 = new URL(args.connectionString);
  if (url4.port === "" && (url4.protocol == "postgresql:" || url4.protocol == "postgres:")) {
    url4.port = "5432";
  }
  if (url4.protocol === "") {
    logger.log("You must specify the database protocol - e.g. 'postgresql'.");
  } else if (url4.protocol !== "postgresql:" && url4.protocol !== "postgres:") {
    logger.log(
      "Only PostgreSQL or PostgreSQL compatible databases are currently supported."
    );
  } else if (url4.host === "") {
    logger.log(
      "You must provide a hostname or IP address in your connection string - e.g. 'user:password@database-hostname.example.com:5432/databasename"
    );
  } else if (url4.port === "") {
    logger.log(
      "You must provide a port number - e.g. 'user:password@database.example.com:port/databasename"
    );
  } else if (url4.pathname === "") {
    logger.log(
      "You must provide a database name as the path component - e.g. /postgres"
    );
  } else if (url4.username === "") {
    logger.log(
      "You must provide a username - e.g. 'user:password@database.example.com:port/databasename'"
    );
  } else if (url4.password === "") {
    logger.log(
      "You must provide a password - e.g. 'user:password@database.example.com:port/databasename' "
    );
  } else {
    logger.log(`\u{1F6A7} Creating '${args.name}'`);
    const database = await createConfig(config, {
      name: args.name,
      origin: {
        host: url4.hostname,
        port: parseInt(url4.port),
        scheme: url4.protocol.replace(":", ""),
        database: decodeURIComponent(url4.pathname.replace("/", "")),
        user: decodeURIComponent(url4.username),
        password: decodeURIComponent(url4.password)
      },
      caching: {
        disabled: args.cachingDisabled,
        max_age: args.maxAge,
        stale_while_revalidate: args.swr
      }
    });
    logger.log(
      `\u2705 Created new Hyperdrive config
`,
      JSON.stringify(database, null, 2)
    );
  }
}
__name(handler13, "handler");

// src/hyperdrive/delete.ts
init_import_meta_url();
function options13(yargs) {
  return yargs.positional("id", {
    type: "string",
    demandOption: true,
    description: "The ID of the Hyperdrive config"
  });
}
__name(options13, "options");
async function handler14(args) {
  const config = readConfig(args.config, args);
  logger.log(`\u{1F5D1}\uFE0F Deleting Hyperdrive database config ${args.id}`);
  await deleteConfig(config, args.id);
  logger.log(`\u2705 Deleted`);
}
__name(handler14, "handler");

// src/hyperdrive/get.ts
init_import_meta_url();
function options14(yargs) {
  return yargs.positional("id", {
    type: "string",
    demandOption: true,
    description: "The ID of the Hyperdrive config"
  });
}
__name(options14, "options");
async function handler15(args) {
  const config = readConfig(args.config, args);
  const database = await getConfig(config, args.id);
  logger.log(JSON.stringify(database, null, 2));
}
__name(handler15, "handler");

// src/hyperdrive/list.ts
init_import_meta_url();
function options15(yargs) {
  return yargs;
}
__name(options15, "options");
async function handler16(args) {
  const config = readConfig(args.config, args);
  logger.log(`\u{1F4CB} Listing Hyperdrive configs`);
  const databases = await listConfigs(config);
  logger.table(
    databases.map((database) => ({
      id: database.id,
      name: database.name,
      user: database.origin.user ?? "",
      host: database.origin.host ?? "",
      port: database.origin.port?.toString() ?? "",
      database: database.origin.database ?? "",
      caching: JSON.stringify(database.caching)
    }))
  );
}
__name(handler16, "handler");

// src/hyperdrive/update.ts
init_import_meta_url();
function options16(yargs) {
  return yargs.positional("id", {
    type: "string",
    demandOption: true,
    description: "The ID of the Hyperdrive config"
  }).options({
    name: { type: "string", describe: "Give your config a new name" },
    "origin-host": {
      type: "string",
      describe: "The host of the origin database"
    },
    "origin-port": {
      type: "number",
      describe: "The port number of the origin database"
    },
    "origin-scheme": {
      type: "string",
      describe: "The scheme used to connect to the origin database - e.g. postgresql or postgres"
    },
    database: {
      type: "string",
      describe: "The name of the database within the origin database"
    },
    "origin-user": {
      type: "string",
      describe: "The username used to connect to the origin database"
    },
    "origin-password": {
      type: "string",
      describe: "The password used to connect to the origin database"
    },
    "caching-disabled": {
      type: "boolean",
      describe: "Disables the caching of SQL responses",
      default: false
    },
    "max-age": {
      type: "number",
      describe: "Specifies max duration for which items should persist in the cache, cannot be set when caching is disabled"
    },
    swr: {
      type: "number",
      describe: "Indicates the number of seconds cache may serve the response after it becomes stale, cannot be set when caching is disabled"
    }
  });
}
__name(options16, "options");
var requiredOriginOptions = [
  "originHost",
  "originPort",
  "database",
  "originUser",
  "originPassword"
];
function camelToKebab(str) {
  return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
}
__name(camelToKebab, "camelToKebab");
function isOptionSet(args, key) {
  return key in args && args[key] !== void 0;
}
__name(isOptionSet, "isOptionSet");
async function handler17(args) {
  const allOriginFieldsSet = requiredOriginOptions.every(
    (field) => isOptionSet(args, field)
  );
  const noOriginFieldSet = requiredOriginOptions.every(
    (field) => !isOptionSet(args, field)
  );
  if (!allOriginFieldsSet && !noOriginFieldSet) {
    throw new UserError(
      `When updating the origin, all of the following must be set: ${requiredOriginOptions.map((option) => camelToKebab(option)).join(", ")}`
    );
  }
  const config = readConfig(args.config, args);
  logger.log(`\u{1F6A7} Updating '${args.id}'`);
  const database = {};
  if (args.name !== void 0) {
    database.name = args.name;
  }
  if (allOriginFieldsSet) {
    database.origin = {
      scheme: args.originScheme ?? "postgresql",
      host: args.originHost,
      port: args.originPort,
      database: args.database,
      user: args.originUser,
      password: args.originPassword
    };
  }
  database.caching = {
    disabled: args.cachingDisabled,
    max_age: args.maxAge,
    stale_while_revalidate: args.swr
  };
  const updated = await patchConfig(config, args.id, database);
  logger.log(
    `\u2705 Updated ${updated.id} Hyperdrive config
`,
    JSON.stringify(updated, null, 2)
  );
}
__name(handler17, "handler");

// src/hyperdrive/index.ts
function hyperdrive(yargs) {
  return yargs.command(
    "create <name>",
    "Create a Hyperdrive config",
    options12,
    handler13
  ).command(
    "delete <id>",
    "Delete a Hyperdrive config",
    options13,
    handler14
  ).command("get <id>", "Get a Hyperdrive config", options14, handler15).command("list", "List Hyperdrive configs", options15, handler16).command(
    "update <id>",
    "Update a Hyperdrive config",
    options16,
    handler17
  );
}
__name(hyperdrive, "hyperdrive");

// src/kv/index.ts
init_import_meta_url();
var import_node_buffer4 = require("node:buffer");
var import_consumers = require("node:stream/consumers");
var import_node_string_decoder = require("node:string_decoder");

// src/utils/getValidBindingName.ts
init_import_meta_url();
function getValidBindingName(name, fallback) {
  let bindingName = name.replace(/[\s-]/g, "_");
  bindingName = bindingName.replace(/[^a-zA-Z0-9_]/g, "");
  bindingName = bindingName.replace(/_+/g, "_");
  if (/^[0-9]/.test(bindingName)) {
    bindingName = "_" + bindingName;
  }
  if (!bindingName.length || /^_+$/.test(bindingName)) {
    return fallback;
  }
  return bindingName;
}
__name(getValidBindingName, "getValidBindingName");

// src/kv/index.ts
function kvNamespace(kvYargs) {
  return kvYargs.command(
    "create <namespace>",
    "Create a new namespace",
    (yargs) => {
      return yargs.positional("namespace", {
        describe: "The name of the new namespace",
        type: "string",
        demandOption: true
      }).option("preview", {
        type: "boolean",
        describe: "Interact with a preview namespace"
      });
    },
    async (args) => {
      await printWranglerBanner();
      const config = readConfig(args.config, args);
      if (!config.name) {
        logger.warn(
          "No configured name present, using `worker` as a prefix for the title"
        );
      }
      const name = config.name || "worker";
      const environment = args.env ? `-${args.env}` : "";
      const preview = args.preview ? "_preview" : "";
      const title = `${name}${environment}-${args.namespace}${preview}`;
      const accountId = await requireAuth(config);
      logger.log(`\u{1F300} Creating namespace with title "${title}"`);
      const namespaceId = await createKVNamespace(accountId, title);
      await sendMetricsEvent("create kv namespace", {
        sendMetrics: config.send_metrics
      });
      logger.log("\u2728 Success!");
      const envString = args.env ? ` under [env.${args.env}]` : "";
      const previewString = args.preview ? "preview_" : "";
      logger.log(
        `Add the following to your configuration file in your kv_namespaces array${envString}:`
      );
      logger.log(
        `{ binding = "${getValidBindingName(
          args.namespace,
          "KV"
        )}", ${previewString}id = "${namespaceId}" }`
      );
    }
  ).command(
    "list",
    "Outputs a list of all KV namespaces associated with your account id.",
    (listArgs) => listArgs,
    async (args) => {
      const config = readConfig(args.config, args);
      const accountId = await requireAuth(config);
      logger.log(
        JSON.stringify(await listKVNamespaces(accountId), null, "  ")
      );
      await sendMetricsEvent("list kv namespaces", {
        sendMetrics: config.send_metrics
      });
    }
  ).command(
    "delete",
    "Deletes a given namespace.",
    (yargs) => {
      return yargs.option("binding", {
        type: "string",
        requiresArg: true,
        describe: "The name of the namespace to delete"
      }).option("namespace-id", {
        type: "string",
        requiresArg: true,
        describe: "The id of the namespace to delete"
      }).check(demandOneOfOption("binding", "namespace-id")).option("preview", {
        type: "boolean",
        describe: "Interact with a preview namespace"
      });
    },
    async (args) => {
      await printWranglerBanner();
      const config = readConfig(args.config, args);
      let id;
      try {
        id = getKVNamespaceId(args, config);
      } catch (e3) {
        throw new CommandLineArgsError(
          "Not able to delete namespace.\n" + (e3.message ?? e3)
        );
      }
      const accountId = await requireAuth(config);
      logger.log(`Deleting KV namespace ${id}.`);
      await deleteKVNamespace(accountId, id);
      logger.log(`Deleted KV namespace ${id}.`);
      await sendMetricsEvent("delete kv namespace", {
        sendMetrics: config.send_metrics
      });
    }
  );
}
__name(kvNamespace, "kvNamespace");
var kvKey = /* @__PURE__ */ __name((kvYargs) => {
  return kvYargs.command(
    "put <key> [value]",
    "Writes a single key/value pair to the given namespace.",
    (yargs) => {
      return yargs.positional("key", {
        type: "string",
        describe: "The key to write to",
        demandOption: true
      }).positional("value", {
        type: "string",
        describe: "The value to write"
      }).option("binding", {
        type: "string",
        requiresArg: true,
        describe: "The binding of the namespace to write to"
      }).option("namespace-id", {
        type: "string",
        requiresArg: true,
        describe: "The id of the namespace to write to"
      }).check(demandOneOfOption("binding", "namespace-id")).option("preview", {
        type: "boolean",
        describe: "Interact with a preview namespace"
      }).option("ttl", {
        type: "number",
        describe: "Time for which the entries should be visible"
      }).option("expiration", {
        type: "number",
        describe: "Time since the UNIX epoch after which the entry expires"
      }).option("metadata", {
        type: "string",
        describe: "Arbitrary JSON that is associated with a key",
        coerce: (jsonStr) => {
          try {
            return JSON.parse(jsonStr);
          } catch (_3) {
          }
        }
      }).option("path", {
        type: "string",
        requiresArg: true,
        describe: "Read value from the file at a given path"
      }).option("local", {
        type: "boolean",
        describe: "Interact with local storage"
      }).option("persist-to", {
        type: "string",
        describe: "Directory for local persistence"
      }).check(demandOneOfOption("value", "path"));
    },
    async ({ key, ttl, expiration, metadata, ...args }) => {
      await printWranglerBanner();
      const config = readConfig(args.config, args);
      const namespaceId = getKVNamespaceId(args, config);
      const value = args.path ? readFileSyncToBuffer(args.path) : (
        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
        args.value
      );
      const metadataLog = metadata ? ` with metadata "${JSON.stringify(metadata)}"` : "";
      if (args.path) {
        logger.log(
          `Writing the contents of ${args.path} to the key "${key}" on namespace ${namespaceId}${metadataLog}.`
        );
      } else {
        logger.log(
          `Writing the value "${value}" to key "${key}" on namespace ${namespaceId}${metadataLog}.`
        );
      }
      let metricEvent;
      if (args.local) {
        await usingLocalNamespace(
          args.persistTo,
          config.configPath,
          namespaceId,
          (namespace) => namespace.put(key, new import_node_buffer4.Blob([value]).stream(), {
            expiration,
            expirationTtl: ttl,
            metadata
          })
        );
        metricEvent = "write kv key-value (local)";
      } else {
        const accountId = await requireAuth(config);
        await putKVKeyValue(accountId, namespaceId, {
          key,
          value,
          expiration,
          expiration_ttl: ttl,
          metadata
        });
        metricEvent = "write kv key-value";
      }
      await sendMetricsEvent(metricEvent, {
        sendMetrics: config.send_metrics
      });
    }
  ).command(
    "list",
    "Outputs a list of all keys in a given namespace.",
    (yargs) => {
      return yargs.option("binding", {
        type: "string",
        requiresArg: true,
        describe: "The name of the namespace to list"
      }).option("namespace-id", {
        type: "string",
        requiresArg: true,
        describe: "The id of the namespace to list"
      }).check(demandOneOfOption("binding", "namespace-id")).option("preview", {
        type: "boolean",
        // In the case of listing keys we will default to non-preview mode
        default: false,
        describe: "Interact with a preview namespace"
      }).option("prefix", {
        type: "string",
        requiresArg: true,
        describe: "A prefix to filter listed keys"
      }).option("local", {
        type: "boolean",
        describe: "Interact with local storage"
      }).option("persist-to", {
        type: "string",
        describe: "Directory for local persistence"
      });
    },
    async ({ prefix, ...args }) => {
      const config = readConfig(args.config, args);
      const namespaceId = getKVNamespaceId(args, config);
      let result;
      let metricEvent;
      if (args.local) {
        const listResult = await usingLocalNamespace(
          args.persistTo,
          config.configPath,
          namespaceId,
          (namespace) => namespace.list({ prefix })
        );
        result = listResult.keys;
        metricEvent = "list kv keys (local)";
      } else {
        const accountId = await requireAuth(config);
        result = await listKVNamespaceKeys(accountId, namespaceId, prefix);
        metricEvent = "list kv keys";
      }
      logger.log(JSON.stringify(result, void 0, 2));
      await sendMetricsEvent(metricEvent, {
        sendMetrics: config.send_metrics
      });
    }
  ).command(
    "get <key>",
    "Reads a single value by key from the given namespace.",
    (yargs) => {
      return yargs.positional("key", {
        describe: "The key value to get.",
        type: "string",
        demandOption: true
      }).option("binding", {
        type: "string",
        requiresArg: true,
        describe: "The name of the namespace to get from"
      }).option("namespace-id", {
        type: "string",
        requiresArg: true,
        describe: "The id of the namespace to get from"
      }).check(demandOneOfOption("binding", "namespace-id")).option("preview", {
        type: "boolean",
        describe: "Interact with a preview namespace"
      }).option("preview", {
        type: "boolean",
        // In the case of getting key values we will default to non-preview mode
        default: false,
        describe: "Interact with a preview namespace"
      }).option("text", {
        type: "boolean",
        default: false,
        describe: "Decode the returned value as a utf8 string"
      }).option("local", {
        type: "boolean",
        describe: "Interact with local storage"
      }).option("persist-to", {
        type: "string",
        describe: "Directory for local persistence"
      });
    },
    async ({ key, ...args }) => {
      const config = readConfig(args.config, args);
      const namespaceId = getKVNamespaceId(args, config);
      let bufferKVValue;
      let metricEvent;
      if (args.local) {
        const val = await usingLocalNamespace(
          args.persistTo,
          config.configPath,
          namespaceId,
          async (namespace) => {
            const stream2 = await namespace.get(key, "stream");
            return stream2 === null ? null : await (0, import_consumers.arrayBuffer)(stream2);
          }
        );
        if (val === null) {
          logger.log("Value not found");
          return;
        }
        bufferKVValue = Buffer.from(val);
        metricEvent = "read kv value (local)";
      } else {
        const accountId = await requireAuth(config);
        bufferKVValue = Buffer.from(
          await getKVKeyValue(accountId, namespaceId, key)
        );
        metricEvent = "read kv value";
      }
      if (args.text) {
        const decoder = new import_node_string_decoder.StringDecoder("utf8");
        logger.log(decoder.write(bufferKVValue));
      } else {
        process.stdout.write(bufferKVValue);
      }
      await sendMetricsEvent(metricEvent, {
        sendMetrics: config.send_metrics
      });
    }
  ).command(
    "delete <key>",
    "Removes a single key value pair from the given namespace.",
    (yargs) => {
      return yargs.positional("key", {
        describe: "The key value to delete",
        type: "string",
        demandOption: true
      }).option("binding", {
        type: "string",
        requiresArg: true,
        describe: "The name of the namespace to delete from"
      }).option("namespace-id", {
        type: "string",
        requiresArg: true,
        describe: "The id of the namespace to delete from"
      }).check(demandOneOfOption("binding", "namespace-id")).option("preview", {
        type: "boolean",
        describe: "Interact with a preview namespace"
      }).option("local", {
        type: "boolean",
        describe: "Interact with local storage"
      }).option("persist-to", {
        type: "string",
        describe: "Directory for local persistence"
      });
    },
    async ({ key, ...args }) => {
      await printWranglerBanner();
      const config = readConfig(args.config, args);
      const namespaceId = getKVNamespaceId(args, config);
      logger.log(`Deleting the key "${key}" on namespace ${namespaceId}.`);
      let metricEvent;
      if (args.local) {
        await usingLocalNamespace(
          args.persistTo,
          config.configPath,
          namespaceId,
          (namespace) => namespace.delete(key)
        );
        metricEvent = "delete kv key-value (local)";
      } else {
        const accountId = await requireAuth(config);
        await deleteKVKeyValue(accountId, namespaceId, key);
        metricEvent = "delete kv key-value";
      }
      await sendMetricsEvent(metricEvent, {
        sendMetrics: config.send_metrics
      });
    }
  );
}, "kvKey");
var kvBulk = /* @__PURE__ */ __name((kvYargs) => {
  return kvYargs.command(
    "put <filename>",
    "Upload multiple key-value pairs to a namespace",
    (yargs) => {
      return yargs.positional("filename", {
        describe: `The JSON file of key-value pairs to upload, in form [{"key":..., "value":...}"...]`,
        type: "string",
        demandOption: true
      }).option("binding", {
        type: "string",
        requiresArg: true,
        describe: "The name of the namespace to insert values into"
      }).option("namespace-id", {
        type: "string",
        requiresArg: true,
        describe: "The id of the namespace to insert values into"
      }).check(demandOneOfOption("binding", "namespace-id")).option("preview", {
        type: "boolean",
        describe: "Interact with a preview namespace"
      }).option("local", {
        type: "boolean",
        describe: "Interact with local storage"
      }).option("persist-to", {
        type: "string",
        describe: "Directory for local persistence"
      });
    },
    async ({ filename, ...args }) => {
      await printWranglerBanner();
      const config = readConfig(args.config, args);
      const namespaceId = getKVNamespaceId(args, config);
      const content = parseJSON(readFileSync5(filename), filename);
      if (!Array.isArray(content)) {
        throw new UserError(
          `Unexpected JSON input from "${filename}".
Expected an array of key-value objects but got type "${typeof content}".`
        );
      }
      const errors = [];
      const warnings = [];
      for (let i = 0; i < content.length; i++) {
        const keyValue = content[i];
        if (!isKVKeyValue(keyValue)) {
          errors.push(
            `The item at index ${i} is ${JSON.stringify(keyValue)}`
          );
        } else {
          const props = unexpectedKVKeyValueProps(keyValue);
          if (props.length > 0) {
            warnings.push(
              `The item at index ${i} contains unexpected properties: ${JSON.stringify(
                props
              )}.`
            );
          }
        }
      }
      if (warnings.length > 0) {
        logger.warn(
          `Unexpected key-value properties in "${filename}".
` + warnings.join("\n")
        );
      }
      if (errors.length > 0) {
        throw new UserError(
          `Unexpected JSON input from "${filename}".
Each item in the array should be an object that matches:

interface KeyValue {
  key: string;
  value: string;
  expiration?: number;
  expiration_ttl?: number;
  metadata?: object;
  base64?: boolean;
}

` + errors.join("\n")
        );
      }
      let metricEvent;
      if (args.local) {
        await usingLocalNamespace(
          args.persistTo,
          config.configPath,
          namespaceId,
          async (namespace) => {
            for (const value of content) {
              await namespace.put(value.key, value.value, {
                expiration: value.expiration,
                expirationTtl: value.expiration_ttl,
                metadata: value.metadata
              });
            }
          }
        );
        metricEvent = "write kv key-values (bulk) (local)";
      } else {
        const accountId = await requireAuth(config);
        await putKVBulkKeyValue(accountId, namespaceId, content);
        metricEvent = "write kv key-values (bulk)";
      }
      await sendMetricsEvent(metricEvent, {
        sendMetrics: config.send_metrics
      });
      logger.log("Success!");
    }
  ).command(
    "delete <filename>",
    "Delete multiple key-value pairs from a namespace",
    (yargs) => {
      return yargs.positional("filename", {
        describe: `The JSON file of keys to delete, in the form ["key1", "key2", ...]`,
        type: "string",
        demandOption: true
      }).option("binding", {
        type: "string",
        requiresArg: true,
        describe: "The name of the namespace to delete from"
      }).option("namespace-id", {
        type: "string",
        requiresArg: true,
        describe: "The id of the namespace to delete from"
      }).check(demandOneOfOption("binding", "namespace-id")).option("preview", {
        type: "boolean",
        describe: "Interact with a preview namespace"
      }).option("force", {
        type: "boolean",
        alias: "f",
        describe: "Do not ask for confirmation before deleting"
      }).option("local", {
        type: "boolean",
        describe: "Interact with local storage"
      }).option("persist-to", {
        type: "string",
        describe: "Directory for local persistence"
      });
    },
    async ({ filename, ...args }) => {
      await printWranglerBanner();
      const config = readConfig(args.config, args);
      const namespaceId = getKVNamespaceId(args, config);
      if (!args.force) {
        const result = await confirm(
          `Are you sure you want to delete all the keys read from "${filename}" from kv-namespace with id "${namespaceId}"?`
        );
        if (!result) {
          logger.log(`Not deleting keys read from "${filename}".`);
          return;
        }
      }
      const content = parseJSON(readFileSync5(filename), filename);
      if (!Array.isArray(content)) {
        throw new UserError(
          `Unexpected JSON input from "${filename}".
Expected an array of strings but got:
${content}`
        );
      }
      const errors = [];
      for (let i = 0; i < content.length; i++) {
        const key = content[i];
        if (typeof key !== "string") {
          errors.push(
            `The item at index ${i} is type: "${typeof key}" - ${JSON.stringify(
              key
            )}`
          );
        }
      }
      if (errors.length > 0) {
        throw new UserError(
          `Unexpected JSON input from "${filename}".
Expected an array of strings.
` + errors.join("\n")
        );
      }
      let metricEvent;
      if (args.local) {
        await usingLocalNamespace(
          args.persistTo,
          config.configPath,
          namespaceId,
          async (namespace) => {
            for (const key of content)
              await namespace.delete(key);
          }
        );
        metricEvent = "delete kv key-values (bulk) (local)";
      } else {
        const accountId = await requireAuth(config);
        await deleteKVBulkKeyValue(accountId, namespaceId, content);
        metricEvent = "delete kv key-values (bulk)";
      }
      await sendMetricsEvent(metricEvent, {
        sendMetrics: config.send_metrics
      });
      logger.log("Success!");
    }
  );
}, "kvBulk");

// src/mtls-certificate/cli.ts
init_import_meta_url();

// src/api/mtls-certificate.ts
init_import_meta_url();
var ErrorMTlsCertificateNameNotFound = class extends UserError {
};
__name(ErrorMTlsCertificateNameNotFound, "ErrorMTlsCertificateNameNotFound");
var ErrorMTlsCertificateManyNamesMatch = class extends UserError {
};
__name(ErrorMTlsCertificateManyNamesMatch, "ErrorMTlsCertificateManyNamesMatch");
async function uploadMTlsCertificateFromFs(accountId, details) {
  return await uploadMTlsCertificate(accountId, {
    certificateChain: readFileSync5(details.certificateChainFilename),
    privateKey: readFileSync5(details.privateKeyFilename),
    name: details.name
  });
}
__name(uploadMTlsCertificateFromFs, "uploadMTlsCertificateFromFs");
async function uploadMTlsCertificate(accountId, body) {
  return await fetchResult(`/accounts/${accountId}/mtls_certificates`, {
    method: "POST",
    body: JSON.stringify({
      name: body.name,
      certificates: body.certificateChain,
      private_key: body.privateKey,
      ca: false
    })
  });
}
__name(uploadMTlsCertificate, "uploadMTlsCertificate");
async function getMTlsCertificate(accountId, id) {
  return await fetchResult(
    `/accounts/${accountId}/mtls_certificates/${id}`,
    {}
  );
}
__name(getMTlsCertificate, "getMTlsCertificate");
async function listMTlsCertificates(accountId, filter) {
  const params = new URLSearchParams();
  params.append("ca", "false");
  if (filter.name) {
    params.append("name", filter.name);
  }
  return await fetchResult(
    `/accounts/${accountId}/mtls_certificates`,
    {},
    params
  );
}
__name(listMTlsCertificates, "listMTlsCertificates");
async function getMTlsCertificateByName(accountId, name) {
  const certificates = await listMTlsCertificates(accountId, { name });
  if (certificates.length === 0) {
    throw new ErrorMTlsCertificateNameNotFound(
      `certificate not found with name "${name}"`
    );
  }
  if (certificates.length > 1) {
    throw new ErrorMTlsCertificateManyNamesMatch(
      `multiple certificates found with name "${name}"`
    );
  }
  const certificate = certificates[0];
  return certificate;
}
__name(getMTlsCertificateByName, "getMTlsCertificateByName");
async function deleteMTlsCertificate(accountId, certificateId) {
  return await fetchResult(
    `/accounts/${accountId}/mtls_certificates/${certificateId}`,
    { method: "DELETE" }
  );
}
__name(deleteMTlsCertificate, "deleteMTlsCertificate");

// src/mtls-certificate/cli.ts
function uploadMTlsCertificateOptions(yargs) {
  return yargs.option("cert", {
    describe: "The path to a certificate file (.pem) containing a chain of certificates to upload",
    type: "string",
    demandOption: true
  }).option("key", {
    describe: "The path to a file containing the private key for your leaf certificate",
    type: "string",
    demandOption: true
  }).option("name", {
    describe: "The name for the certificate",
    type: "string"
  });
}
__name(uploadMTlsCertificateOptions, "uploadMTlsCertificateOptions");
var uploadMTlsCertificateHandler = withConfig(async ({ config, cert, key, name }) => {
  const accountId = await requireAuth(config);
  logger.log(
    name ? `Uploading mTLS Certificate ${name}...` : `Uploading mTLS Certificate...`
  );
  const certResponse = await uploadMTlsCertificateFromFs(accountId, {
    certificateChainFilename: cert,
    privateKeyFilename: key,
    name
  });
  const expiresOn = new Date(certResponse.expires_on).toLocaleDateString();
  logger.log(
    name ? `Success! Uploaded mTLS Certificate ${name}` : `Success! Uploaded mTLS Certificate`
  );
  logger.log(`ID: ${certResponse.id}`);
  logger.log(`Issuer: ${certResponse.issuer}`);
  logger.log(`Expires on ${expiresOn}`);
});
var listMTlsCertificatesHandler = withConfig(async ({ config }) => {
  const accountId = await requireAuth(config);
  const certificates = await listMTlsCertificates(accountId, {});
  for (const certificate of certificates) {
    logger.log(`ID: ${certificate.id}`);
    if (certificate.name) {
      logger.log(`Name: ${certificate.name}`);
    }
    logger.log(`Issuer: ${certificate.issuer}`);
    logger.log(
      `Created on: ${new Date(certificate.uploaded_on).toLocaleDateString()}`
    );
    logger.log(
      `Expires on: ${new Date(certificate.expires_on).toLocaleDateString()}`
    );
    logger.log("\n");
  }
});
function deleteMTlsCertificateOptions(yargs) {
  return yargs.option("id", {
    describe: "The id of the mTLS certificate to delete",
    type: "string"
  }).option("name", {
    describe: "The name of the mTLS certificate record to delete",
    type: "string"
  });
}
__name(deleteMTlsCertificateOptions, "deleteMTlsCertificateOptions");
var deleteMTlsCertificateHandler = withConfig(async ({ config, id, name }) => {
  const accountId = await requireAuth(config);
  if (id && name) {
    return logger.error(`Error: can't provide both --id and --name.`);
  } else if (!id && !name) {
    return logger.error(`Error: must provide --id or --name.`);
  }
  let certificate;
  if (id) {
    certificate = await getMTlsCertificate(accountId, id);
  } else {
    certificate = await getMTlsCertificateByName(accountId, name);
  }
  const response = await confirm(
    certificate.name ? `Are you sure you want to delete certificate ${certificate.id} (${certificate.name})?` : `Are you sure you want to delete certificate ${certificate.id}?`
  );
  if (!response) {
    logger.log("Not deleting");
    return;
  }
  await deleteMTlsCertificate(accountId, certificate.id);
  logger.log(
    certificate.name ? `Deleted certificate ${certificate.id} (${certificate.name}) successfully` : `Deleted certificate ${certificate.id} successfully`
  );
});
var mTlsCertificateCommands = /* @__PURE__ */ __name((yargs) => {
  yargs.command(
    "upload",
    "Upload an mTLS certificate",
    uploadMTlsCertificateOptions,
    uploadMTlsCertificateHandler
  );
  yargs.command(
    "list",
    "List uploaded mTLS certificates",
    (a) => a,
    listMTlsCertificatesHandler
  );
  yargs.command(
    "delete",
    "Delete an mTLS certificate",
    deleteMTlsCertificateOptions,
    deleteMTlsCertificateHandler
  );
}, "mTlsCertificateCommands");

// src/pages/index.ts
init_import_meta_url();

// src/pages/build.ts
init_import_meta_url();
var import_node_crypto6 = require("node:crypto");
var import_node_fs27 = require("node:fs");
var import_promises13 = require("node:fs/promises");
var import_node_path41 = __toESM(require("node:path"));

// src/api/pages/create-worker-bundle-contents.ts
init_import_meta_url();
var import_node_fs25 = require("node:fs");
var import_node_path33 = __toESM(require("node:path"));
var import_undici14 = __toESM(require_undici());
async function createUploadWorkerBundleContents(workerBundle, config) {
  const workerBundleFormData = createWorkerBundleFormData(workerBundle, config);
  const metadata = JSON.parse(workerBundleFormData.get("metadata"));
  if (config === void 0) {
    delete metadata.bindings;
  }
  workerBundleFormData.set("metadata", JSON.stringify(metadata));
  return await new import_undici14.Response(workerBundleFormData).blob();
}
__name(createUploadWorkerBundleContents, "createUploadWorkerBundleContents");
function createWorkerBundleFormData(workerBundle, config) {
  const mainModule = {
    name: import_node_path33.default.basename(workerBundle.resolvedEntryPointPath),
    filePath: workerBundle.resolvedEntryPointPath,
    content: (0, import_node_fs25.readFileSync)(workerBundle.resolvedEntryPointPath, {
      encoding: "utf-8"
    }),
    type: workerBundle.bundleType || "esm"
  };
  const bindings = {
    kv_namespaces: config?.kv_namespaces,
    vars: config?.vars,
    browser: config?.browser,
    ai: config?.ai,
    version_metadata: config?.version_metadata,
    durable_objects: config?.durable_objects,
    queues: config?.queues.producers?.map((producer) => {
      return { binding: producer.binding, queue_name: producer.queue };
    }),
    r2_buckets: config?.r2_buckets,
    d1_databases: config?.d1_databases,
    vectorize: config?.vectorize,
    hyperdrive: config?.hyperdrive,
    services: config?.services,
    analytics_engine_datasets: config?.analytics_engine_datasets,
    mtls_certificates: config?.mtls_certificates,
    send_email: void 0,
    wasm_modules: void 0,
    text_blobs: void 0,
    data_blobs: void 0,
    constellation: void 0,
    dispatch_namespaces: void 0,
    logfwdr: void 0,
    unsafe: void 0
  };
  const placement = config?.placement?.mode === "smart" ? { mode: "smart" } : void 0;
  const worker = {
    name: mainModule.name,
    main: mainModule,
    modules: workerBundle.modules,
    bindings,
    migrations: void 0,
    compatibility_date: config?.compatibility_date,
    compatibility_flags: config?.compatibility_flags,
    usage_model: void 0,
    keepVars: void 0,
    keepSecrets: void 0,
    logpush: void 0,
    sourceMaps: void 0,
    placement,
    tail_consumers: void 0,
    limits: config?.limits
  };
  return createWorkerUploadForm(worker);
}
__name(createWorkerBundleFormData, "createWorkerBundleFormData");

// src/pages/buildFunctions.ts
init_import_meta_url();
var import_node_fs26 = require("node:fs");
var import_node_path40 = require("node:path");

// src/pages/functions/buildPlugin.ts
init_import_meta_url();
var import_promises10 = require("node:fs/promises");
var import_node_path36 = require("node:path");

// src/pages/utils.ts
init_import_meta_url();
var import_node_path34 = __toESM(require("node:path"));
var RUNNING_BUILDERS = [];
var CLEANUP_CALLBACKS = [];
var CLEANUP = /* @__PURE__ */ __name(() => {
  CLEANUP_CALLBACKS.forEach((callback) => callback());
  RUNNING_BUILDERS.forEach((builder) => builder.stop?.());
}, "CLEANUP");
function isUrl(maybeUrl) {
  if (!maybeUrl)
    return false;
  try {
    new URL(maybeUrl);
    return true;
  } catch (e3) {
    return false;
  }
}
__name(isUrl, "isUrl");
var projectRootCacheCwd;
var projectRootCache;
var tmpDirCacheProjectRoot;
var tmpDirCache;
function getPagesProjectRoot() {
  const cwd2 = process.cwd();
  if (projectRootCache !== void 0 && projectRootCacheCwd === cwd2) {
    return projectRootCache;
  }
  const packagePath = findUpSync("package.json");
  projectRootCache = packagePath ? import_node_path34.default.dirname(packagePath) : process.cwd();
  projectRootCacheCwd = cwd2;
  return projectRootCache;
}
__name(getPagesProjectRoot, "getPagesProjectRoot");
function getPagesTmpDir() {
  const projectRoot = getPagesProjectRoot();
  if (tmpDirCache !== void 0 && tmpDirCacheProjectRoot === projectRoot) {
    return tmpDirCache;
  }
  const tmpDir = getWranglerTmpDir(getPagesProjectRoot(), "pages");
  tmpDirCache = tmpDir.path;
  tmpDirCacheProjectRoot = projectRoot;
  return tmpDirCache;
}
__name(getPagesTmpDir, "getPagesTmpDir");

// src/pages/functions/buildWorker.ts
init_import_meta_url();
var import_promises9 = require("node:fs/promises");
var import_node_path35 = require("node:path");
var import_esbuild3 = require("esbuild");

// ../../node_modules/.pnpm/nanoid@3.3.6/node_modules/nanoid/index.js
init_import_meta_url();
var import_crypto = __toESM(require("crypto"), 1);

// ../../node_modules/.pnpm/nanoid@3.3.6/node_modules/nanoid/url-alphabet/index.js
init_import_meta_url();
var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";

// ../../node_modules/.pnpm/nanoid@3.3.6/node_modules/nanoid/index.js
var POOL_SIZE_MULTIPLIER = 128;
var pool;
var poolOffset;
var fillPool = /* @__PURE__ */ __name((bytes) => {
  if (!pool || pool.length < bytes) {
    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
    import_crypto.default.randomFillSync(pool);
    poolOffset = 0;
  } else if (poolOffset + bytes > pool.length) {
    import_crypto.default.randomFillSync(pool);
    poolOffset = 0;
  }
  poolOffset += bytes;
}, "fillPool");
var nanoid = /* @__PURE__ */ __name((size = 21) => {
  fillPool(size -= 0);
  let id = "";
  for (let i = poolOffset - size; i < poolOffset; i++) {
    id += urlAlphabet[pool[i] & 63];
  }
  return id;
}, "nanoid");

// src/pages/functions/buildWorker.ts
function buildWorkerFromFunctions({
  routesModule,
  outfile = (0, import_node_path35.join)(getPagesTmpDir(), `./functionsWorker-${Math.random()}.js`),
  outdir,
  minify = false,
  sourcemap = false,
  fallbackService = "ASSETS",
  watch: watch6 = false,
  onEnd = /* @__PURE__ */ __name(() => {
  }, "onEnd"),
  buildOutputDirectory,
  legacyNodeCompat,
  nodejsCompat,
  functionsDirectory,
  local,
  defineNavigatorUserAgent,
  external
}) {
  const entry = {
    file: (0, import_node_path35.resolve)(getBasePath(), "templates/pages-template-worker.ts"),
    directory: functionsDirectory,
    format: "modules",
    moduleRoot: functionsDirectory
  };
  const moduleCollector = createModuleCollector({
    entry,
    findAdditionalModules: false
  });
  return bundleWorker(entry, outdir ? (0, import_node_path35.resolve)(outdir) : (0, import_node_path35.resolve)(outfile), {
    bundle: true,
    additionalModules: [],
    moduleCollector,
    inject: [routesModule],
    ...outdir ? { entryName: "index" } : {},
    minify,
    sourcemap,
    watch: watch6,
    legacyNodeCompat,
    nodejsCompat,
    define: {
      __FALLBACK_SERVICE__: JSON.stringify(fallbackService)
    },
    doBindings: [],
    // Pages functions don't support internal Durable Objects
    external,
    plugins: [
      buildNotifierPlugin(onEnd),
      {
        name: "Assets",
        setup(pluginBuild) {
          const identifiers = /* @__PURE__ */ new Map();
          pluginBuild.onResolve({ filter: /^assets:/ }, async (args) => {
            const directory = (0, import_node_path35.resolve)(
              args.resolveDir,
              args.path.slice("assets:".length)
            );
            const exists = await (0, import_promises9.access)(directory).then(() => true).catch(() => false);
            const isDirectory2 = exists && (await (0, import_promises9.lstat)(directory)).isDirectory();
            if (!isDirectory2) {
              return {
                errors: [
                  {
                    text: `'${directory}' does not exist or is not a directory.`
                  }
                ]
              };
            }
            identifiers.set(directory, nanoid());
            if (!buildOutputDirectory) {
              console.warn(
                "You're attempting to import static assets as part of your Pages Functions, but have not specified a directory in which to put them. You must use 'wrangler pages dev <directory>' rather than 'wrangler pages dev -- <command>' to import static assets in Functions."
              );
            }
            return { path: directory, namespace: "assets" };
          });
          pluginBuild.onLoad(
            { filter: /.*/, namespace: "assets" },
            async (args) => {
              const identifier = identifiers.get(args.path);
              if (buildOutputDirectory) {
                const staticAssetsOutputDirectory = (0, import_node_path35.join)(
                  buildOutputDirectory,
                  "cdn-cgi",
                  "pages-plugins",
                  identifier
                );
                await (0, import_promises9.rm)(staticAssetsOutputDirectory, {
                  force: true,
                  recursive: true
                });
                await (0, import_promises9.cp)(args.path, staticAssetsOutputDirectory, {
                  force: true,
                  recursive: true
                });
                return {
                  // TODO: Watch args.path for changes and re-copy when updated
                  contents: `export const onRequest = ({ request, env, functionPath }) => {
                    const url = new URL(request.url)
                    const relativePathname = \`/\${url.pathname.replace(functionPath, "") || ""}\`.replace(/^\\/\\//, '/');
                    url.pathname = '/cdn-cgi/pages-plugins/${identifier}' + relativePathname
                    request = new Request(url.toString(), request)
                    return env.ASSETS.fetch(request)
                  }`
                };
              }
            }
          );
        }
      }
    ],
    isOutfile: !outdir,
    serveAssetsFromWorker: false,
    checkFetch: local,
    targetConsumer: local ? "dev" : "deploy",
    forPages: true,
    local,
    projectRoot: getPagesProjectRoot(),
    defineNavigatorUserAgent
  });
}
__name(buildWorkerFromFunctions, "buildWorkerFromFunctions");
function buildRawWorker({
  workerScriptPath,
  outfile = (0, import_node_path35.join)(getPagesTmpDir(), `./functionsWorker-${Math.random()}.js`),
  outdir,
  directory,
  bundle = true,
  externalModules,
  minify = false,
  sourcemap = false,
  watch: watch6 = false,
  plugins = [],
  onEnd = /* @__PURE__ */ __name(() => {
  }, "onEnd"),
  legacyNodeCompat,
  nodejsCompat,
  local,
  additionalModules = [],
  defineNavigatorUserAgent,
  external
}) {
  const entry = {
    file: workerScriptPath,
    directory: (0, import_node_path35.resolve)(directory),
    format: "modules",
    moduleRoot: (0, import_node_path35.resolve)(directory)
  };
  const moduleCollector = externalModules ? noopModuleCollector : createModuleCollector({ entry, findAdditionalModules: false });
  return bundleWorker(entry, outdir ? (0, import_node_path35.resolve)(outdir) : (0, import_node_path35.resolve)(outfile), {
    bundle,
    moduleCollector,
    additionalModules,
    minify,
    sourcemap,
    watch: watch6,
    legacyNodeCompat,
    nodejsCompat,
    define: {},
    doBindings: [],
    // Pages functions don't support internal Durable Objects
    external,
    plugins: [
      ...plugins,
      buildNotifierPlugin(onEnd),
      ...externalModules ? [
        // In some cases, we want to enable bundling in esbuild so that we can flatten a shim around the entrypoint, but we still don't want to actually bundle in all the chunks that a Worker references.
        // This plugin allows us to mark those chunks as external so they are not inlined.
        {
          name: "external-fixer",
          setup(pluginBuild) {
            pluginBuild.onResolve({ filter: /.*/ }, async (args) => {
              if (externalModules.includes(
                (0, import_node_path35.resolve)(args.resolveDir, args.path)
              )) {
                return { path: args.path, external: true };
              }
            });
          }
        }
      ] : []
    ],
    isOutfile: !outdir,
    serveAssetsFromWorker: false,
    checkFetch: local,
    targetConsumer: local ? "dev" : "deploy",
    forPages: true,
    local,
    projectRoot: getPagesProjectRoot(),
    defineNavigatorUserAgent
  });
}
__name(buildRawWorker, "buildRawWorker");
async function produceWorkerBundleForWorkerJSDirectory({
  workerJSDirectory,
  bundle,
  buildOutputDirectory,
  nodejsCompat,
  defineNavigatorUserAgent
}) {
  const entrypoint = (0, import_node_path35.resolve)((0, import_node_path35.join)(workerJSDirectory, "index.js"));
  const additionalModules = await findAdditionalModules(
    {
      file: entrypoint,
      directory: (0, import_node_path35.resolve)(workerJSDirectory),
      format: "modules",
      moduleRoot: (0, import_node_path35.resolve)(workerJSDirectory)
    },
    [
      {
        type: "ESModule",
        globs: ["**/*.js", "**/*.mjs"]
      }
    ]
  );
  if (!bundle) {
    return {
      modules: additionalModules,
      dependencies: {},
      resolvedEntryPointPath: entrypoint,
      bundleType: "esm",
      stop: async () => {
      },
      sourceMapPath: void 0
    };
  }
  const outfile = (0, import_node_path35.join)(
    getPagesTmpDir(),
    `./bundledWorker-${Math.random()}.mjs`
  );
  const bundleResult = await buildRawWorker({
    workerScriptPath: entrypoint,
    bundle: true,
    externalModules: additionalModules.map(
      (m2) => (0, import_node_path35.join)(workerJSDirectory, m2.name)
    ),
    outfile,
    directory: buildOutputDirectory,
    local: false,
    sourcemap: true,
    watch: false,
    onEnd: () => {
    },
    nodejsCompat,
    additionalModules,
    defineNavigatorUserAgent
  });
  return {
    modules: bundleResult.modules,
    dependencies: bundleResult.dependencies,
    resolvedEntryPointPath: bundleResult.resolvedEntryPointPath,
    bundleType: bundleResult.bundleType,
    stop: bundleResult.stop,
    sourceMapPath: bundleResult.sourceMapPath
  };
}
__name(produceWorkerBundleForWorkerJSDirectory, "produceWorkerBundleForWorkerJSDirectory");
function buildNotifierPlugin(onEnd) {
  return {
    name: "wrangler notifier and monitor",
    setup(pluginBuild) {
      pluginBuild.onEnd((result) => {
        if (result.errors.length > 0) {
          logger.error(
            `${result.errors.length} error(s) and ${result.warnings.length} warning(s) when compiling Worker.`
          );
        } else if (result.warnings.length > 0) {
          logger.warn(
            `${result.warnings.length} warning(s) when compiling Worker.`
          );
          onEnd();
        } else {
          logger.log("\u2728 Compiled Worker successfully");
          onEnd();
        }
      });
    }
  };
}
__name(buildNotifierPlugin, "buildNotifierPlugin");
async function checkRawWorker(scriptPath3, nodejsCompat, onEnd) {
  await (0, import_esbuild3.build)({
    entryPoints: [scriptPath3],
    write: false,
    // we need it to be bundled so that any imports that are used are affected by the blocker plugin
    bundle: true,
    plugins: [blockWorkerJsImports(nodejsCompat), buildNotifierPlugin(onEnd)],
    logLevel: "silent"
  });
}
__name(checkRawWorker, "checkRawWorker");
function blockWorkerJsImports(nodejsCompat) {
  return {
    name: "block-worker-js-imports",
    setup(build5) {
      build5.onResolve({ filter: /.*/g }, (args) => {
        if (args.kind === "entry-point") {
          return {
            path: args.path
          };
        }
        if (nodejsCompat && args.path.startsWith("node:") || args.path.startsWith("cloudflare:")) {
          return {
            path: args.path,
            external: true
          };
        }
        throw new FatalError(
          "_worker.js is not being bundled by Wrangler but it is importing from another file.\nThis will throw an error if deployed.\nYou should bundle the Worker in a pre-build step, remove the import if it is unused, or ask Wrangler to bundle it by setting `--bundle`.",
          1
        );
      });
    }
  };
}
__name(blockWorkerJsImports, "blockWorkerJsImports");

// src/pages/functions/buildPlugin.ts
function buildPluginFromFunctions({
  routesModule,
  outdir,
  minify = false,
  sourcemap = false,
  watch: watch6 = false,
  onEnd = /* @__PURE__ */ __name(() => {
  }, "onEnd"),
  legacyNodeCompat,
  functionsDirectory,
  local,
  defineNavigatorUserAgent,
  external
}) {
  const entry = {
    file: (0, import_node_path36.resolve)(getBasePath(), "templates/pages-template-plugin.ts"),
    directory: functionsDirectory,
    format: "modules",
    moduleRoot: functionsDirectory
  };
  const moduleCollector = createModuleCollector({
    entry,
    findAdditionalModules: false
  });
  return bundleWorker(entry, (0, import_node_path36.resolve)(outdir), {
    bundle: true,
    additionalModules: [],
    moduleCollector,
    inject: [routesModule],
    entryName: "index",
    minify,
    sourcemap,
    watch: watch6,
    legacyNodeCompat,
    // We don't currently have a mechanism for Plugins 'requiring' a specific compat date/flag,
    // but if someone wants to publish a Plugin which does require this new `nodejs_compat` flag
    // and they document that on their README.md, we should let them.
    nodejsCompat: true,
    define: {},
    doBindings: [],
    // Pages functions don't support internal Durable Objects
    external,
    plugins: [
      buildNotifierPlugin(onEnd),
      {
        name: "Assets",
        setup(pluginBuild) {
          pluginBuild.onResolve({ filter: /^assets:/ }, async (args) => {
            const directory = (0, import_node_path36.resolve)(
              args.resolveDir,
              args.path.slice("assets:".length)
            );
            const exists = await (0, import_promises10.access)(directory).then(() => true).catch(() => false);
            const isDirectory2 = exists && (await (0, import_promises10.lstat)(directory)).isDirectory();
            if (!isDirectory2) {
              return {
                errors: [
                  {
                    text: `'${directory}' does not exist or is not a directory.`
                  }
                ]
              };
            }
            const path67 = `assets:./${(0, import_node_path36.relative)(outdir, directory)}`;
            return { path: path67, external: true, namespace: "assets" };
          });
        }
      },
      // TODO: Replace this with a proper outdir solution for Plugins
      // But for now, let's just mark all wasm/bin files as external
      {
        name: "Mark externals",
        setup(pluginBuild) {
          pluginBuild.onResolve({ filter: /.*\.(wasm|bin)$/ }, async (args) => {
            return {
              external: true,
              path: `./${(0, import_node_path36.relative)(
                outdir,
                (0, import_node_path36.resolve)(args.resolveDir, args.path)
              )}`
            };
          });
        }
      }
    ],
    serveAssetsFromWorker: false,
    checkFetch: local,
    targetConsumer: local ? "dev" : "deploy",
    forPages: true,
    local,
    projectRoot: getPagesProjectRoot(),
    defineNavigatorUserAgent
  });
}
__name(buildPluginFromFunctions, "buildPluginFromFunctions");

// src/pages/functions/filepath-routing.ts
init_import_meta_url();
var import_promises11 = __toESM(require("node:fs/promises"));
var import_node_path37 = __toESM(require("node:path"));
var import_esbuild4 = require("esbuild");
async function generateConfigFromFileTree({
  baseDir,
  baseURL
}) {
  let routeEntries = [];
  if (!baseURL.startsWith("/")) {
    baseURL = `/${baseURL}`;
  }
  if (baseURL.endsWith("/")) {
    baseURL = baseURL.slice(0, -1);
  }
  await forEachFile(baseDir, async (filepath) => {
    const ext = import_node_path37.default.extname(filepath);
    if (/^\.(mjs|js|ts|tsx|jsx)$/.test(ext)) {
      const { metafile } = await (0, import_esbuild4.build)({
        metafile: true,
        write: false,
        bundle: false,
        entryPoints: [import_node_path37.default.resolve(filepath)]
      }).catch((e3) => {
        throw new FunctionsBuildError(e3.message);
      });
      const exportNames = [];
      if (metafile) {
        for (const output in metafile?.outputs) {
          exportNames.push(...metafile.outputs[output].exports);
        }
      }
      for (const exportName of exportNames) {
        const [match, method = ""] = exportName.match(
          /^onRequest(Get|Post|Put|Patch|Delete|Options|Head)?$/
        ) ?? [];
        if (match) {
          const basename4 = import_node_path37.default.basename(filepath).slice(0, -ext.length);
          const isIndexFile = basename4 === "index";
          const isMiddlewareFile = basename4 === "_middleware" || basename4 === "_middleware_";
          let routePath = import_node_path37.default.relative(baseDir, filepath).slice(0, -ext.length);
          let mountPath = import_node_path37.default.dirname(routePath);
          if (isIndexFile || isMiddlewareFile) {
            routePath = import_node_path37.default.dirname(routePath);
          }
          if (routePath === ".") {
            routePath = "";
          }
          if (mountPath === ".") {
            mountPath = "";
          }
          routePath = `${baseURL}/${routePath}`;
          mountPath = `${baseURL}/${mountPath}`;
          routePath = convertCatchallParams(routePath);
          routePath = convertSimpleParams(routePath);
          mountPath = convertCatchallParams(mountPath);
          mountPath = convertSimpleParams(mountPath);
          const modulePath = toUrlPath(import_node_path37.default.relative(baseDir, filepath));
          const routeEntry = {
            routePath: toUrlPath(routePath),
            mountPath: toUrlPath(mountPath),
            method: method.toUpperCase(),
            [isMiddlewareFile ? "middleware" : "module"]: [
              `${modulePath}:${exportName}`
            ]
          };
          routeEntries.push(routeEntry);
        }
      }
    }
  });
  routeEntries = routeEntries.reduce(
    (acc, { routePath, ...rest }) => {
      const existingRouteEntry = acc.find(
        (routeEntry) => routeEntry.routePath === routePath && routeEntry.method === rest.method
      );
      if (existingRouteEntry !== void 0) {
        Object.assign(existingRouteEntry, rest);
      } else {
        acc.push({ routePath, ...rest });
      }
      return acc;
    },
    []
  );
  routeEntries.sort((a, b2) => compareRoutes(a, b2));
  return {
    routes: routeEntries
  };
}
__name(generateConfigFromFileTree, "generateConfigFromFileTree");
function compareRoutes({ routePath: routePathA, method: methodA }, { routePath: routePathB, method: methodB }) {
  function parseRoutePath(routePath) {
    return routePath.slice(1).split("/").filter(Boolean);
  }
  __name(parseRoutePath, "parseRoutePath");
  const segmentsA = parseRoutePath(routePathA);
  const segmentsB = parseRoutePath(routePathB);
  if (segmentsA.length !== segmentsB.length) {
    return segmentsB.length - segmentsA.length;
  }
  for (let i = 0; i < segmentsA.length; i++) {
    const isWildcardA = segmentsA[i].includes("*");
    const isWildcardB = segmentsB[i].includes("*");
    const isParamA = segmentsA[i].includes(":");
    const isParamB = segmentsB[i].includes(":");
    if (isWildcardA && !isWildcardB)
      return 1;
    if (!isWildcardA && isWildcardB)
      return -1;
    if (isParamA && !isParamB)
      return 1;
    if (!isParamA && isParamB)
      return -1;
  }
  if (methodA && !methodB)
    return -1;
  if (!methodA && methodB)
    return 1;
  return routePathA.localeCompare(routePathB);
}
__name(compareRoutes, "compareRoutes");
async function forEachFile(baseDir, fn2) {
  const searchPaths = [baseDir];
  const returnValues = [];
  while (isNotEmpty(searchPaths)) {
    const cwd2 = searchPaths.shift();
    const dir = await import_promises11.default.readdir(cwd2, { withFileTypes: true });
    for (const entry of dir) {
      const pathname = import_node_path37.default.join(cwd2, entry.name);
      if (entry.isDirectory()) {
        searchPaths.push(pathname);
      } else if (entry.isFile()) {
        returnValues.push(await fn2(pathname));
      }
    }
  }
  return returnValues;
}
__name(forEachFile, "forEachFile");
function isNotEmpty(array) {
  return array.length > 0;
}
__name(isNotEmpty, "isNotEmpty");
var validParamNameRegExp = /^[A-Za-z0-9_]+$/;
function convertCatchallParams(routePath) {
  return routePath.replace(/\[\[([^\]]+)\]\]/g, (_3, param) => {
    if (validParamNameRegExp.test(param)) {
      return `:${param}*`;
    } else {
      throw new FatalError(
        `Invalid Pages function route parameter - "[[${param}]]". Parameters names must only contain alphanumeric and underscore characters.`
      );
    }
  });
}
__name(convertCatchallParams, "convertCatchallParams");
function convertSimpleParams(routePath) {
  return routePath.replace(/\[([^\]]+)\]/g, (_3, param) => {
    if (validParamNameRegExp.test(param)) {
      return `:${param}`;
    } else {
      throw new FatalError(
        `Invalid Pages function route parameter - "[${param}]". Parameter names must only contain alphanumeric and underscore characters.`
      );
    }
  });
}
__name(convertSimpleParams, "convertSimpleParams");

// src/pages/functions/routes.ts
init_import_meta_url();
var import_promises12 = __toESM(require("node:fs/promises"));
var import_node_path38 = __toESM(require("node:path"));

// src/pages/functions/identifiers.ts
init_import_meta_url();
var RESERVED_KEYWORDS = [
  "do",
  "if",
  "in",
  "for",
  "let",
  "new",
  "try",
  "var",
  "case",
  "else",
  "enum",
  "eval",
  "null",
  "this",
  "true",
  "void",
  "with",
  "await",
  "break",
  "catch",
  "class",
  "const",
  "false",
  "super",
  "throw",
  "while",
  "yield",
  "delete",
  "export",
  "import",
  "public",
  "return",
  "static",
  "switch",
  "typeof",
  "default",
  "extends",
  "finally",
  "package",
  "private",
  "continue",
  "debugger",
  "function",
  "arguments",
  "interface",
  "protected",
  "implements",
  "instanceof",
  "NaN",
  "Infinity",
  "undefined"
];
var reservedKeywordRegex = new RegExp(
  `^${RESERVED_KEYWORDS.join("|")}$`
);
var identifierNameRegex = /^(?:[$_\p{ID_Start}])(?:[$_\u200C\u200D\p{ID_Continue}])*$/u;
var validIdentifierRegex = new RegExp(
  `(?!(${reservedKeywordRegex.source})$)${identifierNameRegex.source}`,
  "u"
);
var isValidIdentifier = /* @__PURE__ */ __name((identifier) => validIdentifierRegex.test(identifier), "isValidIdentifier");
var normalizeIdentifier = /* @__PURE__ */ __name((identifier) => identifier.replace(
  /(?:^[^$_\p{ID_Start}])|[^$_\u200C\u200D\p{ID_Continue}]/gu,
  "_"
), "normalizeIdentifier");

// src/pages/functions/routes.ts
async function writeRoutesModule({
  config,
  srcDir,
  outfile = "_routes.js"
}) {
  const { importMap, routes } = parseConfig(config, srcDir);
  const routesModule = generateRoutesModule(importMap, routes);
  await import_promises12.default.writeFile(outfile, routesModule);
  return outfile;
}
__name(writeRoutesModule, "writeRoutesModule");
function parseConfig(config, baseDir) {
  const routes = [];
  const importMap = /* @__PURE__ */ new Map();
  const identifierCount = /* @__PURE__ */ new Map();
  function parseModuleIdentifiers(paths) {
    if (typeof paths === "undefined") {
      paths = [];
    }
    if (typeof paths === "string") {
      paths = [paths];
    }
    return paths.map((modulePath) => {
      const [filepath, name = "default"] = modulePath.split(":");
      let { identifier } = importMap.get(modulePath) ?? {};
      const resolvedPath = import_node_path38.default.resolve(baseDir, filepath);
      if (import_node_path38.default.relative(baseDir, resolvedPath).startsWith("..")) {
        throw new UserError(`Invalid module path "${filepath}"`);
      }
      if (name !== "default" && !isValidIdentifier(name)) {
        throw new UserError(`Invalid module identifier "${name}"`);
      }
      if (!identifier) {
        identifier = normalizeIdentifier(`__${filepath}_${name}`);
        let count = identifierCount.get(identifier) ?? 0;
        identifierCount.set(identifier, ++count);
        if (count > 1) {
          identifier += `_${count}`;
        }
        importMap.set(modulePath, { filepath: resolvedPath, name, identifier });
      }
      return identifier;
    });
  }
  __name(parseModuleIdentifiers, "parseModuleIdentifiers");
  for (const { routePath, mountPath, method, ...props } of config.routes ?? []) {
    routes.push({
      routePath,
      mountPath,
      method,
      middlewares: parseModuleIdentifiers(props.middleware),
      modules: parseModuleIdentifiers(props.module)
    });
  }
  return { routes, importMap };
}
__name(parseConfig, "parseConfig");
function generateRoutesModule(importMap, routes) {
  return `${[...importMap.values()].map(
    ({ filepath, name, identifier }) => `import { ${name} as ${identifier} } from ${JSON.stringify(filepath)}`
  ).join("\n")}

export const routes = [
  ${routes.map(
    (route2) => `  {
      routePath: "${route2.routePath}",
      mountPath: "${route2.mountPath}",
      method: "${route2.method}",
      middlewares: [${route2.middlewares.join(", ")}],
      modules: [${route2.modules.join(", ")}],
    },`
  ).join("\n")}
  ]`;
}
__name(generateRoutesModule, "generateRoutesModule");

// src/pages/functions/routes-transformation.ts
init_import_meta_url();
var import_node_path39 = require("node:path");

// src/pages/functions/routes-consolidation.ts
init_import_meta_url();
function consolidateRoutes(routes) {
  const routesShortened = Array.from(
    new Set(routes.map((route2) => shortenRoute(route2)))
  );
  const routesMap = /* @__PURE__ */ new Map();
  for (const route2 of routesShortened) {
    routesMap.set(route2, true);
  }
  for (const route2 of routesShortened.filter((r3) => r3.endsWith("/*"))) {
    if (routesMap.has(route2)) {
      const routeTrimmed = route2.substring(0, route2.length - 1);
      for (const nextRoute of routesMap.keys()) {
        if (nextRoute !== route2 && nextRoute.startsWith(routeTrimmed)) {
          routesMap.delete(nextRoute);
        }
      }
    }
  }
  return Array.from(routesMap.keys());
}
__name(consolidateRoutes, "consolidateRoutes");
function shortenRoute(routeToShorten, maxLength = MAX_FUNCTIONS_ROUTES_RULE_LENGTH) {
  if (routeToShorten.length <= maxLength) {
    return routeToShorten;
  }
  let route2 = routeToShorten;
  for (let i = 0; i < routeToShorten.length; i++) {
    for (let j2 = maxLength - 1 - i; j2 > 0; j2--) {
      if (route2[j2] === "/") {
        route2 = route2.slice(0, j2) + "/*";
        break;
      }
    }
    if (route2.length <= maxLength) {
      break;
    }
  }
  if (route2.length > maxLength) {
    route2 = "/*";
  }
  return route2;
}
__name(shortenRoute, "shortenRoute");

// src/pages/functions/routes-transformation.ts
function convertRoutesToGlobPatterns(routes) {
  const convertedRoutes = routes.map(({ routePath, middleware }) => {
    const globbedRoutePath = routePath.replace(/:\w+\*?.*/, "*");
    if (typeof middleware === "string" || Array.isArray(middleware) && middleware.length > 0) {
      if (!globbedRoutePath.endsWith("*")) {
        return toUrlPath((0, import_node_path39.join)(globbedRoutePath, "*"));
      }
    }
    return toUrlPath(globbedRoutePath);
  });
  return Array.from(new Set(convertedRoutes));
}
__name(convertRoutesToGlobPatterns, "convertRoutesToGlobPatterns");
function convertRoutesToRoutesJSONSpec(routes) {
  const reversedRoutes = [...routes].reverse();
  const include = convertRoutesToGlobPatterns(reversedRoutes);
  return optimizeRoutesJSONSpec({
    version: ROUTES_SPEC_VERSION,
    description: ROUTES_SPEC_DESCRIPTION,
    include,
    exclude: []
  });
}
__name(convertRoutesToRoutesJSONSpec, "convertRoutesToRoutesJSONSpec");
function optimizeRoutesJSONSpec(spec) {
  const optimizedSpec = { ...spec };
  let consolidatedRoutes = consolidateRoutes(optimizedSpec.include);
  if (consolidatedRoutes.length > MAX_FUNCTIONS_ROUTES_RULES) {
    consolidatedRoutes = ["/*"];
  }
  consolidatedRoutes.sort((a, b2) => compareRoutes2(b2, a));
  optimizedSpec.include = consolidatedRoutes;
  return optimizedSpec;
}
__name(optimizeRoutesJSONSpec, "optimizeRoutesJSONSpec");
function compareRoutes2(routeA, routeB) {
  function parseRoutePath(routePath) {
    return routePath.slice(1).split("/").filter(Boolean);
  }
  __name(parseRoutePath, "parseRoutePath");
  const segmentsA = parseRoutePath(routeA);
  const segmentsB = parseRoutePath(routeB);
  if (segmentsA.length !== segmentsB.length) {
    return segmentsB.length - segmentsA.length;
  }
  for (let i = 0; i < segmentsA.length; i++) {
    const isWildcardA = segmentsA[i].includes("*");
    const isWildcardB = segmentsB[i].includes("*");
    if (isWildcardA && !isWildcardB)
      return 1;
    if (!isWildcardA && isWildcardB)
      return -1;
  }
  return routeA.localeCompare(routeB);
}
__name(compareRoutes2, "compareRoutes");

// src/pages/buildFunctions.ts
async function buildFunctions({
  outfile,
  outdir,
  outputConfigPath,
  functionsDirectory,
  minify = false,
  sourcemap = false,
  fallbackService = "ASSETS",
  watch: watch6 = false,
  onEnd,
  plugin = false,
  buildOutputDirectory,
  routesOutputPath,
  legacyNodeCompat,
  nodejsCompat,
  local,
  routesModule = (0, import_node_path40.join)(
    getPagesTmpDir(),
    `./functionsRoutes-${Math.random()}.mjs`
  ),
  defineNavigatorUserAgent,
  external
}) {
  RUNNING_BUILDERS.forEach(
    (runningBuilder) => runningBuilder.stop && runningBuilder.stop()
  );
  const baseURL = toUrlPath("/");
  const config = await generateConfigFromFileTree({
    baseDir: functionsDirectory,
    baseURL
  });
  if (!config.routes || config.routes.length === 0) {
    throw new FunctionsNoRoutesError(
      `Failed to find any routes while compiling Functions in: ${functionsDirectory}`
    );
  }
  if (routesOutputPath) {
    const routesJSON = convertRoutesToRoutesJSONSpec(config.routes);
    (0, import_node_fs26.writeFileSync)(routesOutputPath, JSON.stringify(routesJSON, null, 2));
  }
  if (outputConfigPath) {
    (0, import_node_fs26.writeFileSync)(
      outputConfigPath,
      JSON.stringify({ ...config, baseURL }, null, 2)
    );
  }
  await writeRoutesModule({
    config,
    srcDir: functionsDirectory,
    outfile: routesModule
  });
  const absoluteFunctionsDirectory = (0, import_node_path40.resolve)(functionsDirectory);
  let bundle;
  if (plugin) {
    if (outdir === void 0) {
      throw new FatalError(
        "Must specify an output directory when building a Plugin.",
        1
      );
    }
    bundle = await buildPluginFromFunctions({
      routesModule,
      outdir,
      minify,
      sourcemap,
      watch: watch6,
      legacyNodeCompat,
      functionsDirectory: absoluteFunctionsDirectory,
      local,
      defineNavigatorUserAgent,
      external
    });
  } else {
    bundle = await buildWorkerFromFunctions({
      routesModule,
      outfile,
      outdir,
      minify,
      sourcemap,
      fallbackService,
      watch: watch6,
      functionsDirectory: absoluteFunctionsDirectory,
      local,
      onEnd,
      buildOutputDirectory,
      legacyNodeCompat,
      nodejsCompat,
      defineNavigatorUserAgent,
      external
    });
  }
  RUNNING_BUILDERS.push(bundle);
  return bundle;
}
__name(buildFunctions, "buildFunctions");

// src/pages/build.ts
function Options8(yargs) {
  return yargs.positional("directory", {
    type: "string",
    default: "functions",
    description: "The directory of Pages Functions"
  }).options({
    outfile: {
      type: "string",
      description: "The location of the output Worker script"
    },
    outdir: {
      type: "string",
      description: "Output directory for the bundled Worker"
    },
    "output-config-path": {
      type: "string",
      description: "The location for the output config file"
    },
    "build-metadata-path": {
      type: "string",
      description: "The location for the build metadata file"
    },
    "project-directory": {
      type: "string",
      description: "The location of the Pages project"
    },
    "output-routes-path": {
      type: "string",
      description: "The location for the output _routes.json file"
    },
    minify: {
      type: "boolean",
      default: false,
      description: "Minify the output Worker script"
    },
    sourcemap: {
      type: "boolean",
      default: false,
      description: "Generate a sourcemap for the output Worker script"
    },
    "fallback-service": {
      type: "string",
      default: "ASSETS",
      description: "The service to fallback to at the end of the `next` chain. Setting to '' will fallback to the global `fetch`."
    },
    watch: {
      type: "boolean",
      default: false,
      description: "Watch for changes to the functions and automatically rebuild the Worker script"
    },
    plugin: {
      type: "boolean",
      default: false,
      description: "Build a plugin rather than a Worker script"
    },
    "build-output-directory": {
      type: "string",
      description: "The directory to output static assets to"
    },
    "node-compat": {
      describe: "Enable Node.js compatibility",
      default: false,
      type: "boolean",
      hidden: true
    },
    "compatibility-date": {
      describe: "Date to use for compatibility checks",
      type: "string",
      requiresArg: true
    },
    "compatibility-flags": {
      describe: "Flags to use for compatibility checks",
      alias: "compatibility-flag",
      type: "string",
      requiresArg: true,
      array: true
    },
    bindings: {
      type: "string",
      describe: "Bindings used in Functions (used to register beta product shims)",
      deprecated: true,
      hidden: true
    },
    external: {
      describe: "A list of module imports to exclude from bundling",
      type: "string",
      array: true
    }
  });
}
__name(Options8, "Options");
var Handler8 = /* @__PURE__ */ __name(async (args) => {
  const validatedArgs = await validateArgs(args);
  let bundle = void 0;
  if (validatedArgs.plugin) {
    const {
      directory,
      outfile,
      outdir,
      outputConfigPath,
      outputRoutesPath: routesOutputPath,
      minify,
      sourcemap,
      fallbackService,
      watch: watch6,
      plugin,
      nodejsCompat,
      legacyNodeCompat,
      defineNavigatorUserAgent,
      external
    } = validatedArgs;
    try {
      bundle = await buildFunctions({
        outfile,
        outdir,
        outputConfigPath,
        functionsDirectory: directory,
        minify,
        sourcemap,
        fallbackService,
        // This only watches already existing files using the esbuild watching mechanism
        // it will not watch new files that are added to the functions directory!
        watch: watch6,
        plugin,
        legacyNodeCompat,
        nodejsCompat,
        routesOutputPath,
        local: false,
        defineNavigatorUserAgent,
        external
      });
    } catch (e3) {
      if (e3 instanceof FunctionsNoRoutesError) {
        throw new FatalError(
          getFunctionsNoRoutesWarning(directory),
          EXIT_CODE_FUNCTIONS_NO_ROUTES_ERROR
        );
      } else {
        throw e3;
      }
    }
    if (outfile && outfile !== bundle.resolvedEntryPointPath) {
      (0, import_node_fs27.writeFileSync)(
        outfile,
        `export { default } from './${(0, import_node_path41.relative)(
          (0, import_node_path41.dirname)(outfile),
          bundle.resolvedEntryPointPath
        )}'`
      );
    }
  } else {
    const {
      config,
      buildMetadataPath,
      buildMetadata,
      directory,
      outfile,
      outdir,
      outputConfigPath,
      outputRoutesPath: routesOutputPath,
      minify,
      sourcemap,
      fallbackService,
      watch: watch6,
      plugin,
      buildOutputDirectory,
      nodejsCompat,
      legacyNodeCompat,
      workerScriptPath,
      defineNavigatorUserAgent,
      external
    } = validatedArgs;
    if (workerScriptPath) {
      if ((0, import_node_fs27.lstatSync)(workerScriptPath).isDirectory()) {
        bundle = await produceWorkerBundleForWorkerJSDirectory({
          workerJSDirectory: workerScriptPath,
          bundle: true,
          buildOutputDirectory,
          nodejsCompat,
          defineNavigatorUserAgent
        });
      } else {
        bundle = await buildRawWorker({
          workerScriptPath,
          outdir,
          directory: buildOutputDirectory,
          local: false,
          sourcemap,
          watch: watch6,
          nodejsCompat,
          defineNavigatorUserAgent,
          externalModules: external
        });
      }
    } else {
      try {
        bundle = await buildFunctions({
          outdir,
          outputConfigPath,
          functionsDirectory: directory,
          minify,
          sourcemap,
          fallbackService,
          watch: watch6,
          plugin,
          buildOutputDirectory,
          legacyNodeCompat,
          nodejsCompat,
          routesOutputPath,
          local: false,
          defineNavigatorUserAgent,
          external
        });
      } catch (e3) {
        if (e3 instanceof FunctionsNoRoutesError) {
          throw new FatalError(
            getFunctionsNoRoutesWarning(directory),
            EXIT_CODE_FUNCTIONS_NO_ROUTES_ERROR
          );
        } else {
          throw e3;
        }
      }
    }
    if (outdir) {
      await writeAdditionalModules(bundle.modules, outdir);
    }
    if (outfile) {
      const workerBundleContents = await createUploadWorkerBundleContents(
        bundle,
        config
      );
      (0, import_node_fs27.mkdirSync)((0, import_node_path41.dirname)(outfile), { recursive: true });
      (0, import_node_fs27.writeFileSync)(
        outfile,
        Buffer.from(await workerBundleContents.arrayBuffer())
      );
    }
    if (buildMetadataPath && buildMetadata) {
      (0, import_node_fs27.writeFileSync)(buildMetadataPath, JSON.stringify(buildMetadata));
    }
  }
  await sendMetricsEvent("build pages functions");
}, "Handler");
async function maybeReadPagesConfig(args) {
  if (!args.projectDirectory || !args.buildMetadataPath) {
    return;
  }
  const configPath = import_node_path41.default.resolve(args.projectDirectory, "wrangler.toml");
  if (!(0, import_node_fs27.existsSync)(configPath)) {
    return void 0;
  }
  try {
    const config = readConfig(
      configPath,
      {
        ...args,
        // eslint-disable-next-line turbo/no-undeclared-env-vars
        env: process.env.PAGES_ENVIRONMENT
      },
      true
    );
    return {
      ...config,
      hash: (0, import_node_crypto6.createHash)("sha256").update(await (0, import_promises13.readFile)(configPath)).digest("hex")
    };
  } catch (e3) {
    if (e3 instanceof FatalError && e3.code === EXIT_CODE_INVALID_PAGES_CONFIG) {
      return void 0;
    }
    throw e3;
  }
}
__name(maybeReadPagesConfig, "maybeReadPagesConfig");
var validateArgs = /* @__PURE__ */ __name(async (args) => {
  const config = await maybeReadPagesConfig(args);
  if (args.outdir && args.outfile) {
    throw new FatalError(
      "Cannot specify both an `--outdir` and an `--outfile`.",
      1
    );
  }
  if (args.plugin) {
    if (args.outfile) {
      logger.warn(
        "Creating a Pages Plugin with `--outfile` is now deprecated. Please use `--outdir` instead."
      );
      args.outdir = (0, import_node_path41.dirname)((0, import_node_path41.resolve)(args.outfile));
    } else if (!args.outfile && !args.outdir) {
      args.outfile ??= "_worker.js";
      args.outdir = ".";
      logger.warn(
        "Creating a Pages Plugin without `--outdir` is now deprecated. Please add an `--outdir` argument."
      );
    }
    if (args.bindings) {
      throw new FatalError(
        "The `--bindings` flag cannot be used when creating a Pages Plugin with `--plugin`.",
        1
      );
    }
    if (args.buildOutputDirectory) {
      throw new FatalError(
        "The `--build-output-directory` flag cannot be used when creating a Pages Plugin with `--plugin`.",
        1
      );
    }
  } else {
    if (!args.outdir) {
      args.outfile ??= "_worker.bundle";
    }
    args.buildOutputDirectory ??= args.outfile ? (0, import_node_path41.dirname)(args.outfile) : ".";
  }
  args.buildOutputDirectory = config?.pages_build_output_dir ?? (args.buildOutputDirectory ? (0, import_node_path41.resolve)(args.buildOutputDirectory) : void 0);
  if (args.outdir) {
    args.outdir = (0, import_node_path41.resolve)(args.outdir);
  }
  if (args.outfile) {
    args.outfile = (0, import_node_path41.resolve)(args.outfile);
  }
  const { nodeCompat: legacyNodeCompat, ...argsExceptNodeCompat } = args;
  if (legacyNodeCompat) {
    console.warn(
      "Enabling Node.js compatibility mode for builtins and globals. This is experimental and has serious tradeoffs. Please see https://github.com/ionic-team/rollup-plugin-node-polyfills/ for more details."
    );
  }
  const nodejsCompat = !!args.compatibilityFlags?.includes("nodejs_compat");
  const defineNavigatorUserAgent = isNavigatorDefined(
    args.compatibilityDate,
    args.compatibilityFlags
  );
  if (legacyNodeCompat && nodejsCompat) {
    throw new UserError(
      "The `nodejs_compat` compatibility flag cannot be used in conjunction with the legacy `--node-compat` flag. If you want to use the Workers runtime Node.js compatibility features, please remove the `--node-compat` argument from your CLI command."
    );
  }
  let workerScriptPath;
  if (args.buildOutputDirectory) {
    const prospectiveWorkerScriptPath = (0, import_node_path41.resolve)(
      args.buildOutputDirectory,
      "_worker.js"
    );
    const foundWorkerScript = (0, import_node_fs27.existsSync)(prospectiveWorkerScriptPath);
    if (foundWorkerScript) {
      workerScriptPath = prospectiveWorkerScriptPath;
    } else if (!foundWorkerScript && !(0, import_node_fs27.existsSync)(args.directory)) {
      throw new FatalError(
        `Could not find anything to build.
We first looked inside the build output directory (${(0, import_node_path41.basename)(
          (0, import_node_path41.resolve)(args.buildOutputDirectory)
        )}), then looked for the Functions directory (${(0, import_node_path41.basename)(
          args.directory
        )}) but couldn't find anything to build.
	\u27A4 If you are trying to build _worker.js, please make sure you provide the [--build-output-directory] containing your static files.
	\u27A4 If you are trying to build Pages Functions, please make sure [directory] points to the location of your Functions files.`,
        EXIT_CODE_FUNCTIONS_NOTHING_TO_BUILD_ERROR
      );
    }
  } else if (!(0, import_node_fs27.existsSync)(args.directory)) {
    throw new FatalError(
      `Could not find anything to build.
We looked for the Functions directory (${(0, import_node_path41.basename)(
        args.directory
      )}) but couldn't find anything to build.
	\u27A4 Please make sure [directory] points to the location of your Functions files.`,
      EXIT_CODE_FUNCTIONS_NOTHING_TO_BUILD_ERROR
    );
  }
  return {
    ...argsExceptNodeCompat,
    workerScriptPath,
    nodejsCompat,
    legacyNodeCompat,
    defineNavigatorUserAgent,
    config,
    buildMetadata: config && args.projectDirectory && config.pages_build_output_dir ? {
      wrangler_config_hash: config.hash,
      build_output_directory: import_node_path41.default.relative(
        args.projectDirectory,
        config.pages_build_output_dir
      )
    } : void 0
  };
}, "validateArgs");

// src/pages/build-env.ts
init_import_meta_url();
var import_node_fs28 = require("node:fs");
var import_node_path42 = __toESM(require("node:path"));
function Options9(yargs) {
  return yargs.positional("projectDir", {
    type: "string",
    description: "The location of the Pages project"
  }).options({
    outfile: {
      type: "string",
      description: "The location to write the build environment file"
    }
  });
}
__name(Options9, "Options");
var Handler9 = /* @__PURE__ */ __name(async (args) => {
  if (!args.projectDir) {
    throw new FatalError("No Pages project location specified");
  }
  if (!args.outfile) {
    throw new FatalError("No outfile specified");
  }
  logger.log(
    "Checking for configuration in a wrangler.toml configuration file (BETA)\n"
  );
  const configPath = import_node_path42.default.resolve(args.projectDir, "wrangler.toml");
  if (!(0, import_node_fs28.existsSync)(configPath)) {
    logger.debug("No wrangler.toml configuration file found. Exiting.");
    process.exitCode = EXIT_CODE_NO_CONFIG_FOUND;
    return;
  }
  logger.log("Found wrangler.toml file. Reading build configuration...");
  let config;
  try {
    config = readConfig(
      configPath,
      {
        ...args,
        // eslint-disable-next-line turbo/no-undeclared-env-vars
        env: process.env.PAGES_ENVIRONMENT
      },
      true
    );
  } catch (err) {
    if (err instanceof FatalError && err.code === EXIT_CODE_INVALID_PAGES_CONFIG) {
      logger.debug("wrangler.toml file is invalid. Exiting.");
      process.exitCode = EXIT_CODE_INVALID_PAGES_CONFIG;
      return;
    }
    throw err;
  }
  const textVars = Object.fromEntries(
    Object.entries(config.vars).filter(([_3, v2]) => typeof v2 === "string")
  );
  const buildConfiguration = {
    vars: textVars,
    pages_build_output_dir: import_node_path42.default.relative(
      args.projectDir,
      config.pages_build_output_dir
    )
  };
  (0, import_node_fs28.writeFileSync)(args.outfile, JSON.stringify(buildConfiguration));
  logger.debug(`Build configuration written to ${args.outfile}`);
  logger.debug(JSON.stringify(buildConfiguration), null, 2);
  const vars = Object.entries(buildConfiguration.vars);
  const message = [
    `Build environment variables: ${vars.length === 0 ? "(none found)" : ""}`,
    ...vars.map(([key, value]) => `  - ${key}: ${value}`)
  ].join("\n");
  logger.log(
    `pages_build_output_dir: ${buildConfiguration.pages_build_output_dir}`
  );
  logger.log(message);
}, "Handler");

// src/pages/deploy.tsx
init_import_meta_url();
var import_node_child_process4 = require("node:child_process");
var import_ink9 = __toESM(require_build2());
var import_ink_select_input2 = __toESM(require_build3());
var import_react13 = __toESM(require_react());

// src/api/pages/deploy.tsx
init_import_meta_url();
var import_node_crypto7 = require("node:crypto");
var import_node_fs29 = require("node:fs");
var import_promises16 = require("node:fs/promises");
var import_node_path45 = __toESM(require("node:path"));
var import_node_process11 = require("node:process");
var import_undici15 = __toESM(require_undici());

// src/pages/upload.tsx
init_import_meta_url();
var import_promises15 = require("node:fs/promises");
var import_node_path44 = require("node:path");
var import_ink7 = __toESM(require_build2());
var import_ink_spinner = __toESM(require_build4());

// ../../node_modules/.pnpm/p-queue@7.2.0/node_modules/p-queue/dist/index.js
init_import_meta_url();
var import_eventemitter3 = __toESM(require_eventemitter3(), 1);

// ../../node_modules/.pnpm/p-timeout@5.0.2/node_modules/p-timeout/index.js
init_import_meta_url();
var TimeoutError = class extends Error {
  constructor(message) {
    super(message);
    this.name = "TimeoutError";
  }
};
__name(TimeoutError, "TimeoutError");
function pTimeout(promise, milliseconds, fallback, options29) {
  let timer;
  const cancelablePromise = new Promise((resolve19, reject) => {
    if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
      throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
    }
    if (milliseconds === Number.POSITIVE_INFINITY) {
      resolve19(promise);
      return;
    }
    options29 = {
      customTimers: { setTimeout, clearTimeout },
      ...options29
    };
    timer = options29.customTimers.setTimeout.call(void 0, () => {
      if (typeof fallback === "function") {
        try {
          resolve19(fallback());
        } catch (error2) {
          reject(error2);
        }
        return;
      }
      const message = typeof fallback === "string" ? fallback : `Promise timed out after ${milliseconds} milliseconds`;
      const timeoutError2 = fallback instanceof Error ? fallback : new TimeoutError(message);
      if (typeof promise.cancel === "function") {
        promise.cancel();
      }
      reject(timeoutError2);
    }, milliseconds);
    (async () => {
      try {
        resolve19(await promise);
      } catch (error2) {
        reject(error2);
      } finally {
        options29.customTimers.clearTimeout.call(void 0, timer);
      }
    })();
  });
  cancelablePromise.clear = () => {
    clearTimeout(timer);
    timer = void 0;
  };
  return cancelablePromise;
}
__name(pTimeout, "pTimeout");

// ../../node_modules/.pnpm/p-queue@7.2.0/node_modules/p-queue/dist/priority-queue.js
init_import_meta_url();

// ../../node_modules/.pnpm/p-queue@7.2.0/node_modules/p-queue/dist/lower-bound.js
init_import_meta_url();
function lowerBound(array, value, comparator) {
  let first = 0;
  let count = array.length;
  while (count > 0) {
    const step = Math.trunc(count / 2);
    let it2 = first + step;
    if (comparator(array[it2], value) <= 0) {
      first = ++it2;
      count -= step + 1;
    } else {
      count = step;
    }
  }
  return first;
}
__name(lowerBound, "lowerBound");

// ../../node_modules/.pnpm/p-queue@7.2.0/node_modules/p-queue/dist/priority-queue.js
var __classPrivateFieldGet2 = function(receiver, state, kind, f) {
  if (kind === "a" && !f)
    throw new TypeError("Private accessor was defined without a getter");
  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
    throw new TypeError("Cannot read private member from an object whose class did not declare it");
  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _PriorityQueue_queue;
var PriorityQueue = class {
  constructor() {
    _PriorityQueue_queue.set(this, []);
  }
  enqueue(run, options29) {
    options29 = {
      priority: 0,
      ...options29
    };
    const element = {
      priority: options29.priority,
      run
    };
    if (this.size && __classPrivateFieldGet2(this, _PriorityQueue_queue, "f")[this.size - 1].priority >= options29.priority) {
      __classPrivateFieldGet2(this, _PriorityQueue_queue, "f").push(element);
      return;
    }
    const index = lowerBound(__classPrivateFieldGet2(this, _PriorityQueue_queue, "f"), element, (a, b2) => b2.priority - a.priority);
    __classPrivateFieldGet2(this, _PriorityQueue_queue, "f").splice(index, 0, element);
  }
  dequeue() {
    const item = __classPrivateFieldGet2(this, _PriorityQueue_queue, "f").shift();
    return item === null || item === void 0 ? void 0 : item.run;
  }
  filter(options29) {
    return __classPrivateFieldGet2(this, _PriorityQueue_queue, "f").filter((element) => element.priority === options29.priority).map((element) => element.run);
  }
  get size() {
    return __classPrivateFieldGet2(this, _PriorityQueue_queue, "f").length;
  }
};
__name(PriorityQueue, "PriorityQueue");
_PriorityQueue_queue = /* @__PURE__ */ new WeakMap();

// ../../node_modules/.pnpm/p-queue@7.2.0/node_modules/p-queue/dist/index.js
var __classPrivateFieldSet2 = function(receiver, state, value, kind, f) {
  if (kind === "m")
    throw new TypeError("Private method is not writable");
  if (kind === "a" && !f)
    throw new TypeError("Private accessor was defined without a setter");
  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
    throw new TypeError("Cannot write private member to an object whose class did not declare it");
  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
};
var __classPrivateFieldGet3 = function(receiver, state, kind, f) {
  if (kind === "a" && !f)
    throw new TypeError("Private accessor was defined without a getter");
  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
    throw new TypeError("Cannot read private member from an object whose class did not declare it");
  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _PQueue_instances;
var _PQueue_carryoverConcurrencyCount;
var _PQueue_isIntervalIgnored;
var _PQueue_intervalCount;
var _PQueue_intervalCap;
var _PQueue_interval;
var _PQueue_intervalEnd;
var _PQueue_intervalId;
var _PQueue_timeoutId;
var _PQueue_queue;
var _PQueue_queueClass;
var _PQueue_pendingCount;
var _PQueue_concurrency;
var _PQueue_isPaused;
var _PQueue_resolveEmpty;
var _PQueue_resolveIdle;
var _PQueue_timeout;
var _PQueue_throwOnTimeout;
var _PQueue_doesIntervalAllowAnother_get;
var _PQueue_doesConcurrentAllowAnother_get;
var _PQueue_next;
var _PQueue_resolvePromises;
var _PQueue_onResumeInterval;
var _PQueue_isIntervalPaused;
var _PQueue_tryToStartAnother;
var _PQueue_initializeIntervalIfNeeded;
var _PQueue_onInterval;
var _PQueue_processQueue;
var empty = /* @__PURE__ */ __name(() => {
}, "empty");
var timeoutError = new TimeoutError();
var AbortError = class extends Error {
};
__name(AbortError, "AbortError");
var PQueue = class extends import_eventemitter3.default {
  constructor(options29) {
    var _a2, _b2, _c2, _d;
    super();
    _PQueue_instances.add(this);
    _PQueue_carryoverConcurrencyCount.set(this, void 0);
    _PQueue_isIntervalIgnored.set(this, void 0);
    _PQueue_intervalCount.set(this, 0);
    _PQueue_intervalCap.set(this, void 0);
    _PQueue_interval.set(this, void 0);
    _PQueue_intervalEnd.set(this, 0);
    _PQueue_intervalId.set(this, void 0);
    _PQueue_timeoutId.set(this, void 0);
    _PQueue_queue.set(this, void 0);
    _PQueue_queueClass.set(this, void 0);
    _PQueue_pendingCount.set(this, 0);
    _PQueue_concurrency.set(this, void 0);
    _PQueue_isPaused.set(this, void 0);
    _PQueue_resolveEmpty.set(this, empty);
    _PQueue_resolveIdle.set(this, empty);
    _PQueue_timeout.set(this, void 0);
    _PQueue_throwOnTimeout.set(this, void 0);
    options29 = {
      carryoverConcurrencyCount: false,
      intervalCap: Number.POSITIVE_INFINITY,
      interval: 0,
      concurrency: Number.POSITIVE_INFINITY,
      autoStart: true,
      queueClass: PriorityQueue,
      ...options29
    };
    if (!(typeof options29.intervalCap === "number" && options29.intervalCap >= 1)) {
      throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${(_b2 = (_a2 = options29.intervalCap) === null || _a2 === void 0 ? void 0 : _a2.toString()) !== null && _b2 !== void 0 ? _b2 : ""}\` (${typeof options29.intervalCap})`);
    }
    if (options29.interval === void 0 || !(Number.isFinite(options29.interval) && options29.interval >= 0)) {
      throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${(_d = (_c2 = options29.interval) === null || _c2 === void 0 ? void 0 : _c2.toString()) !== null && _d !== void 0 ? _d : ""}\` (${typeof options29.interval})`);
    }
    __classPrivateFieldSet2(this, _PQueue_carryoverConcurrencyCount, options29.carryoverConcurrencyCount, "f");
    __classPrivateFieldSet2(this, _PQueue_isIntervalIgnored, options29.intervalCap === Number.POSITIVE_INFINITY || options29.interval === 0, "f");
    __classPrivateFieldSet2(this, _PQueue_intervalCap, options29.intervalCap, "f");
    __classPrivateFieldSet2(this, _PQueue_interval, options29.interval, "f");
    __classPrivateFieldSet2(this, _PQueue_queue, new options29.queueClass(), "f");
    __classPrivateFieldSet2(this, _PQueue_queueClass, options29.queueClass, "f");
    this.concurrency = options29.concurrency;
    __classPrivateFieldSet2(this, _PQueue_timeout, options29.timeout, "f");
    __classPrivateFieldSet2(this, _PQueue_throwOnTimeout, options29.throwOnTimeout === true, "f");
    __classPrivateFieldSet2(this, _PQueue_isPaused, options29.autoStart === false, "f");
  }
  get concurrency() {
    return __classPrivateFieldGet3(this, _PQueue_concurrency, "f");
  }
  set concurrency(newConcurrency) {
    if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) {
      throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
    }
    __classPrivateFieldSet2(this, _PQueue_concurrency, newConcurrency, "f");
    __classPrivateFieldGet3(this, _PQueue_instances, "m", _PQueue_processQueue).call(this);
  }
  /**
  Adds a sync or async task to the queue. Always returns a promise.
  */
  async add(fn2, options29 = {}) {
    return new Promise((resolve19, reject) => {
      const run = /* @__PURE__ */ __name(async () => {
        var _a2;
        var _b2, _c2;
        __classPrivateFieldSet2(this, _PQueue_pendingCount, (_b2 = __classPrivateFieldGet3(this, _PQueue_pendingCount, "f"), _b2++, _b2), "f");
        __classPrivateFieldSet2(this, _PQueue_intervalCount, (_c2 = __classPrivateFieldGet3(this, _PQueue_intervalCount, "f"), _c2++, _c2), "f");
        try {
          if ((_a2 = options29.signal) === null || _a2 === void 0 ? void 0 : _a2.aborted) {
            reject(new AbortError("The task was aborted."));
            return;
          }
          const operation = __classPrivateFieldGet3(this, _PQueue_timeout, "f") === void 0 && options29.timeout === void 0 ? fn2({ signal: options29.signal }) : pTimeout(Promise.resolve(fn2({ signal: options29.signal })), options29.timeout === void 0 ? __classPrivateFieldGet3(this, _PQueue_timeout, "f") : options29.timeout, () => {
            if (options29.throwOnTimeout === void 0 ? __classPrivateFieldGet3(this, _PQueue_throwOnTimeout, "f") : options29.throwOnTimeout) {
              reject(timeoutError);
            }
            return void 0;
          });
          const result = await operation;
          resolve19(result);
          this.emit("completed", result);
        } catch (error2) {
          reject(error2);
          this.emit("error", error2);
        }
        __classPrivateFieldGet3(this, _PQueue_instances, "m", _PQueue_next).call(this);
      }, "run");
      __classPrivateFieldGet3(this, _PQueue_queue, "f").enqueue(run, options29);
      __classPrivateFieldGet3(this, _PQueue_instances, "m", _PQueue_tryToStartAnother).call(this);
      this.emit("add");
    });
  }
  /**
      Same as `.add()`, but accepts an array of sync or async functions.
  
      @returns A promise that resolves when all functions are resolved.
      */
  async addAll(functions, options29) {
    return Promise.all(functions.map(async (function_) => this.add(function_, options29)));
  }
  /**
  Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
  */
  start() {
    if (!__classPrivateFieldGet3(this, _PQueue_isPaused, "f")) {
      return this;
    }
    __classPrivateFieldSet2(this, _PQueue_isPaused, false, "f");
    __classPrivateFieldGet3(this, _PQueue_instances, "m", _PQueue_processQueue).call(this);
    return this;
  }
  /**
  Put queue execution on hold.
  */
  pause() {
    __classPrivateFieldSet2(this, _PQueue_isPaused, true, "f");
  }
  /**
  Clear the queue.
  */
  clear() {
    __classPrivateFieldSet2(this, _PQueue_queue, new (__classPrivateFieldGet3(this, _PQueue_queueClass, "f"))(), "f");
  }
  /**
      Can be called multiple times. Useful if you for example add additional items at a later time.
  
      @returns A promise that settles when the queue becomes empty.
      */
  async onEmpty() {
    if (__classPrivateFieldGet3(this, _PQueue_queue, "f").size === 0) {
      return;
    }
    return new Promise((resolve19) => {
      const existingResolve = __classPrivateFieldGet3(this, _PQueue_resolveEmpty, "f");
      __classPrivateFieldSet2(this, _PQueue_resolveEmpty, () => {
        existingResolve();
        resolve19();
      }, "f");
    });
  }
  /**
      @returns A promise that settles when the queue size is less than the given limit: `queue.size < limit`.
  
      If you want to avoid having the queue grow beyond a certain size you can `await queue.onSizeLessThan()` before adding a new item.
  
      Note that this only limits the number of items waiting to start. There could still be up to `concurrency` jobs already running that this call does not include in its calculation.
      */
  async onSizeLessThan(limit) {
    if (__classPrivateFieldGet3(this, _PQueue_queue, "f").size < limit) {
      return;
    }
    return new Promise((resolve19) => {
      const listener = /* @__PURE__ */ __name(() => {
        if (__classPrivateFieldGet3(this, _PQueue_queue, "f").size < limit) {
          this.removeListener("next", listener);
          resolve19();
        }
      }, "listener");
      this.on("next", listener);
    });
  }
  /**
      The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
  
      @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
      */
  async onIdle() {
    if (__classPrivateFieldGet3(this, _PQueue_pendingCount, "f") === 0 && __classPrivateFieldGet3(this, _PQueue_queue, "f").size === 0) {
      return;
    }
    return new Promise((resolve19) => {
      const existingResolve = __classPrivateFieldGet3(this, _PQueue_resolveIdle, "f");
      __classPrivateFieldSet2(this, _PQueue_resolveIdle, () => {
        existingResolve();
        resolve19();
      }, "f");
    });
  }
  /**
  Size of the queue, the number of queued items waiting to run.
  */
  get size() {
    return __classPrivateFieldGet3(this, _PQueue_queue, "f").size;
  }
  /**
      Size of the queue, filtered by the given options.
  
      For example, this can be used to find the number of items remaining in the queue with a specific priority level.
      */
  sizeBy(options29) {
    return __classPrivateFieldGet3(this, _PQueue_queue, "f").filter(options29).length;
  }
  /**
  Number of running items (no longer in the queue).
  */
  get pending() {
    return __classPrivateFieldGet3(this, _PQueue_pendingCount, "f");
  }
  /**
  Whether the queue is currently paused.
  */
  get isPaused() {
    return __classPrivateFieldGet3(this, _PQueue_isPaused, "f");
  }
  get timeout() {
    return __classPrivateFieldGet3(this, _PQueue_timeout, "f");
  }
  /**
  Set the timeout for future operations.
  */
  set timeout(milliseconds) {
    __classPrivateFieldSet2(this, _PQueue_timeout, milliseconds, "f");
  }
};
__name(PQueue, "PQueue");
_PQueue_carryoverConcurrencyCount = /* @__PURE__ */ new WeakMap(), _PQueue_isIntervalIgnored = /* @__PURE__ */ new WeakMap(), _PQueue_intervalCount = /* @__PURE__ */ new WeakMap(), _PQueue_intervalCap = /* @__PURE__ */ new WeakMap(), _PQueue_interval = /* @__PURE__ */ new WeakMap(), _PQueue_intervalEnd = /* @__PURE__ */ new WeakMap(), _PQueue_intervalId = /* @__PURE__ */ new WeakMap(), _PQueue_timeoutId = /* @__PURE__ */ new WeakMap(), _PQueue_queue = /* @__PURE__ */ new WeakMap(), _PQueue_queueClass = /* @__PURE__ */ new WeakMap(), _PQueue_pendingCount = /* @__PURE__ */ new WeakMap(), _PQueue_concurrency = /* @__PURE__ */ new WeakMap(), _PQueue_isPaused = /* @__PURE__ */ new WeakMap(), _PQueue_resolveEmpty = /* @__PURE__ */ new WeakMap(), _PQueue_resolveIdle = /* @__PURE__ */ new WeakMap(), _PQueue_timeout = /* @__PURE__ */ new WeakMap(), _PQueue_throwOnTimeout = /* @__PURE__ */ new WeakMap(), _PQueue_instances = /* @__PURE__ */ new WeakSet(), _PQueue_doesIntervalAllowAnother_get = /* @__PURE__ */ __name(function _PQueue_doesIntervalAllowAnother_get2() {
  return __classPrivateFieldGet3(this, _PQueue_isIntervalIgnored, "f") || __classPrivateFieldGet3(this, _PQueue_intervalCount, "f") < __classPrivateFieldGet3(this, _PQueue_intervalCap, "f");
}, "_PQueue_doesIntervalAllowAnother_get"), _PQueue_doesConcurrentAllowAnother_get = /* @__PURE__ */ __name(function _PQueue_doesConcurrentAllowAnother_get2() {
  return __classPrivateFieldGet3(this, _PQueue_pendingCount, "f") < __classPrivateFieldGet3(this, _PQueue_concurrency, "f");
}, "_PQueue_doesConcurrentAllowAnother_get"), _PQueue_next = /* @__PURE__ */ __name(function _PQueue_next2() {
  var _a2;
  __classPrivateFieldSet2(this, _PQueue_pendingCount, (_a2 = __classPrivateFieldGet3(this, _PQueue_pendingCount, "f"), _a2--, _a2), "f");
  __classPrivateFieldGet3(this, _PQueue_instances, "m", _PQueue_tryToStartAnother).call(this);
  this.emit("next");
}, "_PQueue_next"), _PQueue_resolvePromises = /* @__PURE__ */ __name(function _PQueue_resolvePromises2() {
  __classPrivateFieldGet3(this, _PQueue_resolveEmpty, "f").call(this);
  __classPrivateFieldSet2(this, _PQueue_resolveEmpty, empty, "f");
  if (__classPrivateFieldGet3(this, _PQueue_pendingCount, "f") === 0) {
    __classPrivateFieldGet3(this, _PQueue_resolveIdle, "f").call(this);
    __classPrivateFieldSet2(this, _PQueue_resolveIdle, empty, "f");
    this.emit("idle");
  }
}, "_PQueue_resolvePromises"), _PQueue_onResumeInterval = /* @__PURE__ */ __name(function _PQueue_onResumeInterval2() {
  __classPrivateFieldGet3(this, _PQueue_instances, "m", _PQueue_onInterval).call(this);
  __classPrivateFieldGet3(this, _PQueue_instances, "m", _PQueue_initializeIntervalIfNeeded).call(this);
  __classPrivateFieldSet2(this, _PQueue_timeoutId, void 0, "f");
}, "_PQueue_onResumeInterval"), _PQueue_isIntervalPaused = /* @__PURE__ */ __name(function _PQueue_isIntervalPaused2() {
  const now = Date.now();
  if (__classPrivateFieldGet3(this, _PQueue_intervalId, "f") === void 0) {
    const delay = __classPrivateFieldGet3(this, _PQueue_intervalEnd, "f") - now;
    if (delay < 0) {
      __classPrivateFieldSet2(this, _PQueue_intervalCount, __classPrivateFieldGet3(this, _PQueue_carryoverConcurrencyCount, "f") ? __classPrivateFieldGet3(this, _PQueue_pendingCount, "f") : 0, "f");
    } else {
      if (__classPrivateFieldGet3(this, _PQueue_timeoutId, "f") === void 0) {
        __classPrivateFieldSet2(this, _PQueue_timeoutId, setTimeout(() => {
          __classPrivateFieldGet3(this, _PQueue_instances, "m", _PQueue_onResumeInterval).call(this);
        }, delay), "f");
      }
      return true;
    }
  }
  return false;
}, "_PQueue_isIntervalPaused"), _PQueue_tryToStartAnother = /* @__PURE__ */ __name(function _PQueue_tryToStartAnother2() {
  if (__classPrivateFieldGet3(this, _PQueue_queue, "f").size === 0) {
    if (__classPrivateFieldGet3(this, _PQueue_intervalId, "f")) {
      clearInterval(__classPrivateFieldGet3(this, _PQueue_intervalId, "f"));
    }
    __classPrivateFieldSet2(this, _PQueue_intervalId, void 0, "f");
    __classPrivateFieldGet3(this, _PQueue_instances, "m", _PQueue_resolvePromises).call(this);
    return false;
  }
  if (!__classPrivateFieldGet3(this, _PQueue_isPaused, "f")) {
    const canInitializeInterval = !__classPrivateFieldGet3(this, _PQueue_instances, "m", _PQueue_isIntervalPaused).call(this);
    if (__classPrivateFieldGet3(this, _PQueue_instances, "a", _PQueue_doesIntervalAllowAnother_get) && __classPrivateFieldGet3(this, _PQueue_instances, "a", _PQueue_doesConcurrentAllowAnother_get)) {
      const job = __classPrivateFieldGet3(this, _PQueue_queue, "f").dequeue();
      if (!job) {
        return false;
      }
      this.emit("active");
      job();
      if (canInitializeInterval) {
        __classPrivateFieldGet3(this, _PQueue_instances, "m", _PQueue_initializeIntervalIfNeeded).call(this);
      }
      return true;
    }
  }
  return false;
}, "_PQueue_tryToStartAnother"), _PQueue_initializeIntervalIfNeeded = /* @__PURE__ */ __name(function _PQueue_initializeIntervalIfNeeded2() {
  if (__classPrivateFieldGet3(this, _PQueue_isIntervalIgnored, "f") || __classPrivateFieldGet3(this, _PQueue_intervalId, "f") !== void 0) {
    return;
  }
  __classPrivateFieldSet2(this, _PQueue_intervalId, setInterval(() => {
    __classPrivateFieldGet3(this, _PQueue_instances, "m", _PQueue_onInterval).call(this);
  }, __classPrivateFieldGet3(this, _PQueue_interval, "f")), "f");
  __classPrivateFieldSet2(this, _PQueue_intervalEnd, Date.now() + __classPrivateFieldGet3(this, _PQueue_interval, "f"), "f");
}, "_PQueue_initializeIntervalIfNeeded"), _PQueue_onInterval = /* @__PURE__ */ __name(function _PQueue_onInterval2() {
  if (__classPrivateFieldGet3(this, _PQueue_intervalCount, "f") === 0 && __classPrivateFieldGet3(this, _PQueue_pendingCount, "f") === 0 && __classPrivateFieldGet3(this, _PQueue_intervalId, "f")) {
    clearInterval(__classPrivateFieldGet3(this, _PQueue_intervalId, "f"));
    __classPrivateFieldSet2(this, _PQueue_intervalId, void 0, "f");
  }
  __classPrivateFieldSet2(this, _PQueue_intervalCount, __classPrivateFieldGet3(this, _PQueue_carryoverConcurrencyCount, "f") ? __classPrivateFieldGet3(this, _PQueue_pendingCount, "f") : 0, "f");
  __classPrivateFieldGet3(this, _PQueue_instances, "m", _PQueue_processQueue).call(this);
}, "_PQueue_onInterval"), _PQueue_processQueue = /* @__PURE__ */ __name(function _PQueue_processQueue2() {
  while (__classPrivateFieldGet3(this, _PQueue_instances, "m", _PQueue_tryToStartAnother).call(this)) {
  }
}, "_PQueue_processQueue");

// src/pages/upload.tsx
var import_react10 = __toESM(require_react());

// src/pages/validate.tsx
init_import_meta_url();
var import_promises14 = require("node:fs/promises");
var import_node_path43 = require("node:path");
var import_mime2 = __toESM(require_mime2());
var import_minimatch = __toESM(require_minimatch());
init_hash();
function Options10(yargs) {
  return yargs.positional("directory", {
    type: "string",
    demandOption: true,
    description: "The directory of static files to validate"
  });
}
__name(Options10, "Options");
var Handler10 = /* @__PURE__ */ __name(async ({ directory }) => {
  if (!directory) {
    throw new FatalError("Must specify a directory.", 1);
  }
  await validate({
    directory
  });
}, "Handler");
var validate = /* @__PURE__ */ __name(async (args) => {
  const IGNORE_LIST = [
    "_worker.js",
    "_redirects",
    "_headers",
    "_routes.json",
    "functions",
    "**/.DS_Store",
    "**/node_modules",
    "**/.git"
  ].map((pattern) => new import_minimatch.Minimatch(pattern));
  const directory = (0, import_node_path43.resolve)(args.directory);
  const walk = /* @__PURE__ */ __name(async (dir, fileMap2 = /* @__PURE__ */ new Map(), startingDir = dir) => {
    const files = await (0, import_promises14.readdir)(dir);
    await Promise.all(
      files.map(async (file) => {
        const filepath = (0, import_node_path43.join)(dir, file);
        const relativeFilepath = (0, import_node_path43.relative)(startingDir, filepath);
        const filestat = await (0, import_promises14.stat)(filepath);
        for (const minimatch of IGNORE_LIST) {
          if (minimatch.match(relativeFilepath)) {
            return;
          }
        }
        if (filestat.isSymbolicLink()) {
          return;
        }
        if (filestat.isDirectory()) {
          fileMap2 = await walk(filepath, fileMap2, startingDir);
        } else {
          const name = relativeFilepath.split(import_node_path43.sep).join("/");
          if (filestat.size > MAX_ASSET_SIZE) {
            throw new FatalError(
              `Error: Pages only supports files up to ${prettyBytes(
                MAX_ASSET_SIZE,
                { binary: true }
              )} in size
${name} is ${prettyBytes(filestat.size, {
                binary: true
              })} in size`,
              1
            );
          }
          fileMap2.set(name, {
            path: filepath,
            contentType: (0, import_mime2.getType)(name) || "application/octet-stream",
            sizeInBytes: filestat.size,
            hash: hashFile(filepath)
          });
        }
      })
    );
    return fileMap2;
  }, "walk");
  const fileMap = await walk(directory);
  if (fileMap.size > MAX_ASSET_COUNT) {
    throw new FatalError(
      `Error: Pages only supports up to ${MAX_ASSET_COUNT.toLocaleString()} files in a deployment. Ensure you have specified your build output directory correctly.`,
      1
    );
  }
  return fileMap;
}, "validate");

// src/pages/upload.tsx
function Options11(yargs) {
  return yargs.positional("directory", {
    type: "string",
    demandOption: true,
    description: "The directory of static files to upload"
  }).options({
    "output-manifest-path": {
      type: "string",
      description: "The name of the project you want to deploy to"
    },
    "skip-caching": {
      type: "boolean",
      description: "Skip asset caching which speeds up builds"
    }
  });
}
__name(Options11, "Options");
var Handler11 = /* @__PURE__ */ __name(async ({
  directory,
  outputManifestPath,
  skipCaching
}) => {
  if (!directory) {
    throw new FatalError("Must specify a directory.", 1);
  }
  if (!process.env.CF_PAGES_UPLOAD_JWT) {
    throw new FatalError("No JWT given.", 1);
  }
  const fileMap = await validate({ directory });
  const manifest = await upload({
    fileMap,
    jwt: process.env.CF_PAGES_UPLOAD_JWT,
    skipCaching: skipCaching ?? false
  });
  if (outputManifestPath) {
    await (0, import_promises15.mkdir)((0, import_node_path44.dirname)(outputManifestPath), { recursive: true });
    await (0, import_promises15.writeFile)(outputManifestPath, JSON.stringify(manifest));
  }
  logger.log(`\u2728 Upload complete!`);
}, "Handler");
var upload = /* @__PURE__ */ __name(async (args) => {
  async function fetchJwt() {
    if ("jwt" in args) {
      return args.jwt;
    } else {
      return (await fetchResult(
        `/accounts/${args.accountId}/pages/projects/${args.projectName}/upload-token`
      )).jwt;
    }
  }
  __name(fetchJwt, "fetchJwt");
  const files = [...args.fileMap.values()];
  let jwt = await fetchJwt();
  const start = Date.now();
  let attempts = 0;
  const getMissingHashes = /* @__PURE__ */ __name(async (skipCaching) => {
    if (skipCaching) {
      logger.debug("Force skipping cache");
      return files.map(({ hash }) => hash);
    }
    try {
      return await fetchResult(`/pages/assets/check-missing`, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${jwt}`
        },
        body: JSON.stringify({
          hashes: files.map(({ hash }) => hash)
        })
      });
    } catch (e3) {
      if (attempts < MAX_CHECK_MISSING_ATTEMPTS) {
        await new Promise(
          (resolvePromise) => setTimeout(resolvePromise, Math.pow(2, attempts++) * 1e3)
        );
        if (e3.code === 8000013 /* UNAUTHORIZED */ || isJwtExpired(jwt)) {
          jwt = await fetchJwt();
        }
        return getMissingHashes(skipCaching);
      } else {
        throw e3;
      }
    }
  }, "getMissingHashes");
  const missingHashes = await getMissingHashes(args.skipCaching);
  const sortedFiles = files.filter((file) => missingHashes.includes(file.hash)).sort((a, b2) => b2.sizeInBytes - a.sizeInBytes);
  const buckets = new Array(BULK_UPLOAD_CONCURRENCY).fill(null).map(() => ({
    files: [],
    remainingSize: MAX_BUCKET_SIZE
  }));
  let bucketOffset = 0;
  for (const file of sortedFiles) {
    let inserted = false;
    for (let i = 0; i < buckets.length; i++) {
      const bucket = buckets[(i + bucketOffset) % buckets.length];
      if (bucket.remainingSize >= file.sizeInBytes && bucket.files.length < MAX_BUCKET_FILE_COUNT) {
        bucket.files.push(file);
        bucket.remainingSize -= file.sizeInBytes;
        inserted = true;
        break;
      }
    }
    if (!inserted) {
      buckets.push({
        files: [file],
        remainingSize: MAX_BUCKET_SIZE - file.sizeInBytes
      });
    }
    bucketOffset++;
  }
  let counter = args.fileMap.size - sortedFiles.length;
  const { rerender, unmount } = renderProgress(counter, args.fileMap.size);
  const queue = new PQueue({ concurrency: BULK_UPLOAD_CONCURRENCY });
  for (const bucket of buckets) {
    if (bucket.files.length === 0)
      continue;
    attempts = 0;
    const doUpload = /* @__PURE__ */ __name(async () => {
      const payload = await Promise.all(
        bucket.files.map(async (file) => ({
          key: file.hash,
          value: (await (0, import_promises15.readFile)(file.path)).toString("base64"),
          metadata: {
            contentType: file.contentType
          },
          base64: true
        }))
      );
      try {
        logger.debug("POST /pages/assets/upload");
        const res = await fetchResult(`/pages/assets/upload`, {
          method: "POST",
          headers: {
            "Content-Type": "application/json",
            Authorization: `Bearer ${jwt}`
          },
          body: JSON.stringify(payload)
        });
        logger.debug("result:", res);
      } catch (e3) {
        if (attempts < MAX_UPLOAD_ATTEMPTS) {
          logger.debug("failed:", e3, "retrying...");
          await new Promise(
            (resolvePromise) => setTimeout(resolvePromise, Math.pow(2, attempts) * 1e3)
          );
          if (e3.code === 8000013 /* UNAUTHORIZED */ || isJwtExpired(jwt)) {
            jwt = await fetchJwt();
          } else {
            attempts++;
          }
          return doUpload();
        } else {
          logger.debug("failed:", e3);
          throw e3;
        }
      }
    }, "doUpload");
    void queue.add(
      () => doUpload().then(
        () => {
          counter += bucket.files.length;
          rerender(counter, args.fileMap.size);
        },
        (error2) => {
          return Promise.reject(
            new FatalError(
              `Failed to upload files. Please try again. Error: ${JSON.stringify(
                error2
              )})`,
              error2.code || 1
            )
          );
        }
      )
    );
  }
  await queue.onIdle();
  unmount();
  const uploadMs = Date.now() - start;
  const skipped = args.fileMap.size - missingHashes.length;
  const skippedMessage = skipped > 0 ? `(${skipped} already uploaded) ` : "";
  logger.log(
    `\u2728 Success! Uploaded ${sortedFiles.length} files ${skippedMessage}${formatTime(uploadMs)}
`
  );
  const doUpsertHashes = /* @__PURE__ */ __name(async () => {
    try {
      return await fetchResult(`/pages/assets/upsert-hashes`, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${jwt}`
        },
        body: JSON.stringify({
          hashes: files.map(({ hash }) => hash)
        })
      });
    } catch (e3) {
      await new Promise((resolvePromise) => setTimeout(resolvePromise, 1e3));
      if (e3.code === 8000013 /* UNAUTHORIZED */ || isJwtExpired(jwt)) {
        jwt = await fetchJwt();
      }
      return await fetchResult(`/pages/assets/upsert-hashes`, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${jwt}`
        },
        body: JSON.stringify({
          hashes: files.map(({ hash }) => hash)
        })
      });
    }
  }, "doUpsertHashes");
  try {
    await doUpsertHashes();
  } catch {
    logger.warn(
      "Failed to update file hashes. Every upload appeared to succeed for this deployment, but you might need to re-upload for future deployments. This shouldn't have any impact other than slowing the upload speed of your next deployment."
    );
  }
  return Object.fromEntries(
    [...args.fileMap.entries()].map(([fileName, file]) => [
      `/${fileName}`,
      file.hash
    ])
  );
}, "upload");
function isJwtExpired(token) {
  try {
    const decodedJwt = JSON.parse(
      Buffer.from(token.split(".")[1], "base64").toString()
    );
    const dateNow = (/* @__PURE__ */ new Date()).getTime() / 1e3;
    return decodedJwt.exp <= dateNow;
  } catch (e3) {
    if (e3 instanceof Error) {
      throw new Error(`Invalid token: ${e3.message}`);
    }
  }
}
__name(isJwtExpired, "isJwtExpired");
function formatTime(duration) {
  return `(${(duration / 1e3).toFixed(2)} sec)`;
}
__name(formatTime, "formatTime");
function renderProgress(done, total) {
  if (isInteractive()) {
    const { rerender, unmount } = (0, import_ink7.render)(
      /* @__PURE__ */ import_react10.default.createElement(Progress, { done, total })
    );
    return {
      // eslint-disable-next-line @typescript-eslint/no-shadow
      rerender(done2, total2) {
        rerender(/* @__PURE__ */ import_react10.default.createElement(Progress, { done: done2, total: total2 }));
      },
      unmount
    };
  } else {
    const rerender = /* @__PURE__ */ __name((done2, total2) => {
      logger.log(`Uploading... (${done2}/${total2})`);
    }, "rerender");
    rerender(done, total);
    return { rerender, unmount() {
    } };
  }
}
__name(renderProgress, "renderProgress");
function Progress({ done, total }) {
  return /* @__PURE__ */ import_react10.default.createElement(import_react10.default.Fragment, null, /* @__PURE__ */ import_react10.default.createElement(import_ink7.Text, null, isInteractive() ? /* @__PURE__ */ import_react10.default.createElement(import_ink_spinner.default, { type: "earth" }) : null, ` Uploading... (${done}/${total})
`));
}
__name(Progress, "Progress");

// src/api/pages/deploy.tsx
async function deploy2({
  directory,
  accountId,
  projectName,
  branch,
  skipCaching,
  commitMessage,
  commitHash,
  commitDirty,
  functionsDirectory: customFunctionsDirectory,
  bundle,
  args
}) {
  let _headers, _redirects, _routesGenerated, _routesCustom, _workerJSIsDirectory = false, _workerJS;
  bundle = bundle ?? true;
  const _workerPath = (0, import_node_path45.resolve)(directory, "_worker.js");
  try {
    _headers = (0, import_node_fs29.readFileSync)((0, import_node_path45.join)(directory, "_headers"), "utf-8");
  } catch {
  }
  try {
    _redirects = (0, import_node_fs29.readFileSync)((0, import_node_path45.join)(directory, "_redirects"), "utf-8");
  } catch {
  }
  try {
    _routesCustom = (0, import_node_fs29.readFileSync)((0, import_node_path45.join)(directory, "_routes.json"), "utf-8");
  } catch {
  }
  try {
    _workerJSIsDirectory = (0, import_node_fs29.lstatSync)(_workerPath).isDirectory();
    if (!_workerJSIsDirectory) {
      _workerJS = (0, import_node_fs29.readFileSync)(_workerPath, "utf-8");
    }
  } catch {
  }
  const project = await fetchResult(
    `/accounts/${accountId}/pages/projects/${projectName}`
  );
  let isProduction = true;
  if (branch) {
    isProduction = project.production_branch === branch;
  }
  const env5 = isProduction ? "production" : "preview";
  const deploymentConfig = project.deployment_configs[env5];
  let config;
  try {
    config = readConfig(
      void 0,
      { ...args, experimentalJsonConfig: false, env: env5 },
      true
    );
  } catch (err) {
    if (!(err instanceof FatalError && err.code === EXIT_CODE_INVALID_PAGES_CONFIG)) {
      throw err;
    }
  }
  const nodejsCompat = config !== void 0 ? config.compatibility_flags?.includes("nodejs_compat") ?? false : deploymentConfig.compatibility_flags?.includes("nodejs_compat") ?? false;
  const defineNavigatorUserAgent = isNavigatorDefined(
    config?.compatibility_date ?? deploymentConfig.compatibility_date,
    config?.compatibility_flags ?? deploymentConfig.compatibility_flags
  );
  let builtFunctions = void 0;
  let workerBundle = void 0;
  const functionsDirectory = customFunctionsDirectory || (0, import_node_path45.join)((0, import_node_process11.cwd)(), "functions");
  const routesOutputPath = !(0, import_node_fs29.existsSync)((0, import_node_path45.join)(directory, "_routes.json")) ? (0, import_node_path45.join)(getPagesTmpDir(), `_routes-${Math.random()}.json`) : void 0;
  let filepathRoutingConfig;
  if (!_workerJS && (0, import_node_fs29.existsSync)(functionsDirectory)) {
    const outputConfigPath = (0, import_node_path45.join)(
      getPagesTmpDir(),
      `functions-filepath-routing-config-${Math.random()}.json`
    );
    try {
      workerBundle = await buildFunctions({
        outputConfigPath,
        functionsDirectory,
        onEnd: () => {
        },
        buildOutputDirectory: directory,
        routesOutputPath,
        local: false,
        nodejsCompat,
        defineNavigatorUserAgent
      });
      builtFunctions = (0, import_node_fs29.readFileSync)(
        workerBundle.resolvedEntryPointPath,
        "utf-8"
      );
      filepathRoutingConfig = (0, import_node_fs29.readFileSync)(outputConfigPath, "utf-8");
    } catch (e3) {
      if (e3 instanceof FunctionsNoRoutesError) {
        logger.warn(
          getFunctionsNoRoutesWarning(functionsDirectory, "skipping")
        );
      } else {
        throw e3;
      }
    }
  }
  const fileMap = await validate({ directory });
  const manifest = await upload({
    fileMap,
    accountId,
    projectName,
    skipCaching: skipCaching ?? false
  });
  const formData = new import_undici15.FormData();
  formData.append("manifest", JSON.stringify(manifest));
  if (branch) {
    formData.append("branch", branch);
  }
  if (commitMessage) {
    formData.append("commit_message", commitMessage);
  }
  if (commitHash) {
    formData.append("commit_hash", commitHash);
  }
  if (commitDirty !== void 0) {
    formData.append("commit_dirty", commitDirty);
  }
  if (_headers) {
    formData.append("_headers", new import_undici15.File([_headers], "_headers"));
    logger.log(`\u2728 Uploading _headers`);
  }
  if (_redirects) {
    formData.append("_redirects", new import_undici15.File([_redirects], "_redirects"));
    logger.log(`\u2728 Uploading _redirects`);
  }
  if (filepathRoutingConfig) {
    formData.append(
      "functions-filepath-routing-config.json",
      new import_undici15.File(
        [filepathRoutingConfig],
        "functions-filepath-routing-config.json"
      )
    );
  }
  if (config !== void 0 && config.configPath !== void 0 && config.pages_build_output_dir) {
    const configHash = (0, import_node_crypto7.createHash)("sha256").update(await (0, import_promises16.readFile)(config.configPath)).digest("hex");
    const outputDir = import_node_path45.default.relative(
      process.cwd(),
      config.pages_build_output_dir
    );
    formData.append("wrangler_config_hash", configHash);
    formData.append("pages_build_output_dir", outputDir);
  }
  if (_workerJSIsDirectory) {
    workerBundle = await produceWorkerBundleForWorkerJSDirectory({
      workerJSDirectory: _workerPath,
      bundle,
      buildOutputDirectory: directory,
      nodejsCompat,
      defineNavigatorUserAgent
    });
  } else if (_workerJS) {
    if (bundle) {
      const outfile = (0, import_node_path45.join)(
        getPagesTmpDir(),
        `./bundledWorker-${Math.random()}.mjs`
      );
      workerBundle = await buildRawWorker({
        workerScriptPath: _workerPath,
        outfile,
        directory,
        local: false,
        sourcemap: true,
        watch: false,
        onEnd: () => {
        },
        nodejsCompat,
        defineNavigatorUserAgent
      });
    } else {
      await checkRawWorker(_workerPath, nodejsCompat, () => {
      });
      workerBundle = {
        modules: [],
        dependencies: {},
        stop: void 0,
        resolvedEntryPointPath: _workerPath,
        bundleType: "esm"
      };
    }
  }
  if (_workerJS || _workerJSIsDirectory) {
    const workerBundleContents = await createUploadWorkerBundleContents(
      workerBundle,
      config
    );
    formData.append(
      "_worker.bundle",
      new import_undici15.File([workerBundleContents], "_worker.bundle")
    );
    logger.log(`\u2728 Uploading Worker bundle`);
    if (_routesCustom) {
      try {
        const routesCustomJSON = JSON.parse(_routesCustom);
        validateRoutes(routesCustomJSON, (0, import_node_path45.join)(directory, "_routes.json"));
        formData.append(
          "_routes.json",
          new import_undici15.File([_routesCustom], "_routes.json")
        );
        logger.log(`\u2728 Uploading _routes.json`);
      } catch (err) {
        if (err instanceof FatalError) {
          throw err;
        }
      }
    }
  }
  if (builtFunctions && !_workerJS && !_workerJSIsDirectory) {
    const workerBundleContents = await createUploadWorkerBundleContents(
      workerBundle,
      config
    );
    formData.append(
      "_worker.bundle",
      new import_undici15.File([workerBundleContents], "_worker.bundle")
    );
    logger.log(`\u2728 Uploading Functions bundle`);
    if (_routesCustom) {
      try {
        const routesCustomJSON = JSON.parse(_routesCustom);
        validateRoutes(routesCustomJSON, (0, import_node_path45.join)(directory, "_routes.json"));
        formData.append(
          "_routes.json",
          new import_undici15.File([_routesCustom], "_routes.json")
        );
        logger.log(`\u2728 Uploading _routes.json`);
      } catch (err) {
        if (err instanceof FatalError) {
          throw err;
        }
      }
    } else if (routesOutputPath) {
      try {
        _routesGenerated = (0, import_node_fs29.readFileSync)(routesOutputPath, "utf-8");
        if (_routesGenerated) {
          formData.append(
            "_routes.json",
            new import_undici15.File([_routesGenerated], "_routes.json")
          );
        }
      } catch {
      }
    }
  }
  let attempts = 0;
  let lastErr;
  while (attempts < MAX_DEPLOYMENT_ATTEMPTS) {
    try {
      const deploymentResponse = await fetchResult(
        `/accounts/${accountId}/pages/projects/${projectName}/deployments`,
        {
          method: "POST",
          body: formData
        }
      );
      return deploymentResponse;
    } catch (e3) {
      lastErr = e3;
      if (e3.code === 8e6 /* UNKNOWN_ERROR */ && attempts < MAX_DEPLOYMENT_ATTEMPTS) {
        logger.debug("failed:", e3, "retrying...");
        await new Promise(
          (resolvePromise) => setTimeout(resolvePromise, Math.pow(2, attempts++) * 1e3)
        );
      } else {
        logger.debug("failed:", e3);
        throw e3;
      }
    }
  }
  throw lastErr;
}
__name(deploy2, "deploy");

// src/pages/projects.tsx
init_import_meta_url();
var import_node_child_process3 = require("node:child_process");
var import_ink_table7 = __toESM(require_dist4());
var import_react11 = __toESM(require_react());

// ../../node_modules/.pnpm/timeago.js@4.0.2/node_modules/timeago.js/esm/index.js
init_import_meta_url();

// ../../node_modules/.pnpm/timeago.js@4.0.2/node_modules/timeago.js/esm/lang/en_US.js
init_import_meta_url();
var EN_US = ["second", "minute", "hour", "day", "week", "month", "year"];
function en_US_default(diff, idx) {
  if (idx === 0)
    return ["just now", "right now"];
  var unit = EN_US[Math.floor(idx / 2)];
  if (diff > 1)
    unit += "s";
  return [diff + " " + unit + " ago", "in " + diff + " " + unit];
}
__name(en_US_default, "default");

// ../../node_modules/.pnpm/timeago.js@4.0.2/node_modules/timeago.js/esm/lang/zh_CN.js
init_import_meta_url();
var ZH_CN = ["\u79D2", "\u5206\u949F", "\u5C0F\u65F6", "\u5929", "\u5468", "\u4E2A\u6708", "\u5E74"];
function zh_CN_default(diff, idx) {
  if (idx === 0)
    return ["\u521A\u521A", "\u7247\u523B\u540E"];
  var unit = ZH_CN[~~(idx / 2)];
  return [diff + " " + unit + "\u524D", diff + " " + unit + "\u540E"];
}
__name(zh_CN_default, "default");

// ../../node_modules/.pnpm/timeago.js@4.0.2/node_modules/timeago.js/esm/register.js
init_import_meta_url();
var Locales = {};
var register = /* @__PURE__ */ __name(function(locale, func) {
  Locales[locale] = func;
}, "register");
var getLocale = /* @__PURE__ */ __name(function(locale) {
  return Locales[locale] || Locales["en_US"];
}, "getLocale");

// ../../node_modules/.pnpm/timeago.js@4.0.2/node_modules/timeago.js/esm/format.js
init_import_meta_url();

// ../../node_modules/.pnpm/timeago.js@4.0.2/node_modules/timeago.js/esm/utils/date.js
init_import_meta_url();
var SEC_ARRAY = [
  60,
  60,
  24,
  7,
  365 / 7 / 12,
  12
];
function toDate(input) {
  if (input instanceof Date)
    return input;
  if (!isNaN(input) || /^\d+$/.test(input))
    return new Date(parseInt(input));
  input = (input || "").trim().replace(/\.\d+/, "").replace(/-/, "/").replace(/-/, "/").replace(/(\d)T(\d)/, "$1 $2").replace(/Z/, " UTC").replace(/([+-]\d\d):?(\d\d)/, " $1$2");
  return new Date(input);
}
__name(toDate, "toDate");
function formatDiff(diff, localeFunc) {
  var agoIn = diff < 0 ? 1 : 0;
  diff = Math.abs(diff);
  var totalSec = diff;
  var idx = 0;
  for (; diff >= SEC_ARRAY[idx] && idx < SEC_ARRAY.length; idx++) {
    diff /= SEC_ARRAY[idx];
  }
  diff = Math.floor(diff);
  idx *= 2;
  if (diff > (idx === 0 ? 9 : 1))
    idx += 1;
  return localeFunc(diff, idx, totalSec)[agoIn].replace("%s", diff.toString());
}
__name(formatDiff, "formatDiff");
function diffSec(date, relativeDate) {
  var relDate = relativeDate ? toDate(relativeDate) : /* @__PURE__ */ new Date();
  return (+relDate - +toDate(date)) / 1e3;
}
__name(diffSec, "diffSec");

// ../../node_modules/.pnpm/timeago.js@4.0.2/node_modules/timeago.js/esm/format.js
var format8 = /* @__PURE__ */ __name(function(date, locale, opts) {
  var sec = diffSec(date, opts && opts.relativeDate);
  return formatDiff(sec, getLocale(locale));
}, "format");

// ../../node_modules/.pnpm/timeago.js@4.0.2/node_modules/timeago.js/esm/realtime.js
init_import_meta_url();

// ../../node_modules/.pnpm/timeago.js@4.0.2/node_modules/timeago.js/esm/utils/dom.js
init_import_meta_url();

// ../../node_modules/.pnpm/timeago.js@4.0.2/node_modules/timeago.js/esm/index.js
register("en_US", en_US_default);
register("zh_CN", zh_CN_default);

// src/pages/projects.tsx
function ListOptions3(yargs) {
  return yargs;
}
__name(ListOptions3, "ListOptions");
async function ListHandler3() {
  const config = getConfigCache(PAGES_CONFIG_CACHE_FILENAME);
  const accountId = await requireAuth(config);
  const projects = await listProjects2({ accountId });
  const data = projects.map((project) => {
    return {
      "Project Name": project.name,
      "Project Domains": `${project.domains.join(", ")}`,
      "Git Provider": project.source ? "Yes" : "No",
      "Last Modified": project.latest_deployment ? format8(project.latest_deployment.modified_on) : format8(project.created_on)
    };
  });
  saveToConfigCache(PAGES_CONFIG_CACHE_FILENAME, {
    account_id: accountId
  });
  logger.log(renderToString(/* @__PURE__ */ import_react11.default.createElement(import_ink_table7.default, { data })));
  await sendMetricsEvent("list pages projects");
}
__name(ListHandler3, "ListHandler");
var listProjects2 = /* @__PURE__ */ __name(async ({
  accountId
}) => {
  const pageSize = 10;
  let page = 1;
  const results = [];
  while (results.length % pageSize === 0) {
    const json = await fetchResult(
      `/accounts/${accountId}/pages/projects`,
      {},
      new URLSearchParams({
        per_page: pageSize.toString(),
        page: page.toString()
      })
    );
    page++;
    results.push(...json);
    if (json.length < pageSize) {
      break;
    }
  }
  return results;
}, "listProjects");
function CreateOptions3(yargs) {
  return yargs.positional("project-name", {
    type: "string",
    demandOption: true,
    description: "The name of your Pages project"
  }).options({
    "production-branch": {
      type: "string",
      description: "The name of the production branch of your project"
    },
    "compatibility-flags": {
      describe: "Flags to use for compatibility checks",
      alias: "compatibility-flag",
      type: "string",
      requiresArg: true,
      array: true
    },
    "compatibility-date": {
      describe: "Date to use for compatibility checks",
      type: "string",
      requiresArg: true
    }
  });
}
__name(CreateOptions3, "CreateOptions");
async function CreateHandler3({
  productionBranch,
  compatibilityFlags,
  compatibilityDate,
  projectName
}) {
  const config = getConfigCache(PAGES_CONFIG_CACHE_FILENAME);
  const accountId = await requireAuth(config);
  const isInteractive3 = process.stdin.isTTY;
  if (!projectName && isInteractive3) {
    projectName = await prompt("Enter the name of your new project:");
  }
  if (!projectName) {
    throw new FatalError("Must specify a project name.", 1);
  }
  if (!productionBranch && isInteractive3) {
    let isGitDir = true;
    try {
      (0, import_node_child_process3.execSync)(`git rev-parse --is-inside-work-tree`, {
        stdio: "ignore"
      });
    } catch (err) {
      isGitDir = false;
    }
    if (isGitDir) {
      try {
        productionBranch = (0, import_node_child_process3.execSync)(`git rev-parse --abbrev-ref HEAD`).toString().trim();
      } catch (err) {
      }
    }
    productionBranch = await prompt("Enter the production branch name:", {
      defaultValue: productionBranch ?? "production"
    });
  }
  if (!productionBranch) {
    throw new FatalError("Must specify a production branch.", 1);
  }
  const deploymentConfig = {
    ...compatibilityFlags && {
      compatibility_flags: [...compatibilityFlags]
    },
    ...compatibilityDate && {
      compatibility_date: compatibilityDate
    }
  };
  const body = {
    name: projectName,
    production_branch: productionBranch,
    deployment_configs: {
      production: { ...deploymentConfig },
      preview: { ...deploymentConfig }
    }
  };
  const { subdomain } = await fetchResult(
    `/accounts/${accountId}/pages/projects`,
    {
      method: "POST",
      body: JSON.stringify(body)
    }
  );
  saveToConfigCache(PAGES_CONFIG_CACHE_FILENAME, {
    account_id: accountId,
    project_name: projectName
  });
  logger.log(
    `\u2728 Successfully created the '${projectName}' project. It will be available at https://${subdomain}/ once you create your first deployment.`
  );
  logger.log(
    `To deploy a folder of assets, run 'wrangler pages deploy [directory]'.`
  );
  await sendMetricsEvent("create pages project");
}
__name(CreateHandler3, "CreateHandler");
function DeleteOptions(yargs) {
  return yargs.positional("project-name", {
    type: "string",
    demandOption: true,
    description: "The name of your Pages project"
  }).options({
    yes: {
      alias: "y",
      type: "boolean",
      description: 'Answer "yes" to confirm project deletion'
    }
  });
}
__name(DeleteOptions, "DeleteOptions");
async function DeleteHandler(args) {
  const config = getConfigCache(PAGES_CONFIG_CACHE_FILENAME);
  const accountId = await requireAuth(config);
  const confirmed = args.yes || await confirm(
    `Are you sure you want to delete "${args.projectName}"? This action cannot be undone.`
  );
  if (confirmed) {
    logger.log("Deleting", args.projectName);
    await fetchResult(
      `/accounts/${accountId}/pages/projects/${args.projectName}`,
      { method: "DELETE" }
    );
    logger.log("Successfully deleted", args.projectName);
  }
}
__name(DeleteHandler, "DeleteHandler");

// src/pages/prompt-select-project.tsx
init_import_meta_url();
var import_ink8 = __toESM(require_build2());
var import_ink_select_input = __toESM(require_build3());
var import_react12 = __toESM(require_react());
async function promptSelectProject({
  accountId
}) {
  const projects = await listProjects2({ accountId });
  return new Promise((resolve19) => {
    const { unmount } = (0, import_ink8.render)(
      /* @__PURE__ */ import_react12.default.createElement(import_react12.default.Fragment, null, /* @__PURE__ */ import_react12.default.createElement(import_ink8.Text, null, "Select a project:"), /* @__PURE__ */ import_react12.default.createElement(
        import_ink_select_input.default,
        {
          items: projects.map((project) => ({
            key: project.name,
            label: project.name,
            value: project
          })),
          onSelect: async (selected) => {
            resolve19(selected.value.name);
            unmount();
          }
        }
      ))
    );
  });
}
__name(promptSelectProject, "promptSelectProject");

// src/pages/deploy.tsx
function Options12(yargs) {
  return yargs.positional("directory", {
    type: "string",
    demandOption: true,
    description: "The directory of static files to upload"
  }).options({
    "project-name": {
      type: "string",
      description: "The name of the project you want to deploy to"
    },
    branch: {
      type: "string",
      description: "The name of the branch you want to deploy to"
    },
    "commit-hash": {
      type: "string",
      description: "The SHA to attach to this deployment"
    },
    "commit-message": {
      type: "string",
      description: "The commit message to attach to this deployment"
    },
    "commit-dirty": {
      type: "boolean",
      description: "Whether or not the workspace should be considered dirty for this deployment"
    },
    "skip-caching": {
      type: "boolean",
      description: "Skip asset caching which speeds up builds"
    },
    bundle: {
      type: "boolean",
      default: void 0,
      hidden: true
    },
    "no-bundle": {
      type: "boolean",
      default: false,
      description: "Whether to run bundling on `_worker.js` before deploying"
    },
    config: {
      describe: "Pages does not support wrangler.toml",
      type: "string",
      hidden: true
    }
  });
}
__name(Options12, "Options");
var Handler12 = /* @__PURE__ */ __name(async (args) => {
  let { branch, commitHash, commitMessage, commitDirty } = args;
  if (args._[1] === "publish") {
    logger.warn(
      "`wrangler pages publish` is deprecated and will be removed in the next major version.\nPlease use `wrangler pages deploy` instead, which accepts exactly the same arguments."
    );
  }
  if (args.config) {
    throw new FatalError(
      "Pages does not support custom paths for the `wrangler.toml` configuration file",
      1
    );
  }
  let config;
  const configPath = findWranglerToml(process.cwd(), false);
  try {
    config = readConfig(configPath, { ...args, env: void 0 }, true);
  } catch (err) {
    if (!(err instanceof FatalError && err.code === EXIT_CODE_INVALID_PAGES_CONFIG)) {
      throw err;
    }
  }
  if (configPath && config === void 0) {
    logger.warn(
      `Pages now has wrangler.toml support.
We detected a configuration file at ${configPath} but it is missing the "pages_build_output_dir" field, required by Pages.
If you would like to use this configuration file to deploy your project, please use "pages_build_output_dir" to specify the directory of static files to upload.
Ignoring configuration file for now, and proceeding with project deploy.`
    );
  }
  const directory = args.directory ?? config?.pages_build_output_dir;
  if (!directory) {
    throw new FatalError(
      "Must specify a directory of assets to deploy. Please specify the [<directory>] argument in the `pages deploy` command, or configure `pages_build_output_dir` in your `wrangler.toml` configuration file.",
      1
    );
  }
  const configCache = getConfigCache(
    PAGES_CONFIG_CACHE_FILENAME
  );
  const accountId = await requireAuth(configCache);
  let projectName = args.projectName ?? config?.name ?? configCache.project_name;
  let isExistingProject = true;
  if (projectName) {
    try {
      await fetchResult(
        `/accounts/${accountId}/pages/projects/${projectName}`
      );
    } catch (err) {
      if (err.code !== 8000007) {
        throw err;
      } else {
        isExistingProject = false;
      }
    }
  }
  const isInteractive3 = process.stdin.isTTY;
  if ((!projectName || !isExistingProject) && isInteractive3) {
    let existingOrNew = "new";
    if (!projectName) {
      const duProjects = (await listProjects2({ accountId })).filter(
        (project) => !project.source
      );
      if (duProjects.length > 0) {
        const message = "No project specified. Would you like to create one or use an existing project?";
        const items = [
          {
            key: "new",
            label: "Create a new project",
            value: "new"
          },
          {
            key: "existing",
            label: "Use an existing project",
            value: "existing"
          }
        ];
        existingOrNew = await promptSelectExistingOrNewProject(message, items);
      }
    }
    if (projectName !== void 0 && !isExistingProject) {
      const message = `The project you specified does not exist: "${projectName}". Would you like to create it?"`;
      const items = [
        {
          key: "new",
          label: "Create a new project",
          value: "new"
        }
      ];
      existingOrNew = await promptSelectExistingOrNewProject(message, items);
    }
    switch (existingOrNew) {
      case "existing": {
        projectName = await promptSelectProject({ accountId });
        break;
      }
      case "new": {
        if (!projectName) {
          projectName = await prompt("Enter the name of your new project:");
          if (!projectName) {
            throw new FatalError("Must specify a project name.", 1);
          }
        }
        let isGitDir2 = true;
        try {
          (0, import_node_child_process4.execSync)(`git rev-parse --is-inside-work-tree`, {
            stdio: "ignore"
          });
        } catch (err) {
          isGitDir2 = false;
        }
        const productionBranch = await prompt(
          "Enter the production branch name:",
          {
            defaultValue: isGitDir2 ? (0, import_node_child_process4.execSync)(`git rev-parse --abbrev-ref HEAD`).toString().trim() : "production"
          }
        );
        if (!productionBranch) {
          throw new FatalError("Must specify a production branch.", 1);
        }
        await fetchResult(`/accounts/${accountId}/pages/projects`, {
          method: "POST",
          body: JSON.stringify({
            name: projectName,
            production_branch: productionBranch
          })
        });
        saveToConfigCache(PAGES_CONFIG_CACHE_FILENAME, {
          account_id: accountId,
          project_name: projectName
        });
        logger.log(`\u2728 Successfully created the '${projectName}' project.`);
        await sendMetricsEvent("create pages project");
        break;
      }
    }
  }
  if (!projectName) {
    throw new FatalError("Must specify a project name.", 1);
  }
  let isGitDir = true;
  try {
    (0, import_node_child_process4.execSync)(`git rev-parse --is-inside-work-tree`, {
      stdio: "ignore"
    });
  } catch (err) {
    isGitDir = false;
  }
  let isGitDirty = false;
  if (isGitDir) {
    try {
      isGitDirty = Boolean(
        (0, import_node_child_process4.execSync)(`git status --porcelain`).toString().length
      );
      if (!branch) {
        branch = (0, import_node_child_process4.execSync)(`git rev-parse --abbrev-ref HEAD`).toString().trim();
      }
      if (!commitHash) {
        commitHash = (0, import_node_child_process4.execSync)(`git rev-parse HEAD`).toString().trim();
      }
      if (!commitMessage) {
        commitMessage = (0, import_node_child_process4.execSync)(`git show -s --format=%B ${commitHash}`).toString().trim();
      }
    } catch (err) {
    }
    if (isGitDirty && !commitDirty) {
      logger.warn(
        `Warning: Your working directory is a git repo and has uncommitted changes
To silence this warning, pass in --commit-dirty=true`
      );
    }
    if (commitDirty === void 0) {
      commitDirty = isGitDirty;
    }
  }
  const deploymentResponse = await deploy2({
    directory,
    accountId,
    projectName,
    branch,
    commitMessage,
    commitHash,
    commitDirty,
    skipCaching: args.skipCaching,
    // TODO: Here lies a known bug. If you specify both `--bundle` and `--no-bundle`, this behavior is undefined and you will get unexpected results.
    // There is no sane way to get the true value out of yargs, so here we are.
    bundle: args.bundle ?? !args.noBundle,
    args
  });
  saveToConfigCache(PAGES_CONFIG_CACHE_FILENAME, {
    account_id: accountId,
    project_name: projectName
  });
  logger.log(
    `\u2728 Deployment complete! Take a peek over at ${deploymentResponse.url}`
  );
  await sendMetricsEvent("create pages deployment");
}, "Handler");
function promptSelectExistingOrNewProject(message, items) {
  return new Promise((resolve19) => {
    const { unmount } = (0, import_ink9.render)(
      /* @__PURE__ */ import_react13.default.createElement(import_react13.default.Fragment, null, /* @__PURE__ */ import_react13.default.createElement(import_ink9.Text, null, message), /* @__PURE__ */ import_react13.default.createElement(
        import_ink_select_input2.default,
        {
          items,
          onSelect: async (selected) => {
            resolve19(selected.value);
            unmount();
          }
        }
      ))
    );
  });
}
__name(promptSelectExistingOrNewProject, "promptSelectExistingOrNewProject");

// src/pages/deployment-tails.ts
init_import_meta_url();
var import_promises17 = require("node:timers/promises");
var import_signal_exit6 = __toESM(require_signal_exit());

// src/tail/createTail.ts
init_import_meta_url();
var import_https_proxy_agent = __toESM(require_dist6());

// ../../node_modules/.pnpm/ws@8.11.0/node_modules/ws/wrapper.mjs
init_import_meta_url();
var import_stream2 = __toESM(require_stream3(), 1);
var import_receiver = __toESM(require_receiver4(), 1);
var import_sender = __toESM(require_sender2(), 1);
var import_websocket = __toESM(require_websocket4(), 1);
var import_websocket_server = __toESM(require_websocket_server2(), 1);
var wrapper_default = import_websocket.default;

// src/tail/filters.ts
init_import_meta_url();
function translateCLICommandToFilterMessage(cliFilters) {
  const apiFilters = [];
  if (cliFilters.samplingRate) {
    apiFilters.push(parseSamplingRate(cliFilters.samplingRate));
  }
  if (cliFilters.status) {
    apiFilters.push(parseOutcome(cliFilters.status));
  }
  if (cliFilters.method) {
    apiFilters.push(parseMethod(cliFilters.method));
  }
  if (cliFilters.header) {
    apiFilters.push(parseHeader(cliFilters.header));
  }
  if (cliFilters.clientIp) {
    apiFilters.push(parseIP(cliFilters.clientIp));
  }
  if (cliFilters.search) {
    apiFilters.push(parseQuery(cliFilters.search));
  }
  if (cliFilters.versionId) {
    apiFilters.push(parseScriptVersion(cliFilters.versionId));
  }
  return {
    filters: apiFilters
  };
}
__name(translateCLICommandToFilterMessage, "translateCLICommandToFilterMessage");
function parseSamplingRate(sampling_rate) {
  if (sampling_rate <= 0 || sampling_rate >= 1) {
    throw new UserError(
      "A sampling rate must be between 0 and 1 in order to have any effect.\nFor example, a sampling rate of 0.25 means 25% of events will be logged."
    );
  }
  return { sampling_rate };
}
__name(parseSamplingRate, "parseSamplingRate");
function parseOutcome(statuses) {
  const outcomes = /* @__PURE__ */ new Set();
  for (const status2 of statuses) {
    switch (status2) {
      case "ok":
        outcomes.add("ok");
        break;
      case "canceled":
        outcomes.add("canceled");
        break;
      case "error":
        outcomes.add("exception");
        outcomes.add("exceededCpu");
        outcomes.add("exceededMemory");
        outcomes.add("unknown");
        break;
      default:
        break;
    }
  }
  return {
    outcome: Array.from(outcomes)
  };
}
__name(parseOutcome, "parseOutcome");
function parseMethod(method) {
  return { method };
}
__name(parseMethod, "parseMethod");
function parseHeader(header) {
  const [headerKey, headerQuery] = header.split(":", 2);
  return {
    header: {
      key: headerKey.trim(),
      query: headerQuery?.trim()
    }
  };
}
__name(parseHeader, "parseHeader");
function parseIP(client_ip) {
  return { client_ip };
}
__name(parseIP, "parseIP");
function parseQuery(query) {
  return { query };
}
__name(parseQuery, "parseQuery");
function parseScriptVersion(scriptVersion) {
  return { scriptVersion };
}
__name(parseScriptVersion, "parseScriptVersion");

// src/tail/printing.ts
init_import_meta_url();
var import_chalk12 = __toESM(require_chalk());
function prettyPrintLogs(data) {
  const eventMessage2 = JSON.parse(data.toString());
  if (isScheduledEvent(eventMessage2.event)) {
    const cronPattern = eventMessage2.event.cron;
    const datetime = new Date(
      eventMessage2.event.scheduledTime
    ).toLocaleString();
    const outcome = prettifyOutcome(eventMessage2.outcome);
    logger.log(`"${cronPattern}" @ ${datetime} - ${outcome}`);
  } else if (isRequestEvent(eventMessage2.event)) {
    const requestMethod = eventMessage2.event?.request.method.toUpperCase();
    const url4 = eventMessage2.event?.request.url;
    const outcome = prettifyOutcome(eventMessage2.outcome);
    const datetime = new Date(eventMessage2.eventTimestamp).toLocaleString();
    logger.log(
      url4 ? `${requestMethod} ${url4} - ${outcome} @ ${datetime}` : `[missing request] - ${outcome} @ ${datetime}`
    );
  } else if (isEmailEvent(eventMessage2.event)) {
    const outcome = prettifyOutcome(eventMessage2.outcome);
    const datetime = new Date(eventMessage2.eventTimestamp).toLocaleString();
    const mailFrom = eventMessage2.event.mailFrom;
    const rcptTo = eventMessage2.event.rcptTo;
    const rawSize = eventMessage2.event.rawSize;
    logger.log(
      `Email from:${mailFrom} to:${rcptTo} size:${rawSize} @ ${datetime} - ${outcome}`
    );
  } else if (isAlarmEvent(eventMessage2.event)) {
    const outcome = prettifyOutcome(eventMessage2.outcome);
    const datetime = new Date(
      eventMessage2.event.scheduledTime
    ).toLocaleString();
    logger.log(`Alarm @ ${datetime} - ${outcome}`);
  } else if (isTailEvent(eventMessage2.event)) {
    const outcome = prettifyOutcome(eventMessage2.outcome);
    const datetime = new Date(eventMessage2.eventTimestamp).toLocaleString();
    const tailedScripts = new Set(
      eventMessage2.event.consumedEvents.map((consumedEvent) => consumedEvent.scriptName).filter((scriptName) => !!scriptName)
    );
    logger.log(
      `Tailing ${Array.from(tailedScripts).join(
        ","
      )} - ${outcome} @ ${datetime}`
    );
  } else if (isTailInfo(eventMessage2.event)) {
    if (eventMessage2.event.type === "overload") {
      logger.log(`${import_chalk12.default.red.bold(eventMessage2.event.message)}`);
    } else if (eventMessage2.event.type === "overload-stop") {
      logger.log(`${import_chalk12.default.yellow.bold(eventMessage2.event.message)}`);
    }
  } else if (isQueueEvent(eventMessage2.event)) {
    const outcome = prettifyOutcome(eventMessage2.outcome);
    const datetime = new Date(eventMessage2.eventTimestamp).toLocaleString();
    const queueName = eventMessage2.event.queue;
    const batchSize = eventMessage2.event.batchSize;
    const batchSizeMsg = `${batchSize} message${batchSize !== 1 ? "s" : ""}`;
    logger.log(
      `Queue ${queueName} (${batchSizeMsg}) - ${outcome} @ ${datetime}`
    );
  } else {
    const outcome = prettifyOutcome(eventMessage2.outcome);
    const datetime = new Date(eventMessage2.eventTimestamp).toLocaleString();
    logger.log(`Unknown Event - ${outcome} @ ${datetime}`);
  }
  if (eventMessage2.logs.length > 0) {
    eventMessage2.logs.forEach(({ level, message }) => {
      logger.log(`  (${level})`, ...message);
    });
  }
  if (eventMessage2.exceptions.length > 0) {
    eventMessage2.exceptions.forEach(({ name, message }) => {
      logger.error(`  ${name}:`, message);
    });
  }
}
__name(prettyPrintLogs, "prettyPrintLogs");
function jsonPrintLogs(data) {
  console.log(JSON.stringify(JSON.parse(data.toString()), null, 2));
}
__name(jsonPrintLogs, "jsonPrintLogs");
function isRequestEvent(event) {
  return Boolean(event && "request" in event);
}
__name(isRequestEvent, "isRequestEvent");
function isScheduledEvent(event) {
  return Boolean(event && "cron" in event);
}
__name(isScheduledEvent, "isScheduledEvent");
function isEmailEvent(event) {
  return Boolean(event && "mailFrom" in event);
}
__name(isEmailEvent, "isEmailEvent");
function isQueueEvent(event) {
  return Boolean(event && "queue" in event);
}
__name(isQueueEvent, "isQueueEvent");
function isAlarmEvent(event) {
  return Boolean(event && "scheduledTime" in event && !("cron" in event));
}
__name(isAlarmEvent, "isAlarmEvent");
function isTailEvent(event) {
  return Boolean(event && "consumedEvents" in event);
}
__name(isTailEvent, "isTailEvent");
function isTailInfo(event) {
  return Boolean(event && "message" in event && "type" in event);
}
__name(isTailInfo, "isTailInfo");
function prettifyOutcome(outcome) {
  switch (outcome) {
    case "ok":
      return "Ok";
    case "canceled":
      return "Canceled";
    case "exceededCpu":
      return "Exceeded CPU Limit";
    case "exceededMemory":
      return "Exceeded Memory Limit";
    case "exception":
      return "Exception Thrown";
    case "unknown":
    default:
      return "Unknown";
  }
}
__name(prettifyOutcome, "prettifyOutcome");

// src/tail/createTail.ts
var TRACE_VERSION = "trace-v1";
function makeCreateTailUrl(accountId, workerName, env5) {
  return env5 ? `/accounts/${accountId}/workers/services/${workerName}/environments/${env5}/tails` : `/accounts/${accountId}/workers/scripts/${workerName}/tails`;
}
__name(makeCreateTailUrl, "makeCreateTailUrl");
function makeDeleteTailUrl(accountId, workerName, tailId, env5) {
  return env5 ? `/accounts/${accountId}/workers/services/${workerName}/environments/${env5}/tails/${tailId}` : `/accounts/${accountId}/workers/scripts/${workerName}/tails/${tailId}`;
}
__name(makeDeleteTailUrl, "makeDeleteTailUrl");
async function createPagesTail({
  accountId,
  projectName,
  deploymentId,
  filters,
  debug = false
}) {
  const tailRecord = await fetchResult(
    `/accounts/${accountId}/pages/projects/${projectName}/deployments/${deploymentId}/tails`,
    {
      method: "POST",
      body: JSON.stringify(filters)
    }
  );
  const deleteTail = /* @__PURE__ */ __name(async () => fetchResult(
    `/accounts/${accountId}/pages/projects/${projectName}/deployments/${deploymentId}/tails/${tailRecord.id}`,
    { method: "DELETE" }
  ), "deleteTail");
  const p2 = proxy ? { agent: new import_https_proxy_agent.HttpsProxyAgent(proxy) } : {};
  const tail = new wrapper_default(tailRecord.url, TRACE_VERSION, {
    headers: {
      "Sec-WebSocket-Protocol": TRACE_VERSION,
      // needs to be `trace-v1` to be accepted
      "User-Agent": `wrangler-js/${version}`
    },
    ...p2
  });
  tail.on("open", () => {
    tail.send(
      JSON.stringify({ debug }),
      { binary: false, compress: false, mask: false, fin: true },
      (err) => {
        if (err) {
          throw err;
        }
      }
    );
  });
  return { tail, deleteTail, expiration: tailRecord.expires_at };
}
__name(createPagesTail, "createPagesTail");
async function createTail(accountId, workerName, filters, debug, env5) {
  const createTailUrl = makeCreateTailUrl(accountId, workerName, env5);
  const {
    id: tailId,
    url: websocketUrl,
    expires_at: expiration
  } = await fetchResult(createTailUrl, {
    method: "POST",
    body: JSON.stringify(filters)
  });
  const deleteUrl = makeDeleteTailUrl(accountId, workerName, tailId, env5);
  async function deleteTail() {
    await fetchResult(deleteUrl, { method: "DELETE" });
  }
  __name(deleteTail, "deleteTail");
  const p2 = proxy ? { agent: new import_https_proxy_agent.HttpsProxyAgent(proxy) } : {};
  const tail = new wrapper_default(websocketUrl, TRACE_VERSION, {
    headers: {
      "Sec-WebSocket-Protocol": TRACE_VERSION,
      // needs to be `trace-v1` to be accepted
      "User-Agent": `wrangler-js/${version}`
    },
    ...p2
  });
  tail.on("open", function() {
    tail.send(
      JSON.stringify({ debug }),
      { binary: false, compress: false, mask: false, fin: true },
      (err) => {
        if (err) {
          throw err;
        }
      }
    );
  });
  return { tail, expiration, deleteTail };
}
__name(createTail, "createTail");

// src/pages/deployment-tails.ts
var statusChoices = ["ok", "error", "canceled"];
var isStatusChoiceList = /* @__PURE__ */ __name((data) => data?.every((d2) => statusChoices.includes(d2)) ?? false, "isStatusChoiceList");
function Options13(yargs) {
  return yargs.positional("deployment", {
    type: "string",
    description: "(Optional) ID or URL of the deployment to tail. Specify by environment if deployment ID is unknown."
  }).options({
    "project-name": {
      type: "string",
      description: "The name of the project you would like to tail"
    },
    environment: {
      type: "string",
      choices: ["production", "preview"],
      default: "production",
      description: "When not providing a specific deployment ID, specifying environment will grab the latest production or preview deployment"
    }
  }).option("format", {
    default: process.stdout.isTTY ? "pretty" : "json",
    choices: ["json", "pretty"],
    describe: "The format of log entries"
  }).option("debug", {
    type: "boolean",
    hidden: true,
    default: false,
    describe: "If a log would have been filtered out, send it through anyway alongside the filter which would have blocked it."
  }).option("status", {
    choices: statusChoices,
    describe: "Filter by invocation status",
    array: true
  }).option("header", {
    type: "string",
    requiresArg: true,
    describe: "Filter by HTTP header"
  }).option("method", {
    type: "string",
    requiresArg: true,
    describe: "Filter by HTTP method",
    array: true
  }).option("search", {
    type: "string",
    requiresArg: true,
    describe: "Filter by a text match in console.log messages"
  }).option("sampling-rate", {
    type: "number",
    describe: "Adds a percentage of requests to log sampling rate"
  }).option("ip", {
    type: "string",
    requiresArg: true,
    describe: 'Filter by the IP address the request originates from. Use "self" to filter for your own IP',
    array: true
  });
}
__name(Options13, "Options");
async function Handler13({
  deployment,
  projectName,
  environment,
  header,
  ip: clientIp,
  method,
  samplingRate,
  search,
  status: status2,
  format: format10 = "pretty",
  debug,
  ...args
}) {
  if (status2 && !isStatusChoiceList(status2)) {
    throw new FatalError(
      "Invalid value for `--status`. Valid options: " + statusChoices.join(", ")
    );
  }
  if (format10 === "pretty") {
    await printWranglerBanner();
  }
  const config = readConfig(args.config, args);
  const pagesConfig = getConfigCache(
    PAGES_CONFIG_CACHE_FILENAME
  );
  const accountId = await requireAuth(pagesConfig);
  let deploymentId = deployment;
  if (!isInteractive()) {
    if (!deploymentId) {
      throw new FatalError(
        "Must specify a deployment in non-interactive mode.",
        1
      );
    }
    if (!projectName) {
      throw new FatalError(
        "Must specify a project name in non-interactive mode.",
        1
      );
    }
  }
  if (!projectName && isInteractive()) {
    projectName = await promptSelectProject({ accountId });
  }
  if (!deployment && !projectName) {
    throw new FatalError("Must specify a project name or deployment.", 1);
  }
  const deployments2 = await fetchResult(
    `/accounts/${accountId}/pages/projects/${projectName}/deployments`
  );
  const envDeployments = deployments2.filter(
    (d2) => d2.environment === environment
  );
  if (isUrl(deployment)) {
    const { hostname: deploymentHostname } = new URL(deployment);
    const targetDeployment = envDeployments.find(
      (d2) => new URL(d2.url).hostname === deploymentHostname
    );
    if (!targetDeployment) {
      throw new FatalError(
        "Could not find deployment match url: " + deployment,
        1
      );
    }
    deploymentId = targetDeployment.id;
  } else if (!deployment) {
    if (envDeployments.length === 0) {
      throw new FatalError("No deployments for environment: " + environment, 1);
    }
    if (format10 === "pretty") {
      logger.log(
        "No deployment specified. Using latest deployment for",
        environment,
        "environment."
      );
    }
    const latestDeployment = envDeployments.map((d2) => ({ id: d2.id, created_on: new Date(d2.created_on) })).sort((a, b2) => +b2.created_on - +a.created_on)[0];
    deploymentId = latestDeployment.id;
  }
  if (!deploymentId || !projectName) {
    throw new Error("An unknown error occurred.");
  }
  const filters = translateCLICommandToFilterMessage({
    header,
    clientIp,
    method,
    samplingRate,
    search,
    status: status2
  });
  await sendMetricsEvent("begin pages log stream", {
    sendMetrics: config.send_metrics
  });
  const { tail, deleteTail } = await createPagesTail({
    accountId,
    projectName,
    deploymentId,
    filters,
    debug
  });
  const onCloseTail = (() => {
    let didTerminate = false;
    return async () => {
      if (didTerminate)
        return;
      tail.terminate();
      await deleteTail();
      await sendMetricsEvent("end pages log stream", {
        sendMetrics: config.send_metrics
      });
      didTerminate = true;
    };
  })();
  (0, import_signal_exit6.default)(onCloseTail);
  tail.on("message", (data) => {
    if (format10 === "pretty") {
      prettyPrintLogs(data);
    } else {
      jsonPrintLogs(data);
    }
  });
  tail.on("close", onCloseTail);
  while (tail.readyState !== tail.OPEN) {
    switch (tail.readyState) {
      case tail.CONNECTING:
        await (0, import_promises17.setTimeout)(100);
        break;
      case tail.CLOSING:
        await (0, import_promises17.setTimeout)(100);
        break;
      case tail.CLOSED:
        await sendMetricsEvent("end log stream", {
          sendMetrics: config.send_metrics
        });
        throw new Error(
          `Connection to deployment ${deploymentId} closed unexpectedly.`
        );
    }
  }
  if (format10 === "pretty") {
    logger.log(`Connected to deployment ${deploymentId}, waiting for logs...`);
  }
}
__name(Handler13, "Handler");

// src/pages/deployments.tsx
init_import_meta_url();
var import_ink_table8 = __toESM(require_dist4());
var import_react14 = __toESM(require_react());
function ListOptions4(yargs) {
  return yargs.options({
    "project-name": {
      type: "string",
      description: "The name of the project you would like to list deployments for"
    }
  });
}
__name(ListOptions4, "ListOptions");
async function ListHandler4({ projectName }) {
  const config = getConfigCache(PAGES_CONFIG_CACHE_FILENAME);
  const accountId = await requireAuth(config);
  projectName ??= config.project_name;
  const isInteractive3 = process.stdin.isTTY;
  if (!projectName && isInteractive3) {
    projectName = await promptSelectProject({ accountId });
  }
  if (!projectName) {
    throw new FatalError("Must specify a project name.", 1);
  }
  const deployments2 = await fetchResult(
    `/accounts/${accountId}/pages/projects/${projectName}/deployments`
  );
  const titleCase = /* @__PURE__ */ __name((word) => word.charAt(0).toUpperCase() + word.slice(1), "titleCase");
  const shortSha = /* @__PURE__ */ __name((sha) => sha.slice(0, 7), "shortSha");
  const getStatus = /* @__PURE__ */ __name((deployment) => {
    if (deployment.latest_stage.status === `success`) {
      return format8(deployment.latest_stage.ended_on);
    }
    return titleCase(deployment.latest_stage.status);
  }, "getStatus");
  const data = deployments2.map((deployment) => {
    return {
      Environment: titleCase(deployment.environment),
      Branch: deployment.deployment_trigger.metadata.branch,
      Source: shortSha(deployment.deployment_trigger.metadata.commit_hash),
      Deployment: deployment.url,
      Status: getStatus(deployment),
      // TODO: Use a url shortener
      Build: `https://dash.cloudflare.com/${accountId}/pages/view/${deployment.project_name}/${deployment.id}`
    };
  });
  saveToConfigCache(PAGES_CONFIG_CACHE_FILENAME, {
    account_id: accountId
  });
  logger.log(renderToString(/* @__PURE__ */ import_react14.default.createElement(import_ink_table8.default, { data })));
  await sendMetricsEvent("list pages deployments");
}
__name(ListHandler4, "ListHandler");

// src/pages/dev.ts
init_import_meta_url();
var import_node_child_process5 = require("node:child_process");
var import_node_fs30 = require("node:fs");
var import_node_path46 = require("node:path");
var import_chokidar2 = require("chokidar");
var esbuild3 = __toESM(require("esbuild"));

// src/deployment-bundle/esbuild-plugins/alias-external.ts
init_import_meta_url();
function esbuildAliasExternalPlugin(aliases2) {
  return {
    name: "external alias imports plugin",
    setup(build5) {
      build5.onResolve({ filter: /.*/g }, (args) => {
        if (args.kind === "entry-point") {
          return {
            path: args.path
          };
        }
        if (!Object.keys(aliases2).includes(args.path)) {
          throw new Error("unrecognized module: " + args.path);
        }
        return {
          path: aliases2[args.path],
          external: true
        };
      });
    }
  };
}
__name(esbuildAliasExternalPlugin, "esbuildAliasExternalPlugin");

// src/pages/dev.ts
var DURABLE_OBJECTS_BINDING_REGEXP = new RegExp(
  /^(?<binding>[^=]+)=(?<className>[^@\s]+)(@(?<scriptName>.*)$)?$/
);
var BINDING_REGEXP = new RegExp(/^(?<binding>[^=]+)(?:=(?<ref>[^\s]+))?$/);
var SERVICE_BINDING_REGEXP = new RegExp(
  /^(?<binding>[^=]+)=(?<service>[^@#\s]+)(@(?<environment>.*)$)?(#(?<entrypoint>.*))?$/
);
var DEFAULT_IP = process.platform === "win32" ? "127.0.0.1" : "localhost";
var DEFAULT_PAGES_LOCAL_PORT = 8788;
var DEFAULT_SCRIPT_PATH = "_worker.js";
function Options14(yargs) {
  return yargs.positional("directory", {
    type: "string",
    demandOption: void 0,
    description: "The directory of static assets to serve"
  }).positional("command", {
    type: "string",
    demandOption: void 0,
    description: "The proxy command to run  [deprecated]"
    // no official way to deprecate a positional argument
  }).options({
    local: {
      type: "boolean",
      default: true,
      description: "Run on my machine",
      deprecated: true,
      hidden: true
    },
    "compatibility-date": {
      describe: "Date to use for compatibility checks",
      type: "string"
    },
    "compatibility-flags": {
      describe: "Flags to use for compatibility checks",
      alias: "compatibility-flag",
      type: "string",
      array: true
    },
    ip: {
      type: "string",
      // On Windows, when specifying `localhost` as the socket hostname,
      // `workerd` will only listen on the IPv4 loopback `127.0.0.1`, not the
      // IPv6 `::1`: https://github.com/cloudflare/workerd/issues/1408
      // On Node 17+, `fetch()` will only try to fetch the IPv6 address.
      // For now, on Windows, we default to listening on IPv4 only and using
      // `127.0.0.1` when sending control requests to `workerd` (e.g. with the
      // `ProxyController`).
      description: "The IP address to listen on"
    },
    port: {
      type: "number",
      description: "The port to listen on (serve from)"
    },
    "inspector-port": {
      type: "number",
      describe: "Port for devtools to connect to"
    },
    proxy: {
      type: "number",
      description: "The port to proxy (where the static assets are served)",
      deprecated: true
    },
    "script-path": {
      type: "string",
      description: "The location of the single Worker script if not using functions  [default: _worker.js]",
      // hacking in a fake default message here so we can detect when user is setting this and show a deprecation message
      deprecated: true
    },
    bundle: {
      type: "boolean",
      default: void 0,
      hidden: true
    },
    "no-bundle": {
      type: "boolean",
      default: false,
      description: "Whether to run bundling on `_worker.js`"
    },
    binding: {
      type: "array",
      description: "Bind variable/secret (KEY=VALUE)",
      alias: "b"
    },
    kv: {
      type: "array",
      description: "KV namespace to bind (--kv KV_BINDING)",
      alias: "k"
    },
    d1: {
      type: "array",
      description: "D1 database to bind (--d1 D1_BINDING)"
    },
    do: {
      type: "array",
      description: "Durable Object to bind (--do DO_BINDING=CLASS_NAME@SCRIPT_NAME)",
      alias: "o"
    },
    r2: {
      type: "array",
      description: "R2 bucket to bind (--r2 R2_BINDING)"
    },
    ai: {
      type: "string",
      description: "AI to bind (--ai AI_BINDING)"
    },
    "version-metadata": {
      type: "string",
      description: "Worker Version metadata (--version-metadata VERSION_METADATA_BINDING)"
    },
    service: {
      type: "array",
      description: "Service to bind (--service SERVICE=SCRIPT_NAME)",
      alia: "s"
    },
    "live-reload": {
      type: "boolean",
      default: false,
      description: "Auto reload HTML pages when change is detected"
    },
    "local-protocol": {
      describe: "Protocol to listen to requests on, defaults to http.",
      choices: ["http", "https"]
    },
    "https-key-path": {
      describe: "Path to a custom certificate key",
      type: "string",
      requiresArg: true
    },
    "https-cert-path": {
      describe: "Path to a custom certificate",
      type: "string",
      requiresArg: true
    },
    "persist-to": {
      describe: "Specify directory to use for local persistence (defaults to .wrangler/state)",
      type: "string",
      requiresArg: true
    },
    "node-compat": {
      describe: "Enable Node.js compatibility",
      default: false,
      type: "boolean",
      hidden: true
    },
    "experimental-local": {
      describe: "Run on my machine using the Cloudflare Workers runtime",
      type: "boolean",
      deprecated: true,
      hidden: true
    },
    config: {
      describe: "Pages does not support custom paths for the wrangler.toml configuration file",
      type: "string",
      hidden: true
    },
    "log-level": {
      choices: ["debug", "info", "log", "warn", "error", "none"],
      describe: "Specify logging level"
    },
    "show-interactive-dev-session": {
      describe: "Show interactive dev session (defaults to true if the terminal supports interactivity)",
      type: "boolean"
    }
  });
}
__name(Options14, "Options");
var Handler14 = /* @__PURE__ */ __name(async (args) => {
  if (args.logLevel) {
    logger.loggerLevel = args.logLevel;
  }
  if (args.experimentalLocal) {
    logger.warn(
      "--experimental-local is no longer required and will be removed in a future version.\n`wrangler pages dev` now uses the local Cloudflare Workers runtime by default."
    );
  }
  if (args.config) {
    throw new FatalError(
      "Pages does not support custom paths for the `wrangler.toml` configuration file",
      1
    );
  }
  if (args.scriptPath !== void 0) {
    logger.warn(
      `\`--script-path\` is deprecated and will be removed in a future version of Wrangler.
The Worker script should be named \`_worker.js\` and located in the build output directory of your project (specified with \`wrangler pages dev <directory>\`).`
    );
  }
  const config = readConfig(void 0, { ...args, env: void 0 });
  const resolvedDirectory = args.directory ?? config.pages_build_output_dir;
  const [_pages, _dev, ...remaining] = args._;
  const command2 = remaining;
  let proxyPort;
  let directory = resolvedDirectory;
  if (directory !== void 0 && command2.length > 0) {
    throw new FatalError(
      "Specify either a directory OR a proxy command, not both.",
      1
    );
  } else if (directory === void 0) {
    proxyPort = await spawnProxyProcess({
      port: args.proxy,
      command: command2
    });
    if (proxyPort === void 0)
      return void 0;
  } else {
    directory = (0, import_node_path46.resolve)(directory);
  }
  const {
    compatibilityDate,
    compatibilityFlags,
    ip: ip2,
    port: port2,
    inspectorPort,
    localProtocol
  } = resolvePagesDevServerSettings(config, args);
  const {
    vars,
    kv_namespaces,
    do_bindings,
    d1_databases,
    r2_buckets,
    services,
    ai: ai2
  } = getBindingsFromArgs(args);
  let scriptReadyResolve;
  const scriptReadyPromise = new Promise(
    (promiseResolve) => scriptReadyResolve = promiseResolve
  );
  const singleWorkerScriptPath = args.scriptPath ?? DEFAULT_SCRIPT_PATH;
  const workerScriptPath = directory !== void 0 ? (0, import_node_path46.join)(directory, singleWorkerScriptPath) : (0, import_node_path46.resolve)(singleWorkerScriptPath);
  const usingWorkerDirectory = (0, import_node_fs30.existsSync)(workerScriptPath) && (0, import_node_fs30.lstatSync)(workerScriptPath).isDirectory();
  const usingWorkerScript = (0, import_node_fs30.existsSync)(workerScriptPath);
  const enableBundling = args.bundle ?? !args.noBundle;
  const functionsDirectory = "./functions";
  let usingFunctions = !usingWorkerScript && (0, import_node_fs30.existsSync)(functionsDirectory);
  let scriptPath3 = "";
  const legacyNodeCompat = args.nodeCompat;
  const nodejsCompat = compatibilityFlags?.includes("nodejs_compat") ?? false;
  const defineNavigatorUserAgent = isNavigatorDefined(
    compatibilityDate,
    compatibilityFlags
  );
  let modules = [];
  if (usingWorkerDirectory) {
    const runBuild = /* @__PURE__ */ __name(async () => {
      const bundleResult = await produceWorkerBundleForWorkerJSDirectory({
        workerJSDirectory: workerScriptPath,
        bundle: enableBundling,
        buildOutputDirectory: directory ?? ".",
        nodejsCompat,
        defineNavigatorUserAgent
      });
      modules = bundleResult.modules;
      scriptPath3 = bundleResult.resolvedEntryPointPath;
    }, "runBuild");
    await runBuild().then(() => scriptReadyResolve());
    (0, import_chokidar2.watch)([workerScriptPath], {
      persistent: true,
      ignoreInitial: true
    }).on("all", async () => {
      try {
        await runBuild();
      } catch (e3) {
        if (isBuildFailure(e3)) {
          logger.warn("Error building worker script:", e3.message);
          return;
        }
        throw e3;
      }
    });
  } else if (usingWorkerScript) {
    scriptPath3 = workerScriptPath;
    let runBuild = /* @__PURE__ */ __name(async () => {
      await checkRawWorker(
        workerScriptPath,
        nodejsCompat,
        () => scriptReadyResolve()
      );
    }, "runBuild");
    if (enableBundling) {
      scriptPath3 = (0, import_node_path46.join)(
        getPagesTmpDir(),
        `./bundledWorker-${Math.random()}.mjs`
      );
      runBuild = /* @__PURE__ */ __name(async () => {
        try {
          await buildRawWorker({
            workerScriptPath: usingWorkerDirectory ? (0, import_node_path46.join)(workerScriptPath, "index.js") : workerScriptPath,
            outfile: scriptPath3,
            directory: directory ?? ".",
            nodejsCompat,
            local: true,
            sourcemap: true,
            watch: false,
            onEnd: () => scriptReadyResolve(),
            defineNavigatorUserAgent
          });
        } catch (e3) {
          logger.warn("Failed to bundle _worker.js.", e3);
        }
      }, "runBuild");
    }
    await runBuild();
    (0, import_chokidar2.watch)([workerScriptPath], {
      persistent: true,
      ignoreInitial: true
    }).on("all", async (event) => {
      if (event === "unlink") {
        return;
      }
      await runBuild();
    });
  } else if (usingFunctions) {
    scriptPath3 = (0, import_node_path46.join)(
      getPagesTmpDir(),
      `./functionsWorker-${Math.random()}.mjs`
    );
    const routesModule = (0, import_node_path46.join)(
      getPagesTmpDir(),
      `./functionsRoutes-${Math.random()}.mjs`
    );
    if (legacyNodeCompat) {
      console.warn(
        "Enabling Node.js compatibility mode for builtins and globals. This is experimental and has serious tradeoffs. Please see https://github.com/ionic-team/rollup-plugin-node-polyfills/ for more details."
      );
    }
    if (legacyNodeCompat && nodejsCompat) {
      throw new FatalError(
        "The `nodejs_compat` compatibility flag cannot be used in conjunction with the legacy `--node-compat` flag. If you want to use the Workers runtime Node.js compatibility features, please remove the `--node-compat` argument from your CLI command or `node_compat = true` from your config file.",
        1
      );
    }
    logger.log(`Compiling worker to "${scriptPath3}"...`);
    const onEnd = /* @__PURE__ */ __name(() => scriptReadyResolve(), "onEnd");
    try {
      const buildFn = /* @__PURE__ */ __name(async () => {
        await buildFunctions({
          outfile: scriptPath3,
          functionsDirectory,
          sourcemap: true,
          watch: false,
          onEnd,
          buildOutputDirectory: directory,
          legacyNodeCompat,
          nodejsCompat,
          local: true,
          routesModule,
          defineNavigatorUserAgent
        });
        await sendMetricsEvent("build pages functions");
      }, "buildFn");
      await buildFn();
      (0, import_chokidar2.watch)([functionsDirectory], {
        persistent: true,
        ignoreInitial: true
      }).on("all", async () => {
        try {
          await buildFn();
        } catch (e3) {
          if (e3 instanceof FunctionsNoRoutesError) {
            logger.warn(
              getFunctionsNoRoutesWarning(functionsDirectory, "skipping")
            );
          } else if (e3 instanceof FunctionsBuildError) {
            logger.warn(
              getFunctionsBuildWarning(functionsDirectory, e3.message)
            );
          } else {
            throw e3;
          }
        }
      });
    } catch (e3) {
      if (e3 instanceof FunctionsNoRoutesError) {
        logger.warn(
          getFunctionsNoRoutesWarning(functionsDirectory, "skipping")
        );
        onEnd();
        usingFunctions = false;
      } else {
        throw e3;
      }
    }
  }
  if (!usingFunctions && !usingWorkerScript) {
    scriptReadyResolve();
    logger.log("No functions. Shimming...");
    scriptPath3 = (0, import_node_path46.resolve)(getBasePath(), "templates/pages-shim.ts");
  }
  await scriptReadyPromise;
  if (scriptPath3 === "") {
    throw new Error(
      "Failed to start wrangler pages dev due to an unknown error"
    );
  }
  let scriptEntrypoint = scriptPath3;
  if (directory && (usingFunctions || usingWorkerScript || usingWorkerDirectory)) {
    const routesJSONPath = (0, import_node_path46.join)(directory, "_routes.json");
    if ((0, import_node_fs30.existsSync)(routesJSONPath)) {
      let routesJSONContents;
      const runBuild = /* @__PURE__ */ __name(async (entrypointFile, outfile, routes) => {
        await esbuild3.build({
          entryPoints: [
            (0, import_node_path46.resolve)(getBasePath(), "templates/pages-dev-pipeline.ts")
          ],
          bundle: true,
          sourcemap: true,
          format: "esm",
          plugins: [
            esbuildAliasExternalPlugin({
              __ENTRY_POINT__: entrypointFile,
              "./pages-dev-util": (0, import_node_path46.resolve)(
                getBasePath(),
                "templates/pages-dev-util.ts"
              )
            })
          ],
          outfile,
          define: {
            __ROUTES__: routes
          }
        });
      }, "runBuild");
      try {
        routesJSONContents = (0, import_node_fs30.readFileSync)(routesJSONPath, "utf-8");
        validateRoutes(JSON.parse(routesJSONContents), directory);
        scriptEntrypoint = (0, import_node_path46.join)(
          getPagesTmpDir(),
          `${Math.random().toString(36).slice(2)}.js`
        );
        await runBuild(scriptPath3, scriptEntrypoint, routesJSONContents);
      } catch (err) {
        if (err instanceof FatalError) {
          throw err;
        } else {
          throw new FatalError(
            `Could not validate _routes.json at ${directory}: ${err}`,
            1
          );
        }
      }
      (0, import_chokidar2.watch)([routesJSONPath], {
        persistent: true,
        ignoreInitial: true
      }).on("all", async (event) => {
        try {
          if (event === "unlink") {
            return;
          }
          routesJSONContents = (0, import_node_fs30.readFileSync)(routesJSONPath, "utf-8");
          validateRoutes(JSON.parse(routesJSONContents), directory);
          await runBuild(scriptPath3, scriptEntrypoint, routesJSONContents);
        } catch (err) {
          const error2 = err instanceof FatalError ? err : `Could not validate _routes.json at ${directory}: ${err}`;
          const defaultRoutesJSONSpec = {
            version: ROUTES_SPEC_VERSION,
            include: ["/*"],
            exclude: []
          };
          logger.error(error2);
          logger.warn(
            `Falling back to the following _routes.json default: ${JSON.stringify(
              defaultRoutesJSONSpec,
              null,
              2
            )}`
          );
          routesJSONContents = JSON.stringify(defaultRoutesJSONSpec);
          await runBuild(scriptPath3, scriptEntrypoint, routesJSONContents);
        }
      });
    }
  }
  const { stop, waitUntilExit } = await unstable_dev(scriptEntrypoint, {
    env: void 0,
    ip: ip2,
    port: port2,
    inspectorPort,
    localProtocol,
    httpsKeyPath: args.httpsKeyPath,
    httpsCertPath: args.httpsCertPath,
    compatibilityDate,
    compatibilityFlags,
    nodeCompat: legacyNodeCompat,
    vars,
    kv: kv_namespaces,
    durableObjects: do_bindings,
    r2: r2_buckets,
    services,
    ai: ai2,
    rules: usingWorkerDirectory ? [
      {
        type: "ESModule",
        globs: ["**/*.js", "**/*.mjs"]
      }
    ] : void 0,
    bundle: enableBundling,
    persistTo: args.persistTo,
    inspect: void 0,
    logLevel: args.logLevel,
    updateCheck: true,
    experimental: {
      processEntrypoint: true,
      additionalModules: modules,
      d1Databases: d1_databases,
      disableExperimentalWarning: true,
      enablePagesAssetsServiceBinding: {
        proxyPort,
        directory
      },
      liveReload: args.liveReload,
      forceLocal: true,
      showInteractiveDevSession: args.showInteractiveDevSession,
      testMode: false,
      watch: true
    }
  });
  await sendMetricsEvent("run pages dev");
  CLEANUP_CALLBACKS.push(stop);
  process.on("exit", CLEANUP);
  process.on("SIGINT", CLEANUP);
  process.on("SIGTERM", CLEANUP);
  await waitUntilExit();
  CLEANUP();
  process.exit(0);
}, "Handler");
function isWindows() {
  return process.platform === "win32";
}
__name(isWindows, "isWindows");
async function sleep(ms) {
  await new Promise((promiseResolve) => setTimeout(promiseResolve, ms));
}
__name(sleep, "sleep");
function getPids(pid) {
  const pids = [pid];
  let command2, regExp;
  if (isWindows()) {
    command2 = `wmic process where (ParentProcessId=${pid}) get ProcessId`;
    regExp = new RegExp(/(\d+)/);
  } else {
    command2 = `pgrep -P ${pid}`;
    regExp = new RegExp(/(\d+)/);
  }
  try {
    const newPids = (0, import_node_child_process5.execSync)(command2).toString().split("\n").map((line) => line.match(regExp)).filter((line) => line !== null).map((match) => parseInt(match[1]));
    pids.push(...newPids.map(getPids).flat());
  } catch {
  }
  return pids;
}
__name(getPids, "getPids");
function getPort(pid) {
  let command2, regExp;
  if (isWindows()) {
    command2 = process.env.SYSTEMROOT + "\\system32\\netstat.exe -nao";
    regExp = new RegExp(`TCP\\s+.*:(\\d+)\\s+.*:\\d+\\s+LISTENING\\s+${pid}`);
  } else {
    command2 = "lsof -nPi";
    regExp = new RegExp(`${pid}\\s+.*TCP\\s+.*:(\\d+)\\s+\\(LISTEN\\)`);
  }
  try {
    const matches = (0, import_node_child_process5.execSync)(command2).toString().split("\n").map((line) => line.match(regExp)).filter((line) => line !== null);
    const match = matches[0];
    if (match)
      return parseInt(match[1]);
  } catch (thrown) {
    logger.error(
      `Error scanning for ports of process with PID ${pid}: ${thrown}`
    );
  }
}
__name(getPort, "getPort");
async function spawnProxyProcess({
  port: port2,
  command: command2
}) {
  if (command2.length > 0 || port2 !== void 0) {
    logger.warn(
      `Specifying a \`-- <command>\` or \`--proxy\` is deprecated and will be removed in a future version of Wrangler.
Build your application to a directory and run the \`wrangler pages dev <directory>\` instead.
This results in a more faithful emulation of production behavior.`
    );
  }
  if (command2.length === 0) {
    if (port2 !== void 0) {
      return port2;
    }
    CLEANUP();
    throw new FatalError(
      "Must specify a directory of static assets to serve, or a command to run, or a proxy port, or configure `pages_build_output_dir` in `wrangler.toml`.",
      1
    );
  }
  logger.log(`Running ${quote(command2)}...`);
  const proxy2 = (0, import_node_child_process5.spawn)(
    command2[0].toString(),
    command2.slice(1).map((value) => value.toString()),
    {
      shell: isWindows(),
      env: {
        BROWSER: "none",
        ...process.env
      }
    }
  );
  CLEANUP_CALLBACKS.push(() => {
    proxy2.kill();
  });
  proxy2.stdout.on("data", (data) => {
    logger.log(`[proxy]: ${data}`);
  });
  proxy2.stderr.on("data", (data) => {
    logger.error(`[proxy]: ${data}`);
  });
  proxy2.on("close", (code) => {
    logger.error(`Proxy exited with status ${code}.`);
    CLEANUP();
    process.exitCode = code ?? 0;
  });
  while (!proxy2.pid) {
  }
  if (port2 === void 0) {
    logger.log(
      `Sleeping ${SECONDS_TO_WAIT_FOR_PROXY} seconds to allow proxy process to start before attempting to automatically determine port...`
    );
    logger.log("To skip, specify the proxy port with --proxy.");
    await sleep(SECONDS_TO_WAIT_FOR_PROXY * 1e3);
    port2 = getPids(proxy2.pid).map(getPort).filter((nr) => nr !== void 0)[0];
    if (port2 === void 0) {
      CLEANUP();
      throw new FatalError(
        "Could not automatically determine proxy port. Please specify the proxy port with --proxy.",
        1
      );
    } else {
      logger.log(`Automatically determined the proxy port to be ${port2}.`);
    }
  }
  return port2;
}
__name(spawnProxyProcess, "spawnProxyProcess");
function resolvePagesDevServerSettings(config, args) {
  let compatibilityDate = args.compatibilityDate || config.compatibility_date;
  if (!compatibilityDate) {
    const currentDate = (/* @__PURE__ */ new Date()).toISOString().substring(0, 10);
    logger.warn(
      `No compatibility_date was specified. Using today's date: ${currentDate}.
Pass it in your terminal:
\`\`\`
--compatibility-date=${currentDate}
\`\`\`
See https://developers.cloudflare.com/workers/platform/compatibility-dates/ for more information.`
    );
    compatibilityDate = currentDate;
  }
  return {
    compatibilityDate,
    compatibilityFlags: args.compatibilityFlags ?? config.compatibility_flags,
    ip: args.ip ?? config.dev.ip ?? DEFAULT_IP,
    // because otherwise `unstable_dev` will default the port number to `0`
    port: args.port ?? config.dev?.port ?? DEFAULT_PAGES_LOCAL_PORT,
    inspectorPort: args.inspectorPort ?? config.dev?.inspector_port,
    localProtocol: args.localProtocol ?? config.dev?.local_protocol
  };
}
__name(resolvePagesDevServerSettings, "resolvePagesDevServerSettings");
function getBindingsFromArgs(args) {
  let vars = {};
  if (args.binding?.length) {
    vars = Object.fromEntries(
      args.binding.map((binding) => binding.toString().split("=")).map(([key, ...values]) => [key, values.join("=")])
    );
  }
  let kvNamespaces;
  if (args.kv?.length) {
    kvNamespaces = args.kv.map((kv) => {
      const { binding, ref } = BINDING_REGEXP.exec(kv.toString())?.groups || {};
      if (!binding) {
        logger.warn("Could not parse KV binding:", kv.toString());
        return;
      }
      return {
        binding,
        id: ref || kv.toString()
      };
    }).filter(Boolean);
  }
  let durableObjectsBindings;
  if (args.do?.length) {
    durableObjectsBindings = args.do.map((durableObject) => {
      const { binding, className, scriptName } = DURABLE_OBJECTS_BINDING_REGEXP.exec(durableObject.toString())?.groups || {};
      if (!binding || !className) {
        logger.warn(
          "Could not parse Durable Object binding:",
          durableObject.toString()
        );
        return;
      }
      return {
        name: binding,
        class_name: className,
        script_name: scriptName
      };
    }).filter(Boolean);
  }
  let d1Databases;
  if (args.d1?.length) {
    d1Databases = args.d1.map((d12) => {
      const { binding, ref } = BINDING_REGEXP.exec(d12.toString())?.groups || {};
      if (!binding) {
        logger.warn("Could not parse D1 binding:", d12.toString());
        return;
      }
      return {
        binding,
        database_id: ref || d12.toString(),
        database_name: `local-${d12}`
      };
    }).filter(Boolean);
  }
  let r2Buckets;
  if (args.r2?.length) {
    r2Buckets = args.r2.map((r23) => {
      const { binding, ref } = BINDING_REGEXP.exec(r23.toString())?.groups || {};
      if (!binding) {
        logger.warn("Could not parse R2 binding:", r23.toString());
        return;
      }
      return { binding, bucket_name: ref || binding.toString() };
    }).filter(Boolean);
  }
  let services;
  if (args.service?.length) {
    services = args.service.map((serviceBinding) => {
      const { binding, service, environment, entrypoint } = SERVICE_BINDING_REGEXP.exec(serviceBinding.toString())?.groups || {};
      if (!binding || !service) {
        logger.warn(
          "Could not parse Service binding:",
          serviceBinding.toString()
        );
        return;
      }
      let serviceName = service;
      if (environment) {
        serviceName = `${service}-${environment}`;
      }
      return {
        binding,
        service: serviceName,
        environment,
        entrypoint
      };
    }).filter(Boolean);
    if (services.find(({ environment }) => !!environment)) {
      logger.warn("Support for service binding environments is experimental.");
    }
  }
  let ai2;
  if (args.ai) {
    ai2 = { binding: args.ai.toString() };
  }
  let version_metadata;
  if (args.versionMetadata) {
    version_metadata = { binding: args.versionMetadata.toString() };
  }
  return {
    vars,
    kv_namespaces: kvNamespaces,
    d1_databases: d1Databases,
    r2_buckets: r2Buckets,
    services,
    ai: ai2,
    version_metadata,
    // don't construct the full `EnvironmentNonInheritable["durable_objects"]` shape here.
    // `startDev()` will do that for us in its `getBindings()` function
    do_bindings: durableObjectsBindings
  };
}
__name(getBindingsFromArgs, "getBindingsFromArgs");

// src/pages/download-config.ts
init_import_meta_url();
var import_fs8 = require("fs");
var import_promises18 = require("node:fs/promises");
var import_toml4 = __toESM(require_toml());
var import_chalk13 = __toESM(require_chalk());
async function toEnvironment(project, accountId) {
  const configObj = {};
  configObj.compatibility_date = project.compatibility_date ?? (/* @__PURE__ */ new Date()).toISOString().substring(0, 10);
  if (project.compatibility_flags?.length)
    configObj.compatibility_flags = project.compatibility_flags;
  for (const [name, envVar] of Object.entries(project.env_vars ?? {})) {
    if (envVar?.value && envVar?.type == "plain_text") {
      configObj.vars ??= {};
      configObj.vars[name] = envVar?.value;
    }
  }
  for (const [name, namespace] of Object.entries(project.kv_namespaces ?? {})) {
    configObj.kv_namespaces ??= [];
    configObj.kv_namespaces.push({ id: namespace.namespace_id, binding: name });
  }
  for (const [name, ns] of Object.entries(
    project.durable_object_namespaces ?? {}
  )) {
    configObj.durable_objects ??= { bindings: [] };
    if (ns.class_name && ns.class_name !== "") {
      configObj.durable_objects.bindings.push({
        name,
        class_name: ns.class_name,
        script_name: ns.service,
        environment: ns.environment
      });
    } else {
      const namespace = await fetchResult(
        `/accounts/${accountId}/workers/durable_objects/namespaces/${ns.namespace_id}`
      );
      configObj.durable_objects.bindings.push({
        name,
        class_name: namespace.class,
        script_name: namespace.script,
        environment: namespace.environment
      });
    }
  }
  for (const [name, namespace] of Object.entries(project.d1_databases ?? {})) {
    configObj.d1_databases ??= [];
    configObj.d1_databases.push({
      database_id: namespace.id,
      binding: name,
      database_name: name
    });
  }
  for (const [name, bucket] of Object.entries(project.r2_buckets ?? {})) {
    configObj.r2_buckets ??= [];
    configObj.r2_buckets.push({
      bucket_name: bucket.name,
      binding: name
    });
  }
  for (const [name, { service, environment }] of Object.entries(
    project.services ?? {}
  )) {
    configObj.services ??= [];
    configObj.services.push({
      binding: name,
      service,
      environment
    });
  }
  for (const [name, queue] of Object.entries(project.queue_producers ?? {})) {
    configObj.queues ??= { producers: [] };
    configObj.queues?.producers?.push({
      binding: name,
      queue: queue.name
    });
  }
  for (const [name, { dataset }] of Object.entries(
    project.analytics_engine_datasets ?? {}
  )) {
    configObj.analytics_engine_datasets ??= [];
    configObj.analytics_engine_datasets.push({
      binding: name,
      dataset
    });
  }
  for (const [name] of Object.entries(project.ai_bindings ?? {})) {
    configObj.ai = { binding: name };
  }
  return configObj;
}
__name(toEnvironment, "toEnvironment");
async function writeWranglerToml(toml) {
  await (0, import_promises18.writeFile)(
    "wrangler.toml",
    [
      `# Generated by Wrangler on ${/* @__PURE__ */ new Date()}`,
      import_toml4.default.stringify(toml)
    ].join("\n")
  );
}
__name(writeWranglerToml, "writeWranglerToml");
async function downloadProject(accountId, projectName) {
  const project = await fetchResult(
    `/accounts/${accountId}/pages/projects/${projectName}`
  );
  logger.debug(JSON.stringify(project, null, 2));
  return {
    name: project.name,
    pages_build_output_dir: project.build_config.destination_dir,
    ...await toEnvironment(project.deployment_configs.preview, accountId),
    env: {
      production: await toEnvironment(
        project.deployment_configs.production,
        accountId
      )
    }
  };
}
__name(downloadProject, "downloadProject");
function Options15(yargs) {
  return yargs.positional("projectName", {
    type: "string",
    description: "The Pages project to download"
  }).option("force", {
    describe: "Overwrite an existing `wrangler.toml` file without prompting",
    type: "boolean"
  });
}
__name(Options15, "Options");
var Handler15 = /* @__PURE__ */ __name(async ({ projectName, force }) => {
  void sendMetricsEvent("download pages config");
  await printWranglerBanner();
  const projectConfig = getConfigCache(
    PAGES_CONFIG_CACHE_FILENAME
  );
  const accountId = await requireAuth(projectConfig);
  projectName ??= projectConfig.project_name;
  if (!projectName) {
    throw new FatalError("Must specify a project name.", 1);
  }
  const config = await downloadProject(accountId, projectName);
  if (!force && (0, import_fs8.existsSync)("wrangler.toml")) {
    const overwrite = await confirm(
      "Your existing `wrangler.toml` file will be overwritten. Continue?",
      { fallbackValue: false }
    );
    if (!overwrite) {
      throw new FatalError("Not overwriting existing `wrangler.toml` file");
    }
  }
  await writeWranglerToml(config);
  logger.info(
    import_chalk13.default.green(
      "Success! Your project settings have been downloaded to wrangler.toml"
    )
  );
}, "Handler");

// src/pages/functions.ts
init_import_meta_url();
var import_node_fs31 = require("node:fs");
var import_node_path47 = __toESM(require("node:path"));
function OptimizeRoutesOptions(yargs) {
  return yargs.options({
    "routes-path": {
      type: "string",
      demandOption: true,
      description: "The location of the _routes.json file"
    }
  }).options({
    "output-routes-path": {
      type: "string",
      demandOption: true,
      description: "The location of the optimized output routes file"
    }
  });
}
__name(OptimizeRoutesOptions, "OptimizeRoutesOptions");
async function OptimizeRoutesHandler({
  routesPath,
  outputRoutesPath
}) {
  let routesFileContents;
  const routesOutputDirectory = import_node_path47.default.dirname(outputRoutesPath);
  if (!(0, import_node_fs31.existsSync)(routesPath)) {
    throw new FatalError(
      `Oops! File ${routesPath} does not exist. Please make sure --routes-path is a valid file path (for example "/public/_routes.json").`,
      1
    );
  }
  if (!(0, import_node_fs31.existsSync)(routesOutputDirectory) || !(0, import_node_fs31.lstatSync)(routesOutputDirectory).isDirectory()) {
    throw new FatalError(
      `Oops! Folder ${routesOutputDirectory} does not exist. Please make sure --output-routes-path is a valid file path (for example "/public/_routes.json").`,
      1
    );
  }
  try {
    routesFileContents = (0, import_node_fs31.readFileSync)(routesPath, "utf-8");
  } catch (err) {
    throw new FatalError(`Error while reading ${routesPath} file: ${err}`);
  }
  const routes = JSON.parse(routesFileContents);
  validateRoutes(routes, routesPath);
  const optimizedRoutes = optimizeRoutesJSONSpec(routes);
  const optimizedRoutesContents = JSON.stringify(optimizedRoutes);
  try {
    (0, import_node_fs31.writeFileSync)(outputRoutesPath, optimizedRoutesContents);
  } catch (err) {
    throw new FatalError(
      `Error writing to ${outputRoutesPath} file: ${err}`,
      1
    );
  }
}
__name(OptimizeRoutesHandler, "OptimizeRoutesHandler");

// src/pages/secret/index.ts
init_import_meta_url();
var import_node_path48 = __toESM(require("node:path"));
var import_node_readline2 = __toESM(require("node:readline"));
var import_chalk14 = __toESM(require_chalk());
function isPagesEnv(env5) {
  return ["production", "preview"].includes(env5);
}
__name(isPagesEnv, "isPagesEnv");
function trimTrailingWhitespace(str) {
  return str.trimEnd();
}
__name(trimTrailingWhitespace, "trimTrailingWhitespace");
function readFromStdin() {
  return new Promise((resolve19, reject) => {
    const stdin = process.stdin;
    const chunks = [];
    stdin.on("readable", () => {
      let chunk;
      while (null !== (chunk = stdin.read())) {
        chunks.push(chunk);
      }
    });
    stdin.on("end", () => {
      resolve19(chunks.join(""));
    });
    stdin.on("error", (err) => {
      reject(err);
    });
  });
}
__name(readFromStdin, "readFromStdin");
async function pagesProject(env5, cliProjectName) {
  env5 ??= "production";
  if (!isPagesEnv(env5)) {
    throw new FatalError(
      `Pages does not support the "${env5}" named environment. Please specify "production" (default) or "preview"`,
      1
    );
  }
  let config;
  const configPath = findWranglerToml(process.cwd(), false);
  try {
    config = readConfig(
      configPath,
      { env: void 0, experimentalJsonConfig: false },
      true
    );
  } catch (err) {
    if (!(err instanceof FatalError && err.code === EXIT_CODE_INVALID_PAGES_CONFIG)) {
      throw err;
    }
  }
  if (configPath && config === void 0) {
    logger.warn(
      `Pages now has wrangler.toml support.
We detected a configuration file at ${configPath} but it is missing the "pages_build_output_dir" field, required by Pages.
If you would like to use this configuration file for your project, please use "pages_build_output_dir" to specify the directory of static files to upload.
Ignoring configuration file for now.`
    );
  }
  const configCache = getConfigCache(
    PAGES_CONFIG_CACHE_FILENAME
  );
  const accountId = await requireAuth(configCache);
  const projectName = cliProjectName ?? config?.name ?? configCache.project_name;
  let project;
  if (projectName) {
    try {
      project = await fetchResult(
        `/accounts/${accountId}/pages/projects/${projectName}`
      );
    } catch (err) {
      if (err.code === 8000007) {
        throw new FatalError(`Project "${projectName}" does not exist.`, 1);
      }
      throw err;
    }
  } else {
    throw new FatalError("Must specify a project name.", 1);
  }
  return { env: env5, project, accountId, config };
}
__name(pagesProject, "pagesProject");
var secret = /* @__PURE__ */ __name((secretYargs, subHelp) => {
  return secretYargs.command(subHelp).command(
    "put <key>",
    "Create or update a secret variable for a Pages project",
    (yargs) => {
      return yargs.positional("key", {
        describe: "The variable name to be accessible in the Pages project",
        type: "string"
      }).option("project-name", {
        type: "string",
        alias: ["project"],
        description: "The name of your Pages project"
      });
    },
    async (args) => {
      await printWranglerBanner();
      const { env: env5, project, accountId, config } = await pagesProject(
        args.env,
        args.projectName
      );
      const secretValue = trimTrailingWhitespace(
        isInteractive() ? await prompt("Enter a secret value:", { isSecret: true }) : await readFromStdin()
      );
      logger.log(
        `\u{1F300} Creating the secret for the Pages project "${project.name}" (${env5})`
      );
      await fetchResult(
        `/accounts/${accountId}/pages/projects/${project.name}`,
        {
          method: "PATCH",
          body: JSON.stringify({
            deployment_configs: {
              [env5]: {
                env_vars: {
                  [args.key]: {
                    value: secretValue,
                    type: "secret_text"
                  }
                },
                wrangler_config_hash: project.deployment_configs[env5].wrangler_config_hash
              }
            }
          })
        }
      );
      await sendMetricsEvent("create pages encrypted variable", {
        sendMetrics: config?.send_metrics
      });
      logger.log(`\u2728 Success! Uploaded secret ${args.key}`);
    }
  ).command(
    "bulk [json]",
    "\u{1F5C4}\uFE0F Bulk upload secrets for a Pages project",
    (yargs) => {
      return yargs.positional("json", {
        describe: `The JSON file of key-value pairs to upload, in form {"key": value, ...}`,
        type: "string"
      }).option("project-name", {
        type: "string",
        alias: ["project"],
        description: "The name of your Pages project"
      });
    },
    async (args) => {
      await printWranglerBanner();
      const { env: env5, project, accountId } = await pagesProject(
        args.env,
        args.projectName
      );
      logger.log(
        `\u{1F300} Creating the secrets for the Pages project "${project.name}" (${env5})`
      );
      let content;
      if (args.json) {
        const jsonFilePath = import_node_path48.default.resolve(args.json);
        content = parseJSON(
          readFileSync5(jsonFilePath),
          jsonFilePath
        );
      } else {
        try {
          const rl = import_node_readline2.default.createInterface({ input: process.stdin });
          let pipedInput = "";
          for await (const line of rl) {
            pipedInput += line;
          }
          content = parseJSON(pipedInput);
        } catch {
          throw new FatalError(
            `\u{1F6A8} Please provide a JSON file or valid JSON pipe`
          );
        }
      }
      if (!content) {
        throw new FatalError(
          `\u{1F6A8} No content found in JSON file or piped input.`
        );
      }
      const upsertBindings = Object.fromEntries(
        Object.entries(content).map(([key, value]) => {
          return [
            key,
            {
              type: "secret_text",
              value
            }
          ];
        })
      );
      try {
        await fetchResult(
          `/accounts/${accountId}/pages/projects/${project.name}`,
          {
            method: "PATCH",
            body: JSON.stringify({
              deployment_configs: {
                [env5]: {
                  env_vars: {
                    ...upsertBindings
                  },
                  wrangler_config_hash: project.deployment_configs[env5].wrangler_config_hash
                }
              }
            })
          }
        );
        logger.log("Finished processing secrets JSON file:");
        logger.log(
          `\u2728 ${Object.keys(upsertBindings).length} secrets successfully uploaded`
        );
      } catch (err) {
        logger.log("Finished processing secrets JSON file:");
        logger.log(`\u2728 0 secrets successfully uploaded`);
        throw new FatalError(
          `\u{1F6A8} ${Object.keys(upsertBindings).length} secrets failed to upload`
        );
      }
    }
  ).command(
    "delete <key>",
    "Delete a secret variable from a Pages project",
    async (yargs) => {
      return yargs.positional("key", {
        describe: "The variable name to be accessible in the Pages project",
        type: "string"
      }).option("project-name", {
        type: "string",
        alias: ["project"],
        description: "The name of your Pages project"
      });
    },
    async (args) => {
      await printWranglerBanner();
      const { env: env5, project, accountId, config } = await pagesProject(
        args.env,
        args.projectName
      );
      if (await confirm(
        `Are you sure you want to permanently delete the secret ${args.key} on the Pages project ${project.name} (${env5})?`
      )) {
        logger.log(
          `\u{1F300} Deleting the secret ${args.key} on the Pages project ${project.name} (${env5})`
        );
        await fetchResult(
          `/accounts/${accountId}/pages/projects/${project.name}`,
          {
            method: "PATCH",
            body: JSON.stringify({
              deployment_configs: {
                [env5]: {
                  env_vars: {
                    [args.key]: null
                  },
                  wrangler_config_hash: project.deployment_configs[env5].wrangler_config_hash
                }
              }
            })
          }
        );
        await sendMetricsEvent("delete pages encrypted variable", {
          sendMetrics: config?.send_metrics
        });
        logger.log(`\u2728 Success! Deleted secret ${args.key}`);
      }
    }
  ).command(
    "list",
    "List all secrets for a Pages project",
    (yargs) => {
      return yargs.option("project-name", {
        type: "string",
        alias: ["project"],
        description: "The name of your Pages project"
      });
    },
    async (args) => {
      await printWranglerBanner();
      const { env: env5, project, config } = await pagesProject(
        args.env,
        args.projectName
      );
      const secrets = Object.entries(
        project.deployment_configs[env5].env_vars ?? {}
      ).filter(([_3, val]) => val?.type === "secret_text");
      const message = [
        `The "${import_chalk14.default.blue(
          env5
        )}" environment of your Pages project "${import_chalk14.default.blue(
          project.name
        )}" has access to the following secrets:`,
        ...secrets.map(
          ([name]) => `  - ${name}: ${import_chalk14.default.italic("Value Encrypted")}`
        )
      ].join("\n");
      logger.log(message);
      await sendMetricsEvent("list pages encrypted variables", {
        sendMetrics: config?.send_metrics
      });
    }
  );
}, "secret");

// src/pages/index.ts
process.on("SIGINT", () => {
  CLEANUP();
  process.exit();
});
process.on("SIGTERM", () => {
  CLEANUP();
  process.exit();
});
function pages(yargs, subHelp) {
  return yargs.command(subHelp).command(
    "dev [directory] [-- command..]",
    "\u{1F9D1}\u200D\u{1F4BB} Develop your full-stack Pages application locally",
    Options14,
    Handler14
  ).command(
    "functions",
    false,
    (args) => args.command(subHelp).command(
      "build [directory]",
      "Compile a folder of Cloudflare Pages Functions into a single Worker",
      Options8,
      Handler8
    ).command(
      "build-env [projectDir]",
      "Render a list of environment variables from the config file",
      Options9,
      Handler9
    ).command(
      "optimize-routes [routesPath] [outputRoutesPath]",
      "Consolidate and optimize the route paths declared in _routes.json",
      OptimizeRoutesOptions,
      OptimizeRoutesHandler
    )
  ).command(
    "project",
    "\u26A1\uFE0F Interact with your Pages projects",
    (args) => args.command(subHelp).command(
      "list",
      "List your Cloudflare Pages projects",
      ListOptions3,
      ListHandler3
    ).command(
      "create [project-name]",
      "Create a new Cloudflare Pages project",
      CreateOptions3,
      CreateHandler3
    ).command(
      "delete [project-name]",
      "Delete a Cloudflare Pages project",
      DeleteOptions,
      DeleteHandler
    ).command("upload [directory]", false, Options11, Handler11).command(
      "validate [directory]",
      false,
      Options10,
      Handler10
    )
  ).command(
    "deployment",
    "\u{1F680} Interact with the deployments of a project",
    (args) => args.command(subHelp).command(
      "list",
      "List deployments in your Cloudflare Pages project",
      ListOptions4,
      ListHandler4
    ).command(
      "create [directory]",
      "\u{1F199} Publish a directory of static assets as a Pages deployment",
      Options12,
      Handler12
    ).command(
      "tail [deployment]",
      "Start a tailing session for a project's deployment and livestream logs from your Functions",
      Options13,
      Handler13
    )
  ).command(
    ["deploy [directory]", "publish [directory]"],
    "\u{1F199} Deploy a directory of static assets as a Pages deployment",
    Options12,
    Handler12
  ).command(
    "secret",
    "\u{1F92B} Generate a secret that can be referenced in a Pages project",
    (secretYargs) => secret(secretYargs, subHelp)
  ).command(
    "download",
    "\u26A1\uFE0F Download settings from your project",
    (args) => args.command(
      "config [projectName]",
      "Experimental: Download your Pages project config as a wrangler.toml file",
      Options15,
      Handler15
    )
  );
}
__name(pages, "pages");

// src/pubsub/pubsub-commands.ts
init_import_meta_url();

// src/pubsub/index.ts
init_import_meta_url();
var pubSubBetaWarning = "\u{1F477}\u{1F3FD} 'wrangler pubsub ...' commands are currently in private beta. If your account isn't authorized, commands will fail. Visit the Pub/Sub docs for more info: https://developers.cloudflare.com/pub-sub/";
async function listPubSubNamespaces(accountId) {
  return await fetchResult(
    `/accounts/${accountId}/pubsub/namespaces`
  );
}
__name(listPubSubNamespaces, "listPubSubNamespaces");
async function createPubSubNamespace(accountId, namespace) {
  return await fetchResult(`/accounts/${accountId}/pubsub/namespaces`, {
    method: "POST",
    body: JSON.stringify(namespace)
  });
}
__name(createPubSubNamespace, "createPubSubNamespace");
async function deletePubSubNamespace(accountId, namespace) {
  return await fetchResult(
    `/accounts/${accountId}/pubsub/namespaces/${namespace}`,
    { method: "DELETE" }
  );
}
__name(deletePubSubNamespace, "deletePubSubNamespace");
async function describePubSubNamespace(accountId, namespace) {
  return await fetchResult(
    `/accounts/${accountId}/pubsub/namespaces/${namespace}`,
    { method: "GET" }
  );
}
__name(describePubSubNamespace, "describePubSubNamespace");
async function deletePubSubBroker(accountId, namespace, broker) {
  return await fetchResult(
    `/accounts/${accountId}/pubsub/namespaces/${namespace}/brokers/${broker}`,
    { method: "DELETE" }
  );
}
__name(deletePubSubBroker, "deletePubSubBroker");
async function describePubSubBroker(accountId, namespace, broker) {
  return await fetchResult(
    `/accounts/${accountId}/pubsub/namespaces/${namespace}/brokers/${broker}`,
    { method: "GET" }
  );
}
__name(describePubSubBroker, "describePubSubBroker");
async function listPubSubBrokers(accountId, namespace) {
  return await fetchResult(
    `/accounts/${accountId}/pubsub/namespaces/${namespace}/brokers`
  );
}
__name(listPubSubBrokers, "listPubSubBrokers");
async function createPubSubBroker(accountId, namespace, broker) {
  return await fetchResult(
    `/accounts/${accountId}/pubsub/namespaces/${namespace}/brokers`,
    { method: "POST", body: JSON.stringify(broker) }
  );
}
__name(createPubSubBroker, "createPubSubBroker");
async function updatePubSubBroker(accountId, namespace, broker, update) {
  return await fetchResult(
    `/accounts/${accountId}/pubsub/namespaces/${namespace}/brokers/${broker}`,
    { method: "PATCH", body: JSON.stringify(update) }
  );
}
__name(updatePubSubBroker, "updatePubSubBroker");
async function getPubSubBrokerPublicKeys(accountId, namespace, broker) {
  return await fetchResult(
    `/accounts/${accountId}/pubsub/namespaces/${namespace}/brokers/${broker}/publickeys`
  );
}
__name(getPubSubBrokerPublicKeys, "getPubSubBrokerPublicKeys");
async function issuePubSubBrokerTokens(accountId, namespace, broker, number, type, clientIds, expiration) {
  let url4 = `/accounts/${accountId}/pubsub/namespaces/${namespace}/brokers/${broker}/credentials`;
  const params = new URLSearchParams();
  params.append("number", `${number}`);
  params.append("type", type);
  if (clientIds) {
    for (const id of clientIds) {
      params.append("clientid", id);
    }
  }
  if (expiration) {
    params.append("expiration", `${expiration}`);
  }
  url4 = url4 + `?${params.toString()}`;
  return await fetchResult(url4);
}
__name(issuePubSubBrokerTokens, "issuePubSubBrokerTokens");
async function revokePubSubBrokerTokens(accountId, namespace, broker, jti) {
  let url4 = `/accounts/${accountId}/pubsub/namespaces/${namespace}/brokers/${broker}/revocations`;
  const params = new URLSearchParams();
  for (const j2 of jti) {
    params.append("jti", j2);
  }
  url4 = url4 + `?${params.toString()}`;
  return await fetchResult(url4, { method: "POST", body: "" });
}
__name(revokePubSubBrokerTokens, "revokePubSubBrokerTokens");
async function unrevokePubSubBrokerTokens(accountId, namespace, broker, jti) {
  let url4 = `/accounts/${accountId}/pubsub/namespaces/${namespace}/brokers/${broker}/revocations`;
  const params = new URLSearchParams();
  for (const j2 of jti) {
    params.append("jti", j2);
  }
  url4 = url4 + `?${params.toString()}`;
  return await fetchResult(url4, { method: "DELETE" });
}
__name(unrevokePubSubBrokerTokens, "unrevokePubSubBrokerTokens");
async function listRevokedPubSubBrokerTokens(accountId, namespace, broker) {
  return await fetchResult(
    `/accounts/${accountId}/pubsub/namespaces/${namespace}/brokers/${broker}/revocations`
  );
}
__name(listRevokedPubSubBrokerTokens, "listRevokedPubSubBrokerTokens");

// src/pubsub/pubsub-commands.ts
function pubSubCommands(pubsubYargs, subHelp) {
  return pubsubYargs.command(subHelp).command(
    "namespace",
    "Manage your Pub/Sub Namespaces",
    (pubsubNamespaceYargs) => {
      return pubsubNamespaceYargs.command(
        "create <name>",
        "Create a new Pub/Sub Namespace",
        (yargs) => {
          return yargs.positional("name", {
            describe: "The name of the new Namespace. This name will form part of the public endpoint, in the form <broker>.<namespace>.cloudflarepubsub.com",
            type: "string",
            demandOption: true
          }).option("description", {
            describe: "Textual description of Namespace",
            type: "string"
          }).epilogue(pubSubBetaWarning);
        },
        async (args) => {
          const config = readConfig(args.config, args);
          const accountId = await requireAuth(config);
          const namespace = {
            name: args.name
          };
          if (args.description) {
            namespace.description = args.description;
          }
          logger.log(`Creating Pub/Sub Namespace ${args.name}...`);
          await createPubSubNamespace(accountId, namespace);
          logger.log(`Success! Created Pub/Sub Namespace ${args.name}`);
          await sendMetricsEvent("create pubsub namespace", {
            sendMetrics: config.send_metrics
          });
        }
      ).command(
        "list",
        "List your existing Pub/Sub Namespaces",
        (yargs) => {
          return yargs.epilogue(pubSubBetaWarning);
        },
        async (args) => {
          const config = readConfig(args.config, args);
          const accountId = await requireAuth(config);
          logger.log(await listPubSubNamespaces(accountId));
          await sendMetricsEvent("list pubsub namespaces", {
            sendMetrics: config.send_metrics
          });
        }
      ).command(
        "delete <name>",
        "Delete a Pub/Sub Namespace",
        (yargs) => {
          return yargs.positional("name", {
            describe: "The name of the namespace to delete",
            type: "string",
            demandOption: true
          }).epilogue(pubSubBetaWarning);
        },
        async (args) => {
          const config = readConfig(args.config, args);
          const accountId = await requireAuth(config);
          if (await confirm(
            `\uFE0F\u2757\uFE0F Are you sure you want to delete the Pub/Sub Namespace ${args.name}? This cannot be undone.
This name will be available for others to register.`
          )) {
            logger.log(`Deleting namespace ${args.name}...`);
            await deletePubSubNamespace(accountId, args.name);
            logger.log(`Deleted namespace ${args.name}.`);
            await sendMetricsEvent("delete pubsub namespace", {
              sendMetrics: config.send_metrics
            });
          }
        }
      ).command(
        "describe <name>",
        "Describe a Pub/Sub Namespace",
        (yargs) => {
          return yargs.positional("name", {
            describe: "The name of the namespace to describe.",
            type: "string",
            demandOption: true
          }).epilogue(pubSubBetaWarning);
        },
        async (args) => {
          const config = readConfig(args.config, args);
          const accountId = await requireAuth(config);
          logger.log(
            await describePubSubNamespace(accountId, args.name)
          );
          await sendMetricsEvent("view pubsub namespace", {
            sendMetrics: config.send_metrics
          });
        }
      ).epilogue(pubSubBetaWarning);
    }
  ).command("broker", "Interact with your Pub/Sub Brokers", (brokersYargs) => {
    brokersYargs.command(
      "create <name>",
      "Create a new Pub/Sub Broker",
      (yargs) => yargs.positional("name", {
        describe: "The name of the Pub/Sub Broker. This name will form part of the public endpoint, in the form <broker>.<namespace>.cloudflarepubsub.com",
        type: "string",
        demandOption: true
      }).option("namespace", {
        describe: "An existing Namespace to associate the Broker with. This name will form part of the public endpoint, in the form <broker>.<namespace>.cloudflarepubsub.com",
        type: "string",
        alias: "ns",
        demandOption: true
      }).option("description", {
        describe: "Longer description for the broker",
        type: "string"
      }).option("expiration", {
        describe: "Time to allow token validity (can use seconds, hours, months, weeks, years)",
        type: "string"
      }).option("on-publish-url", {
        describe: "A (HTTPS) Cloudflare Worker (or webhook) URL that messages will be sent to on-publish.",
        type: "string"
      }).epilogue(pubSubBetaWarning),
      async (args) => {
        const config = readConfig(args.config, args);
        const accountId = await requireAuth(config);
        const broker = {
          name: args.name
        };
        if (args.description) {
          broker.description = args.description;
        }
        if (args.expiration) {
          const expiration = parseHumanDuration(args.expiration);
          if (isNaN(expiration)) {
            throw new CommandLineArgsError(
              `${args.expiration} is not a time duration.  (Example of valid values are: 1y, 6 days)`
            );
          }
          broker.expiration = expiration;
        }
        if (args["on-publish-url"]) {
          broker.on_publish = {
            url: args["on-publish-url"]
          };
        }
        logger.log(
          await createPubSubBroker(accountId, args.namespace, broker)
        );
        await sendMetricsEvent("create pubsub broker", {
          sendMetrics: config.send_metrics
        });
      }
    );
    brokersYargs.command(
      "update <name>",
      "Update an existing Pub/Sub Broker's configuration.",
      (yargs) => yargs.positional("name", {
        describe: "The name of an existing Pub/Sub Broker",
        type: "string",
        demandOption: true
      }).option("namespace", {
        describe: "The Namespace the Broker is associated with",
        type: "string",
        alias: "ns",
        demandOption: true
      }).option("description", {
        describe: "A optional description of the Broker.",
        type: "string"
      }).option("expiration", {
        describe: "The expiration date for all client credentials issued by the Broker (can use seconds, hours, months, weeks, years)",
        type: "string"
      }).option("on-publish-url", {
        describe: "A (HTTPS) Cloudflare Worker (or webhook) URL that messages will be sent to on-publish.",
        type: "string"
      }).epilogue(pubSubBetaWarning),
      async (args) => {
        const config = readConfig(args.config, args);
        const accountId = await requireAuth(config);
        const broker = {};
        if (args.description) {
          broker.description = args.description;
        }
        if (args.expiration) {
          const expiration = parseHumanDuration(args.expiration);
          if (isNaN(expiration)) {
            throw new CommandLineArgsError(
              `${args.expiration} is not a time duration. Examples of valid values include: '1y', '24h', or '6 days'.`
            );
          }
          broker.expiration = expiration;
        }
        if (args["on-publish-url"]) {
          broker.on_publish = {
            url: args["on-publish-url"]
          };
        }
        logger.log(
          await updatePubSubBroker(
            accountId,
            args.namespace,
            args.name,
            broker
          )
        );
        logger.log(`Successfully updated Pub/Sub Broker ${args.name}`);
        await sendMetricsEvent("update pubsub broker", {
          sendMetrics: config.send_metrics
        });
      }
    );
    brokersYargs.command(
      "list",
      "List the Pub/Sub Brokers within a Namespace",
      (yargs) => {
        return yargs.option("namespace", {
          describe: "The Namespace the Brokers are associated with.",
          type: "string",
          alias: "ns",
          demandOption: true
        }).epilogue(pubSubBetaWarning);
      },
      async (args) => {
        const config = readConfig(args.config, args);
        const accountId = await requireAuth(config);
        logger.log(await listPubSubBrokers(accountId, args.namespace));
        await sendMetricsEvent("list pubsub brokers", {
          sendMetrics: config.send_metrics
        });
      }
    );
    brokersYargs.command(
      "delete <name>",
      "Delete an existing Pub/Sub Broker",
      (yargs) => {
        return yargs.positional("name", {
          describe: "The name of the Broker to delete",
          type: "string",
          demandOption: true
        }).option("namespace", {
          describe: "The Namespace the Broker is associated with.",
          type: "string",
          alias: "ns",
          demandOption: true
        }).epilogue(pubSubBetaWarning);
      },
      async (args) => {
        const config = readConfig(args.config, args);
        const accountId = await requireAuth(config);
        if (await confirm(
          `\uFE0F\u2757\uFE0F Are you sure you want to delete the Pub/Sub Broker ${args.name}? This cannot be undone.
All existing clients will be disconnected.`
        )) {
          logger.log(`Deleting Pub/Sub Broker ${args.name}.`);
          await deletePubSubBroker(
            accountId,
            args.namespace,
            args.name
          );
          logger.log(`Deleted Pub/Sub Broker ${args.name}.`);
          await sendMetricsEvent("delete pubsub broker", {
            sendMetrics: config.send_metrics
          });
        }
      }
    ).command(
      "describe <name>",
      "Describe an existing Pub/Sub Broker.",
      (yargs) => {
        return yargs.positional("name", {
          describe: "The name of the Broker to describe.",
          type: "string",
          demandOption: true
        }).option("namespace", {
          describe: "The Namespace the Broker is associated with.",
          type: "string",
          alias: "ns",
          demandOption: true
        }).epilogue(pubSubBetaWarning);
      },
      async (args) => {
        const config = readConfig(args.config, args);
        const accountId = await requireAuth(config);
        logger.log(
          await describePubSubBroker(
            accountId,
            args.namespace,
            args.name
          )
        );
        await sendMetricsEvent("view pubsub broker", {
          sendMetrics: config.send_metrics
        });
      }
    );
    brokersYargs.command(
      "issue <name>",
      "Issue new client credentials for a specific Pub/Sub Broker.",
      (yargs) => {
        return yargs.positional("name", {
          describe: "The name of the Broker to issue credentials for.",
          type: "string",
          demandOption: true
        }).option("namespace", {
          describe: "The Namespace the Broker is associated with.",
          type: "string",
          alias: "ns",
          demandOption: true
        }).option("number", {
          describe: "The number of credentials to generate.",
          type: "number",
          alias: "n",
          default: 1
        }).option("type", {
          describe: "The type of credential to generate.",
          type: "string",
          default: "TOKEN"
        }).option("expiration", {
          describe: "The expiration to set on the issued credentials. This overrides any Broker-level expiration that is set.",
          type: "string",
          alias: "exp"
        }).option("client-id", {
          describe: "A list of existing clientIds to generate tokens for. By default, clientIds are randomly generated.",
          type: "string",
          alias: "jti",
          array: true
        }).epilogue(pubSubBetaWarning);
      },
      async (args) => {
        const config = readConfig(args.config, args);
        const accountId = await requireAuth(config);
        let parsedExpiration;
        if (args.expiration) {
          const expiration = parseHumanDuration(args.expiration);
          if (isNaN(expiration)) {
            throw new CommandLineArgsError(
              `${args.expiration} is not a time duration. Example of valid values are: 1y, 6 days.`
            );
          }
          parsedExpiration = expiration;
        }
        logger.log(
          `\u{1F511} Issuing credential(s) for ${args.name}.${args.namespace}...`
        );
        logger.log(
          await issuePubSubBrokerTokens(
            accountId,
            args.namespace,
            args.name,
            args.number,
            args.type,
            args["client-id"],
            parsedExpiration
          )
        );
        await sendMetricsEvent("issue pubsub broker credentials", {
          sendMetrics: config.send_metrics
        });
      }
    );
    brokersYargs.command(
      "revoke <name>",
      "Revoke a set of active client credentials associated with the given Broker",
      (yargs) => {
        return yargs.positional("name", {
          describe: "The name of the Broker to revoke credentials against.",
          type: "string",
          demandOption: true
        }).option("namespace", {
          describe: "The Namespace the Broker is associated with.",
          type: "string",
          alias: "ns",
          demandOption: true
        }).option("jti", {
          describe: "Tokens to revoke",
          type: "string",
          demandOption: true,
          array: true
        }).epilogue(pubSubBetaWarning);
      },
      async (args) => {
        const config = readConfig(args.config, args);
        const accountId = await requireAuth(config);
        const numTokens = args.jti.length;
        logger.log(
          `\u{1F534} Revoking access to ${args.name} for ${numTokens} credential(s)...`
        );
        await revokePubSubBrokerTokens(
          accountId,
          args.namespace,
          args.name,
          args.jti
        );
        logger.log(`Revoked ${args.jti.length} credential(s).`);
        await sendMetricsEvent("revoke pubsub broker credentials", {
          sendMetrics: config.send_metrics
        });
      }
    );
    brokersYargs.command(
      "unrevoke <name>",
      "Restore access to a set of previously revoked client credentials.",
      (yargs) => {
        return yargs.positional("name", {
          describe: "The name of the Broker to revoke credentials against.",
          type: "string",
          demandOption: true
        }).option("namespace", {
          describe: "The Namespace the Broker is associated with.",
          type: "string",
          alias: "ns",
          demandOption: true
        }).option("jti", {
          describe: "Tokens to revoke",
          type: "string",
          demandOption: true,
          array: true
        }).epilogue(pubSubBetaWarning);
      },
      async (args) => {
        const config = readConfig(args.config, args);
        const accountId = await requireAuth(config);
        const numTokens = args.jti.length;
        logger.log(
          `\u{1F7E2} Restoring access to ${args.broker} for ${numTokens} credential(s)...`
        );
        await unrevokePubSubBrokerTokens(
          accountId,
          args.namespace,
          args.name,
          args.jti
        );
        logger.log(`Unrevoked ${numTokens} credential(s)`);
        await sendMetricsEvent("unrevoke pubsub broker credentials", {
          sendMetrics: config.send_metrics
        });
      }
    );
    brokersYargs.command(
      "show-revocations <name>",
      "Show all previously revoked client credentials.",
      (yargs) => {
        return yargs.positional("name", {
          describe: "The name of the Broker to revoke credentials against.",
          type: "string",
          demandOption: true
        }).option("namespace", {
          describe: "The Namespace the Broker is associated with.",
          type: "string",
          alias: "ns",
          demandOption: true
        }).epilogue(pubSubBetaWarning);
      },
      async (args) => {
        const config = readConfig(args.config, args);
        const accountId = await requireAuth(config);
        logger.log(`Listing previously revoked tokens for ${args.name}...`);
        logger.log(
          await listRevokedPubSubBrokerTokens(
            accountId,
            args.namespace,
            args.name
          )
        );
        await sendMetricsEvent(
          "list pubsub broker revoked credentials",
          {
            sendMetrics: config.send_metrics
          }
        );
      }
    );
    brokersYargs.command(
      "public-keys <name>",
      "Show the public keys used for verifying on-publish hooks and credentials for a Broker.",
      (yargs) => {
        return yargs.positional("name", {
          describe: "The name of the Broker to revoke credentials against.",
          type: "string",
          demandOption: true
        }).option("namespace", {
          describe: "The Namespace the Broker is associated with.",
          type: "string",
          alias: "ns",
          demandOption: true
        }).epilogue(pubSubBetaWarning);
      },
      async (args) => {
        const config = readConfig(args.config, args);
        const accountId = await requireAuth(config);
        logger.log(
          await getPubSubBrokerPublicKeys(
            accountId,
            args.namespace,
            args.name
          )
        );
        await sendMetricsEvent("list pubsub broker public-keys", {
          sendMetrics: config.send_metrics
        });
      }
    );
    brokersYargs.epilogue(pubSubBetaWarning);
    return brokersYargs;
  }).epilogue(pubSubBetaWarning);
}
__name(pubSubCommands, "pubSubCommands");

// src/queues/cli/commands/index.ts
init_import_meta_url();

// src/queues/utils.ts
init_import_meta_url();

// src/queues/constants.ts
init_import_meta_url();
var INVALID_CONSUMER_SETTINGS_ERROR = 100127;
var INVALID_QUEUE_SETTINGS_ERROR = 100128;

// src/queues/utils.ts
var isFetchError = /* @__PURE__ */ __name((err) => err instanceof Error, "isFetchError");
var HandleUnauthorizedError = /* @__PURE__ */ __name(async (_msg, err) => {
  if (isFetchError(err) && err.code === 10023) {
    const accountId = await getAccountId();
    if (accountId) {
      return logger.log(
        `Queues is not currently enabled on this account. Go to https://dash.cloudflare.com/${accountId}/workers/queues to enable it.`
      );
    }
  }
  return err;
}, "HandleUnauthorizedError");
function handleFetchError(e3) {
  if (e3.code === INVALID_CONSUMER_SETTINGS_ERROR) {
    throw new UserError(`The specified consumer settings are invalid.`);
  }
  if (e3.code === INVALID_QUEUE_SETTINGS_ERROR) {
    throw new UserError(`The specified queue settings are invalid.`);
  }
  throw e3;
}
__name(handleFetchError, "handleFetchError");

// src/queues/cli/commands/consumer/index.ts
init_import_meta_url();

// src/queues/cli/commands/consumer/http-pull/index.ts
init_import_meta_url();

// src/queues/cli/commands/consumer/http-pull/add.ts
init_import_meta_url();

// src/queues/client.ts
init_import_meta_url();
var import_node_url13 = require("node:url");
var queuesUrl = /* @__PURE__ */ __name((accountId, queueId) => {
  let url4 = `/accounts/${accountId}/queues`;
  if (queueId) {
    url4 += `/${queueId}`;
  }
  return url4;
}, "queuesUrl");
var queueConsumersUrl = /* @__PURE__ */ __name((accountId, queueId, consumerId) => {
  let url4 = `${queuesUrl(accountId, queueId)}/consumers`;
  if (consumerId) {
    url4 += `/${consumerId}`;
  }
  return url4;
}, "queueConsumersUrl");
async function createQueue(config, body) {
  const accountId = await requireAuth(config);
  return fetchResult(queuesUrl(accountId), {
    method: "POST",
    body: JSON.stringify(body)
  });
}
__name(createQueue, "createQueue");
async function deleteQueue(config, queueName) {
  const queue = await getQueue(config, queueName);
  return deleteQueueById(config, queue.queue_id);
}
__name(deleteQueue, "deleteQueue");
async function deleteQueueById(config, queueId) {
  const accountId = await requireAuth(config);
  return fetchResult(queuesUrl(accountId, queueId), {
    method: "DELETE"
  });
}
__name(deleteQueueById, "deleteQueueById");
async function listQueues(config, page, name) {
  page = page ?? 1;
  const accountId = await requireAuth(config);
  const params = new import_node_url13.URLSearchParams({ page: page.toString() });
  if (name) {
    params.append("name", name);
  }
  return fetchResult(queuesUrl(accountId), {}, params);
}
__name(listQueues, "listQueues");
async function listAllQueues(config, queueNames) {
  const accountId = await requireAuth(config);
  const params = new import_node_url13.URLSearchParams();
  queueNames.forEach((e3) => {
    params.append("name", e3);
  });
  return fetchPagedListResult(queuesUrl(accountId), {}, params);
}
__name(listAllQueues, "listAllQueues");
async function getQueue(config, queueName) {
  const queues2 = await listQueues(config, 1, queueName);
  if (queues2.length === 0) {
    throw new UserError(
      `Queue "${queueName}" does not exist. To create it, run: wrangler queues create ${queueName}`
    );
  }
  return queues2[0];
}
__name(getQueue, "getQueue");
async function ensureQueuesExistByConfig(config) {
  const producers = (config.queues.producers || []).map(
    (producer) => producer.queue
  );
  const consumers2 = (config.queues.consumers || []).map(
    (consumer) => consumer.queue
  );
  const queueNames = producers.concat(consumers2);
  await ensureQueuesExist(config, queueNames);
}
__name(ensureQueuesExistByConfig, "ensureQueuesExistByConfig");
async function ensureQueuesExist(config, queueNames) {
  if (queueNames.length > 0) {
    const existingQueues = (await listAllQueues(config, queueNames)).map(
      (q2) => q2.queue_name
    );
    if (queueNames.length !== existingQueues.length) {
      const queueSet = new Set(existingQueues);
      for (const queue of queueNames) {
        if (!queueSet.has(queue)) {
          throw new UserError(
            `Queue "${queue}" does not exist. To create it, run: wrangler queues create ${queue}`
          );
        }
      }
    }
  }
}
__name(ensureQueuesExist, "ensureQueuesExist");
async function getQueueById(config, queueId) {
  const accountId = await requireAuth(config);
  return fetchResult(queuesUrl(accountId, queueId), {});
}
__name(getQueueById, "getQueueById");
async function putQueue(config, queueName, body) {
  const queue = await getQueue(config, queueName);
  return putQueueById(config, queue.queue_id, body);
}
__name(putQueue, "putQueue");
async function putQueueById(config, queueId, body) {
  const accountId = await requireAuth(config);
  return fetchResult(queuesUrl(accountId, queueId), {
    method: "PUT",
    body: JSON.stringify(body)
  });
}
__name(putQueueById, "putQueueById");
async function postConsumer(config, queueName, body) {
  const queue = await getQueue(config, queueName);
  return postConsumerById(config, queue.queue_id, body);
}
__name(postConsumer, "postConsumer");
async function postConsumerById(config, queueId, body) {
  const accountId = await requireAuth(config);
  return fetchResult(queueConsumersUrl(accountId, queueId), {
    method: "POST",
    body: JSON.stringify(body)
  });
}
__name(postConsumerById, "postConsumerById");
async function putConsumerById(config, queueId, consumerId, body) {
  const accountId = await requireAuth(config);
  return fetchResult(queueConsumersUrl(accountId, queueId, consumerId), {
    method: "PUT",
    body: JSON.stringify(body)
  });
}
__name(putConsumerById, "putConsumerById");
async function putConsumer(config, queueName, scriptName, envName, body) {
  const queue = await getQueue(config, queueName);
  const targetConsumer = await resolveWorkerConsumerByName(
    config,
    scriptName,
    envName,
    queue
  );
  return putConsumerById(
    config,
    queue.queue_id,
    targetConsumer.consumer_id,
    body
  );
}
__name(putConsumer, "putConsumer");
async function resolveWorkerConsumerByName(config, consumerName, envName, queue) {
  const queueName = queue.queue_name;
  const consumers2 = queue.consumers.filter(
    (c2) => c2.type === "worker" && (c2.script === consumerName || c2.service === consumerName)
  );
  if (consumers2.length === 0) {
    throw new UserError(
      `No worker consumer '${consumerName}' exists for queue ${queue.queue_name}`
    );
  }
  if (consumers2.length > 1) {
    const targetEnv = envName ?? await getDefaultService(config, consumerName);
    const targetConsumers = consumers2.filter(
      (c2) => c2.environment === targetEnv
    );
    if (targetConsumers.length === 0) {
      throw new UserError(
        `No worker consumer '${consumerName}' exists for queue ${queueName}`
      );
    }
    return consumers2[0];
  }
  if (consumers2[0].service) {
    const targetEnv = envName ?? await getDefaultService(config, consumerName);
    if (targetEnv != consumers2[0].environment) {
      throw new UserError(
        `No worker consumer '${consumerName}' exists for queue ${queueName}`
      );
    }
  }
  return consumers2[0];
}
__name(resolveWorkerConsumerByName, "resolveWorkerConsumerByName");
async function deleteConsumerById(config, queueId, consumerId) {
  const accountId = await requireAuth(config);
  return fetchResult(queueConsumersUrl(accountId, queueId, consumerId), {
    method: "DELETE"
  });
}
__name(deleteConsumerById, "deleteConsumerById");
async function deletePullConsumer(config, queueName) {
  const queue = await getQueue(config, queueName);
  const consumer = queue.consumers[0];
  if (consumer?.type !== "http_pull") {
    throw new UserError(`No http_pull consumer exists for queue ${queueName}`);
  }
  return deleteConsumerById(config, queue.queue_id, consumer.consumer_id);
}
__name(deletePullConsumer, "deletePullConsumer");
async function getDefaultService(config, serviceName) {
  const accountId = await requireAuth(config);
  const service = await fetchResult(
    `/accounts/${accountId}/workers/services/${serviceName}`,
    {
      method: "GET"
    }
  );
  logger.info(service);
  return service.default_environment.environment;
}
__name(getDefaultService, "getDefaultService");
async function deleteWorkerConsumer(config, queueName, scriptName, envName) {
  const queue = await getQueue(config, queueName);
  const targetConsumer = await resolveWorkerConsumerByName(
    config,
    scriptName,
    envName,
    queue
  );
  return deleteConsumerById(config, queue.queue_id, targetConsumer.consumer_id);
}
__name(deleteWorkerConsumer, "deleteWorkerConsumer");

// src/queues/cli/commands/consumer/http-pull/add.ts
function options17(yargs) {
  return yargs.positional("queue-name", {
    type: "string",
    demandOption: true,
    description: "Name of the queue for the consumer"
  }).options({
    "batch-size": {
      type: "number",
      describe: "Maximum number of messages per batch"
    },
    "message-retries": {
      type: "number",
      describe: "Maximum number of retries for each message"
    },
    "dead-letter-queue": {
      type: "string",
      describe: "Queue to send messages that failed to be consumed"
    },
    "visibility-timeout-secs": {
      type: "number",
      describe: "The number of seconds a message will wait for an acknowledgement before being returned to the queue."
    },
    "retry-delay-secs": {
      type: "number",
      describe: "The number of seconds to wait before retrying a message"
    }
  });
}
__name(options17, "options");
function createBody(args) {
  return {
    type: "http_pull",
    settings: {
      batch_size: args.batchSize,
      max_retries: args.messageRetries,
      visibility_timeout_ms: args.visibilityTimeoutSecs ? args.visibilityTimeoutSecs * 1e3 : void 0,
      retry_delay: args.retryDelaySecs
    },
    dead_letter_queue: args.deadLetterQueue
  };
}
__name(createBody, "createBody");
async function handler18(args) {
  const config = readConfig(args.config, args);
  if (Array.isArray(args.retryDelaySecs)) {
    throw new CommandLineArgsError(
      `Cannot specify --retry-delay-secs multiple times`
    );
  }
  const body = createBody(args);
  logger.log(`Adding consumer to queue ${args.queueName}.`);
  await postConsumer(config, args.queueName, body);
  logger.log(`Added consumer to queue ${args.queueName}.`);
}
__name(handler18, "handler");

// src/queues/cli/commands/consumer/http-pull/remove.ts
init_import_meta_url();
function options18(yargs) {
  return yargs.positional("queue-name", {
    type: "string",
    demandOption: true,
    description: "Name of the queue for the consumer"
  });
}
__name(options18, "options");
async function handler19(args) {
  const config = readConfig(args.config, args);
  logger.log(`Removing consumer from queue ${args.queueName}.`);
  await deletePullConsumer(config, args.queueName);
  logger.log(`Removed consumer from queue ${args.queueName}.`);
}
__name(handler19, "handler");

// src/queues/cli/commands/consumer/http-pull/index.ts
function pullConsumers(yargs) {
  yargs.command(
    "add <queue-name>",
    "Add a Queue HTTP Pull Consumer",
    options17,
    handler18
  );
  yargs.command(
    "remove <queue-name>",
    "Remove a Queue HTTP Pull Consumer",
    options18,
    handler19
  );
}
__name(pullConsumers, "pullConsumers");

// src/queues/cli/commands/consumer/worker/index.ts
init_import_meta_url();

// src/queues/cli/commands/consumer/worker/add.ts
init_import_meta_url();
function options19(yargs) {
  return yargs.positional("queue-name", {
    type: "string",
    demandOption: true,
    description: "Name of the queue to configure"
  }).positional("script-name", {
    type: "string",
    demandOption: true,
    description: "Name of the consumer script"
  }).options({
    "batch-size": {
      type: "number",
      describe: "Maximum number of messages per batch"
    },
    "batch-timeout": {
      type: "number",
      describe: "Maximum number of seconds to wait to fill a batch with messages"
    },
    "message-retries": {
      type: "number",
      describe: "Maximum number of retries for each message"
    },
    "dead-letter-queue": {
      type: "string",
      describe: "Queue to send messages that failed to be consumed"
    },
    "max-concurrency": {
      type: "number",
      describe: "The maximum number of concurrent consumer Worker invocations. Must be a positive integer"
    },
    "retry-delay-secs": {
      type: "number",
      describe: "The number of seconds to wait before retrying a message"
    }
  });
}
__name(options19, "options");
function createBody2(args) {
  return {
    script_name: args.scriptName,
    // TODO(soon) is this still the correct usage of the environment?
    environment_name: args.env ?? "",
    // API expects empty string as default
    type: "worker",
    settings: {
      batch_size: args.batchSize,
      max_retries: args.messageRetries,
      max_wait_time_ms: args.batchTimeout ? 1e3 * args.batchTimeout : void 0,
      max_concurrency: args.maxConcurrency,
      retry_delay: args.retryDelaySecs
    },
    dead_letter_queue: args.deadLetterQueue
  };
}
__name(createBody2, "createBody");
async function handler20(args) {
  const config = readConfig(args.config, args);
  if (Array.isArray(args.retryDelaySecs)) {
    throw new CommandLineArgsError(
      `Cannot specify --retry-delay-secs multiple times`
    );
  }
  const body = createBody2(args);
  logger.log(`Adding consumer to queue ${args.queueName}.`);
  await postConsumer(config, args.queueName, body);
  logger.log(`Added consumer to queue ${args.queueName}.`);
}
__name(handler20, "handler");

// src/queues/cli/commands/consumer/worker/remove.ts
init_import_meta_url();
function options20(yargs) {
  return yargs.positional("queue-name", {
    type: "string",
    demandOption: true,
    description: "Name of the queue to configure"
  }).positional("script-name", {
    type: "string",
    demandOption: true,
    description: "Name of the consumer script"
  });
}
__name(options20, "options");
async function handler21(args) {
  const config = readConfig(args.config, args);
  logger.log(`Removing consumer from queue ${args.queueName}.`);
  await deleteWorkerConsumer(config, args.queueName, args.scriptName, args.env);
  logger.log(`Removed consumer from queue ${args.queueName}.`);
}
__name(handler21, "handler");

// src/queues/cli/commands/consumer/worker/index.ts
function workerConsumers(yargs) {
  yargs.command(
    "add <queue-name> <script-name>",
    "Add a Queue Worker Consumer",
    options19,
    handler20
  );
  yargs.command(
    "remove <queue-name> <script-name>",
    "Remove a Queue Worker Consumer",
    options20,
    handler21
  );
}
__name(workerConsumers, "workerConsumers");

// src/queues/cli/commands/consumer/index.ts
function consumers(yargs) {
  yargs.command(
    "add <queue-name> <script-name>",
    "Add a Queue Worker Consumer",
    options19,
    handler20
  );
  yargs.command(
    "remove <queue-name> <script-name>",
    "Remove a Queue Worker Consumer",
    options20,
    handler21
  );
  yargs.command(
    "http",
    "Configure Queue HTTP Pull Consumers",
    async (consumersYargs) => {
      await pullConsumers(consumersYargs);
    }
  );
  yargs.command(
    "worker",
    "Configure Queue Worker Consumers",
    async (consumersYargs) => {
      await workerConsumers(consumersYargs);
    }
  );
}
__name(consumers, "consumers");

// src/queues/cli/commands/create.ts
init_import_meta_url();
function options21(yargs) {
  return yargs.positional("name", {
    type: "string",
    demandOption: true,
    description: "The name of the queue"
  }).options({
    "delivery-delay-secs": {
      type: "number",
      describe: "How long a published message should be delayed for, in seconds. Must be a positive integer"
    }
  });
}
__name(options21, "options");
function createBody3(args) {
  const body = {
    queue_name: args.name
  };
  if (Array.isArray(args.deliveryDelaySecs)) {
    throw new CommandLineArgsError(
      "Cannot specify --delivery-delay-secs multiple times"
    );
  }
  if (args.deliveryDelaySecs != void 0) {
    body.settings = {
      delivery_delay: args.deliveryDelaySecs
    };
  }
  return body;
}
__name(createBody3, "createBody");
async function handler22(args) {
  const config = readConfig(args.config, args);
  const body = createBody3(args);
  try {
    logger.log(`Creating queue ${args.name}.`);
    await createQueue(config, body);
    logger.log(`Created queue ${args.name}.`);
  } catch (e3) {
    handleFetchError(e3);
  }
}
__name(handler22, "handler");

// src/queues/cli/commands/delete.ts
init_import_meta_url();
function options22(yargs) {
  return yargs.positional("name", {
    type: "string",
    demandOption: true,
    description: "The name of the queue"
  });
}
__name(options22, "options");
async function handler23(args) {
  const config = readConfig(args.config, args);
  logger.log(`Deleting queue ${args.name}.`);
  await deleteQueue(config, args.name);
  logger.log(`Deleted queue ${args.name}.`);
}
__name(handler23, "handler");

// src/queues/cli/commands/list.ts
init_import_meta_url();
function options23(yargs) {
  return yargs.options({
    page: {
      type: "number",
      describe: "Page number for pagination"
    }
  });
}
__name(options23, "options");
async function handler24(args) {
  const config = readConfig(args.config, args);
  const queues2 = await listQueues(config, args.page);
  logger.table(
    queues2.map((queue) => ({
      id: queue.queue_id,
      name: queue.queue_name,
      created_on: queue.created_on,
      modified_on: queue.modified_on,
      producers: queue.producers_total_count.toString(),
      consumers: queue.consumers_total_count.toString()
    }))
  );
}
__name(handler24, "handler");

// src/queues/cli/commands/index.ts
function queues(yargs) {
  yargs.command("list", "List Queues", options23, handler24);
  yargs.command(
    "create <name>",
    "Create a Queue",
    options21,
    handler22
  );
  yargs.command(
    "delete <name>",
    "Delete a Queue",
    options22,
    handler23
  );
  yargs.command(
    "consumer",
    "Configure Queue Consumers",
    async (consumersYargs) => {
      await consumers(consumersYargs);
    }
  );
  yargs.fail(HandleUnauthorizedError);
}
__name(queues, "queues");

// src/r2/index.ts
init_import_meta_url();
var import_node_buffer5 = require("node:buffer");
var fs23 = __toESM(require("node:fs"));
var path50 = __toESM(require("node:path"));
var stream = __toESM(require("node:stream"));
var import_web = require("node:stream/web");

// src/r2/constants.ts
init_import_meta_url();
var MAX_UPLOAD_SIZE = 300 * 1024 * 1024;

// src/r2/helpers.ts
init_import_meta_url();
var import_miniflare11 = require("miniflare");
async function listR2Buckets(accountId, jurisdiction) {
  const headers = {};
  if (jurisdiction !== void 0) {
    headers["cf-r2-jurisdiction"] = jurisdiction;
  }
  const results = await fetchResult(`/accounts/${accountId}/r2/buckets`, { headers });
  return results.buckets;
}
__name(listR2Buckets, "listR2Buckets");
async function createR2Bucket(accountId, bucketName, jurisdiction, storageClass) {
  const headers = {};
  if (jurisdiction !== void 0) {
    headers["cf-r2-jurisdiction"] = jurisdiction;
  }
  return await fetchResult(`/accounts/${accountId}/r2/buckets`, {
    method: "POST",
    body: JSON.stringify({
      name: bucketName,
      ...storageClass !== void 0 && { storageClass }
    }),
    headers
  });
}
__name(createR2Bucket, "createR2Bucket");
async function updateR2BucketStorageClass(accountId, bucketName, storageClass, jurisdiction) {
  const headers = {};
  if (jurisdiction !== void 0) {
    headers["cf-r2-jurisdiction"] = jurisdiction;
  }
  headers["cf-r2-storage-class"] = storageClass;
  return await fetchResult(
    `/accounts/${accountId}/r2/buckets/${bucketName}`,
    {
      method: "PATCH",
      headers
    }
  );
}
__name(updateR2BucketStorageClass, "updateR2BucketStorageClass");
async function deleteR2Bucket(accountId, bucketName, jurisdiction) {
  const headers = {};
  if (jurisdiction !== void 0) {
    headers["cf-r2-jurisdiction"] = jurisdiction;
  }
  return await fetchResult(
    `/accounts/${accountId}/r2/buckets/${bucketName}`,
    { method: "DELETE", headers }
  );
}
__name(deleteR2Bucket, "deleteR2Bucket");
function bucketAndKeyFromObjectPath(objectPath = "") {
  const match = /^([^/]+)\/(.*)/.exec(objectPath);
  if (match === null) {
    throw new UserError(
      `The object path must be in the form of {bucket}/{key} you provided ${objectPath}`
    );
  }
  return { bucket: match[1], key: match[2] };
}
__name(bucketAndKeyFromObjectPath, "bucketAndKeyFromObjectPath");
async function getR2Object(accountId, bucketName, objectName, jurisdiction) {
  const headers = {};
  if (jurisdiction !== void 0) {
    headers["cf-r2-jurisdiction"] = jurisdiction;
  }
  const response = await fetchR2Objects(
    `/accounts/${accountId}/r2/buckets/${bucketName}/objects/${objectName}`,
    {
      method: "GET",
      headers
    }
  );
  return response === null ? null : response.body;
}
__name(getR2Object, "getR2Object");
async function putR2Object(accountId, bucketName, objectName, object, options29, jurisdiction, storageClass) {
  const headerKeys = [
    "content-length",
    "content-type",
    "content-disposition",
    "content-encoding",
    "content-language",
    "cache-control",
    "expires"
  ];
  const headers = {};
  for (const key of headerKeys) {
    const value = options29[key] || "";
    if (value && typeof value === "string")
      headers[key] = value;
  }
  if (jurisdiction !== void 0) {
    headers["cf-r2-jurisdiction"] = jurisdiction;
  }
  if (storageClass !== void 0) {
    headers["cf-r2-storage-class"] = storageClass;
  }
  const result = await fetchR2Objects(
    `/accounts/${accountId}/r2/buckets/${bucketName}/objects/${objectName}`,
    {
      body: object,
      headers,
      method: "PUT",
      duplex: "half"
    }
  );
  if (result === null) {
    throw new UserError("The specified bucket does not exist.");
  }
}
__name(putR2Object, "putR2Object");
async function deleteR2Object(accountId, bucketName, objectName, jurisdiction) {
  const headers = {};
  if (jurisdiction !== void 0) {
    headers["cf-r2-jurisdiction"] = jurisdiction;
  }
  await fetchR2Objects(
    `/accounts/${accountId}/r2/buckets/${bucketName}/objects/${objectName}`,
    { method: "DELETE", headers }
  );
}
__name(deleteR2Object, "deleteR2Object");
async function usingLocalBucket(persistTo, configPath, bucketName, closure) {
  const persist = getLocalPersistencePath(persistTo, configPath);
  const persistOptions = buildPersistOptions(persist);
  const mf = new import_miniflare11.Miniflare({
    modules: true,
    // TODO(soon): import `reduceError()` from `miniflare:shared`
    script: `
		function reduceError(e) {
			return {
				name: e?.name,
				message: e?.message ?? String(e),
				stack: e?.stack,
				cause: e?.cause === undefined ? undefined : reduceError(e.cause),
			};
		}
		export default {
			async fetch(request, env, ctx) {
				try {
					if (request.method !== "PUT") return new Response(null, { status: 405 });
					const url = new URL(request.url);
					const key = url.pathname.substring(1);
					const optsHeader = request.headers.get("Wrangler-R2-Put-Options");
					const opts = JSON.parse(optsHeader);
					await env.BUCKET.put(key, request.body, opts);
					return new Response(null, { status: 204 });
				} catch (e) {
					const error = reduceError(e);
					return Response.json(error, {
						status: 500,
						headers: { "MF-Experimental-Error-Stack": "true" },
					});
				}
			}
		}`,
    ...persistOptions,
    r2Buckets: { BUCKET: bucketName }
  });
  const bucket = await mf.getR2Bucket("BUCKET");
  try {
    return await closure(bucket, mf);
  } finally {
    await mf.dispose();
  }
}
__name(usingLocalBucket, "usingLocalBucket");
async function getR2Sippy(accountId, bucketName, jurisdiction) {
  const headers = {};
  if (jurisdiction !== void 0) {
    headers["cf-r2-jurisdiction"] = jurisdiction;
  }
  return await fetchResult(
    `/accounts/${accountId}/r2/buckets/${bucketName}/sippy`,
    { method: "GET", headers }
  );
}
__name(getR2Sippy, "getR2Sippy");
async function deleteR2Sippy(accountId, bucketName, jurisdiction) {
  const headers = {};
  if (jurisdiction !== void 0) {
    headers["cf-r2-jurisdiction"] = jurisdiction;
  }
  return await fetchResult(
    `/accounts/${accountId}/r2/buckets/${bucketName}/sippy`,
    { method: "DELETE", headers }
  );
}
__name(deleteR2Sippy, "deleteR2Sippy");
async function putR2Sippy(accountId, bucketName, params, jurisdiction) {
  const headers = {
    "Content-Type": "application/json"
  };
  if (jurisdiction !== void 0) {
    headers["cf-r2-jurisdiction"] = jurisdiction;
  }
  return await fetchResult(
    `/accounts/${accountId}/r2/buckets/${bucketName}/sippy`,
    { method: "PUT", body: JSON.stringify(params), headers }
  );
}
__name(putR2Sippy, "putR2Sippy");
var actionsForEventCategories = {
  "object-create": ["PutObject", "CompleteMultipartUpload", "CopyObject"],
  "object-delete": ["DeleteObject"]
};
var eventCategoryByAction = {
  PutObject: "object-create",
  CompleteMultipartUpload: "object-create",
  CopyObject: "object-create",
  DeleteObject: "object-delete"
};
function eventNotificationHeaders(apiCredentials) {
  const headers = {
    "Content-Type": "application/json"
  };
  if ("apiToken" in apiCredentials) {
    headers["Authorization"] = `Bearer ${apiCredentials.apiToken}`;
  } else {
    headers["X-Auth-Key"] = apiCredentials.authKey;
    headers["X-Auth-Email"] = apiCredentials.authEmail;
  }
  return headers;
}
__name(eventNotificationHeaders, "eventNotificationHeaders");
async function tableFromNotificationGetResponse(config, response, queueIdentifier) {
  const reducer = /* @__PURE__ */ __name(async ([_3, { queue, rules }]) => {
    const queueResp = await queueIdentifier(config, queue);
    const rows = [];
    for (const { prefix = "", suffix = "", actions } of rules) {
      rows.push({
        queue_name: queueResp.queue_name,
        prefix,
        suffix,
        event_type: Array.from(
          actions.reduce((acc, action) => {
            acc.add(eventCategoryByAction[action]);
            return acc;
          }, /* @__PURE__ */ new Set())
        ).join(",")
      });
    }
    return rows;
  }, "reducer");
  let tableOutput = [];
  for (const entry of Object.entries(response)) {
    const result = await reducer(entry);
    tableOutput = tableOutput.concat(...result);
  }
  return tableOutput;
}
__name(tableFromNotificationGetResponse, "tableFromNotificationGetResponse");
async function getEventNotificationConfig(apiCredentials, accountId, bucketName) {
  const headers = eventNotificationHeaders(apiCredentials);
  logger.log(`Fetching notification configuration for bucket ${bucketName}...`);
  return await fetchResult(
    `/accounts/${accountId}/event_notifications/r2/${bucketName}/configuration`,
    { method: "GET", headers }
  );
}
__name(getEventNotificationConfig, "getEventNotificationConfig");
async function putEventNotificationConfig(config, apiCredentials, accountId, bucketName, queueName, eventTypes, prefix, suffix) {
  const queue = await getQueue(config, queueName);
  const headers = eventNotificationHeaders(apiCredentials);
  let actions = [];
  for (const et of eventTypes) {
    actions = actions.concat(actionsForEventCategories[et]);
  }
  const body = {
    rules: [{ prefix, suffix, actions }]
  };
  const ruleFor = eventTypes.map(
    (et) => et === "object-create" ? "creation" : "deletion"
  );
  logger.log(
    `Creating event notification rule for object ${ruleFor.join(
      " and "
    )} (${actions.join(",")})`
  );
  return await fetchResult(
    `/accounts/${accountId}/event_notifications/r2/${bucketName}/configuration/queues/${queue.queue_id}`,
    { method: "PUT", body: JSON.stringify(body), headers }
  );
}
__name(putEventNotificationConfig, "putEventNotificationConfig");
async function deleteEventNotificationConfig(config, apiCredentials, accountId, bucketName, queueName) {
  const queue = await getQueue(config, queueName);
  const headers = eventNotificationHeaders(apiCredentials);
  logger.log(
    `Disabling event notifications for "${bucketName}" to queue ${queueName}...`
  );
  return await fetchResult(
    `/accounts/${accountId}/event_notifications/r2/${bucketName}/configuration/queues/${queue.queue_id}`,
    { method: "DELETE", headers }
  );
}
__name(deleteEventNotificationConfig, "deleteEventNotificationConfig");

// src/r2/notification.ts
init_import_meta_url();
function GetOptions(yargs) {
  return yargs.positional("bucket", {
    describe: "The name of the bucket for which notifications will be emitted",
    type: "string",
    demandOption: true
  });
}
__name(GetOptions, "GetOptions");
async function GetHandler(args) {
  await printWranglerBanner();
  const config = readConfig(args.config, args);
  const accountId = await requireAuth(config);
  const apiCreds = requireApiToken();
  const resp = await getEventNotificationConfig(
    apiCreds,
    accountId,
    `${args.bucket}`
  );
  const tableOutput = await tableFromNotificationGetResponse(
    config,
    resp[args.bucket],
    getQueueById
  );
  logger.table(tableOutput);
}
__name(GetHandler, "GetHandler");
function CreateOptions4(yargs) {
  return yargs.positional("bucket", {
    describe: "The name of the bucket for which notifications will be emitted",
    type: "string",
    demandOption: true
  }).option("event-types", {
    describe: "Specify the kinds of object events to emit notifications for. ex. '--event-types object-create object-delete'",
    alias: "event-type",
    choices: Object.keys(actionsForEventCategories),
    demandOption: true,
    requiresArg: true,
    type: "array"
  }).option("prefix", {
    describe: "only actions on objects with this prefix will emit notifications",
    requiresArg: false,
    type: "string"
  }).option("suffix", {
    describe: "only actions on objects with this suffix will emit notifications",
    type: "string"
  }).option("queue", {
    describe: "The name of the queue to which event notifications will be sent. ex '--queue my-queue'",
    demandOption: true,
    requiresArg: true,
    type: "string"
  });
}
__name(CreateOptions4, "CreateOptions");
async function CreateHandler4(args) {
  await printWranglerBanner();
  const config = readConfig(args.config, args);
  const accountId = await requireAuth(config);
  const apiCreds = requireApiToken();
  const { bucket, queue, eventTypes, prefix = "", suffix = "" } = args;
  await putEventNotificationConfig(
    config,
    apiCreds,
    accountId,
    `${bucket}`,
    `${queue}`,
    eventTypes,
    `${prefix}`,
    `${suffix}`
  );
  logger.log("Configuration created successfully!");
}
__name(CreateHandler4, "CreateHandler");
function DeleteOptions2(yargs) {
  return yargs.positional("bucket", {
    describe: "The name of the bucket for which notifications will be emitted",
    type: "string",
    demandOption: true
  }).option("queue", {
    describe: "The name of the queue that is configured to receive notifications. ex '--queue my-queue'",
    demandOption: true,
    requiresArg: true,
    type: "string"
  });
}
__name(DeleteOptions2, "DeleteOptions");
async function DeleteHandler2(args) {
  await printWranglerBanner();
  const config = readConfig(args.config, args);
  const accountId = await requireAuth(config);
  const apiCreds = requireApiToken();
  const { bucket, queue } = args;
  await deleteEventNotificationConfig(
    config,
    apiCreds,
    accountId,
    `${bucket}`,
    `${queue}`
  );
  logger.log("Configuration deleted successfully!");
}
__name(DeleteHandler2, "DeleteHandler");

// src/r2/sippy.ts
init_import_meta_url();
var NO_SUCH_OBJECT_KEY = 10007;
var SIPPY_PROVIDER_CHOICES = ["AWS", "GCS"];
function EnableOptions(yargs) {
  return yargs.positional("name", {
    describe: "The name of the bucket",
    type: "string",
    demandOption: true
  }).option("jurisdiction", {
    describe: "The jurisdiction where the bucket exists",
    alias: "J",
    requiresArg: true,
    type: "string"
  }).option("provider", {
    choices: SIPPY_PROVIDER_CHOICES
  }).option("bucket", {
    description: "The name of the upstream bucket",
    string: true
  }).option("region", {
    description: "(AWS provider only) The region of the upstream bucket",
    string: true
  }).option("access-key-id", {
    description: "(AWS provider only) The secret access key id for the upstream bucket",
    string: true
  }).option("secret-access-key", {
    description: "(AWS provider only) The secret access key for the upstream bucket",
    string: true
  }).option("service-account-key-file", {
    description: "(GCS provider only) The path to your Google Cloud service account key JSON file",
    string: true
  }).option("client-email", {
    description: "(GCS provider only) The client email for your Google Cloud service account key",
    string: true
  }).option("private-key", {
    description: "(GCS provider only) The private key for your Google Cloud service account key",
    string: true
  }).option("r2-access-key-id", {
    description: "The secret access key id for this R2 bucket",
    string: true
  }).option("r2-secret-access-key", {
    description: "The secret access key for this R2 bucket",
    string: true
  });
}
__name(EnableOptions, "EnableOptions");
async function EnableHandler(args) {
  const isInteractive3 = process.stdin.isTTY;
  const config = readConfig(args.config, args);
  const accountId = await requireAuth(config);
  if (isInteractive3) {
    args.provider ??= await prompt(
      "Enter the cloud storage provider of your bucket (AWS or GCS):"
    );
    if (!args.provider) {
      throw new UserError("Must specify a cloud storage provider.");
    }
    if (!SIPPY_PROVIDER_CHOICES.includes(args.provider)) {
      throw new UserError("Cloud storage provider must be: AWS or GCS");
    }
    args.bucket ??= await prompt(
      `Enter the name of your ${args.provider} bucket:`
    );
    if (!args.bucket) {
      throw new UserError(`Must specify ${args.provider} bucket name.`);
    }
    if (args.provider === "AWS") {
      args.region ??= await prompt(
        "Enter the AWS region where your S3 bucket is located (example: us-west-2):"
      );
      if (!args.region) {
        throw new UserError("Must specify an AWS Region.");
      }
      args.accessKeyId ??= await prompt(
        "Enter your AWS Access Key ID (requires read and list access):"
      );
      if (!args.accessKeyId) {
        throw new UserError("Must specify an AWS Access Key ID.");
      }
      args.secretAccessKey ??= await prompt(
        "Enter your AWS Secret Access Key:"
      );
      if (!args.secretAccessKey) {
        throw new UserError("Must specify an AWS Secret Access Key.");
      }
    } else if (args.provider === "GCS") {
      if (!(args.clientEmail && args.privateKey) && !args.serviceAccountKeyFile) {
        args.serviceAccountKeyFile = await prompt(
          "Enter the path to your Google Cloud service account key JSON file:"
        );
        if (!args.serviceAccountKeyFile) {
          throw new UserError(
            "Must specify the path to a service account key JSON file."
          );
        }
      }
    }
    args.r2AccessKeyId ??= await prompt(
      "Enter your R2 Access Key ID (requires read and write access):"
    );
    if (!args.r2AccessKeyId) {
      throw new UserError("Must specify an R2 Access Key ID.");
    }
    args.r2SecretAccessKey ??= await prompt("Enter your R2 Secret Access Key:");
    if (!args.r2SecretAccessKey) {
      throw new UserError("Must specify an R2 Secret Access Key.");
    }
  }
  let sippyConfig;
  if (args.provider === "AWS") {
    if (!args.region)
      throw new UserError("Error: must provide --region.");
    if (!args.bucket)
      throw new UserError("Error: must provide --bucket.");
    if (!args.accessKeyId)
      throw new UserError("Error: must provide --access-key-id.");
    if (!args.secretAccessKey)
      throw new UserError("Error: must provide --secret-access-key.");
    if (!args.r2AccessKeyId)
      throw new UserError("Error: must provide --r2-access-key-id.");
    if (!args.r2SecretAccessKey)
      throw new UserError("Error: must provide --r2-secret-access-key.");
    sippyConfig = {
      source: {
        provider: "aws",
        region: args.region,
        bucket: args.bucket,
        accessKeyId: args.accessKeyId,
        secretAccessKey: args.secretAccessKey
      },
      destination: {
        provider: "r2",
        accessKeyId: args.r2AccessKeyId,
        secretAccessKey: args.r2SecretAccessKey
      }
    };
  } else if (args.provider === "GCS") {
    if (args.serviceAccountKeyFile) {
      const serviceAccount = JSON.parse(
        readFileSync5(args.serviceAccountKeyFile)
      );
      if ("client_email" in serviceAccount && "private_key" in serviceAccount) {
        args.clientEmail = serviceAccount.client_email;
        args.privateKey = serviceAccount.private_key;
      }
    }
    if (!args.bucket)
      throw new UserError("Error: must provide --bucket.");
    if (!args.clientEmail)
      throw new UserError(
        "Error: must provide --service-account-key-file or --client-email."
      );
    if (!args.privateKey)
      throw new UserError(
        "Error: must provide --service-account-key-file or --private-key."
      );
    args.privateKey = args.privateKey.replace(/\\n/g, "\n");
    if (!args.r2AccessKeyId)
      throw new UserError("Error: must provide --r2-access-key-id.");
    if (!args.r2SecretAccessKey)
      throw new UserError("Error: must provide --r2-secret-access-key.");
    sippyConfig = {
      source: {
        provider: "gcs",
        bucket: args.bucket,
        clientEmail: args.clientEmail,
        privateKey: args.privateKey
      },
      destination: {
        provider: "r2",
        accessKeyId: args.r2AccessKeyId,
        secretAccessKey: args.r2SecretAccessKey
      }
    };
  } else {
    throw new UserError(
      "Error: unrecognized provider. Possible options are AWS & GCS."
    );
  }
  await putR2Sippy(accountId, args.name, sippyConfig, args.jurisdiction);
  logger.log(`\u2728 Successfully enabled Sippy on the '${args.name}' bucket.`);
}
__name(EnableHandler, "EnableHandler");
function GetOptions2(yargs) {
  return yargs.positional("name", {
    describe: "The name of the bucket",
    type: "string",
    demandOption: true
  }).option("jurisdiction", {
    describe: "The jurisdiction where the bucket exists",
    alias: "J",
    requiresArg: true,
    type: "string"
  });
}
__name(GetOptions2, "GetOptions");
async function GetHandler2(args) {
  const config = readConfig(args.config, args);
  const accountId = await requireAuth(config);
  try {
    const sippyConfig = await getR2Sippy(
      accountId,
      args.name,
      args.jurisdiction
    );
    logger.log("Sippy configuration:", sippyConfig);
  } catch (e3) {
    if (e3 instanceof APIError && "code" in e3 && e3.code === NO_SUCH_OBJECT_KEY) {
      logger.log(`No Sippy configuration found for the '${args.name}' bucket.`);
    } else {
      throw e3;
    }
  }
}
__name(GetHandler2, "GetHandler");
function DisableOptions(yargs) {
  return yargs.positional("name", {
    describe: "The name of the bucket",
    type: "string",
    demandOption: true
  }).option("jurisdiction", {
    describe: "The jurisdiction where the bucket exists",
    alias: "J",
    requiresArg: true,
    type: "string"
  });
}
__name(DisableOptions, "DisableOptions");
async function DisableHandler(args) {
  const config = readConfig(args.config, args);
  const accountId = await requireAuth(config);
  await deleteR2Sippy(accountId, args.name, args.jurisdiction);
  logger.log(`\u2728 Successfully disabled Sippy on the '${args.name}' bucket.`);
}
__name(DisableHandler, "DisableHandler");

// src/r2/index.ts
var CHUNK_SIZE = 1024;
async function createFileReadableStream(filePath) {
  const handle = await fs23.promises.open(filePath, "r");
  let position = 0;
  return new import_web.ReadableStream({
    async pull(controller) {
      const buffer = new Uint8Array(CHUNK_SIZE);
      const { bytesRead } = await handle.read(buffer, 0, CHUNK_SIZE, position);
      if (bytesRead === 0) {
        await handle.close();
        controller.close();
      } else {
        position += bytesRead;
        controller.enqueue(buffer.subarray(0, bytesRead));
      }
    },
    cancel() {
      return handle.close();
    }
  });
}
__name(createFileReadableStream, "createFileReadableStream");
function r22(r2Yargs) {
  return r2Yargs.command("object", "Manage R2 objects", (r2ObjectYargs) => {
    return r2ObjectYargs.command(
      "get <objectPath>",
      "Fetch an object from an R2 bucket",
      (objectArgs) => {
        return objectArgs.positional("objectPath", {
          describe: "The source object path in the form of {bucket}/{key}",
          type: "string"
        }).option("file", {
          describe: "The destination file to create",
          alias: "f",
          conflicts: "pipe",
          requiresArg: true,
          type: "string"
        }).option("pipe", {
          describe: "Enables the file to be piped to a destination, rather than specified with the --file option",
          alias: "p",
          conflicts: "file",
          type: "boolean"
        }).option("local", {
          type: "boolean",
          describe: "Interact with local storage"
        }).option("persist-to", {
          type: "string",
          describe: "Directory for local persistence"
        }).option("jurisdiction", {
          describe: "The jurisdiction where the object exists",
          alias: "J",
          requiresArg: true,
          type: "string"
        });
      },
      async (objectGetYargs) => {
        const config = readConfig(objectGetYargs.config, objectGetYargs);
        const { objectPath, pipe, jurisdiction } = objectGetYargs;
        const { bucket, key } = bucketAndKeyFromObjectPath(objectPath);
        let fullBucketName = bucket;
        if (jurisdiction !== void 0) {
          fullBucketName += ` (${jurisdiction})`;
        }
        let file = objectGetYargs.file;
        if (!file && !pipe) {
          file = key;
        }
        if (!pipe) {
          await printWranglerBanner();
          logger.log(`Downloading "${key}" from "${fullBucketName}".`);
        }
        let output;
        if (file) {
          fs23.mkdirSync(path50.dirname(file), { recursive: true });
          output = fs23.createWriteStream(file);
        } else {
          output = process.stdout;
        }
        if (objectGetYargs.local) {
          await usingLocalBucket(
            objectGetYargs.persistTo,
            config.configPath,
            bucket,
            async (r2Bucket) => {
              const object = await r2Bucket.get(key);
              if (object === null) {
                throw new UserError("The specified key does not exist.");
              }
              await stream.promises.pipeline(object.body, output);
            }
          );
        } else {
          const accountId = await requireAuth(config);
          const input = await getR2Object(
            accountId,
            bucket,
            key,
            jurisdiction
          );
          if (input === null) {
            throw new UserError("The specified key does not exist.");
          }
          await stream.promises.pipeline(input, output);
        }
        if (!pipe)
          logger.log("Download complete.");
      }
    ).command(
      "put <objectPath>",
      "Create an object in an R2 bucket",
      (Objectyargs) => {
        return Objectyargs.positional("objectPath", {
          describe: "The destination object path in the form of {bucket}/{key}",
          type: "string"
        }).option("file", {
          describe: "The path of the file to upload",
          alias: "f",
          conflicts: "pipe",
          requiresArg: true,
          type: "string"
        }).option("pipe", {
          describe: "Enables the file to be piped in, rather than specified with the --file option",
          alias: "p",
          conflicts: "file",
          type: "boolean"
        }).option("content-type", {
          describe: "A standard MIME type describing the format of the object data",
          alias: "ct",
          requiresArg: true,
          type: "string"
        }).option("content-disposition", {
          describe: "Specifies presentational information for the object",
          alias: "cd",
          requiresArg: true,
          type: "string"
        }).option("content-encoding", {
          describe: "Specifies what content encodings have been applied to the object and thus what decoding mechanisms must be applied to obtain the media-type referenced by the Content-Type header field",
          alias: "ce",
          requiresArg: true,
          type: "string"
        }).option("content-language", {
          describe: "The language the content is in",
          alias: "cl",
          requiresArg: true,
          type: "string"
        }).option("cache-control", {
          describe: "Specifies caching behavior along the request/reply chain",
          alias: "cc",
          requiresArg: true,
          type: "string"
        }).option("expires", {
          describe: "The date and time at which the object is no longer cacheable",
          alias: "e",
          requiresArg: true,
          type: "string"
        }).option("local", {
          type: "boolean",
          describe: "Interact with local storage"
        }).option("persist-to", {
          type: "string",
          describe: "Directory for local persistence"
        }).option("jurisdiction", {
          describe: "The jurisdiction where the object will be created",
          alias: "J",
          requiresArg: true,
          type: "string"
        }).option("storage-class", {
          describe: "The storage class of the object to be created",
          alias: "s",
          requiresArg: false,
          type: "string"
        });
      },
      async (objectPutYargs) => {
        await printWranglerBanner();
        const config = readConfig(objectPutYargs.config, objectPutYargs);
        const {
          objectPath,
          file,
          pipe,
          local,
          persistTo,
          jurisdiction,
          storageClass,
          ...options29
        } = objectPutYargs;
        const { bucket, key } = bucketAndKeyFromObjectPath(objectPath);
        if (!file && !pipe) {
          throw new CommandLineArgsError(
            "Either the --file or --pipe options are required."
          );
        }
        let object;
        let objectSize;
        if (file) {
          object = await createFileReadableStream(file);
          const stats = fs23.statSync(file);
          objectSize = stats.size;
        } else {
          const buffer = await new Promise((resolve19, reject) => {
            const stdin = process.stdin;
            const chunks = Array();
            stdin.on("data", (chunk) => chunks.push(chunk));
            stdin.on("end", () => resolve19(Buffer.concat(chunks)));
            stdin.on(
              "error",
              (err) => reject(
                new CommandLineArgsError(
                  `Could not pipe. Reason: "${err.message}"`
                )
              )
            );
          });
          const blob = new import_node_buffer5.Blob([buffer]);
          object = blob.stream();
          objectSize = blob.size;
        }
        if (objectSize > MAX_UPLOAD_SIZE) {
          throw new FatalError(
            `Error: Wrangler only supports uploading files up to ${prettyBytes(
              MAX_UPLOAD_SIZE,
              { binary: true }
            )} in size
${key} is ${prettyBytes(objectSize, {
              binary: true
            })} in size`,
            1
          );
        }
        let fullBucketName = bucket;
        if (jurisdiction !== void 0) {
          fullBucketName += ` (${jurisdiction})`;
        }
        let storageClassLog = ``;
        if (storageClass !== void 0) {
          storageClassLog = ` with ${storageClass} storage class`;
        }
        logger.log(
          `Creating object "${key}"${storageClassLog} in bucket "${fullBucketName}".`
        );
        if (local) {
          await usingLocalBucket(
            persistTo,
            config.configPath,
            bucket,
            async (r2Bucket, mf) => {
              const putOptions = {
                httpMetadata: {
                  contentType: options29.contentType,
                  contentDisposition: options29.contentDisposition,
                  contentEncoding: options29.contentEncoding,
                  contentLanguage: options29.contentLanguage,
                  cacheControl: options29.cacheControl,
                  // @ts-expect-error `@cloudflare/workers-types` is wrong
                  //  here, `number`'s are allowed for `Date`s
                  // TODO(now): fix
                  cacheExpiry: options29.expires === void 0 ? void 0 : parseInt(options29.expires)
                },
                customMetadata: void 0,
                sha1: void 0,
                sha256: void 0,
                onlyIf: void 0,
                md5: void 0,
                sha384: void 0,
                sha512: void 0
              };
              await mf.dispatchFetch(`http://localhost/${key}`, {
                method: "PUT",
                body: object,
                duplex: "half",
                headers: {
                  "Content-Length": objectSize.toString(),
                  "Wrangler-R2-Put-Options": JSON.stringify(putOptions)
                }
              });
            }
          );
        } else {
          const accountId = await requireAuth(config);
          await putR2Object(
            accountId,
            bucket,
            key,
            object,
            {
              ...options29,
              "content-length": `${objectSize}`
            },
            jurisdiction,
            storageClass
          );
        }
        logger.log("Upload complete.");
      }
    ).command(
      "delete <objectPath>",
      "Delete an object in an R2 bucket",
      (objectDeleteYargs) => {
        return objectDeleteYargs.positional("objectPath", {
          describe: "The destination object path in the form of {bucket}/{key}",
          type: "string"
        }).option("local", {
          type: "boolean",
          describe: "Interact with local storage"
        }).option("persist-to", {
          type: "string",
          describe: "Directory for local persistence"
        }).option("jurisdiction", {
          describe: "The jurisdiction where the object exists",
          alias: "J",
          requiresArg: true,
          type: "string"
        });
      },
      async (args) => {
        const { objectPath, jurisdiction } = args;
        await printWranglerBanner();
        const config = readConfig(args.config, args);
        const { bucket, key } = bucketAndKeyFromObjectPath(objectPath);
        let fullBucketName = bucket;
        if (jurisdiction !== void 0) {
          fullBucketName += ` (${jurisdiction})`;
        }
        logger.log(
          `Deleting object "${key}" from bucket "${fullBucketName}".`
        );
        if (args.local) {
          await usingLocalBucket(
            args.persistTo,
            config.configPath,
            bucket,
            (r2Bucket) => r2Bucket.delete(key)
          );
        } else {
          const accountId = await requireAuth(config);
          await deleteR2Object(accountId, bucket, key, jurisdiction);
        }
        logger.log("Delete complete.");
      }
    );
  }).command("bucket", "Manage R2 buckets", (r2BucketYargs) => {
    r2BucketYargs.command(
      "create <name>",
      "Create a new R2 bucket",
      (yargs) => {
        return yargs.positional("name", {
          describe: "The name of the new bucket",
          type: "string",
          demandOption: true
        }).option("jurisdiction", {
          describe: "The jurisdiction where the new bucket will be created",
          alias: "J",
          requiresArg: true,
          type: "string"
        }).option("storage-class", {
          describe: "The default storage class for objects uploaded to this bucket",
          alias: "s",
          requiresArg: false,
          type: "string"
        });
      },
      async (args) => {
        await printWranglerBanner();
        const config = readConfig(args.config, args);
        const accountId = await requireAuth(config);
        let fullBucketName = `${args.name}`;
        if (args.jurisdiction !== void 0) {
          fullBucketName += ` (${args.jurisdiction})`;
        }
        let defaultStorageClass = ` with default storage class set to `;
        if (args.storageClass !== void 0) {
          defaultStorageClass += args.storageClass;
        } else {
          defaultStorageClass += "Standard";
        }
        logger.log(
          `Creating bucket ${fullBucketName}${defaultStorageClass}.`
        );
        await createR2Bucket(
          accountId,
          args.name,
          args.jurisdiction,
          args.storageClass
        );
        logger.log(`Created bucket ${fullBucketName}${defaultStorageClass}.`);
        await sendMetricsEvent("create r2 bucket", {
          sendMetrics: config.send_metrics
        });
      }
    );
    r2BucketYargs.command("update", "Update bucket state", (updateYargs) => {
      updateYargs.command(
        "storage-class <name>",
        "Update the default storage class of an existing R2 bucket",
        (yargs) => {
          return yargs.positional("name", {
            describe: "The name of the existing bucket",
            type: "string",
            demandOption: true
          }).option("jurisdiction", {
            describe: "The jurisdiction of the bucket to be updated",
            alias: "J",
            requiresArg: true,
            type: "string"
          }).option("storage-class", {
            describe: "The new default storage class for this bucket",
            alias: "s",
            demandOption: true,
            requiresArg: true,
            type: "string"
          });
        },
        async (args) => {
          await printWranglerBanner();
          const config = readConfig(args.config, args);
          const accountId = await requireAuth(config);
          let fullBucketName = `${args.name}`;
          if (args.jurisdiction !== void 0) {
            fullBucketName += ` (${args.jurisdiction})`;
          }
          logger.log(
            `Updating bucket ${fullBucketName} to ${args.storageClass} default storage class.`
          );
          await updateR2BucketStorageClass(
            accountId,
            args.name,
            args.storageClass,
            args.jurisdiction
          );
          logger.log(
            `Updated bucket ${fullBucketName} to ${args.storageClass} default storage class.`
          );
        }
      );
    });
    r2BucketYargs.command(
      "list",
      "List R2 buckets",
      (listArgs) => {
        return listArgs.option("jurisdiction", {
          describe: "The jurisdiction to list",
          alias: "J",
          requiresArg: true,
          type: "string"
        });
      },
      async (args) => {
        const config = readConfig(args.config, args);
        const { jurisdiction } = args;
        const accountId = await requireAuth(config);
        logger.log(
          JSON.stringify(
            await listR2Buckets(accountId, jurisdiction),
            null,
            2
          )
        );
        await sendMetricsEvent("list r2 buckets", {
          sendMetrics: config.send_metrics
        });
      }
    );
    r2BucketYargs.command(
      "delete <name>",
      "Delete an R2 bucket",
      (yargs) => {
        return yargs.positional("name", {
          describe: "The name of the bucket to delete",
          type: "string",
          demandOption: true
        }).option("jurisdiction", {
          describe: "The jurisdiction where the bucket exists",
          alias: "J",
          requiresArg: true,
          type: "string"
        });
      },
      async (args) => {
        await printWranglerBanner();
        const config = readConfig(args.config, args);
        const accountId = await requireAuth(config);
        let fullBucketName = `${args.name}`;
        if (args.jurisdiction !== void 0) {
          fullBucketName += ` (${args.jurisdiction})`;
        }
        logger.log(`Deleting bucket ${fullBucketName}.`);
        await deleteR2Bucket(accountId, args.name, args.jurisdiction);
        logger.log(`Deleted bucket ${fullBucketName}.`);
        await sendMetricsEvent("delete r2 bucket", {
          sendMetrics: config.send_metrics
        });
      }
    );
    r2BucketYargs.command(
      "sippy",
      "Manage Sippy incremental migration on an R2 bucket",
      (sippyYargs) => {
        return sippyYargs.command(
          "enable <name>",
          "Enable Sippy on an R2 bucket",
          EnableOptions,
          EnableHandler
        ).command(
          "disable <name>",
          "Disable Sippy on an R2 bucket",
          DisableOptions,
          DisableHandler
        ).command(
          "get <name>",
          "Check the status of Sippy on an R2 bucket",
          GetOptions2,
          GetHandler2
        );
      }
    );
    r2BucketYargs.command(
      "notification",
      "Manage event notifications for an R2 bucket",
      (r2EvNotifyYargs) => {
        return r2EvNotifyYargs.command(
          "get <bucket>",
          "Get event notification configuration for a bucket",
          GetOptions,
          GetHandler
        ).command(
          "create <bucket>",
          "Create new event notification configuration for an R2 bucket",
          CreateOptions4,
          CreateHandler4
        ).command(
          "delete <bucket>",
          "Delete event notification configuration for an R2 bucket and queue",
          DeleteOptions2,
          DeleteHandler2
        );
      }
    );
    return r2BucketYargs;
  });
}
__name(r22, "r2");

// src/secret/index.ts
init_import_meta_url();
var import_node_path49 = __toESM(require("node:path"));
var import_node_readline3 = __toESM(require("node:readline"));
var import_undici16 = __toESM(require_undici());
function isMissingWorkerError(e3) {
  return typeof e3 === "object" && e3 !== null && e3.code === 10007;
}
__name(isMissingWorkerError, "isMissingWorkerError");
async function createDraftWorker({
  config,
  args,
  accountId,
  scriptName
}) {
  await fetchResult(
    !isLegacyEnv(config) && args.env ? `/accounts/${accountId}/workers/services/${scriptName}/environments/${args.env}` : `/accounts/${accountId}/workers/scripts/${scriptName}`,
    {
      method: "PUT",
      body: createWorkerUploadForm({
        name: scriptName,
        main: {
          name: scriptName,
          filePath: void 0,
          content: `export default { fetch() {} }`,
          type: "esm"
        },
        bindings: {
          kv_namespaces: [],
          send_email: [],
          vars: {},
          durable_objects: { bindings: [] },
          queues: [],
          r2_buckets: [],
          d1_databases: [],
          vectorize: [],
          hyperdrive: [],
          constellation: [],
          services: [],
          analytics_engine_datasets: [],
          wasm_modules: {},
          browser: void 0,
          ai: void 0,
          version_metadata: void 0,
          text_blobs: {},
          data_blobs: {},
          dispatch_namespaces: [],
          mtls_certificates: [],
          logfwdr: { bindings: [] },
          unsafe: {
            bindings: void 0,
            metadata: void 0,
            capnp: void 0
          }
        },
        modules: [],
        migrations: void 0,
        compatibility_date: void 0,
        compatibility_flags: void 0,
        usage_model: void 0,
        keepVars: false,
        // this doesn't matter since it's a new script anyway
        keepSecrets: false,
        // this doesn't matter since it's a new script anyway
        logpush: false,
        sourceMaps: void 0,
        placement: void 0,
        tail_consumers: void 0,
        limits: void 0
      })
    }
  );
}
__name(createDraftWorker, "createDraftWorker");
var secret2 = /* @__PURE__ */ __name((secretYargs) => {
  return secretYargs.option("legacy-env", {
    type: "boolean",
    describe: "Use legacy environments",
    hidden: true
  }).command(
    "put <key>",
    "Create or update a secret variable for a Worker",
    (yargs) => {
      return yargs.positional("key", {
        describe: "The variable name to be accessible in the Worker",
        type: "string"
      }).option("name", {
        describe: "Name of the Worker",
        type: "string",
        requiresArg: true
      });
    },
    async (args) => {
      await printWranglerBanner();
      const config = readConfig(args.config, args);
      const scriptName = getLegacyScriptName(args, config);
      if (!scriptName) {
        throw new UserError(
          "Required Worker name missing. Please specify the Worker name in wrangler.toml, or pass it as an argument with `--name <worker-name>`"
        );
      }
      const accountId = await requireAuth(config);
      const isInteractive3 = process.stdin.isTTY;
      const secretValue = trimTrailingWhitespace2(
        isInteractive3 ? await prompt("Enter a secret value:", { isSecret: true }) : await readFromStdin2()
      );
      logger.log(
        `\u{1F300} Creating the secret for the Worker "${scriptName}" ${args.env && !isLegacyEnv(config) ? `(${args.env})` : ""}`
      );
      async function submitSecret() {
        const url4 = !args.env || isLegacyEnv(config) ? `/accounts/${accountId}/workers/scripts/${scriptName}/secrets` : `/accounts/${accountId}/workers/services/${scriptName}/environments/${args.env}/secrets`;
        return await fetchResult(url4, {
          method: "PUT",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify({
            name: args.key,
            text: secretValue,
            type: "secret_text"
          })
        });
      }
      __name(submitSecret, "submitSecret");
      try {
        await submitSecret();
        await sendMetricsEvent("create encrypted variable", {
          sendMetrics: config.send_metrics
        });
      } catch (e3) {
        if (isMissingWorkerError(e3)) {
          await createDraftWorker({
            config,
            args,
            accountId,
            scriptName
          });
          await submitSecret();
        } else {
          throw e3;
        }
      }
      logger.log(`\u2728 Success! Uploaded secret ${args.key}`);
    }
  ).command(
    "delete <key>",
    "Delete a secret variable from a Worker",
    async (yargs) => {
      await printWranglerBanner();
      return yargs.positional("key", {
        describe: "The variable name to be accessible in the Worker",
        type: "string"
      }).option("name", {
        describe: "Name of the Worker",
        type: "string",
        requiresArg: true
      });
    },
    async (args) => {
      const config = readConfig(args.config, args);
      const scriptName = getLegacyScriptName(args, config);
      if (!scriptName) {
        throw new UserError(
          "Required Worker name missing. Please specify the Worker name in wrangler.toml, or pass it as an argument with `--name <worker-name>`"
        );
      }
      const accountId = await requireAuth(config);
      if (await confirm(
        `Are you sure you want to permanently delete the secret ${args.key} on the Worker ${scriptName}${args.env && !isLegacyEnv(config) ? ` (${args.env})` : ""}?`
      )) {
        logger.log(
          `\u{1F300} Deleting the secret ${args.key} on the Worker ${scriptName}${args.env && !isLegacyEnv(config) ? ` (${args.env})` : ""}`
        );
        const url4 = !args.env || isLegacyEnv(config) ? `/accounts/${accountId}/workers/scripts/${scriptName}/secrets` : `/accounts/${accountId}/workers/services/${scriptName}/environments/${args.env}/secrets`;
        await fetchResult(`${url4}/${args.key}`, { method: "DELETE" });
        await sendMetricsEvent("delete encrypted variable", {
          sendMetrics: config.send_metrics
        });
        logger.log(`\u2728 Success! Deleted secret ${args.key}`);
      }
    }
  ).command(
    "list",
    "List all secrets for a Worker",
    (yargs) => {
      return yargs.option("name", {
        describe: "Name of the Worker",
        type: "string",
        requiresArg: true
      });
    },
    async (args) => {
      const config = readConfig(args.config, args);
      const scriptName = getLegacyScriptName(args, config);
      if (!scriptName) {
        throw new UserError(
          "Required Worker name missing. Please specify the Worker name in wrangler.toml, or pass it as an argument with `--name <worker-name>`"
        );
      }
      const accountId = await requireAuth(config);
      const url4 = !args.env || isLegacyEnv(config) ? `/accounts/${accountId}/workers/scripts/${scriptName}/secrets` : `/accounts/${accountId}/workers/services/${scriptName}/environments/${args.env}/secrets`;
      logger.log(JSON.stringify(await fetchResult(url4), null, "  "));
      await sendMetricsEvent("list encrypted variables", {
        sendMetrics: config.send_metrics
      });
    }
  );
}, "secret");
function trimTrailingWhitespace2(str) {
  return str.trimEnd();
}
__name(trimTrailingWhitespace2, "trimTrailingWhitespace");
function readFromStdin2() {
  return new Promise((resolve19, reject) => {
    const stdin = process.stdin;
    const chunks = [];
    stdin.on("readable", () => {
      let chunk;
      while (null !== (chunk = stdin.read())) {
        chunks.push(chunk);
      }
    });
    stdin.on("end", () => {
      resolve19(chunks.join(""));
    });
    stdin.on("error", (err) => {
      reject(err);
    });
  });
}
__name(readFromStdin2, "readFromStdin");
var secretBulkOptions = /* @__PURE__ */ __name((yargs) => {
  return yargs.positional("json", {
    describe: `The JSON file of key-value pairs to upload, in form {"key": value, ...}`,
    type: "string"
  }).option("name", {
    describe: "Name of the Worker",
    type: "string",
    requiresArg: true
  });
}, "secretBulkOptions");
var secretBulkHandler = /* @__PURE__ */ __name(async (secretBulkArgs) => {
  await printWranglerBanner();
  const config = readConfig(secretBulkArgs.config, secretBulkArgs);
  const scriptName = getLegacyScriptName(secretBulkArgs, config);
  if (!scriptName) {
    const error2 = new UserError(
      "Required Worker name missing. Please specify the Worker name in wrangler.toml, or pass it as an argument with `--name <worker-name>`"
    );
    logger.error(error2.message);
    throw error2;
  }
  const accountId = await requireAuth(config);
  logger.log(
    `\u{1F300} Creating the secrets for the Worker "${scriptName}" ${secretBulkArgs.env && !isLegacyEnv(config) ? `(${secretBulkArgs.env})` : ""}`
  );
  let content;
  if (secretBulkArgs.json) {
    const jsonFilePath = import_node_path49.default.resolve(secretBulkArgs.json);
    content = parseJSON(
      readFileSync5(jsonFilePath),
      jsonFilePath
    );
  } else {
    try {
      const rl = import_node_readline3.default.createInterface({ input: process.stdin });
      let pipedInput = "";
      for await (const line of rl) {
        pipedInput += line;
      }
      content = parseJSON(pipedInput);
    } catch {
      return logger.error(`\u{1F6A8} Please provide a JSON file or valid JSON pipe`);
    }
  }
  if (!content) {
    return logger.error(`\u{1F6A8} No content found in JSON file or piped input.`);
  }
  function getSettings() {
    const url4 = !secretBulkArgs.env || isLegacyEnv(config) ? `/accounts/${accountId}/workers/scripts/${scriptName}/settings` : `/accounts/${accountId}/workers/services/${scriptName}/environments/${secretBulkArgs.env}/settings`;
    return fetchResult(url4);
  }
  __name(getSettings, "getSettings");
  function putBindingsSettings(bindings) {
    const url4 = !secretBulkArgs.env || isLegacyEnv(config) ? `/accounts/${accountId}/workers/scripts/${scriptName}/settings` : `/accounts/${accountId}/workers/services/${scriptName}/environments/${secretBulkArgs.env}/settings`;
    const data = new import_undici16.FormData();
    data.set("settings", JSON.stringify({ bindings }));
    return fetchResult(url4, {
      method: "PATCH",
      body: data
    });
  }
  __name(putBindingsSettings, "putBindingsSettings");
  let existingBindings;
  try {
    const settings = await getSettings();
    existingBindings = settings.bindings;
  } catch (e3) {
    if (isMissingWorkerError(e3)) {
      await createDraftWorker({
        config,
        args: secretBulkArgs,
        accountId,
        scriptName
      });
      existingBindings = [];
    } else {
      throw e3;
    }
  }
  const inheritBindings = existingBindings.filter((binding) => {
    return binding.type !== "secret_text" || content[binding.name] === void 0;
  }).map((binding) => ({ type: binding.type, name: binding.name }));
  const upsertBindings = Object.entries(
    content
  ).map(([key, value]) => {
    return {
      type: "secret_text",
      name: key,
      text: value
    };
  });
  try {
    await putBindingsSettings(inheritBindings.concat(upsertBindings));
    for (const upsertedBinding of upsertBindings) {
      logger.log(
        `\u2728 Successfully created secret for key: ${upsertedBinding.name}`
      );
    }
    logger.log("");
    logger.log("Finished processing secrets JSON file:");
    logger.log(`\u2728 ${upsertBindings.length} secrets successfully uploaded`);
  } catch (err) {
    logger.log("");
    logger.log("Finished processing secrets JSON file:");
    logger.log(`\u2728 0 secrets successfully uploaded`);
    throw new Error(`\u{1F6A8} ${upsertBindings.length} secrets failed to upload`);
  }
}, "secretBulkHandler");

// src/sentry/index.ts
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/index.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/index.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/tracing/hubextensions.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/index.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/aggregate-errors.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/is.js
init_import_meta_url();
var objectToString = Object.prototype.toString;
function isError(wat) {
  switch (objectToString.call(wat)) {
    case "[object Error]":
    case "[object Exception]":
    case "[object DOMException]":
      return true;
    default:
      return isInstanceOf(wat, Error);
  }
}
__name(isError, "isError");
function isBuiltin(wat, className) {
  return objectToString.call(wat) === `[object ${className}]`;
}
__name(isBuiltin, "isBuiltin");
function isString3(wat) {
  return isBuiltin(wat, "String");
}
__name(isString3, "isString");
function isPrimitive(wat) {
  return wat === null || typeof wat !== "object" && typeof wat !== "function";
}
__name(isPrimitive, "isPrimitive");
function isPlainObject(wat) {
  return isBuiltin(wat, "Object");
}
__name(isPlainObject, "isPlainObject");
function isEvent(wat) {
  return typeof Event !== "undefined" && isInstanceOf(wat, Event);
}
__name(isEvent, "isEvent");
function isElement(wat) {
  return typeof Element !== "undefined" && isInstanceOf(wat, Element);
}
__name(isElement, "isElement");
function isRegExp(wat) {
  return isBuiltin(wat, "RegExp");
}
__name(isRegExp, "isRegExp");
function isThenable(wat) {
  return Boolean(wat && wat.then && typeof wat.then === "function");
}
__name(isThenable, "isThenable");
function isSyntheticEvent(wat) {
  return isPlainObject(wat) && "nativeEvent" in wat && "preventDefault" in wat && "stopPropagation" in wat;
}
__name(isSyntheticEvent, "isSyntheticEvent");
function isNaN2(wat) {
  return typeof wat === "number" && wat !== wat;
}
__name(isNaN2, "isNaN");
function isInstanceOf(wat, base) {
  try {
    return wat instanceof base;
  } catch (_e) {
    return false;
  }
}
__name(isInstanceOf, "isInstanceOf");
function isVueViewModel(wat) {
  return !!(typeof wat === "object" && wat !== null && (wat.__isVue || wat._isVue));
}
__name(isVueViewModel, "isVueViewModel");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/string.js
init_import_meta_url();
function truncate3(str, max = 0) {
  if (typeof str !== "string" || max === 0) {
    return str;
  }
  return str.length <= max ? str : `${str.slice(0, max)}...`;
}
__name(truncate3, "truncate");
function snipLine(line, colno) {
  let newLine = line;
  const lineLength = newLine.length;
  if (lineLength <= 150) {
    return newLine;
  }
  if (colno > lineLength) {
    colno = lineLength;
  }
  let start = Math.max(colno - 60, 0);
  if (start < 5) {
    start = 0;
  }
  let end = Math.min(start + 140, lineLength);
  if (end > lineLength - 5) {
    end = lineLength;
  }
  if (end === lineLength) {
    start = Math.max(end - 140, 0);
  }
  newLine = newLine.slice(start, end);
  if (start > 0) {
    newLine = `'{snip} ${newLine}`;
  }
  if (end < lineLength) {
    newLine += " {snip}";
  }
  return newLine;
}
__name(snipLine, "snipLine");
function isMatchingPattern(value, pattern, requireExactStringMatch = false) {
  if (!isString3(value)) {
    return false;
  }
  if (isRegExp(pattern)) {
    return pattern.test(value);
  }
  if (isString3(pattern)) {
    return requireExactStringMatch ? value === pattern : value.includes(pattern);
  }
  return false;
}
__name(isMatchingPattern, "isMatchingPattern");
function stringMatchesSomePattern(testString, patterns = [], requireExactStringMatch = false) {
  return patterns.some((pattern) => isMatchingPattern(testString, pattern, requireExactStringMatch));
}
__name(stringMatchesSomePattern, "stringMatchesSomePattern");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/aggregate-errors.js
function applyAggregateErrorsToEvent(exceptionFromErrorImplementation, parser2, maxValueLimit = 250, key, limit, event, hint) {
  if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {
    return;
  }
  const originalException = event.exception.values.length > 0 ? event.exception.values[event.exception.values.length - 1] : void 0;
  if (originalException) {
    event.exception.values = truncateAggregateExceptions(
      aggregateExceptionsFromError(
        exceptionFromErrorImplementation,
        parser2,
        limit,
        hint.originalException,
        key,
        event.exception.values,
        originalException,
        0
      ),
      maxValueLimit
    );
  }
}
__name(applyAggregateErrorsToEvent, "applyAggregateErrorsToEvent");
function aggregateExceptionsFromError(exceptionFromErrorImplementation, parser2, limit, error2, key, prevExceptions, exception, exceptionId) {
  if (prevExceptions.length >= limit + 1) {
    return prevExceptions;
  }
  let newExceptions = [...prevExceptions];
  if (isInstanceOf(error2[key], Error)) {
    applyExceptionGroupFieldsForParentException(exception, exceptionId);
    const newException = exceptionFromErrorImplementation(parser2, error2[key]);
    const newExceptionId = newExceptions.length;
    applyExceptionGroupFieldsForChildException(newException, key, newExceptionId, exceptionId);
    newExceptions = aggregateExceptionsFromError(
      exceptionFromErrorImplementation,
      parser2,
      limit,
      error2[key],
      key,
      [newException, ...newExceptions],
      newException,
      newExceptionId
    );
  }
  if (Array.isArray(error2.errors)) {
    error2.errors.forEach((childError, i) => {
      if (isInstanceOf(childError, Error)) {
        applyExceptionGroupFieldsForParentException(exception, exceptionId);
        const newException = exceptionFromErrorImplementation(parser2, childError);
        const newExceptionId = newExceptions.length;
        applyExceptionGroupFieldsForChildException(newException, `errors[${i}]`, newExceptionId, exceptionId);
        newExceptions = aggregateExceptionsFromError(
          exceptionFromErrorImplementation,
          parser2,
          limit,
          childError,
          key,
          [newException, ...newExceptions],
          newException,
          newExceptionId
        );
      }
    });
  }
  return newExceptions;
}
__name(aggregateExceptionsFromError, "aggregateExceptionsFromError");
function applyExceptionGroupFieldsForParentException(exception, exceptionId) {
  exception.mechanism = exception.mechanism || { type: "generic", handled: true };
  exception.mechanism = {
    ...exception.mechanism,
    is_exception_group: true,
    exception_id: exceptionId
  };
}
__name(applyExceptionGroupFieldsForParentException, "applyExceptionGroupFieldsForParentException");
function applyExceptionGroupFieldsForChildException(exception, source, exceptionId, parentId) {
  exception.mechanism = exception.mechanism || { type: "generic", handled: true };
  exception.mechanism = {
    ...exception.mechanism,
    type: "chained",
    source,
    exception_id: exceptionId,
    parent_id: parentId
  };
}
__name(applyExceptionGroupFieldsForChildException, "applyExceptionGroupFieldsForChildException");
function truncateAggregateExceptions(exceptions, maxValueLength) {
  return exceptions.map((exception) => {
    if (exception.value) {
      exception.value = truncate3(exception.value, maxValueLength);
    }
    return exception;
  });
}
__name(truncateAggregateExceptions, "truncateAggregateExceptions");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/browser.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/worldwide.js
init_import_meta_url();
function isGlobalObj(obj) {
  return obj && obj.Math == Math ? obj : void 0;
}
__name(isGlobalObj, "isGlobalObj");
var GLOBAL_OBJ = typeof globalThis == "object" && isGlobalObj(globalThis) || // eslint-disable-next-line no-restricted-globals
typeof window == "object" && isGlobalObj(window) || typeof self == "object" && isGlobalObj(self) || typeof global == "object" && isGlobalObj(global) || function() {
  return this;
}() || {};
function getGlobalObject() {
  return GLOBAL_OBJ;
}
__name(getGlobalObject, "getGlobalObject");
function getGlobalSingleton(name, creator, obj) {
  const gbl = obj || GLOBAL_OBJ;
  const __SENTRY__ = gbl.__SENTRY__ = gbl.__SENTRY__ || {};
  const singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());
  return singleton;
}
__name(getGlobalSingleton, "getGlobalSingleton");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/browser.js
var WINDOW = getGlobalObject();
var DEFAULT_MAX_STRING_LENGTH = 80;
function htmlTreeAsString(elem, options29 = {}) {
  if (!elem) {
    return "<unknown>";
  }
  try {
    let currentElem = elem;
    const MAX_TRAVERSE_HEIGHT = 5;
    const out = [];
    let height = 0;
    let len = 0;
    const separator = " > ";
    const sepLength = separator.length;
    let nextStr;
    const keyAttrs = Array.isArray(options29) ? options29 : options29.keyAttrs;
    const maxStringLength = !Array.isArray(options29) && options29.maxStringLength || DEFAULT_MAX_STRING_LENGTH;
    while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {
      nextStr = _htmlElementAsString(currentElem, keyAttrs);
      if (nextStr === "html" || height > 1 && len + out.length * sepLength + nextStr.length >= maxStringLength) {
        break;
      }
      out.push(nextStr);
      len += nextStr.length;
      currentElem = currentElem.parentNode;
    }
    return out.reverse().join(separator);
  } catch (_oO) {
    return "<unknown>";
  }
}
__name(htmlTreeAsString, "htmlTreeAsString");
function _htmlElementAsString(el, keyAttrs) {
  const elem = el;
  const out = [];
  let className;
  let classes;
  let key;
  let attr;
  let i;
  if (!elem || !elem.tagName) {
    return "";
  }
  out.push(elem.tagName.toLowerCase());
  const keyAttrPairs = keyAttrs && keyAttrs.length ? keyAttrs.filter((keyAttr) => elem.getAttribute(keyAttr)).map((keyAttr) => [keyAttr, elem.getAttribute(keyAttr)]) : null;
  if (keyAttrPairs && keyAttrPairs.length) {
    keyAttrPairs.forEach((keyAttrPair) => {
      out.push(`[${keyAttrPair[0]}="${keyAttrPair[1]}"]`);
    });
  } else {
    if (elem.id) {
      out.push(`#${elem.id}`);
    }
    className = elem.className;
    if (className && isString3(className)) {
      classes = className.split(/\s+/);
      for (i = 0; i < classes.length; i++) {
        out.push(`.${classes[i]}`);
      }
    }
  }
  const allowedAttrs = ["aria-label", "type", "name", "title", "alt"];
  for (i = 0; i < allowedAttrs.length; i++) {
    key = allowedAttrs[i];
    attr = elem.getAttribute(key);
    if (attr) {
      out.push(`[${key}="${attr}"]`);
    }
  }
  return out.join("");
}
__name(_htmlElementAsString, "_htmlElementAsString");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/dsn.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/debug-build.js
init_import_meta_url();
var DEBUG_BUILD = typeof __SENTRY_DEBUG__ === "undefined" || __SENTRY_DEBUG__;

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/logger.js
init_import_meta_url();
var PREFIX = "Sentry Logger ";
var CONSOLE_LEVELS = [
  "debug",
  "info",
  "warn",
  "error",
  "log",
  "assert",
  "trace"
];
var originalConsoleMethods = {};
function consoleSandbox(callback) {
  if (!("console" in GLOBAL_OBJ)) {
    return callback();
  }
  const console2 = GLOBAL_OBJ.console;
  const wrappedFuncs = {};
  const wrappedLevels = Object.keys(originalConsoleMethods);
  wrappedLevels.forEach((level) => {
    const originalConsoleMethod = originalConsoleMethods[level];
    wrappedFuncs[level] = console2[level];
    console2[level] = originalConsoleMethod;
  });
  try {
    return callback();
  } finally {
    wrappedLevels.forEach((level) => {
      console2[level] = wrappedFuncs[level];
    });
  }
}
__name(consoleSandbox, "consoleSandbox");
function makeLogger() {
  let enabled = false;
  const logger3 = {
    enable: () => {
      enabled = true;
    },
    disable: () => {
      enabled = false;
    },
    isEnabled: () => enabled
  };
  if (DEBUG_BUILD) {
    CONSOLE_LEVELS.forEach((name) => {
      logger3[name] = (...args) => {
        if (enabled) {
          consoleSandbox(() => {
            GLOBAL_OBJ.console[name](`${PREFIX}[${name}]:`, ...args);
          });
        }
      };
    });
  } else {
    CONSOLE_LEVELS.forEach((name) => {
      logger3[name] = () => void 0;
    });
  }
  return logger3;
}
__name(makeLogger, "makeLogger");
var logger2 = makeLogger();

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/dsn.js
var DSN_REGEX = /^(?:(\w+):)\/\/(?:(\w+)(?::(\w+)?)?@)([\w.-]+)(?::(\d+))?\/(.+)/;
function isValidProtocol(protocol) {
  return protocol === "http" || protocol === "https";
}
__name(isValidProtocol, "isValidProtocol");
function dsnToString(dsn, withPassword = false) {
  const { host, path: path67, pass, port: port2, projectId, protocol, publicKey } = dsn;
  return `${protocol}://${publicKey}${withPassword && pass ? `:${pass}` : ""}@${host}${port2 ? `:${port2}` : ""}/${path67 ? `${path67}/` : path67}${projectId}`;
}
__name(dsnToString, "dsnToString");
function dsnFromString(str) {
  const match = DSN_REGEX.exec(str);
  if (!match) {
    consoleSandbox(() => {
      console.error(`Invalid Sentry Dsn: ${str}`);
    });
    return void 0;
  }
  const [protocol, publicKey, pass = "", host, port2 = "", lastPath] = match.slice(1);
  let path67 = "";
  let projectId = lastPath;
  const split = projectId.split("/");
  if (split.length > 1) {
    path67 = split.slice(0, -1).join("/");
    projectId = split.pop();
  }
  if (projectId) {
    const projectMatch = projectId.match(/^\d+/);
    if (projectMatch) {
      projectId = projectMatch[0];
    }
  }
  return dsnFromComponents({ host, pass, path: path67, projectId, port: port2, protocol, publicKey });
}
__name(dsnFromString, "dsnFromString");
function dsnFromComponents(components) {
  return {
    protocol: components.protocol,
    publicKey: components.publicKey || "",
    pass: components.pass || "",
    host: components.host,
    port: components.port || "",
    path: components.path || "",
    projectId: components.projectId
  };
}
__name(dsnFromComponents, "dsnFromComponents");
function validateDsn(dsn) {
  if (!DEBUG_BUILD) {
    return true;
  }
  const { port: port2, projectId, protocol } = dsn;
  const requiredComponents = ["protocol", "publicKey", "host", "projectId"];
  const hasMissingRequiredComponent = requiredComponents.find((component) => {
    if (!dsn[component]) {
      logger2.error(`Invalid Sentry Dsn: ${component} missing`);
      return true;
    }
    return false;
  });
  if (hasMissingRequiredComponent) {
    return false;
  }
  if (!projectId.match(/^\d+$/)) {
    logger2.error(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);
    return false;
  }
  if (!isValidProtocol(protocol)) {
    logger2.error(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);
    return false;
  }
  if (port2 && isNaN(parseInt(port2, 10))) {
    logger2.error(`Invalid Sentry Dsn: Invalid port ${port2}`);
    return false;
  }
  return true;
}
__name(validateDsn, "validateDsn");
function makeDsn(from) {
  const components = typeof from === "string" ? dsnFromString(from) : dsnFromComponents(from);
  if (!components || !validateDsn(components)) {
    return void 0;
  }
  return components;
}
__name(makeDsn, "makeDsn");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/error.js
init_import_meta_url();
var SentryError = class extends Error {
  /** Display name of this error instance. */
  constructor(message, logLevel = "warn") {
    super(message);
    this.message = message;
    this.name = new.target.prototype.constructor.name;
    Object.setPrototypeOf(this, new.target.prototype);
    this.logLevel = logLevel;
  }
};
__name(SentryError, "SentryError");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/instrument/console.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/object.js
init_import_meta_url();
function fill(source, name, replacementFactory) {
  if (!(name in source)) {
    return;
  }
  const original = source[name];
  const wrapped = replacementFactory(original);
  if (typeof wrapped === "function") {
    markFunctionWrapped(wrapped, original);
  }
  source[name] = wrapped;
}
__name(fill, "fill");
function addNonEnumerableProperty(obj, name, value) {
  try {
    Object.defineProperty(obj, name, {
      // enumerable: false, // the default, so we can save on bundle size by not explicitly setting it
      value,
      writable: true,
      configurable: true
    });
  } catch (o_O) {
    DEBUG_BUILD && logger2.log(`Failed to add non-enumerable property "${name}" to object`, obj);
  }
}
__name(addNonEnumerableProperty, "addNonEnumerableProperty");
function markFunctionWrapped(wrapped, original) {
  try {
    const proto = original.prototype || {};
    wrapped.prototype = original.prototype = proto;
    addNonEnumerableProperty(wrapped, "__sentry_original__", original);
  } catch (o_O) {
  }
}
__name(markFunctionWrapped, "markFunctionWrapped");
function getOriginalFunction(func) {
  return func.__sentry_original__;
}
__name(getOriginalFunction, "getOriginalFunction");
function urlEncode(object) {
  return Object.keys(object).map((key) => `${encodeURIComponent(key)}=${encodeURIComponent(object[key])}`).join("&");
}
__name(urlEncode, "urlEncode");
function convertToPlainObject(value) {
  if (isError(value)) {
    return {
      message: value.message,
      name: value.name,
      stack: value.stack,
      ...getOwnProperties(value)
    };
  } else if (isEvent(value)) {
    const newObj = {
      type: value.type,
      target: serializeEventTarget(value.target),
      currentTarget: serializeEventTarget(value.currentTarget),
      ...getOwnProperties(value)
    };
    if (typeof CustomEvent !== "undefined" && isInstanceOf(value, CustomEvent)) {
      newObj.detail = value.detail;
    }
    return newObj;
  } else {
    return value;
  }
}
__name(convertToPlainObject, "convertToPlainObject");
function serializeEventTarget(target) {
  try {
    return isElement(target) ? htmlTreeAsString(target) : Object.prototype.toString.call(target);
  } catch (_oO) {
    return "<unknown>";
  }
}
__name(serializeEventTarget, "serializeEventTarget");
function getOwnProperties(obj) {
  if (typeof obj === "object" && obj !== null) {
    const extractedProps = {};
    for (const property in obj) {
      if (Object.prototype.hasOwnProperty.call(obj, property)) {
        extractedProps[property] = obj[property];
      }
    }
    return extractedProps;
  } else {
    return {};
  }
}
__name(getOwnProperties, "getOwnProperties");
function extractExceptionKeysForMessage(exception, maxLength = 40) {
  const keys = Object.keys(convertToPlainObject(exception));
  keys.sort();
  if (!keys.length) {
    return "[object has no keys]";
  }
  if (keys[0].length >= maxLength) {
    return truncate3(keys[0], maxLength);
  }
  for (let includedKeys = keys.length; includedKeys > 0; includedKeys--) {
    const serialized = keys.slice(0, includedKeys).join(", ");
    if (serialized.length > maxLength) {
      continue;
    }
    if (includedKeys === keys.length) {
      return serialized;
    }
    return truncate3(serialized, maxLength);
  }
  return "";
}
__name(extractExceptionKeysForMessage, "extractExceptionKeysForMessage");
function dropUndefinedKeys(inputValue) {
  const memoizationMap = /* @__PURE__ */ new Map();
  return _dropUndefinedKeys(inputValue, memoizationMap);
}
__name(dropUndefinedKeys, "dropUndefinedKeys");
function _dropUndefinedKeys(inputValue, memoizationMap) {
  if (isPlainObject(inputValue)) {
    const memoVal = memoizationMap.get(inputValue);
    if (memoVal !== void 0) {
      return memoVal;
    }
    const returnValue = {};
    memoizationMap.set(inputValue, returnValue);
    for (const key of Object.keys(inputValue)) {
      if (typeof inputValue[key] !== "undefined") {
        returnValue[key] = _dropUndefinedKeys(inputValue[key], memoizationMap);
      }
    }
    return returnValue;
  }
  if (Array.isArray(inputValue)) {
    const memoVal = memoizationMap.get(inputValue);
    if (memoVal !== void 0) {
      return memoVal;
    }
    const returnValue = [];
    memoizationMap.set(inputValue, returnValue);
    inputValue.forEach((item) => {
      returnValue.push(_dropUndefinedKeys(item, memoizationMap));
    });
    return returnValue;
  }
  return inputValue;
}
__name(_dropUndefinedKeys, "_dropUndefinedKeys");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/instrument/_handlers.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/stacktrace.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/node-stack-trace.js
init_import_meta_url();
function filenameIsInApp(filename, isNative = false) {
  const isInternal = isNative || filename && // It's not internal if it's an absolute linux path
  !filename.startsWith("/") && // It's not internal if it's an absolute windows path
  !filename.includes(":\\") && // It's not internal if the path is starting with a dot
  !filename.startsWith(".") && // It's not internal if the frame has a protocol. In node, this is usually the case if the file got pre-processed with a bundler like webpack
  !filename.match(/^[a-zA-Z]([a-zA-Z0-9.\-+])*:\/\//);
  return !isInternal && filename !== void 0 && !filename.includes("node_modules/");
}
__name(filenameIsInApp, "filenameIsInApp");
function node(getModule) {
  const FILENAME_MATCH = /^\s*[-]{4,}$/;
  const FULL_MATCH = /at (?:async )?(?:(.+?)\s+\()?(?:(.+):(\d+):(\d+)?|([^)]+))\)?/;
  return (line) => {
    const lineMatch = line.match(FULL_MATCH);
    if (lineMatch) {
      let object;
      let method;
      let functionName;
      let typeName;
      let methodName;
      if (lineMatch[1]) {
        functionName = lineMatch[1];
        let methodStart = functionName.lastIndexOf(".");
        if (functionName[methodStart - 1] === ".") {
          methodStart--;
        }
        if (methodStart > 0) {
          object = functionName.slice(0, methodStart);
          method = functionName.slice(methodStart + 1);
          const objectEnd = object.indexOf(".Module");
          if (objectEnd > 0) {
            functionName = functionName.slice(objectEnd + 1);
            object = object.slice(0, objectEnd);
          }
        }
        typeName = void 0;
      }
      if (method) {
        typeName = object;
        methodName = method;
      }
      if (method === "<anonymous>") {
        methodName = void 0;
        functionName = void 0;
      }
      if (functionName === void 0) {
        methodName = methodName || "<anonymous>";
        functionName = typeName ? `${typeName}.${methodName}` : methodName;
      }
      let filename = lineMatch[2] && lineMatch[2].startsWith("file://") ? lineMatch[2].slice(7) : lineMatch[2];
      const isNative = lineMatch[5] === "native";
      if (!filename && lineMatch[5] && !isNative) {
        filename = lineMatch[5];
      }
      return {
        filename,
        module: getModule ? getModule(filename) : void 0,
        function: functionName,
        lineno: parseInt(lineMatch[3], 10) || void 0,
        colno: parseInt(lineMatch[4], 10) || void 0,
        in_app: filenameIsInApp(filename, isNative)
      };
    }
    if (line.match(FILENAME_MATCH)) {
      return {
        filename: line
      };
    }
    return void 0;
  };
}
__name(node, "node");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/stacktrace.js
var STACKTRACE_FRAME_LIMIT = 50;
var WEBPACK_ERROR_REGEXP = /\(error: (.*)\)/;
var STRIP_FRAME_REGEXP = /captureMessage|captureException/;
function createStackParser(...parsers) {
  const sortedParsers = parsers.sort((a, b2) => a[0] - b2[0]).map((p2) => p2[1]);
  return (stack, skipFirst = 0) => {
    const frames = [];
    const lines = stack.split("\n");
    for (let i = skipFirst; i < lines.length; i++) {
      const line = lines[i];
      if (line.length > 1024) {
        continue;
      }
      const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, "$1") : line;
      if (cleanedLine.match(/\S*Error: /)) {
        continue;
      }
      for (const parser2 of sortedParsers) {
        const frame = parser2(cleanedLine);
        if (frame) {
          frames.push(frame);
          break;
        }
      }
      if (frames.length >= STACKTRACE_FRAME_LIMIT) {
        break;
      }
    }
    return stripSentryFramesAndReverse(frames);
  };
}
__name(createStackParser, "createStackParser");
function stackParserFromStackParserOptions(stackParser) {
  if (Array.isArray(stackParser)) {
    return createStackParser(...stackParser);
  }
  return stackParser;
}
__name(stackParserFromStackParserOptions, "stackParserFromStackParserOptions");
function stripSentryFramesAndReverse(stack) {
  if (!stack.length) {
    return [];
  }
  const localStack = Array.from(stack);
  if (/sentryWrapped/.test(localStack[localStack.length - 1].function || "")) {
    localStack.pop();
  }
  localStack.reverse();
  if (STRIP_FRAME_REGEXP.test(localStack[localStack.length - 1].function || "")) {
    localStack.pop();
    if (STRIP_FRAME_REGEXP.test(localStack[localStack.length - 1].function || "")) {
      localStack.pop();
    }
  }
  return localStack.slice(0, STACKTRACE_FRAME_LIMIT).map((frame) => ({
    ...frame,
    filename: frame.filename || localStack[localStack.length - 1].filename,
    function: frame.function || "?"
  }));
}
__name(stripSentryFramesAndReverse, "stripSentryFramesAndReverse");
var defaultFunctionName = "<anonymous>";
function getFunctionName(fn2) {
  try {
    if (!fn2 || typeof fn2 !== "function") {
      return defaultFunctionName;
    }
    return fn2.name || defaultFunctionName;
  } catch (e3) {
    return defaultFunctionName;
  }
}
__name(getFunctionName, "getFunctionName");
function nodeStackLineParser(getModule) {
  return [90, node(getModule)];
}
__name(nodeStackLineParser, "nodeStackLineParser");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/instrument/_handlers.js
var handlers = {};
var instrumented = {};
function addHandler(type, handler30) {
  handlers[type] = handlers[type] || [];
  handlers[type].push(handler30);
}
__name(addHandler, "addHandler");
function maybeInstrument(type, instrumentFn) {
  if (!instrumented[type]) {
    instrumentFn();
    instrumented[type] = true;
  }
}
__name(maybeInstrument, "maybeInstrument");
function triggerHandlers(type, data) {
  const typeHandlers = type && handlers[type];
  if (!typeHandlers) {
    return;
  }
  for (const handler30 of typeHandlers) {
    try {
      handler30(data);
    } catch (e3) {
      DEBUG_BUILD && logger2.error(
        `Error while triggering instrumentation handler.
Type: ${type}
Name: ${getFunctionName(handler30)}
Error:`,
        e3
      );
    }
  }
}
__name(triggerHandlers, "triggerHandlers");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/instrument/console.js
function addConsoleInstrumentationHandler(handler30) {
  const type = "console";
  addHandler(type, handler30);
  maybeInstrument(type, instrumentConsole);
}
__name(addConsoleInstrumentationHandler, "addConsoleInstrumentationHandler");
function instrumentConsole() {
  if (!("console" in GLOBAL_OBJ)) {
    return;
  }
  CONSOLE_LEVELS.forEach(function(level) {
    if (!(level in GLOBAL_OBJ.console)) {
      return;
    }
    fill(GLOBAL_OBJ.console, level, function(originalConsoleMethod) {
      originalConsoleMethods[level] = originalConsoleMethod;
      return function(...args) {
        const handlerData = { args, level };
        triggerHandlers("console", handlerData);
        const log2 = originalConsoleMethods[level];
        log2 && log2.apply(GLOBAL_OBJ.console, args);
      };
    });
  });
}
__name(instrumentConsole, "instrumentConsole");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/misc.js
init_import_meta_url();
function uuid4() {
  const gbl = GLOBAL_OBJ;
  const crypto5 = gbl.crypto || gbl.msCrypto;
  let getRandomByte = /* @__PURE__ */ __name(() => Math.random() * 16, "getRandomByte");
  try {
    if (crypto5 && crypto5.randomUUID) {
      return crypto5.randomUUID().replace(/-/g, "");
    }
    if (crypto5 && crypto5.getRandomValues) {
      getRandomByte = /* @__PURE__ */ __name(() => crypto5.getRandomValues(new Uint8Array(1))[0], "getRandomByte");
    }
  } catch (_3) {
  }
  return ([1e7] + 1e3 + 4e3 + 8e3 + 1e11).replace(
    /[018]/g,
    (c2) => (
      // eslint-disable-next-line no-bitwise
      (c2 ^ (getRandomByte() & 15) >> c2 / 4).toString(16)
    )
  );
}
__name(uuid4, "uuid4");
function getFirstException(event) {
  return event.exception && event.exception.values ? event.exception.values[0] : void 0;
}
__name(getFirstException, "getFirstException");
function getEventDescription(event) {
  const { message, event_id: eventId } = event;
  if (message) {
    return message;
  }
  const firstException = getFirstException(event);
  if (firstException) {
    if (firstException.type && firstException.value) {
      return `${firstException.type}: ${firstException.value}`;
    }
    return firstException.type || firstException.value || eventId || "<unknown>";
  }
  return eventId || "<unknown>";
}
__name(getEventDescription, "getEventDescription");
function addExceptionTypeValue(event, value, type) {
  const exception = event.exception = event.exception || {};
  const values = exception.values = exception.values || [];
  const firstException = values[0] = values[0] || {};
  if (!firstException.value) {
    firstException.value = value || "";
  }
  if (!firstException.type) {
    firstException.type = type || "Error";
  }
}
__name(addExceptionTypeValue, "addExceptionTypeValue");
function addExceptionMechanism(event, newMechanism) {
  const firstException = getFirstException(event);
  if (!firstException) {
    return;
  }
  const defaultMechanism = { type: "generic", handled: true };
  const currentMechanism = firstException.mechanism;
  firstException.mechanism = { ...defaultMechanism, ...currentMechanism, ...newMechanism };
  if (newMechanism && "data" in newMechanism) {
    const mergedData = { ...currentMechanism && currentMechanism.data, ...newMechanism.data };
    firstException.mechanism.data = mergedData;
  }
}
__name(addExceptionMechanism, "addExceptionMechanism");
var SEMVER_REGEXP = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
function parseSemver(input) {
  const match = input.match(SEMVER_REGEXP) || [];
  const major = parseInt(match[1], 10);
  const minor = parseInt(match[2], 10);
  const patch = parseInt(match[3], 10);
  return {
    buildmetadata: match[5],
    major: isNaN(major) ? void 0 : major,
    minor: isNaN(minor) ? void 0 : minor,
    patch: isNaN(patch) ? void 0 : patch,
    prerelease: match[4]
  };
}
__name(parseSemver, "parseSemver");
function addContextToFrame(lines, frame, linesOfContext = 5) {
  if (frame.lineno === void 0) {
    return;
  }
  const maxLines = lines.length;
  const sourceLine = Math.max(Math.min(maxLines - 1, frame.lineno - 1), 0);
  frame.pre_context = lines.slice(Math.max(0, sourceLine - linesOfContext), sourceLine).map((line) => snipLine(line, 0));
  frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);
  frame.post_context = lines.slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext).map((line) => snipLine(line, 0));
}
__name(addContextToFrame, "addContextToFrame");
function checkOrSetAlreadyCaught(exception) {
  if (exception && exception.__sentry_captured__) {
    return true;
  }
  try {
    addNonEnumerableProperty(exception, "__sentry_captured__", true);
  } catch (err) {
  }
  return false;
}
__name(checkOrSetAlreadyCaught, "checkOrSetAlreadyCaught");
function arrayify(maybeArray) {
  return Array.isArray(maybeArray) ? maybeArray : [maybeArray];
}
__name(arrayify, "arrayify");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/instrument/globalError.js
init_import_meta_url();
var _oldOnErrorHandler = null;
function addGlobalErrorInstrumentationHandler(handler30) {
  const type = "error";
  addHandler(type, handler30);
  maybeInstrument(type, instrumentError);
}
__name(addGlobalErrorInstrumentationHandler, "addGlobalErrorInstrumentationHandler");
function instrumentError() {
  _oldOnErrorHandler = GLOBAL_OBJ.onerror;
  GLOBAL_OBJ.onerror = function(msg, url4, line, column, error2) {
    const handlerData = {
      column,
      error: error2,
      line,
      msg,
      url: url4
    };
    triggerHandlers("error", handlerData);
    if (_oldOnErrorHandler && !_oldOnErrorHandler.__SENTRY_LOADER__) {
      return _oldOnErrorHandler.apply(this, arguments);
    }
    return false;
  };
  GLOBAL_OBJ.onerror.__SENTRY_INSTRUMENTED__ = true;
}
__name(instrumentError, "instrumentError");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/instrument/globalUnhandledRejection.js
init_import_meta_url();
var _oldOnUnhandledRejectionHandler = null;
function addGlobalUnhandledRejectionInstrumentationHandler(handler30) {
  const type = "unhandledrejection";
  addHandler(type, handler30);
  maybeInstrument(type, instrumentUnhandledRejection);
}
__name(addGlobalUnhandledRejectionInstrumentationHandler, "addGlobalUnhandledRejectionInstrumentationHandler");
function instrumentUnhandledRejection() {
  _oldOnUnhandledRejectionHandler = GLOBAL_OBJ.onunhandledrejection;
  GLOBAL_OBJ.onunhandledrejection = function(e3) {
    const handlerData = e3;
    triggerHandlers("unhandledrejection", handlerData);
    if (_oldOnUnhandledRejectionHandler && !_oldOnUnhandledRejectionHandler.__SENTRY_LOADER__) {
      return _oldOnUnhandledRejectionHandler.apply(this, arguments);
    }
    return true;
  };
  GLOBAL_OBJ.onunhandledrejection.__SENTRY_INSTRUMENTED__ = true;
}
__name(instrumentUnhandledRejection, "instrumentUnhandledRejection");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/node.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/env.js
init_import_meta_url();
function isBrowserBundle() {
  return typeof __SENTRY_BROWSER_BUNDLE__ !== "undefined" && !!__SENTRY_BROWSER_BUNDLE__;
}
__name(isBrowserBundle, "isBrowserBundle");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/node.js
function isNodeEnv() {
  return !isBrowserBundle() && Object.prototype.toString.call(typeof process !== "undefined" ? process : 0) === "[object process]";
}
__name(isNodeEnv, "isNodeEnv");
function dynamicRequire(mod, request3) {
  return mod.require(request3);
}
__name(dynamicRequire, "dynamicRequire");
function loadModule(moduleName) {
  let mod;
  try {
    mod = dynamicRequire(module, moduleName);
  } catch (e3) {
  }
  try {
    const { cwd: cwd2 } = dynamicRequire(module, "process");
    mod = dynamicRequire(module, `${cwd2()}/node_modules/${moduleName}`);
  } catch (e3) {
  }
  return mod;
}
__name(loadModule, "loadModule");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/memo.js
init_import_meta_url();
function memoBuilder() {
  const hasWeakSet = typeof WeakSet === "function";
  const inner = hasWeakSet ? /* @__PURE__ */ new WeakSet() : [];
  function memoize(obj) {
    if (hasWeakSet) {
      if (inner.has(obj)) {
        return true;
      }
      inner.add(obj);
      return false;
    }
    for (let i = 0; i < inner.length; i++) {
      const value = inner[i];
      if (value === obj) {
        return true;
      }
    }
    inner.push(obj);
    return false;
  }
  __name(memoize, "memoize");
  function unmemoize(obj) {
    if (hasWeakSet) {
      inner.delete(obj);
    } else {
      for (let i = 0; i < inner.length; i++) {
        if (inner[i] === obj) {
          inner.splice(i, 1);
          break;
        }
      }
    }
  }
  __name(unmemoize, "unmemoize");
  return [memoize, unmemoize];
}
__name(memoBuilder, "memoBuilder");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/normalize.js
init_import_meta_url();
function normalize2(input, depth = 100, maxProperties = Infinity) {
  try {
    return visit2("", input, depth, maxProperties);
  } catch (err) {
    return { ERROR: `**non-serializable** (${err})` };
  }
}
__name(normalize2, "normalize");
function normalizeToSize(object, depth = 3, maxSize = 100 * 1024) {
  const normalized = normalize2(object, depth);
  if (jsonSize(normalized) > maxSize) {
    return normalizeToSize(object, depth - 1, maxSize);
  }
  return normalized;
}
__name(normalizeToSize, "normalizeToSize");
function visit2(key, value, depth = Infinity, maxProperties = Infinity, memo = memoBuilder()) {
  const [memoize, unmemoize] = memo;
  if (value == null || // this matches null and undefined -> eqeq not eqeqeq
  ["number", "boolean", "string"].includes(typeof value) && !isNaN2(value)) {
    return value;
  }
  const stringified = stringifyValue(key, value);
  if (!stringified.startsWith("[object ")) {
    return stringified;
  }
  if (value["__sentry_skip_normalization__"]) {
    return value;
  }
  const remainingDepth = typeof value["__sentry_override_normalization_depth__"] === "number" ? value["__sentry_override_normalization_depth__"] : depth;
  if (remainingDepth === 0) {
    return stringified.replace("object ", "");
  }
  if (memoize(value)) {
    return "[Circular ~]";
  }
  const valueWithToJSON = value;
  if (valueWithToJSON && typeof valueWithToJSON.toJSON === "function") {
    try {
      const jsonValue = valueWithToJSON.toJSON();
      return visit2("", jsonValue, remainingDepth - 1, maxProperties, memo);
    } catch (err) {
    }
  }
  const normalized = Array.isArray(value) ? [] : {};
  let numAdded = 0;
  const visitable = convertToPlainObject(value);
  for (const visitKey in visitable) {
    if (!Object.prototype.hasOwnProperty.call(visitable, visitKey)) {
      continue;
    }
    if (numAdded >= maxProperties) {
      normalized[visitKey] = "[MaxProperties ~]";
      break;
    }
    const visitValue = visitable[visitKey];
    normalized[visitKey] = visit2(visitKey, visitValue, remainingDepth - 1, maxProperties, memo);
    numAdded++;
  }
  unmemoize(value);
  return normalized;
}
__name(visit2, "visit");
function stringifyValue(key, value) {
  try {
    if (key === "domain" && value && typeof value === "object" && value._events) {
      return "[Domain]";
    }
    if (key === "domainEmitter") {
      return "[DomainEmitter]";
    }
    if (typeof global !== "undefined" && value === global) {
      return "[Global]";
    }
    if (typeof window !== "undefined" && value === window) {
      return "[Window]";
    }
    if (typeof document !== "undefined" && value === document) {
      return "[Document]";
    }
    if (isVueViewModel(value)) {
      return "[VueViewModel]";
    }
    if (isSyntheticEvent(value)) {
      return "[SyntheticEvent]";
    }
    if (typeof value === "number" && value !== value) {
      return "[NaN]";
    }
    if (typeof value === "function") {
      return `[Function: ${getFunctionName(value)}]`;
    }
    if (typeof value === "symbol") {
      return `[${String(value)}]`;
    }
    if (typeof value === "bigint") {
      return `[BigInt: ${String(value)}]`;
    }
    const objName = getConstructorName(value);
    if (/^HTML(\w*)Element$/.test(objName)) {
      return `[HTMLElement: ${objName}]`;
    }
    return `[object ${objName}]`;
  } catch (err) {
    return `**non-serializable** (${err})`;
  }
}
__name(stringifyValue, "stringifyValue");
function getConstructorName(value) {
  const prototype = Object.getPrototypeOf(value);
  return prototype ? prototype.constructor.name : "null prototype";
}
__name(getConstructorName, "getConstructorName");
function utf8Length(value) {
  return ~-encodeURI(value).split(/%..|./).length;
}
__name(utf8Length, "utf8Length");
function jsonSize(value) {
  return utf8Length(JSON.stringify(value));
}
__name(jsonSize, "jsonSize");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/promisebuffer.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/syncpromise.js
init_import_meta_url();
var States;
(function(States2) {
  const PENDING = 0;
  States2[States2["PENDING"] = PENDING] = "PENDING";
  const RESOLVED = 1;
  States2[States2["RESOLVED"] = RESOLVED] = "RESOLVED";
  const REJECTED = 2;
  States2[States2["REJECTED"] = REJECTED] = "REJECTED";
})(States || (States = {}));
function resolvedSyncPromise(value) {
  return new SyncPromise((resolve19) => {
    resolve19(value);
  });
}
__name(resolvedSyncPromise, "resolvedSyncPromise");
function rejectedSyncPromise(reason) {
  return new SyncPromise((_3, reject) => {
    reject(reason);
  });
}
__name(rejectedSyncPromise, "rejectedSyncPromise");
var SyncPromise = class {
  constructor(executor) {
    SyncPromise.prototype.__init.call(this);
    SyncPromise.prototype.__init2.call(this);
    SyncPromise.prototype.__init3.call(this);
    SyncPromise.prototype.__init4.call(this);
    this._state = States.PENDING;
    this._handlers = [];
    try {
      executor(this._resolve, this._reject);
    } catch (e3) {
      this._reject(e3);
    }
  }
  /** JSDoc */
  then(onfulfilled, onrejected) {
    return new SyncPromise((resolve19, reject) => {
      this._handlers.push([
        false,
        (result) => {
          if (!onfulfilled) {
            resolve19(result);
          } else {
            try {
              resolve19(onfulfilled(result));
            } catch (e3) {
              reject(e3);
            }
          }
        },
        (reason) => {
          if (!onrejected) {
            reject(reason);
          } else {
            try {
              resolve19(onrejected(reason));
            } catch (e3) {
              reject(e3);
            }
          }
        }
      ]);
      this._executeHandlers();
    });
  }
  /** JSDoc */
  catch(onrejected) {
    return this.then((val) => val, onrejected);
  }
  /** JSDoc */
  finally(onfinally) {
    return new SyncPromise((resolve19, reject) => {
      let val;
      let isRejected;
      return this.then(
        (value) => {
          isRejected = false;
          val = value;
          if (onfinally) {
            onfinally();
          }
        },
        (reason) => {
          isRejected = true;
          val = reason;
          if (onfinally) {
            onfinally();
          }
        }
      ).then(() => {
        if (isRejected) {
          reject(val);
          return;
        }
        resolve19(val);
      });
    });
  }
  /** JSDoc */
  __init() {
    this._resolve = (value) => {
      this._setResult(States.RESOLVED, value);
    };
  }
  /** JSDoc */
  __init2() {
    this._reject = (reason) => {
      this._setResult(States.REJECTED, reason);
    };
  }
  /** JSDoc */
  __init3() {
    this._setResult = (state, value) => {
      if (this._state !== States.PENDING) {
        return;
      }
      if (isThenable(value)) {
        void value.then(this._resolve, this._reject);
        return;
      }
      this._state = state;
      this._value = value;
      this._executeHandlers();
    };
  }
  /** JSDoc */
  __init4() {
    this._executeHandlers = () => {
      if (this._state === States.PENDING) {
        return;
      }
      const cachedHandlers = this._handlers.slice();
      this._handlers = [];
      cachedHandlers.forEach((handler30) => {
        if (handler30[0]) {
          return;
        }
        if (this._state === States.RESOLVED) {
          handler30[1](this._value);
        }
        if (this._state === States.REJECTED) {
          handler30[2](this._value);
        }
        handler30[0] = true;
      });
    };
  }
};
__name(SyncPromise, "SyncPromise");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/promisebuffer.js
function makePromiseBuffer(limit) {
  const buffer = [];
  function isReady() {
    return limit === void 0 || buffer.length < limit;
  }
  __name(isReady, "isReady");
  function remove(task) {
    return buffer.splice(buffer.indexOf(task), 1)[0];
  }
  __name(remove, "remove");
  function add(taskProducer) {
    if (!isReady()) {
      return rejectedSyncPromise(new SentryError("Not adding Promise because buffer limit was reached."));
    }
    const task = taskProducer();
    if (buffer.indexOf(task) === -1) {
      buffer.push(task);
    }
    void task.then(() => remove(task)).then(
      null,
      () => remove(task).then(null, () => {
      })
    );
    return task;
  }
  __name(add, "add");
  function drain(timeout) {
    return new SyncPromise((resolve19, reject) => {
      let counter = buffer.length;
      if (!counter) {
        return resolve19(true);
      }
      const capturedSetTimeout = setTimeout(() => {
        if (timeout && timeout > 0) {
          resolve19(false);
        }
      }, timeout);
      buffer.forEach((item) => {
        void resolvedSyncPromise(item).then(() => {
          if (!--counter) {
            clearTimeout(capturedSetTimeout);
            resolve19(true);
          }
        }, reject);
      });
    });
  }
  __name(drain, "drain");
  return {
    $: buffer,
    add,
    drain
  };
}
__name(makePromiseBuffer, "makePromiseBuffer");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/requestdata.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/cookie.js
init_import_meta_url();
function parseCookie(str) {
  const obj = {};
  let index = 0;
  while (index < str.length) {
    const eqIdx = str.indexOf("=", index);
    if (eqIdx === -1) {
      break;
    }
    let endIdx = str.indexOf(";", index);
    if (endIdx === -1) {
      endIdx = str.length;
    } else if (endIdx < eqIdx) {
      index = str.lastIndexOf(";", eqIdx - 1) + 1;
      continue;
    }
    const key = str.slice(index, eqIdx).trim();
    if (void 0 === obj[key]) {
      let val = str.slice(eqIdx + 1, endIdx).trim();
      if (val.charCodeAt(0) === 34) {
        val = val.slice(1, -1);
      }
      try {
        obj[key] = val.indexOf("%") !== -1 ? decodeURIComponent(val) : val;
      } catch (e3) {
        obj[key] = val;
      }
    }
    index = endIdx + 1;
  }
  return obj;
}
__name(parseCookie, "parseCookie");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/url.js
init_import_meta_url();
function parseUrl(url4) {
  if (!url4) {
    return {};
  }
  const match = url4.match(/^(([^:/?#]+):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/);
  if (!match) {
    return {};
  }
  const query = match[6] || "";
  const fragment = match[8] || "";
  return {
    host: match[4],
    path: match[5],
    protocol: match[2],
    search: query,
    hash: fragment,
    relative: match[5] + query + fragment
    // everything minus origin
  };
}
__name(parseUrl, "parseUrl");
function stripUrlQueryAndFragment(urlPath) {
  return urlPath.split(/[\?#]/, 1)[0];
}
__name(stripUrlQueryAndFragment, "stripUrlQueryAndFragment");
function getNumberOfUrlSegments(url4) {
  return url4.split(/\\?\//).filter((s) => s.length > 0 && s !== ",").length;
}
__name(getNumberOfUrlSegments, "getNumberOfUrlSegments");
function getSanitizedUrlString(url4) {
  const { protocol, host, path: path67 } = url4;
  const filteredHost = host && host.replace(/^.*@/, "[filtered]:[filtered]@").replace(/(:80)$/, "").replace(/(:443)$/, "") || "";
  return `${protocol ? `${protocol}://` : ""}${filteredHost}${path67}`;
}
__name(getSanitizedUrlString, "getSanitizedUrlString");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/requestdata.js
var DEFAULT_INCLUDES = {
  ip: false,
  request: true,
  transaction: true,
  user: true
};
var DEFAULT_REQUEST_INCLUDES = ["cookies", "data", "headers", "method", "query_string", "url"];
var DEFAULT_USER_INCLUDES = ["id", "username", "email"];
function extractPathForTransaction(req, options29 = {}) {
  const method = req.method && req.method.toUpperCase();
  let path67 = "";
  let source = "url";
  if (options29.customRoute || req.route) {
    path67 = options29.customRoute || `${req.baseUrl || ""}${req.route && req.route.path}`;
    source = "route";
  } else if (req.originalUrl || req.url) {
    path67 = stripUrlQueryAndFragment(req.originalUrl || req.url || "");
  }
  let name = "";
  if (options29.method && method) {
    name += method;
  }
  if (options29.method && options29.path) {
    name += " ";
  }
  if (options29.path && path67) {
    name += path67;
  }
  return [name, source];
}
__name(extractPathForTransaction, "extractPathForTransaction");
function extractTransaction(req, type) {
  switch (type) {
    case "path": {
      return extractPathForTransaction(req, { path: true })[0];
    }
    case "handler": {
      return req.route && req.route.stack && req.route.stack[0] && req.route.stack[0].name || "<anonymous>";
    }
    case "methodPath":
    default: {
      const customRoute = req._reconstructedRoute ? req._reconstructedRoute : void 0;
      return extractPathForTransaction(req, { path: true, method: true, customRoute })[0];
    }
  }
}
__name(extractTransaction, "extractTransaction");
function extractUserData(user, keys) {
  const extractedUser = {};
  const attributes = Array.isArray(keys) ? keys : DEFAULT_USER_INCLUDES;
  attributes.forEach((key) => {
    if (user && key in user) {
      extractedUser[key] = user[key];
    }
  });
  return extractedUser;
}
__name(extractUserData, "extractUserData");
function extractRequestData(req, options29) {
  const { include = DEFAULT_REQUEST_INCLUDES, deps } = options29 || {};
  const requestData = {};
  const headers = req.headers || {};
  const method = req.method;
  const host = req.hostname || req.host || headers.host || "<no host>";
  const protocol = req.protocol === "https" || req.socket && req.socket.encrypted ? "https" : "http";
  const originalUrl = req.originalUrl || req.url || "";
  const absoluteUrl = originalUrl.startsWith(protocol) ? originalUrl : `${protocol}://${host}${originalUrl}`;
  include.forEach((key) => {
    switch (key) {
      case "headers": {
        requestData.headers = headers;
        if (!include.includes("cookies")) {
          delete requestData.headers.cookie;
        }
        break;
      }
      case "method": {
        requestData.method = method;
        break;
      }
      case "url": {
        requestData.url = absoluteUrl;
        break;
      }
      case "cookies": {
        requestData.cookies = // TODO (v8 / #5257): We're only sending the empty object for backwards compatibility, so the last bit can
        // come off in v8
        req.cookies || headers.cookie && parseCookie(headers.cookie) || {};
        break;
      }
      case "query_string": {
        requestData.query_string = extractQueryParams(req, deps);
        break;
      }
      case "data": {
        if (method === "GET" || method === "HEAD") {
          break;
        }
        if (req.body !== void 0) {
          requestData.data = isString3(req.body) ? req.body : JSON.stringify(normalize2(req.body));
        }
        break;
      }
      default: {
        if ({}.hasOwnProperty.call(req, key)) {
          requestData[key] = req[key];
        }
      }
    }
  });
  return requestData;
}
__name(extractRequestData, "extractRequestData");
function addRequestDataToEvent(event, req, options29) {
  const include = {
    ...DEFAULT_INCLUDES,
    ...options29 && options29.include
  };
  if (include.request) {
    const extractedRequestData = Array.isArray(include.request) ? extractRequestData(req, { include: include.request, deps: options29 && options29.deps }) : extractRequestData(req, { deps: options29 && options29.deps });
    event.request = {
      ...event.request,
      ...extractedRequestData
    };
  }
  if (include.user) {
    const extractedUser = req.user && isPlainObject(req.user) ? extractUserData(req.user, include.user) : {};
    if (Object.keys(extractedUser).length) {
      event.user = {
        ...event.user,
        ...extractedUser
      };
    }
  }
  if (include.ip) {
    const ip2 = req.ip || req.socket && req.socket.remoteAddress;
    if (ip2) {
      event.user = {
        ...event.user,
        ip_address: ip2
      };
    }
  }
  if (include.transaction && !event.transaction) {
    event.transaction = extractTransaction(req, include.transaction);
  }
  return event;
}
__name(addRequestDataToEvent, "addRequestDataToEvent");
function extractQueryParams(req, deps) {
  let originalUrl = req.originalUrl || req.url || "";
  if (!originalUrl) {
    return;
  }
  if (originalUrl.startsWith("/")) {
    originalUrl = `http://dogs.are.great${originalUrl}`;
  }
  try {
    return req.query || typeof URL !== void 0 && new URL(originalUrl).search.slice(1) || // In Node 8, `URL` isn't in the global scope, so we have to use the built-in module from Node
    deps && deps.url && deps.url.parse(originalUrl).query || void 0;
  } catch (e22) {
    return void 0;
  }
}
__name(extractQueryParams, "extractQueryParams");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/severity.js
init_import_meta_url();
var validSeverityLevels = ["fatal", "error", "warning", "log", "info", "debug"];
function severityLevelFromString(level) {
  return level === "warn" ? "warning" : validSeverityLevels.includes(level) ? level : "log";
}
__name(severityLevelFromString, "severityLevelFromString");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/time.js
init_import_meta_url();
var WINDOW2 = getGlobalObject();
var dateTimestampSource = {
  nowSeconds: () => Date.now() / 1e3
};
function getBrowserPerformance() {
  const { performance: performance2 } = WINDOW2;
  if (!performance2 || !performance2.now) {
    return void 0;
  }
  const timeOrigin = Date.now() - performance2.now();
  return {
    now: () => performance2.now(),
    timeOrigin
  };
}
__name(getBrowserPerformance, "getBrowserPerformance");
function getNodePerformance() {
  try {
    const perfHooks = dynamicRequire(module, "perf_hooks");
    return perfHooks.performance;
  } catch (_3) {
    return void 0;
  }
}
__name(getNodePerformance, "getNodePerformance");
var platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();
var timestampSource = platformPerformance === void 0 ? dateTimestampSource : {
  nowSeconds: () => (platformPerformance.timeOrigin + platformPerformance.now()) / 1e3
};
var dateTimestampInSeconds = dateTimestampSource.nowSeconds.bind(dateTimestampSource);
var timestampInSeconds = timestampSource.nowSeconds.bind(timestampSource);
var _browserPerformanceTimeOriginMode;
var browserPerformanceTimeOrigin = (() => {
  const { performance: performance2 } = WINDOW2;
  if (!performance2 || !performance2.now) {
    _browserPerformanceTimeOriginMode = "none";
    return void 0;
  }
  const threshold = 3600 * 1e3;
  const performanceNow = performance2.now();
  const dateNow = Date.now();
  const timeOriginDelta = performance2.timeOrigin ? Math.abs(performance2.timeOrigin + performanceNow - dateNow) : threshold;
  const timeOriginIsReliable = timeOriginDelta < threshold;
  const navigationStart = performance2.timing && performance2.timing.navigationStart;
  const hasNavigationStart = typeof navigationStart === "number";
  const navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;
  const navigationStartIsReliable = navigationStartDelta < threshold;
  if (timeOriginIsReliable || navigationStartIsReliable) {
    if (timeOriginDelta <= navigationStartDelta) {
      _browserPerformanceTimeOriginMode = "timeOrigin";
      return performance2.timeOrigin;
    } else {
      _browserPerformanceTimeOriginMode = "navigationStart";
      return navigationStart;
    }
  }
  _browserPerformanceTimeOriginMode = "dateNow";
  return dateNow;
})();

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/tracing.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/baggage.js
init_import_meta_url();
var SENTRY_BAGGAGE_KEY_PREFIX = "sentry-";
var SENTRY_BAGGAGE_KEY_PREFIX_REGEX = /^sentry-/;
var MAX_BAGGAGE_STRING_LENGTH = 8192;
function baggageHeaderToDynamicSamplingContext(baggageHeader) {
  if (!isString3(baggageHeader) && !Array.isArray(baggageHeader)) {
    return void 0;
  }
  let baggageObject = {};
  if (Array.isArray(baggageHeader)) {
    baggageObject = baggageHeader.reduce((acc, curr) => {
      const currBaggageObject = baggageHeaderToObject(curr);
      return {
        ...acc,
        ...currBaggageObject
      };
    }, {});
  } else {
    if (!baggageHeader) {
      return void 0;
    }
    baggageObject = baggageHeaderToObject(baggageHeader);
  }
  const dynamicSamplingContext = Object.entries(baggageObject).reduce((acc, [key, value]) => {
    if (key.match(SENTRY_BAGGAGE_KEY_PREFIX_REGEX)) {
      const nonPrefixedKey = key.slice(SENTRY_BAGGAGE_KEY_PREFIX.length);
      acc[nonPrefixedKey] = value;
    }
    return acc;
  }, {});
  if (Object.keys(dynamicSamplingContext).length > 0) {
    return dynamicSamplingContext;
  } else {
    return void 0;
  }
}
__name(baggageHeaderToDynamicSamplingContext, "baggageHeaderToDynamicSamplingContext");
function dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext) {
  if (!dynamicSamplingContext) {
    return void 0;
  }
  const sentryPrefixedDSC = Object.entries(dynamicSamplingContext).reduce(
    (acc, [dscKey, dscValue]) => {
      if (dscValue) {
        acc[`${SENTRY_BAGGAGE_KEY_PREFIX}${dscKey}`] = dscValue;
      }
      return acc;
    },
    {}
  );
  return objectToBaggageHeader(sentryPrefixedDSC);
}
__name(dynamicSamplingContextToSentryBaggageHeader, "dynamicSamplingContextToSentryBaggageHeader");
function baggageHeaderToObject(baggageHeader) {
  return baggageHeader.split(",").map((baggageEntry) => baggageEntry.split("=").map((keyOrValue) => decodeURIComponent(keyOrValue.trim()))).reduce((acc, [key, value]) => {
    acc[key] = value;
    return acc;
  }, {});
}
__name(baggageHeaderToObject, "baggageHeaderToObject");
function objectToBaggageHeader(object) {
  if (Object.keys(object).length === 0) {
    return void 0;
  }
  return Object.entries(object).reduce((baggageHeader, [objectKey, objectValue], currentIndex) => {
    const baggageEntry = `${encodeURIComponent(objectKey)}=${encodeURIComponent(objectValue)}`;
    const newBaggageHeader = currentIndex === 0 ? baggageEntry : `${baggageHeader},${baggageEntry}`;
    if (newBaggageHeader.length > MAX_BAGGAGE_STRING_LENGTH) {
      DEBUG_BUILD && logger2.warn(
        `Not adding key: ${objectKey} with val: ${objectValue} to baggage header due to exceeding baggage size limits.`
      );
      return baggageHeader;
    } else {
      return newBaggageHeader;
    }
  }, "");
}
__name(objectToBaggageHeader, "objectToBaggageHeader");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/tracing.js
var TRACEPARENT_REGEXP = new RegExp(
  "^[ \\t]*([0-9a-f]{32})?-?([0-9a-f]{16})?-?([01])?[ \\t]*$"
  // whitespace
);
function extractTraceparentData(traceparent) {
  if (!traceparent) {
    return void 0;
  }
  const matches = traceparent.match(TRACEPARENT_REGEXP);
  if (!matches) {
    return void 0;
  }
  let parentSampled;
  if (matches[3] === "1") {
    parentSampled = true;
  } else if (matches[3] === "0") {
    parentSampled = false;
  }
  return {
    traceId: matches[1],
    parentSampled,
    parentSpanId: matches[2]
  };
}
__name(extractTraceparentData, "extractTraceparentData");
function tracingContextFromHeaders(sentryTrace, baggage) {
  const traceparentData = extractTraceparentData(sentryTrace);
  const dynamicSamplingContext = baggageHeaderToDynamicSamplingContext(baggage);
  const { traceId, parentSpanId, parentSampled } = traceparentData || {};
  const propagationContext = {
    traceId: traceId || uuid4(),
    spanId: uuid4().substring(16),
    sampled: parentSampled
  };
  if (parentSpanId) {
    propagationContext.parentSpanId = parentSpanId;
  }
  if (dynamicSamplingContext) {
    propagationContext.dsc = dynamicSamplingContext;
  }
  return {
    traceparentData,
    dynamicSamplingContext,
    propagationContext
  };
}
__name(tracingContextFromHeaders, "tracingContextFromHeaders");
function generateSentryTraceHeader(traceId = uuid4(), spanId = uuid4().substring(16), sampled) {
  let sampledString = "";
  if (sampled !== void 0) {
    sampledString = sampled ? "-1" : "-0";
  }
  return `${traceId}-${spanId}${sampledString}`;
}
__name(generateSentryTraceHeader, "generateSentryTraceHeader");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/envelope.js
init_import_meta_url();
function createEnvelope(headers, items = []) {
  return [headers, items];
}
__name(createEnvelope, "createEnvelope");
function addItemToEnvelope(envelope, newItem) {
  const [headers, items] = envelope;
  return [headers, [...items, newItem]];
}
__name(addItemToEnvelope, "addItemToEnvelope");
function forEachEnvelopeItem(envelope, callback) {
  const envelopeItems = envelope[1];
  for (const envelopeItem of envelopeItems) {
    const envelopeItemType = envelopeItem[0].type;
    const result = callback(envelopeItem, envelopeItemType);
    if (result) {
      return true;
    }
  }
  return false;
}
__name(forEachEnvelopeItem, "forEachEnvelopeItem");
function encodeUTF8(input, textEncoder) {
  const utf8 = textEncoder || new TextEncoder();
  return utf8.encode(input);
}
__name(encodeUTF8, "encodeUTF8");
function serializeEnvelope(envelope, textEncoder) {
  const [envHeaders, items] = envelope;
  let parts = JSON.stringify(envHeaders);
  function append(next) {
    if (typeof parts === "string") {
      parts = typeof next === "string" ? parts + next : [encodeUTF8(parts, textEncoder), next];
    } else {
      parts.push(typeof next === "string" ? encodeUTF8(next, textEncoder) : next);
    }
  }
  __name(append, "append");
  for (const item of items) {
    const [itemHeaders, payload] = item;
    append(`
${JSON.stringify(itemHeaders)}
`);
    if (typeof payload === "string" || payload instanceof Uint8Array) {
      append(payload);
    } else {
      let stringifiedPayload;
      try {
        stringifiedPayload = JSON.stringify(payload);
      } catch (e3) {
        stringifiedPayload = JSON.stringify(normalize2(payload));
      }
      append(stringifiedPayload);
    }
  }
  return typeof parts === "string" ? parts : concatBuffers(parts);
}
__name(serializeEnvelope, "serializeEnvelope");
function concatBuffers(buffers) {
  const totalLength = buffers.reduce((acc, buf) => acc + buf.length, 0);
  const merged = new Uint8Array(totalLength);
  let offset = 0;
  for (const buffer of buffers) {
    merged.set(buffer, offset);
    offset += buffer.length;
  }
  return merged;
}
__name(concatBuffers, "concatBuffers");
function createAttachmentEnvelopeItem(attachment, textEncoder) {
  const buffer = typeof attachment.data === "string" ? encodeUTF8(attachment.data, textEncoder) : attachment.data;
  return [
    dropUndefinedKeys({
      type: "attachment",
      length: buffer.length,
      filename: attachment.filename,
      content_type: attachment.contentType,
      attachment_type: attachment.attachmentType
    }),
    buffer
  ];
}
__name(createAttachmentEnvelopeItem, "createAttachmentEnvelopeItem");
var ITEM_TYPE_TO_DATA_CATEGORY_MAP = {
  session: "session",
  sessions: "session",
  attachment: "attachment",
  transaction: "transaction",
  event: "error",
  client_report: "internal",
  user_report: "default",
  profile: "profile",
  replay_event: "replay",
  replay_recording: "replay",
  check_in: "monitor",
  feedback: "feedback",
  // TODO: This is a temporary workaround until we have a proper data category for metrics
  statsd: "unknown"
};
function envelopeItemTypeToDataCategory(type) {
  return ITEM_TYPE_TO_DATA_CATEGORY_MAP[type];
}
__name(envelopeItemTypeToDataCategory, "envelopeItemTypeToDataCategory");
function getSdkMetadataForEnvelopeHeader(metadataOrEvent) {
  if (!metadataOrEvent || !metadataOrEvent.sdk) {
    return;
  }
  const { name, version: version3 } = metadataOrEvent.sdk;
  return { name, version: version3 };
}
__name(getSdkMetadataForEnvelopeHeader, "getSdkMetadataForEnvelopeHeader");
function createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn) {
  const dynamicSamplingContext = event.sdkProcessingMetadata && event.sdkProcessingMetadata.dynamicSamplingContext;
  return {
    event_id: event.event_id,
    sent_at: (/* @__PURE__ */ new Date()).toISOString(),
    ...sdkInfo && { sdk: sdkInfo },
    ...!!tunnel && dsn && { dsn: dsnToString(dsn) },
    ...dynamicSamplingContext && {
      trace: dropUndefinedKeys({ ...dynamicSamplingContext })
    }
  };
}
__name(createEventEnvelopeHeaders, "createEventEnvelopeHeaders");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/ratelimit.js
init_import_meta_url();
var DEFAULT_RETRY_AFTER = 60 * 1e3;
function parseRetryAfterHeader(header, now = Date.now()) {
  const headerDelay = parseInt(`${header}`, 10);
  if (!isNaN(headerDelay)) {
    return headerDelay * 1e3;
  }
  const headerDate = Date.parse(`${header}`);
  if (!isNaN(headerDate)) {
    return headerDate - now;
  }
  return DEFAULT_RETRY_AFTER;
}
__name(parseRetryAfterHeader, "parseRetryAfterHeader");
function disabledUntil(limits, category) {
  return limits[category] || limits.all || 0;
}
__name(disabledUntil, "disabledUntil");
function isRateLimited(limits, category, now = Date.now()) {
  return disabledUntil(limits, category) > now;
}
__name(isRateLimited, "isRateLimited");
function updateRateLimits(limits, { statusCode, headers }, now = Date.now()) {
  const updatedRateLimits = {
    ...limits
  };
  const rateLimitHeader = headers && headers["x-sentry-rate-limits"];
  const retryAfterHeader = headers && headers["retry-after"];
  if (rateLimitHeader) {
    for (const limit of rateLimitHeader.trim().split(",")) {
      const [retryAfter, categories] = limit.split(":", 2);
      const headerDelay = parseInt(retryAfter, 10);
      const delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1e3;
      if (!categories) {
        updatedRateLimits.all = now + delay;
      } else {
        for (const category of categories.split(";")) {
          updatedRateLimits[category] = now + delay;
        }
      }
    }
  } else if (retryAfterHeader) {
    updatedRateLimits.all = now + parseRetryAfterHeader(retryAfterHeader, now);
  } else if (statusCode === 429) {
    updatedRateLimits.all = now + 60 * 1e3;
  }
  return updatedRateLimits;
}
__name(updateRateLimits, "updateRateLimits");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/eventbuilder.js
init_import_meta_url();
function parseStackFrames(stackParser, error2) {
  return stackParser(error2.stack || "", 1);
}
__name(parseStackFrames, "parseStackFrames");
function exceptionFromError(stackParser, error2) {
  const exception = {
    type: error2.name || error2.constructor.name,
    value: error2.message
  };
  const frames = parseStackFrames(stackParser, error2);
  if (frames.length) {
    exception.stacktrace = { frames };
  }
  return exception;
}
__name(exceptionFromError, "exceptionFromError");
function getMessageForObject(exception) {
  if ("name" in exception && typeof exception.name === "string") {
    let message = `'${exception.name}' captured as exception`;
    if ("message" in exception && typeof exception.message === "string") {
      message += ` with message '${exception.message}'`;
    }
    return message;
  } else if ("message" in exception && typeof exception.message === "string") {
    return exception.message;
  } else {
    return `Object captured as exception with keys: ${extractExceptionKeysForMessage(
      exception
    )}`;
  }
}
__name(getMessageForObject, "getMessageForObject");
function eventFromUnknownInput(getCurrentHub3, stackParser, exception, hint) {
  let ex = exception;
  const providedMechanism = hint && hint.data && hint.data.mechanism;
  const mechanism = providedMechanism || {
    handled: true,
    type: "generic"
  };
  if (!isError(exception)) {
    if (isPlainObject(exception)) {
      const hub = getCurrentHub3();
      const client = hub.getClient();
      const normalizeDepth = client && client.getOptions().normalizeDepth;
      hub.configureScope((scope) => {
        scope.setExtra("__serialized__", normalizeToSize(exception, normalizeDepth));
      });
      const message = getMessageForObject(exception);
      ex = hint && hint.syntheticException || new Error(message);
      ex.message = message;
    } else {
      ex = hint && hint.syntheticException || new Error(exception);
      ex.message = exception;
    }
    mechanism.synthetic = true;
  }
  const event = {
    exception: {
      values: [exceptionFromError(stackParser, ex)]
    }
  };
  addExceptionTypeValue(event, void 0, void 0);
  addExceptionMechanism(event, mechanism);
  return {
    ...event,
    event_id: hint && hint.event_id
  };
}
__name(eventFromUnknownInput, "eventFromUnknownInput");
function eventFromMessage(stackParser, message, level = "info", hint, attachStacktrace) {
  const event = {
    event_id: hint && hint.event_id,
    level,
    message
  };
  if (attachStacktrace && hint && hint.syntheticException) {
    const frames = parseStackFrames(stackParser, hint.syntheticException);
    if (frames.length) {
      event.exception = {
        values: [
          {
            value: message,
            stacktrace: { frames }
          }
        ]
      };
    }
  }
  return event;
}
__name(eventFromMessage, "eventFromMessage");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/lru.js
init_import_meta_url();
var LRUMap = class {
  constructor(_maxSize) {
    this._maxSize = _maxSize;
    this._cache = /* @__PURE__ */ new Map();
  }
  /** Get the current size of the cache */
  get size() {
    return this._cache.size;
  }
  /** Get an entry or undefined if it was not in the cache. Re-inserts to update the recently used order */
  get(key) {
    const value = this._cache.get(key);
    if (value === void 0) {
      return void 0;
    }
    this._cache.delete(key);
    this._cache.set(key, value);
    return value;
  }
  /** Insert an entry and evict an older entry if we've reached maxSize */
  set(key, value) {
    if (this._cache.size >= this._maxSize) {
      this._cache.delete(this._cache.keys().next().value);
    }
    this._cache.set(key, value);
  }
  /** Remove an entry and return the entry if it was in the cache */
  remove(key) {
    const value = this._cache.get(key);
    if (value) {
      this._cache.delete(key);
    }
    return value;
  }
  /** Clear all entries */
  clear() {
    this._cache.clear();
  }
  /** Get all the keys */
  keys() {
    return Array.from(this._cache.keys());
  }
  /** Get all the values */
  values() {
    const values = [];
    this._cache.forEach((value) => values.push(value));
    return values;
  }
};
__name(LRUMap, "LRUMap");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/buildPolyfills/_nullishCoalesce.js
init_import_meta_url();
function _nullishCoalesce(lhs, rhsFn) {
  return lhs != null ? lhs : rhsFn();
}
__name(_nullishCoalesce, "_nullishCoalesce");

// ../../node_modules/.pnpm/@sentry+utils@7.87.0/node_modules/@sentry/utils/esm/buildPolyfills/_optionalChain.js
init_import_meta_url();
function _optionalChain(ops) {
  let lastAccessLHS = void 0;
  let value = ops[0];
  let i = 1;
  while (i < ops.length) {
    const op = ops[i];
    const fn2 = ops[i + 1];
    i += 2;
    if ((op === "optionalAccess" || op === "optionalCall") && value == null) {
      return;
    }
    if (op === "access" || op === "optionalAccess") {
      lastAccessLHS = value;
      value = fn2(value);
    } else if (op === "call" || op === "optionalCall") {
      value = fn2((...args) => value.call(lastAccessLHS, ...args));
      lastAccessLHS = void 0;
    }
  }
  return value;
}
__name(_optionalChain, "_optionalChain");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/debug-build.js
init_import_meta_url();
var DEBUG_BUILD2 = typeof __SENTRY_DEBUG__ === "undefined" || __SENTRY_DEBUG__;

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/hub.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/constants.js
init_import_meta_url();
var DEFAULT_ENVIRONMENT = "production";

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/scope.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/eventProcessors.js
init_import_meta_url();
function getGlobalEventProcessors() {
  return getGlobalSingleton("globalEventProcessors", () => []);
}
__name(getGlobalEventProcessors, "getGlobalEventProcessors");
function addGlobalEventProcessor(callback) {
  getGlobalEventProcessors().push(callback);
}
__name(addGlobalEventProcessor, "addGlobalEventProcessor");
function notifyEventProcessors(processors, event, hint, index = 0) {
  return new SyncPromise((resolve19, reject) => {
    const processor = processors[index];
    if (event === null || typeof processor !== "function") {
      resolve19(event);
    } else {
      const result = processor({ ...event }, hint);
      DEBUG_BUILD2 && processor.id && result === null && logger2.log(`Event processor "${processor.id}" dropped event`);
      if (isThenable(result)) {
        void result.then((final) => notifyEventProcessors(processors, final, hint, index + 1).then(resolve19)).then(null, reject);
      } else {
        void notifyEventProcessors(processors, result, hint, index + 1).then(resolve19).then(null, reject);
      }
    }
  });
}
__name(notifyEventProcessors, "notifyEventProcessors");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/session.js
init_import_meta_url();
function makeSession(context2) {
  const startingTime = timestampInSeconds();
  const session = {
    sid: uuid4(),
    init: true,
    timestamp: startingTime,
    started: startingTime,
    duration: 0,
    status: "ok",
    errors: 0,
    ignoreDuration: false,
    toJSON: () => sessionToJSON(session)
  };
  if (context2) {
    updateSession(session, context2);
  }
  return session;
}
__name(makeSession, "makeSession");
function updateSession(session, context2 = {}) {
  if (context2.user) {
    if (!session.ipAddress && context2.user.ip_address) {
      session.ipAddress = context2.user.ip_address;
    }
    if (!session.did && !context2.did) {
      session.did = context2.user.id || context2.user.email || context2.user.username;
    }
  }
  session.timestamp = context2.timestamp || timestampInSeconds();
  if (context2.abnormal_mechanism) {
    session.abnormal_mechanism = context2.abnormal_mechanism;
  }
  if (context2.ignoreDuration) {
    session.ignoreDuration = context2.ignoreDuration;
  }
  if (context2.sid) {
    session.sid = context2.sid.length === 32 ? context2.sid : uuid4();
  }
  if (context2.init !== void 0) {
    session.init = context2.init;
  }
  if (!session.did && context2.did) {
    session.did = `${context2.did}`;
  }
  if (typeof context2.started === "number") {
    session.started = context2.started;
  }
  if (session.ignoreDuration) {
    session.duration = void 0;
  } else if (typeof context2.duration === "number") {
    session.duration = context2.duration;
  } else {
    const duration = session.timestamp - session.started;
    session.duration = duration >= 0 ? duration : 0;
  }
  if (context2.release) {
    session.release = context2.release;
  }
  if (context2.environment) {
    session.environment = context2.environment;
  }
  if (!session.ipAddress && context2.ipAddress) {
    session.ipAddress = context2.ipAddress;
  }
  if (!session.userAgent && context2.userAgent) {
    session.userAgent = context2.userAgent;
  }
  if (typeof context2.errors === "number") {
    session.errors = context2.errors;
  }
  if (context2.status) {
    session.status = context2.status;
  }
}
__name(updateSession, "updateSession");
function closeSession(session, status2) {
  let context2 = {};
  if (status2) {
    context2 = { status: status2 };
  } else if (session.status === "ok") {
    context2 = { status: "exited" };
  }
  updateSession(session, context2);
}
__name(closeSession, "closeSession");
function sessionToJSON(session) {
  return dropUndefinedKeys({
    sid: `${session.sid}`,
    init: session.init,
    // Make sure that sec is converted to ms for date constructor
    started: new Date(session.started * 1e3).toISOString(),
    timestamp: new Date(session.timestamp * 1e3).toISOString(),
    status: session.status,
    errors: session.errors,
    did: typeof session.did === "number" || typeof session.did === "string" ? `${session.did}` : void 0,
    duration: session.duration,
    abnormal_mechanism: session.abnormal_mechanism,
    attrs: {
      release: session.release,
      environment: session.environment,
      ip_address: session.ipAddress,
      user_agent: session.userAgent
    }
  });
}
__name(sessionToJSON, "sessionToJSON");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/scope.js
var DEFAULT_MAX_BREADCRUMBS = 100;
var Scope = class {
  /** Flag if notifying is happening. */
  /** Callback for client to receive scope changes. */
  /** Callback list that will be called after {@link applyToEvent}. */
  /** Array of breadcrumbs. */
  /** User */
  /** Tags */
  /** Extra */
  /** Contexts */
  /** Attachments */
  /** Propagation Context for distributed tracing */
  /**
   * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get
   * sent to Sentry
   */
  /** Fingerprint */
  /** Severity */
  // eslint-disable-next-line deprecation/deprecation
  /** Transaction Name */
  /** Span */
  /** Session */
  /** Request Mode Session Status */
  // NOTE: Any field which gets added here should get added not only to the constructor but also to the `clone` method.
  constructor() {
    this._notifyingListeners = false;
    this._scopeListeners = [];
    this._eventProcessors = [];
    this._breadcrumbs = [];
    this._attachments = [];
    this._user = {};
    this._tags = {};
    this._extra = {};
    this._contexts = {};
    this._sdkProcessingMetadata = {};
    this._propagationContext = generatePropagationContext();
  }
  /**
   * Inherit values from the parent scope.
   * @deprecated Use `scope.clone()` and `new Scope()` instead.
   */
  static clone(scope) {
    return scope ? scope.clone() : new Scope();
  }
  /**
   * Clone this scope instance.
   */
  clone() {
    const newScope = new Scope();
    newScope._breadcrumbs = [...this._breadcrumbs];
    newScope._tags = { ...this._tags };
    newScope._extra = { ...this._extra };
    newScope._contexts = { ...this._contexts };
    newScope._user = this._user;
    newScope._level = this._level;
    newScope._span = this._span;
    newScope._session = this._session;
    newScope._transactionName = this._transactionName;
    newScope._fingerprint = this._fingerprint;
    newScope._eventProcessors = [...this._eventProcessors];
    newScope._requestSession = this._requestSession;
    newScope._attachments = [...this._attachments];
    newScope._sdkProcessingMetadata = { ...this._sdkProcessingMetadata };
    newScope._propagationContext = { ...this._propagationContext };
    return newScope;
  }
  /**
   * Add internal on change listener. Used for sub SDKs that need to store the scope.
   * @hidden
   */
  addScopeListener(callback) {
    this._scopeListeners.push(callback);
  }
  /**
   * @inheritDoc
   */
  addEventProcessor(callback) {
    this._eventProcessors.push(callback);
    return this;
  }
  /**
   * @inheritDoc
   */
  setUser(user) {
    this._user = user || {};
    if (this._session) {
      updateSession(this._session, { user });
    }
    this._notifyScopeListeners();
    return this;
  }
  /**
   * @inheritDoc
   */
  getUser() {
    return this._user;
  }
  /**
   * @inheritDoc
   */
  getRequestSession() {
    return this._requestSession;
  }
  /**
   * @inheritDoc
   */
  setRequestSession(requestSession) {
    this._requestSession = requestSession;
    return this;
  }
  /**
   * @inheritDoc
   */
  setTags(tags) {
    this._tags = {
      ...this._tags,
      ...tags
    };
    this._notifyScopeListeners();
    return this;
  }
  /**
   * @inheritDoc
   */
  setTag(key, value) {
    this._tags = { ...this._tags, [key]: value };
    this._notifyScopeListeners();
    return this;
  }
  /**
   * @inheritDoc
   */
  setExtras(extras) {
    this._extra = {
      ...this._extra,
      ...extras
    };
    this._notifyScopeListeners();
    return this;
  }
  /**
   * @inheritDoc
   */
  setExtra(key, extra) {
    this._extra = { ...this._extra, [key]: extra };
    this._notifyScopeListeners();
    return this;
  }
  /**
   * @inheritDoc
   */
  setFingerprint(fingerprint) {
    this._fingerprint = fingerprint;
    this._notifyScopeListeners();
    return this;
  }
  /**
   * @inheritDoc
   */
  setLevel(level) {
    this._level = level;
    this._notifyScopeListeners();
    return this;
  }
  /**
   * @inheritDoc
   */
  setTransactionName(name) {
    this._transactionName = name;
    this._notifyScopeListeners();
    return this;
  }
  /**
   * @inheritDoc
   */
  setContext(key, context2) {
    if (context2 === null) {
      delete this._contexts[key];
    } else {
      this._contexts[key] = context2;
    }
    this._notifyScopeListeners();
    return this;
  }
  /**
   * @inheritDoc
   */
  setSpan(span) {
    this._span = span;
    this._notifyScopeListeners();
    return this;
  }
  /**
   * @inheritDoc
   */
  getSpan() {
    return this._span;
  }
  /**
   * @inheritDoc
   */
  getTransaction() {
    const span = this.getSpan();
    return span && span.transaction;
  }
  /**
   * @inheritDoc
   */
  setSession(session) {
    if (!session) {
      delete this._session;
    } else {
      this._session = session;
    }
    this._notifyScopeListeners();
    return this;
  }
  /**
   * @inheritDoc
   */
  getSession() {
    return this._session;
  }
  /**
   * @inheritDoc
   */
  update(captureContext) {
    if (!captureContext) {
      return this;
    }
    if (typeof captureContext === "function") {
      const updatedScope = captureContext(this);
      return updatedScope instanceof Scope ? updatedScope : this;
    }
    if (captureContext instanceof Scope) {
      this._tags = { ...this._tags, ...captureContext._tags };
      this._extra = { ...this._extra, ...captureContext._extra };
      this._contexts = { ...this._contexts, ...captureContext._contexts };
      if (captureContext._user && Object.keys(captureContext._user).length) {
        this._user = captureContext._user;
      }
      if (captureContext._level) {
        this._level = captureContext._level;
      }
      if (captureContext._fingerprint) {
        this._fingerprint = captureContext._fingerprint;
      }
      if (captureContext._requestSession) {
        this._requestSession = captureContext._requestSession;
      }
      if (captureContext._propagationContext) {
        this._propagationContext = captureContext._propagationContext;
      }
    } else if (isPlainObject(captureContext)) {
      captureContext = captureContext;
      this._tags = { ...this._tags, ...captureContext.tags };
      this._extra = { ...this._extra, ...captureContext.extra };
      this._contexts = { ...this._contexts, ...captureContext.contexts };
      if (captureContext.user) {
        this._user = captureContext.user;
      }
      if (captureContext.level) {
        this._level = captureContext.level;
      }
      if (captureContext.fingerprint) {
        this._fingerprint = captureContext.fingerprint;
      }
      if (captureContext.requestSession) {
        this._requestSession = captureContext.requestSession;
      }
      if (captureContext.propagationContext) {
        this._propagationContext = captureContext.propagationContext;
      }
    }
    return this;
  }
  /**
   * @inheritDoc
   */
  clear() {
    this._breadcrumbs = [];
    this._tags = {};
    this._extra = {};
    this._user = {};
    this._contexts = {};
    this._level = void 0;
    this._transactionName = void 0;
    this._fingerprint = void 0;
    this._requestSession = void 0;
    this._span = void 0;
    this._session = void 0;
    this._notifyScopeListeners();
    this._attachments = [];
    this._propagationContext = generatePropagationContext();
    return this;
  }
  /**
   * @inheritDoc
   */
  addBreadcrumb(breadcrumb, maxBreadcrumbs) {
    const maxCrumbs = typeof maxBreadcrumbs === "number" ? maxBreadcrumbs : DEFAULT_MAX_BREADCRUMBS;
    if (maxCrumbs <= 0) {
      return this;
    }
    const mergedBreadcrumb = {
      timestamp: dateTimestampInSeconds(),
      ...breadcrumb
    };
    const breadcrumbs = this._breadcrumbs;
    breadcrumbs.push(mergedBreadcrumb);
    this._breadcrumbs = breadcrumbs.length > maxCrumbs ? breadcrumbs.slice(-maxCrumbs) : breadcrumbs;
    this._notifyScopeListeners();
    return this;
  }
  /**
   * @inheritDoc
   */
  getLastBreadcrumb() {
    return this._breadcrumbs[this._breadcrumbs.length - 1];
  }
  /**
   * @inheritDoc
   */
  clearBreadcrumbs() {
    this._breadcrumbs = [];
    this._notifyScopeListeners();
    return this;
  }
  /**
   * @inheritDoc
   */
  addAttachment(attachment) {
    this._attachments.push(attachment);
    return this;
  }
  /**
   * @inheritDoc
   */
  getAttachments() {
    return this._attachments;
  }
  /**
   * @inheritDoc
   */
  clearAttachments() {
    this._attachments = [];
    return this;
  }
  /**
   * Applies data from the scope to the event and runs all event processors on it.
   *
   * @param event Event
   * @param hint Object containing additional information about the original exception, for use by the event processors.
   * @hidden
   */
  applyToEvent(event, hint = {}, additionalEventProcessors) {
    if (this._extra && Object.keys(this._extra).length) {
      event.extra = { ...this._extra, ...event.extra };
    }
    if (this._tags && Object.keys(this._tags).length) {
      event.tags = { ...this._tags, ...event.tags };
    }
    if (this._user && Object.keys(this._user).length) {
      event.user = { ...this._user, ...event.user };
    }
    if (this._contexts && Object.keys(this._contexts).length) {
      event.contexts = { ...this._contexts, ...event.contexts };
    }
    if (this._level) {
      event.level = this._level;
    }
    if (this._transactionName) {
      event.transaction = this._transactionName;
    }
    if (this._span) {
      event.contexts = { trace: this._span.getTraceContext(), ...event.contexts };
      const transaction = this._span.transaction;
      if (transaction) {
        event.sdkProcessingMetadata = {
          dynamicSamplingContext: transaction.getDynamicSamplingContext(),
          ...event.sdkProcessingMetadata
        };
        const transactionName = transaction.name;
        if (transactionName) {
          event.tags = { transaction: transactionName, ...event.tags };
        }
      }
    }
    this._applyFingerprint(event);
    const scopeBreadcrumbs = this._getBreadcrumbs();
    const breadcrumbs = [...event.breadcrumbs || [], ...scopeBreadcrumbs];
    event.breadcrumbs = breadcrumbs.length > 0 ? breadcrumbs : void 0;
    event.sdkProcessingMetadata = {
      ...event.sdkProcessingMetadata,
      ...this._sdkProcessingMetadata,
      propagationContext: this._propagationContext
    };
    return notifyEventProcessors(
      [
        ...additionalEventProcessors || [],
        // eslint-disable-next-line deprecation/deprecation
        ...getGlobalEventProcessors(),
        ...this._eventProcessors
      ],
      event,
      hint
    );
  }
  /**
   * Add data which will be accessible during event processing but won't get sent to Sentry
   */
  setSDKProcessingMetadata(newData) {
    this._sdkProcessingMetadata = { ...this._sdkProcessingMetadata, ...newData };
    return this;
  }
  /**
   * @inheritDoc
   */
  setPropagationContext(context2) {
    this._propagationContext = context2;
    return this;
  }
  /**
   * @inheritDoc
   */
  getPropagationContext() {
    return this._propagationContext;
  }
  /**
   * Get the breadcrumbs for this scope.
   */
  _getBreadcrumbs() {
    return this._breadcrumbs;
  }
  /**
   * This will be called on every set call.
   */
  _notifyScopeListeners() {
    if (!this._notifyingListeners) {
      this._notifyingListeners = true;
      this._scopeListeners.forEach((callback) => {
        callback(this);
      });
      this._notifyingListeners = false;
    }
  }
  /**
   * Applies fingerprint from the scope to the event if there's one,
   * uses message if there's one instead or get rid of empty fingerprint
   */
  _applyFingerprint(event) {
    event.fingerprint = event.fingerprint ? arrayify(event.fingerprint) : [];
    if (this._fingerprint) {
      event.fingerprint = event.fingerprint.concat(this._fingerprint);
    }
    if (event.fingerprint && !event.fingerprint.length) {
      delete event.fingerprint;
    }
  }
};
__name(Scope, "Scope");
function generatePropagationContext() {
  return {
    traceId: uuid4(),
    spanId: uuid4().substring(16)
  };
}
__name(generatePropagationContext, "generatePropagationContext");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/version.js
init_import_meta_url();
var SDK_VERSION = "7.87.0";

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/hub.js
var API_VERSION = parseFloat(SDK_VERSION);
var DEFAULT_BREADCRUMBS = 100;
var Hub = class {
  /** Is a {@link Layer}[] containing the client and scope */
  /** Contains the last event id of a captured event.  */
  /**
   * Creates a new instance of the hub, will push one {@link Layer} into the
   * internal stack on creation.
   *
   * @param client bound to the hub.
   * @param scope bound to the hub.
   * @param version number, higher number means higher priority.
   */
  constructor(client, scope = new Scope(), _version = API_VERSION) {
    this._version = _version;
    this._stack = [{ scope }];
    if (client) {
      this.bindClient(client);
    }
  }
  /**
   * @inheritDoc
   */
  isOlderThan(version3) {
    return this._version < version3;
  }
  /**
   * @inheritDoc
   */
  bindClient(client) {
    const top2 = this.getStackTop();
    top2.client = client;
    if (client && client.setupIntegrations) {
      client.setupIntegrations();
    }
  }
  /**
   * @inheritDoc
   */
  pushScope() {
    const scope = this.getScope().clone();
    this.getStack().push({
      client: this.getClient(),
      scope
    });
    return scope;
  }
  /**
   * @inheritDoc
   */
  popScope() {
    if (this.getStack().length <= 1)
      return false;
    return !!this.getStack().pop();
  }
  /**
   * @inheritDoc
   */
  withScope(callback) {
    const scope = this.pushScope();
    try {
      callback(scope);
    } finally {
      this.popScope();
    }
  }
  /**
   * @inheritDoc
   */
  getClient() {
    return this.getStackTop().client;
  }
  /** Returns the scope of the top stack. */
  getScope() {
    return this.getStackTop().scope;
  }
  /** Returns the scope stack for domains or the process. */
  getStack() {
    return this._stack;
  }
  /** Returns the topmost scope layer in the order domain > local > process. */
  getStackTop() {
    return this._stack[this._stack.length - 1];
  }
  /**
   * @inheritDoc
   */
  captureException(exception, hint) {
    const eventId = this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4();
    const syntheticException = new Error("Sentry syntheticException");
    this._withClient((client, scope) => {
      client.captureException(
        exception,
        {
          originalException: exception,
          syntheticException,
          ...hint,
          event_id: eventId
        },
        scope
      );
    });
    return eventId;
  }
  /**
   * @inheritDoc
   */
  captureMessage(message, level, hint) {
    const eventId = this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4();
    const syntheticException = new Error(message);
    this._withClient((client, scope) => {
      client.captureMessage(
        message,
        level,
        {
          originalException: message,
          syntheticException,
          ...hint,
          event_id: eventId
        },
        scope
      );
    });
    return eventId;
  }
  /**
   * @inheritDoc
   */
  captureEvent(event, hint) {
    const eventId = hint && hint.event_id ? hint.event_id : uuid4();
    if (!event.type) {
      this._lastEventId = eventId;
    }
    this._withClient((client, scope) => {
      client.captureEvent(event, { ...hint, event_id: eventId }, scope);
    });
    return eventId;
  }
  /**
   * @inheritDoc
   */
  lastEventId() {
    return this._lastEventId;
  }
  /**
   * @inheritDoc
   */
  addBreadcrumb(breadcrumb, hint) {
    const { scope, client } = this.getStackTop();
    if (!client)
      return;
    const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS } = client.getOptions && client.getOptions() || {};
    if (maxBreadcrumbs <= 0)
      return;
    const timestamp = dateTimestampInSeconds();
    const mergedBreadcrumb = { timestamp, ...breadcrumb };
    const finalBreadcrumb = beforeBreadcrumb ? consoleSandbox(() => beforeBreadcrumb(mergedBreadcrumb, hint)) : mergedBreadcrumb;
    if (finalBreadcrumb === null)
      return;
    if (client.emit) {
      client.emit("beforeAddBreadcrumb", finalBreadcrumb, hint);
    }
    scope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);
  }
  /**
   * @inheritDoc
   */
  setUser(user) {
    this.getScope().setUser(user);
  }
  /**
   * @inheritDoc
   */
  setTags(tags) {
    this.getScope().setTags(tags);
  }
  /**
   * @inheritDoc
   */
  setExtras(extras) {
    this.getScope().setExtras(extras);
  }
  /**
   * @inheritDoc
   */
  setTag(key, value) {
    this.getScope().setTag(key, value);
  }
  /**
   * @inheritDoc
   */
  setExtra(key, extra) {
    this.getScope().setExtra(key, extra);
  }
  /**
   * @inheritDoc
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  setContext(name, context2) {
    this.getScope().setContext(name, context2);
  }
  /**
   * @inheritDoc
   */
  configureScope(callback) {
    const { scope, client } = this.getStackTop();
    if (client) {
      callback(scope);
    }
  }
  /**
   * @inheritDoc
   */
  run(callback) {
    const oldHub = makeMain(this);
    try {
      callback(this);
    } finally {
      makeMain(oldHub);
    }
  }
  /**
   * @inheritDoc
   */
  getIntegration(integration) {
    const client = this.getClient();
    if (!client)
      return null;
    try {
      return client.getIntegration(integration);
    } catch (_oO) {
      DEBUG_BUILD2 && logger2.warn(`Cannot retrieve integration ${integration.id} from the current Hub`);
      return null;
    }
  }
  /**
   * @inheritDoc
   */
  startTransaction(context2, customSamplingContext) {
    const result = this._callExtensionMethod("startTransaction", context2, customSamplingContext);
    if (DEBUG_BUILD2 && !result) {
      const client = this.getClient();
      if (!client) {
        logger2.warn(
          "Tracing extension 'startTransaction' is missing. You should 'init' the SDK before calling 'startTransaction'"
        );
      } else {
        logger2.warn(`Tracing extension 'startTransaction' has not been added. Call 'addTracingExtensions' before calling 'init':
Sentry.addTracingExtensions();
Sentry.init({...});
`);
      }
    }
    return result;
  }
  /**
   * @inheritDoc
   */
  traceHeaders() {
    return this._callExtensionMethod("traceHeaders");
  }
  /**
   * @inheritDoc
   */
  captureSession(endSession = false) {
    if (endSession) {
      return this.endSession();
    }
    this._sendSessionUpdate();
  }
  /**
   * @inheritDoc
   */
  endSession() {
    const layer = this.getStackTop();
    const scope = layer.scope;
    const session = scope.getSession();
    if (session) {
      closeSession(session);
    }
    this._sendSessionUpdate();
    scope.setSession();
  }
  /**
   * @inheritDoc
   */
  startSession(context2) {
    const { scope, client } = this.getStackTop();
    const { release: release2, environment = DEFAULT_ENVIRONMENT } = client && client.getOptions() || {};
    const { userAgent } = GLOBAL_OBJ.navigator || {};
    const session = makeSession({
      release: release2,
      environment,
      user: scope.getUser(),
      ...userAgent && { userAgent },
      ...context2
    });
    const currentSession = scope.getSession && scope.getSession();
    if (currentSession && currentSession.status === "ok") {
      updateSession(currentSession, { status: "exited" });
    }
    this.endSession();
    scope.setSession(session);
    return session;
  }
  /**
   * Returns if default PII should be sent to Sentry and propagated in ourgoing requests
   * when Tracing is used.
   */
  shouldSendDefaultPii() {
    const client = this.getClient();
    const options29 = client && client.getOptions();
    return Boolean(options29 && options29.sendDefaultPii);
  }
  /**
   * Sends the current Session on the scope
   */
  _sendSessionUpdate() {
    const { scope, client } = this.getStackTop();
    const session = scope.getSession();
    if (session && client && client.captureSession) {
      client.captureSession(session);
    }
  }
  /**
   * Internal helper function to call a method on the top client if it exists.
   *
   * @param method The method to call on the client.
   * @param args Arguments to pass to the client function.
   */
  _withClient(callback) {
    const { scope, client } = this.getStackTop();
    if (client) {
      callback(client, scope);
    }
  }
  /**
   * Calls global extension method and binding current instance to the function call
   */
  // @ts-expect-error Function lacks ending return statement and return type does not include 'undefined'. ts(2366)
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  _callExtensionMethod(method, ...args) {
    const carrier = getMainCarrier();
    const sentry = carrier.__SENTRY__;
    if (sentry && sentry.extensions && typeof sentry.extensions[method] === "function") {
      return sentry.extensions[method].apply(this, args);
    }
    DEBUG_BUILD2 && logger2.warn(`Extension method ${method} couldn't be found, doing nothing.`);
  }
};
__name(Hub, "Hub");
function getMainCarrier() {
  GLOBAL_OBJ.__SENTRY__ = GLOBAL_OBJ.__SENTRY__ || {
    extensions: {},
    hub: void 0
  };
  return GLOBAL_OBJ;
}
__name(getMainCarrier, "getMainCarrier");
function makeMain(hub) {
  const registry = getMainCarrier();
  const oldHub = getHubFromCarrier(registry);
  setHubOnCarrier(registry, hub);
  return oldHub;
}
__name(makeMain, "makeMain");
function getCurrentHub() {
  const registry = getMainCarrier();
  if (registry.__SENTRY__ && registry.__SENTRY__.acs) {
    const hub = registry.__SENTRY__.acs.getCurrentHub();
    if (hub) {
      return hub;
    }
  }
  return getGlobalHub(registry);
}
__name(getCurrentHub, "getCurrentHub");
function getGlobalHub(registry = getMainCarrier()) {
  if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {
    setHubOnCarrier(registry, new Hub());
  }
  return getHubFromCarrier(registry);
}
__name(getGlobalHub, "getGlobalHub");
function ensureHubOnCarrier(carrier, parent = getGlobalHub()) {
  if (!hasHubOnCarrier(carrier) || getHubFromCarrier(carrier).isOlderThan(API_VERSION)) {
    const globalHubTopStack = parent.getStackTop();
    setHubOnCarrier(carrier, new Hub(globalHubTopStack.client, globalHubTopStack.scope.clone()));
  }
}
__name(ensureHubOnCarrier, "ensureHubOnCarrier");
function setAsyncContextStrategy(strategy) {
  const registry = getMainCarrier();
  registry.__SENTRY__ = registry.__SENTRY__ || {};
  registry.__SENTRY__.acs = strategy;
}
__name(setAsyncContextStrategy, "setAsyncContextStrategy");
function hasHubOnCarrier(carrier) {
  return !!(carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub);
}
__name(hasHubOnCarrier, "hasHubOnCarrier");
function getHubFromCarrier(carrier) {
  return getGlobalSingleton("hub", () => new Hub(), carrier);
}
__name(getHubFromCarrier, "getHubFromCarrier");
function setHubOnCarrier(carrier, hub) {
  if (!carrier)
    return false;
  const __SENTRY__ = carrier.__SENTRY__ = carrier.__SENTRY__ || {};
  __SENTRY__.hub = hub;
  return true;
}
__name(setHubOnCarrier, "setHubOnCarrier");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/tracing/errors.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/tracing/utils.js
init_import_meta_url();
function getActiveTransaction(maybeHub) {
  const hub = maybeHub || getCurrentHub();
  const scope = hub.getScope();
  return scope.getTransaction();
}
__name(getActiveTransaction, "getActiveTransaction");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/tracing/errors.js
var errorsInstrumented = false;
function registerErrorInstrumentation() {
  if (errorsInstrumented) {
    return;
  }
  errorsInstrumented = true;
  addGlobalErrorInstrumentationHandler(errorCallback);
  addGlobalUnhandledRejectionInstrumentationHandler(errorCallback);
}
__name(registerErrorInstrumentation, "registerErrorInstrumentation");
function errorCallback() {
  const activeTransaction = getActiveTransaction();
  if (activeTransaction) {
    const status2 = "internal_error";
    DEBUG_BUILD2 && logger2.log(`[Tracing] Transaction: ${status2} -> Global error occured`);
    activeTransaction.setStatus(status2);
  }
}
__name(errorCallback, "errorCallback");
errorCallback.tag = "sentry_tracingErrorCallback";

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/tracing/span.js
init_import_meta_url();
var SpanRecorder = class {
  constructor(maxlen = 1e3) {
    this._maxlen = maxlen;
    this.spans = [];
  }
  /**
   * This is just so that we don't run out of memory while recording a lot
   * of spans. At some point we just stop and flush out the start of the
   * trace tree (i.e.the first n spans with the smallest
   * start_timestamp).
   */
  add(span) {
    if (this.spans.length > this._maxlen) {
      span.spanRecorder = void 0;
    } else {
      this.spans.push(span);
    }
  }
};
__name(SpanRecorder, "SpanRecorder");
var Span = class {
  /**
   * @inheritDoc
   */
  /**
   * @inheritDoc
   */
  /**
   * @inheritDoc
   */
  /**
   * Internal keeper of the status
   */
  /**
   * @inheritDoc
   */
  /**
   * Timestamp in seconds when the span was created.
   */
  /**
   * Timestamp in seconds when the span ended.
   */
  /**
   * @inheritDoc
   */
  /**
   * @inheritDoc
   */
  /**
   * @inheritDoc
   */
  /**
   * @inheritDoc
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  /**
   * List of spans that were finalized
   */
  /**
   * @inheritDoc
   */
  /**
   * The instrumenter that created this span.
   */
  /**
   * The origin of the span, giving context about what created the span.
   */
  /**
   * You should never call the constructor manually, always use `Sentry.startTransaction()`
   * or call `startChild()` on an existing span.
   * @internal
   * @hideconstructor
   * @hidden
   */
  constructor(spanContext = {}) {
    this.traceId = spanContext.traceId || uuid4();
    this.spanId = spanContext.spanId || uuid4().substring(16);
    this.startTimestamp = spanContext.startTimestamp || timestampInSeconds();
    this.tags = spanContext.tags || {};
    this.data = spanContext.data || {};
    this.instrumenter = spanContext.instrumenter || "sentry";
    this.origin = spanContext.origin || "manual";
    if (spanContext.parentSpanId) {
      this.parentSpanId = spanContext.parentSpanId;
    }
    if ("sampled" in spanContext) {
      this.sampled = spanContext.sampled;
    }
    if (spanContext.op) {
      this.op = spanContext.op;
    }
    if (spanContext.description) {
      this.description = spanContext.description;
    }
    if (spanContext.name) {
      this.description = spanContext.name;
    }
    if (spanContext.status) {
      this.status = spanContext.status;
    }
    if (spanContext.endTimestamp) {
      this.endTimestamp = spanContext.endTimestamp;
    }
  }
  /** An alias for `description` of the Span. */
  get name() {
    return this.description || "";
  }
  /** Update the name of the span. */
  set name(name) {
    this.setName(name);
  }
  /**
   * @inheritDoc
   */
  startChild(spanContext) {
    const childSpan = new Span({
      ...spanContext,
      parentSpanId: this.spanId,
      sampled: this.sampled,
      traceId: this.traceId
    });
    childSpan.spanRecorder = this.spanRecorder;
    if (childSpan.spanRecorder) {
      childSpan.spanRecorder.add(childSpan);
    }
    childSpan.transaction = this.transaction;
    if (DEBUG_BUILD2 && childSpan.transaction) {
      const opStr = spanContext && spanContext.op || "< unknown op >";
      const nameStr = childSpan.transaction.name || "< unknown name >";
      const idStr = childSpan.transaction.spanId;
      const logMessage = `[Tracing] Starting '${opStr}' span on transaction '${nameStr}' (${idStr}).`;
      childSpan.transaction.metadata.spanMetadata[childSpan.spanId] = { logMessage };
      logger2.log(logMessage);
    }
    return childSpan;
  }
  /**
   * @inheritDoc
   */
  setTag(key, value) {
    this.tags = { ...this.tags, [key]: value };
    return this;
  }
  /**
   * @inheritDoc
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
  setData(key, value) {
    this.data = { ...this.data, [key]: value };
    return this;
  }
  /**
   * @inheritDoc
   */
  setStatus(value) {
    this.status = value;
    return this;
  }
  /**
   * @inheritDoc
   */
  setHttpStatus(httpStatus) {
    this.setTag("http.status_code", String(httpStatus));
    this.setData("http.response.status_code", httpStatus);
    const spanStatus = spanStatusfromHttpCode(httpStatus);
    if (spanStatus !== "unknown_error") {
      this.setStatus(spanStatus);
    }
    return this;
  }
  /**
   * @inheritDoc
   */
  setName(name) {
    this.description = name;
  }
  /**
   * @inheritDoc
   */
  isSuccess() {
    return this.status === "ok";
  }
  /**
   * @inheritDoc
   */
  finish(endTimestamp) {
    if (DEBUG_BUILD2 && // Don't call this for transactions
    this.transaction && this.transaction.spanId !== this.spanId) {
      const { logMessage } = this.transaction.metadata.spanMetadata[this.spanId];
      if (logMessage) {
        logger2.log(logMessage.replace("Starting", "Finishing"));
      }
    }
    this.endTimestamp = typeof endTimestamp === "number" ? endTimestamp : timestampInSeconds();
  }
  /**
   * @inheritDoc
   */
  toTraceparent() {
    return generateSentryTraceHeader(this.traceId, this.spanId, this.sampled);
  }
  /**
   * @inheritDoc
   */
  toContext() {
    return dropUndefinedKeys({
      data: this.data,
      description: this.description,
      endTimestamp: this.endTimestamp,
      op: this.op,
      parentSpanId: this.parentSpanId,
      sampled: this.sampled,
      spanId: this.spanId,
      startTimestamp: this.startTimestamp,
      status: this.status,
      tags: this.tags,
      traceId: this.traceId
    });
  }
  /**
   * @inheritDoc
   */
  updateWithContext(spanContext) {
    this.data = spanContext.data || {};
    this.description = spanContext.description;
    this.endTimestamp = spanContext.endTimestamp;
    this.op = spanContext.op;
    this.parentSpanId = spanContext.parentSpanId;
    this.sampled = spanContext.sampled;
    this.spanId = spanContext.spanId || this.spanId;
    this.startTimestamp = spanContext.startTimestamp || this.startTimestamp;
    this.status = spanContext.status;
    this.tags = spanContext.tags || {};
    this.traceId = spanContext.traceId || this.traceId;
    return this;
  }
  /**
   * @inheritDoc
   */
  getTraceContext() {
    return dropUndefinedKeys({
      data: Object.keys(this.data).length > 0 ? this.data : void 0,
      description: this.description,
      op: this.op,
      parent_span_id: this.parentSpanId,
      span_id: this.spanId,
      status: this.status,
      tags: Object.keys(this.tags).length > 0 ? this.tags : void 0,
      trace_id: this.traceId,
      origin: this.origin
    });
  }
  /**
   * @inheritDoc
   */
  toJSON() {
    return dropUndefinedKeys({
      data: Object.keys(this.data).length > 0 ? this.data : void 0,
      description: this.description,
      op: this.op,
      parent_span_id: this.parentSpanId,
      span_id: this.spanId,
      start_timestamp: this.startTimestamp,
      status: this.status,
      tags: Object.keys(this.tags).length > 0 ? this.tags : void 0,
      timestamp: this.endTimestamp,
      trace_id: this.traceId,
      origin: this.origin
    });
  }
};
__name(Span, "Span");
function spanStatusfromHttpCode(httpStatus) {
  if (httpStatus < 400 && httpStatus >= 100) {
    return "ok";
  }
  if (httpStatus >= 400 && httpStatus < 500) {
    switch (httpStatus) {
      case 401:
        return "unauthenticated";
      case 403:
        return "permission_denied";
      case 404:
        return "not_found";
      case 409:
        return "already_exists";
      case 413:
        return "failed_precondition";
      case 429:
        return "resource_exhausted";
      default:
        return "invalid_argument";
    }
  }
  if (httpStatus >= 500 && httpStatus < 600) {
    switch (httpStatus) {
      case 501:
        return "unimplemented";
      case 503:
        return "unavailable";
      case 504:
        return "deadline_exceeded";
      default:
        return "internal_error";
    }
  }
  return "unknown_error";
}
__name(spanStatusfromHttpCode, "spanStatusfromHttpCode");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/tracing/transaction.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/tracing/dynamicSamplingContext.js
init_import_meta_url();
function getDynamicSamplingContextFromClient(trace_id, client, scope) {
  const options29 = client.getOptions();
  const { publicKey: public_key } = client.getDsn() || {};
  const { segment: user_segment } = scope && scope.getUser() || {};
  const dsc = dropUndefinedKeys({
    environment: options29.environment || DEFAULT_ENVIRONMENT,
    release: options29.release,
    user_segment,
    public_key,
    trace_id
  });
  client.emit && client.emit("createDsc", dsc);
  return dsc;
}
__name(getDynamicSamplingContextFromClient, "getDynamicSamplingContextFromClient");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/tracing/transaction.js
var Transaction = class extends Span {
  /**
   * The reference to the current hub.
   */
  /**
   * This constructor should never be called manually. Those instrumenting tracing should use
   * `Sentry.startTransaction()`, and internal methods should use `hub.startTransaction()`.
   * @internal
   * @hideconstructor
   * @hidden
   */
  constructor(transactionContext, hub) {
    super(transactionContext);
    delete this.description;
    this._measurements = {};
    this._contexts = {};
    this._hub = hub || getCurrentHub();
    this._name = transactionContext.name || "";
    this.metadata = {
      source: "custom",
      ...transactionContext.metadata,
      spanMetadata: {}
    };
    this._trimEnd = transactionContext.trimEnd;
    this.transaction = this;
    const incomingDynamicSamplingContext = this.metadata.dynamicSamplingContext;
    if (incomingDynamicSamplingContext) {
      this._frozenDynamicSamplingContext = { ...incomingDynamicSamplingContext };
    }
  }
  /** Getter for `name` property */
  get name() {
    return this._name;
  }
  /** Setter for `name` property, which also sets `source` as custom */
  set name(newName) {
    this.setName(newName);
  }
  /**
   * JSDoc
   */
  setName(name, source = "custom") {
    this._name = name;
    this.metadata.source = source;
  }
  /**
   * Attaches SpanRecorder to the span itself
   * @param maxlen maximum number of spans that can be recorded
   */
  initSpanRecorder(maxlen = 1e3) {
    if (!this.spanRecorder) {
      this.spanRecorder = new SpanRecorder(maxlen);
    }
    this.spanRecorder.add(this);
  }
  /**
   * @inheritDoc
   */
  setContext(key, context2) {
    if (context2 === null) {
      delete this._contexts[key];
    } else {
      this._contexts[key] = context2;
    }
  }
  /**
   * @inheritDoc
   */
  setMeasurement(name, value, unit = "") {
    this._measurements[name] = { value, unit };
  }
  /**
   * @inheritDoc
   */
  setMetadata(newMetadata) {
    this.metadata = { ...this.metadata, ...newMetadata };
  }
  /**
   * @inheritDoc
   */
  finish(endTimestamp) {
    const transaction = this._finishTransaction(endTimestamp);
    if (!transaction) {
      return void 0;
    }
    return this._hub.captureEvent(transaction);
  }
  /**
   * @inheritDoc
   */
  toContext() {
    const spanContext = super.toContext();
    return dropUndefinedKeys({
      ...spanContext,
      name: this.name,
      trimEnd: this._trimEnd
    });
  }
  /**
   * @inheritDoc
   */
  updateWithContext(transactionContext) {
    super.updateWithContext(transactionContext);
    this.name = transactionContext.name || "";
    this._trimEnd = transactionContext.trimEnd;
    return this;
  }
  /**
   * @inheritdoc
   *
   * @experimental
   */
  getDynamicSamplingContext() {
    if (this._frozenDynamicSamplingContext) {
      return this._frozenDynamicSamplingContext;
    }
    const hub = this._hub || getCurrentHub();
    const client = hub.getClient();
    if (!client)
      return {};
    const scope = hub.getScope();
    const dsc = getDynamicSamplingContextFromClient(this.traceId, client, scope);
    const maybeSampleRate = this.metadata.sampleRate;
    if (maybeSampleRate !== void 0) {
      dsc.sample_rate = `${maybeSampleRate}`;
    }
    const source = this.metadata.source;
    if (source && source !== "url") {
      dsc.transaction = this.name;
    }
    if (this.sampled !== void 0) {
      dsc.sampled = String(this.sampled);
    }
    return dsc;
  }
  /**
   * Override the current hub with a new one.
   * Used if you want another hub to finish the transaction.
   *
   * @internal
   */
  setHub(hub) {
    this._hub = hub;
  }
  /**
   * Finish the transaction & prepare the event to send to Sentry.
   */
  _finishTransaction(endTimestamp) {
    if (this.endTimestamp !== void 0) {
      return void 0;
    }
    if (!this.name) {
      DEBUG_BUILD2 && logger2.warn("Transaction has no name, falling back to `<unlabeled transaction>`.");
      this.name = "<unlabeled transaction>";
    }
    super.finish(endTimestamp);
    const client = this._hub.getClient();
    if (client && client.emit) {
      client.emit("finishTransaction", this);
    }
    if (this.sampled !== true) {
      DEBUG_BUILD2 && logger2.log("[Tracing] Discarding transaction because its trace was not chosen to be sampled.");
      if (client) {
        client.recordDroppedEvent("sample_rate", "transaction");
      }
      return void 0;
    }
    const finishedSpans = this.spanRecorder ? this.spanRecorder.spans.filter((s) => s !== this && s.endTimestamp) : [];
    if (this._trimEnd && finishedSpans.length > 0) {
      this.endTimestamp = finishedSpans.reduce((prev, current) => {
        if (prev.endTimestamp && current.endTimestamp) {
          return prev.endTimestamp > current.endTimestamp ? prev : current;
        }
        return prev;
      }).endTimestamp;
    }
    const metadata = this.metadata;
    const transaction = {
      contexts: {
        ...this._contexts,
        // We don't want to override trace context
        trace: this.getTraceContext()
      },
      spans: finishedSpans,
      start_timestamp: this.startTimestamp,
      tags: this.tags,
      timestamp: this.endTimestamp,
      transaction: this.name,
      type: "transaction",
      sdkProcessingMetadata: {
        ...metadata,
        dynamicSamplingContext: this.getDynamicSamplingContext()
      },
      ...metadata.source && {
        transaction_info: {
          source: metadata.source
        }
      }
    };
    const hasMeasurements = Object.keys(this._measurements).length > 0;
    if (hasMeasurements) {
      DEBUG_BUILD2 && logger2.log(
        "[Measurements] Adding measurements to transaction",
        JSON.stringify(this._measurements, void 0, 2)
      );
      transaction.measurements = this._measurements;
    }
    DEBUG_BUILD2 && logger2.log(`[Tracing] Finishing ${this.op} transaction: ${this.name}.`);
    return transaction;
  }
};
__name(Transaction, "Transaction");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/tracing/sampling.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/utils/hasTracingEnabled.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/exports.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/utils/prepareEvent.js
init_import_meta_url();
function prepareEvent(options29, event, hint, scope, client) {
  const { normalizeDepth = 3, normalizeMaxBreadth = 1e3 } = options29;
  const prepared = {
    ...event,
    event_id: event.event_id || hint.event_id || uuid4(),
    timestamp: event.timestamp || dateTimestampInSeconds()
  };
  const integrations = hint.integrations || options29.integrations.map((i) => i.name);
  applyClientOptions(prepared, options29);
  applyIntegrationsMetadata(prepared, integrations);
  if (event.type === void 0) {
    applyDebugIds(prepared, options29.stackParser);
  }
  const finalScope = getFinalScope(scope, hint.captureContext);
  if (hint.mechanism) {
    addExceptionMechanism(prepared, hint.mechanism);
  }
  let result = resolvedSyncPromise(prepared);
  const clientEventProcessors = client && client.getEventProcessors ? client.getEventProcessors() : [];
  if (finalScope) {
    if (finalScope.getAttachments) {
      const attachments = [...hint.attachments || [], ...finalScope.getAttachments()];
      if (attachments.length) {
        hint.attachments = attachments;
      }
    }
    result = finalScope.applyToEvent(prepared, hint, clientEventProcessors);
  } else {
    result = notifyEventProcessors(
      [
        ...clientEventProcessors,
        // eslint-disable-next-line deprecation/deprecation
        ...getGlobalEventProcessors()
      ],
      prepared,
      hint
    );
  }
  return result.then((evt) => {
    if (evt) {
      applyDebugMeta(evt);
    }
    if (typeof normalizeDepth === "number" && normalizeDepth > 0) {
      return normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);
    }
    return evt;
  });
}
__name(prepareEvent, "prepareEvent");
function applyClientOptions(event, options29) {
  const { environment, release: release2, dist, maxValueLength = 250 } = options29;
  if (!("environment" in event)) {
    event.environment = "environment" in options29 ? environment : DEFAULT_ENVIRONMENT;
  }
  if (event.release === void 0 && release2 !== void 0) {
    event.release = release2;
  }
  if (event.dist === void 0 && dist !== void 0) {
    event.dist = dist;
  }
  if (event.message) {
    event.message = truncate3(event.message, maxValueLength);
  }
  const exception = event.exception && event.exception.values && event.exception.values[0];
  if (exception && exception.value) {
    exception.value = truncate3(exception.value, maxValueLength);
  }
  const request3 = event.request;
  if (request3 && request3.url) {
    request3.url = truncate3(request3.url, maxValueLength);
  }
}
__name(applyClientOptions, "applyClientOptions");
var debugIdStackParserCache = /* @__PURE__ */ new WeakMap();
function applyDebugIds(event, stackParser) {
  const debugIdMap = GLOBAL_OBJ._sentryDebugIds;
  if (!debugIdMap) {
    return;
  }
  let debugIdStackFramesCache;
  const cachedDebugIdStackFrameCache = debugIdStackParserCache.get(stackParser);
  if (cachedDebugIdStackFrameCache) {
    debugIdStackFramesCache = cachedDebugIdStackFrameCache;
  } else {
    debugIdStackFramesCache = /* @__PURE__ */ new Map();
    debugIdStackParserCache.set(stackParser, debugIdStackFramesCache);
  }
  const filenameDebugIdMap = Object.keys(debugIdMap).reduce((acc, debugIdStackTrace) => {
    let parsedStack;
    const cachedParsedStack = debugIdStackFramesCache.get(debugIdStackTrace);
    if (cachedParsedStack) {
      parsedStack = cachedParsedStack;
    } else {
      parsedStack = stackParser(debugIdStackTrace);
      debugIdStackFramesCache.set(debugIdStackTrace, parsedStack);
    }
    for (let i = parsedStack.length - 1; i >= 0; i--) {
      const stackFrame = parsedStack[i];
      if (stackFrame.filename) {
        acc[stackFrame.filename] = debugIdMap[debugIdStackTrace];
        break;
      }
    }
    return acc;
  }, {});
  try {
    event.exception.values.forEach((exception) => {
      exception.stacktrace.frames.forEach((frame) => {
        if (frame.filename) {
          frame.debug_id = filenameDebugIdMap[frame.filename];
        }
      });
    });
  } catch (e3) {
  }
}
__name(applyDebugIds, "applyDebugIds");
function applyDebugMeta(event) {
  const filenameDebugIdMap = {};
  try {
    event.exception.values.forEach((exception) => {
      exception.stacktrace.frames.forEach((frame) => {
        if (frame.debug_id) {
          if (frame.abs_path) {
            filenameDebugIdMap[frame.abs_path] = frame.debug_id;
          } else if (frame.filename) {
            filenameDebugIdMap[frame.filename] = frame.debug_id;
          }
          delete frame.debug_id;
        }
      });
    });
  } catch (e3) {
  }
  if (Object.keys(filenameDebugIdMap).length === 0) {
    return;
  }
  event.debug_meta = event.debug_meta || {};
  event.debug_meta.images = event.debug_meta.images || [];
  const images = event.debug_meta.images;
  Object.keys(filenameDebugIdMap).forEach((filename) => {
    images.push({
      type: "sourcemap",
      code_file: filename,
      debug_id: filenameDebugIdMap[filename]
    });
  });
}
__name(applyDebugMeta, "applyDebugMeta");
function applyIntegrationsMetadata(event, integrationNames) {
  if (integrationNames.length > 0) {
    event.sdk = event.sdk || {};
    event.sdk.integrations = [...event.sdk.integrations || [], ...integrationNames];
  }
}
__name(applyIntegrationsMetadata, "applyIntegrationsMetadata");
function normalizeEvent(event, depth, maxBreadth) {
  if (!event) {
    return null;
  }
  const normalized = {
    ...event,
    ...event.breadcrumbs && {
      breadcrumbs: event.breadcrumbs.map((b2) => ({
        ...b2,
        ...b2.data && {
          data: normalize2(b2.data, depth, maxBreadth)
        }
      }))
    },
    ...event.user && {
      user: normalize2(event.user, depth, maxBreadth)
    },
    ...event.contexts && {
      contexts: normalize2(event.contexts, depth, maxBreadth)
    },
    ...event.extra && {
      extra: normalize2(event.extra, depth, maxBreadth)
    }
  };
  if (event.contexts && event.contexts.trace && normalized.contexts) {
    normalized.contexts.trace = event.contexts.trace;
    if (event.contexts.trace.data) {
      normalized.contexts.trace.data = normalize2(event.contexts.trace.data, depth, maxBreadth);
    }
  }
  if (event.spans) {
    normalized.spans = event.spans.map((span) => {
      if (span.data) {
        span.data = normalize2(span.data, depth, maxBreadth);
      }
      return span;
    });
  }
  return normalized;
}
__name(normalizeEvent, "normalizeEvent");
function getFinalScope(scope, captureContext) {
  if (!captureContext) {
    return scope;
  }
  const finalScope = scope ? scope.clone() : new Scope();
  finalScope.update(captureContext);
  return finalScope;
}
__name(getFinalScope, "getFinalScope");
function parseEventHintOrCaptureContext(hint) {
  if (!hint) {
    return void 0;
  }
  if (hintIsScopeOrFunction(hint)) {
    return { captureContext: hint };
  }
  if (hintIsScopeContext(hint)) {
    return {
      captureContext: hint
    };
  }
  return hint;
}
__name(parseEventHintOrCaptureContext, "parseEventHintOrCaptureContext");
function hintIsScopeOrFunction(hint) {
  return hint instanceof Scope || typeof hint === "function";
}
__name(hintIsScopeOrFunction, "hintIsScopeOrFunction");
var captureContextKeys = [
  "user",
  "level",
  "extra",
  "contexts",
  "tags",
  "fingerprint",
  "requestSession",
  "propagationContext"
];
function hintIsScopeContext(hint) {
  return Object.keys(hint).some((key) => captureContextKeys.includes(key));
}
__name(hintIsScopeContext, "hintIsScopeContext");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/exports.js
function captureException(exception, hint) {
  return getCurrentHub().captureException(exception, parseEventHintOrCaptureContext(hint));
}
__name(captureException, "captureException");
function addBreadcrumb(breadcrumb) {
  getCurrentHub().addBreadcrumb(breadcrumb);
}
__name(addBreadcrumb, "addBreadcrumb");
async function close(timeout) {
  const client = getClient();
  if (client) {
    return client.close(timeout);
  }
  DEBUG_BUILD2 && logger2.warn("Cannot flush events and disable SDK. No client defined.");
  return Promise.resolve(false);
}
__name(close, "close");
function getClient() {
  return getCurrentHub().getClient();
}
__name(getClient, "getClient");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/utils/hasTracingEnabled.js
function hasTracingEnabled(maybeOptions) {
  if (typeof __SENTRY_TRACING__ === "boolean" && !__SENTRY_TRACING__) {
    return false;
  }
  const client = getClient();
  const options29 = maybeOptions || client && client.getOptions();
  return !!options29 && (options29.enableTracing || "tracesSampleRate" in options29 || "tracesSampler" in options29);
}
__name(hasTracingEnabled, "hasTracingEnabled");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/tracing/sampling.js
function sampleTransaction(transaction, options29, samplingContext) {
  if (!hasTracingEnabled(options29)) {
    transaction.sampled = false;
    return transaction;
  }
  if (transaction.sampled !== void 0) {
    transaction.setMetadata({
      sampleRate: Number(transaction.sampled)
    });
    return transaction;
  }
  let sampleRate;
  if (typeof options29.tracesSampler === "function") {
    sampleRate = options29.tracesSampler(samplingContext);
    transaction.setMetadata({
      sampleRate: Number(sampleRate)
    });
  } else if (samplingContext.parentSampled !== void 0) {
    sampleRate = samplingContext.parentSampled;
  } else if (typeof options29.tracesSampleRate !== "undefined") {
    sampleRate = options29.tracesSampleRate;
    transaction.setMetadata({
      sampleRate: Number(sampleRate)
    });
  } else {
    sampleRate = 1;
    transaction.setMetadata({
      sampleRate
    });
  }
  if (!isValidSampleRate(sampleRate)) {
    DEBUG_BUILD2 && logger2.warn("[Tracing] Discarding transaction because of invalid sample rate.");
    transaction.sampled = false;
    return transaction;
  }
  if (!sampleRate) {
    DEBUG_BUILD2 && logger2.log(
      `[Tracing] Discarding transaction because ${typeof options29.tracesSampler === "function" ? "tracesSampler returned 0 or false" : "a negative sampling decision was inherited or tracesSampleRate is set to 0"}`
    );
    transaction.sampled = false;
    return transaction;
  }
  transaction.sampled = Math.random() < sampleRate;
  if (!transaction.sampled) {
    DEBUG_BUILD2 && logger2.log(
      `[Tracing] Discarding transaction because it's not included in the random sample (sampling rate = ${Number(
        sampleRate
      )})`
    );
    return transaction;
  }
  DEBUG_BUILD2 && logger2.log(`[Tracing] starting ${transaction.op} transaction - ${transaction.name}`);
  return transaction;
}
__name(sampleTransaction, "sampleTransaction");
function isValidSampleRate(rate) {
  if (isNaN2(rate) || !(typeof rate === "number" || typeof rate === "boolean")) {
    DEBUG_BUILD2 && logger2.warn(
      `[Tracing] Given sample rate is invalid. Sample rate must be a boolean or a number between 0 and 1. Got ${JSON.stringify(
        rate
      )} of type ${JSON.stringify(typeof rate)}.`
    );
    return false;
  }
  if (rate < 0 || rate > 1) {
    DEBUG_BUILD2 && logger2.warn(`[Tracing] Given sample rate is invalid. Sample rate must be between 0 and 1. Got ${rate}.`);
    return false;
  }
  return true;
}
__name(isValidSampleRate, "isValidSampleRate");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/tracing/hubextensions.js
function traceHeaders() {
  const scope = this.getScope();
  const span = scope.getSpan();
  return span ? {
    "sentry-trace": span.toTraceparent()
  } : {};
}
__name(traceHeaders, "traceHeaders");
function _startTransaction(transactionContext, customSamplingContext) {
  const client = this.getClient();
  const options29 = client && client.getOptions() || {};
  const configInstrumenter = options29.instrumenter || "sentry";
  const transactionInstrumenter = transactionContext.instrumenter || "sentry";
  if (configInstrumenter !== transactionInstrumenter) {
    DEBUG_BUILD2 && logger2.error(
      `A transaction was started with instrumenter=\`${transactionInstrumenter}\`, but the SDK is configured with the \`${configInstrumenter}\` instrumenter.
The transaction will not be sampled. Please use the ${configInstrumenter} instrumentation to start transactions.`
    );
    transactionContext.sampled = false;
  }
  let transaction = new Transaction(transactionContext, this);
  transaction = sampleTransaction(transaction, options29, {
    parentSampled: transactionContext.parentSampled,
    transactionContext,
    ...customSamplingContext
  });
  if (transaction.sampled) {
    transaction.initSpanRecorder(options29._experiments && options29._experiments.maxSpans);
  }
  if (client && client.emit) {
    client.emit("startTransaction", transaction);
  }
  return transaction;
}
__name(_startTransaction, "_startTransaction");
function addTracingExtensions() {
  const carrier = getMainCarrier();
  if (!carrier.__SENTRY__) {
    return;
  }
  carrier.__SENTRY__.extensions = carrier.__SENTRY__.extensions || {};
  if (!carrier.__SENTRY__.extensions.startTransaction) {
    carrier.__SENTRY__.extensions.startTransaction = _startTransaction;
  }
  if (!carrier.__SENTRY__.extensions.traceHeaders) {
    carrier.__SENTRY__.extensions.traceHeaders = traceHeaders;
  }
  registerErrorInstrumentation();
}
__name(addTracingExtensions, "addTracingExtensions");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/tracing/trace.js
init_import_meta_url();
function trace(context2, callback, onError = () => {
}) {
  const ctx = normalizeContext(context2);
  const hub = getCurrentHub();
  const scope = hub.getScope();
  const parentSpan = scope.getSpan();
  const activeSpan = createChildSpanOrTransaction(hub, parentSpan, ctx);
  scope.setSpan(activeSpan);
  function finishAndSetSpan() {
    activeSpan && activeSpan.finish();
    hub.getScope().setSpan(parentSpan);
  }
  __name(finishAndSetSpan, "finishAndSetSpan");
  let maybePromiseResult;
  try {
    maybePromiseResult = callback(activeSpan);
  } catch (e3) {
    activeSpan && activeSpan.setStatus("internal_error");
    onError(e3);
    finishAndSetSpan();
    throw e3;
  }
  if (isThenable(maybePromiseResult)) {
    Promise.resolve(maybePromiseResult).then(
      () => {
        finishAndSetSpan();
      },
      (e3) => {
        activeSpan && activeSpan.setStatus("internal_error");
        onError(e3);
        finishAndSetSpan();
      }
    );
  } else {
    finishAndSetSpan();
  }
  return maybePromiseResult;
}
__name(trace, "trace");
function createChildSpanOrTransaction(hub, parentSpan, ctx) {
  if (!hasTracingEnabled()) {
    return void 0;
  }
  return parentSpan ? parentSpan.startChild(ctx) : hub.startTransaction(ctx);
}
__name(createChildSpanOrTransaction, "createChildSpanOrTransaction");
function normalizeContext(context2) {
  const ctx = { ...context2 };
  if (ctx.name !== void 0 && ctx.description === void 0) {
    ctx.description = ctx.name;
  }
  return ctx;
}
__name(normalizeContext, "normalizeContext");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/envelope.js
init_import_meta_url();
function enhanceEventWithSdkInfo(event, sdkInfo) {
  if (!sdkInfo) {
    return event;
  }
  event.sdk = event.sdk || {};
  event.sdk.name = event.sdk.name || sdkInfo.name;
  event.sdk.version = event.sdk.version || sdkInfo.version;
  event.sdk.integrations = [...event.sdk.integrations || [], ...sdkInfo.integrations || []];
  event.sdk.packages = [...event.sdk.packages || [], ...sdkInfo.packages || []];
  return event;
}
__name(enhanceEventWithSdkInfo, "enhanceEventWithSdkInfo");
function createSessionEnvelope(session, dsn, metadata, tunnel) {
  const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);
  const envelopeHeaders = {
    sent_at: (/* @__PURE__ */ new Date()).toISOString(),
    ...sdkInfo && { sdk: sdkInfo },
    ...!!tunnel && dsn && { dsn: dsnToString(dsn) }
  };
  const envelopeItem = "aggregates" in session ? [{ type: "sessions" }, session] : [{ type: "session" }, session.toJSON()];
  return createEnvelope(envelopeHeaders, [envelopeItem]);
}
__name(createSessionEnvelope, "createSessionEnvelope");
function createEventEnvelope(event, dsn, metadata, tunnel) {
  const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);
  const eventType = event.type && event.type !== "replay_event" ? event.type : "event";
  enhanceEventWithSdkInfo(event, metadata && metadata.sdk);
  const envelopeHeaders = createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn);
  delete event.sdkProcessingMetadata;
  const eventItem = [{ type: eventType }, event];
  return createEnvelope(envelopeHeaders, [eventItem]);
}
__name(createEventEnvelope, "createEventEnvelope");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/sessionflusher.js
init_import_meta_url();
var SessionFlusher = class {
  constructor(client, attrs) {
    this._client = client;
    this.flushTimeout = 60;
    this._pendingAggregates = {};
    this._isEnabled = true;
    this._intervalId = setInterval(() => this.flush(), this.flushTimeout * 1e3);
    this._sessionAttrs = attrs;
  }
  /** Checks if `pendingAggregates` has entries, and if it does flushes them by calling `sendSession` */
  flush() {
    const sessionAggregates = this.getSessionAggregates();
    if (sessionAggregates.aggregates.length === 0) {
      return;
    }
    this._pendingAggregates = {};
    this._client.sendSession(sessionAggregates);
  }
  /** Massages the entries in `pendingAggregates` and returns aggregated sessions */
  getSessionAggregates() {
    const aggregates = Object.keys(this._pendingAggregates).map((key) => {
      return this._pendingAggregates[parseInt(key)];
    });
    const sessionAggregates = {
      attrs: this._sessionAttrs,
      aggregates
    };
    return dropUndefinedKeys(sessionAggregates);
  }
  /** JSDoc */
  close() {
    clearInterval(this._intervalId);
    this._isEnabled = false;
    this.flush();
  }
  /**
   * Wrapper function for _incrementSessionStatusCount that checks if the instance of SessionFlusher is enabled then
   * fetches the session status of the request from `Scope.getRequestSession().status` on the scope and passes them to
   * `_incrementSessionStatusCount` along with the start date
   */
  incrementSessionStatusCount() {
    if (!this._isEnabled) {
      return;
    }
    const scope = getCurrentHub().getScope();
    const requestSession = scope.getRequestSession();
    if (requestSession && requestSession.status) {
      this._incrementSessionStatusCount(requestSession.status, /* @__PURE__ */ new Date());
      scope.setRequestSession(void 0);
    }
  }
  /**
   * Increments status bucket in pendingAggregates buffer (internal state) corresponding to status of
   * the session received
   */
  _incrementSessionStatusCount(status2, date) {
    const sessionStartedTrunc = new Date(date).setSeconds(0, 0);
    this._pendingAggregates[sessionStartedTrunc] = this._pendingAggregates[sessionStartedTrunc] || {};
    const aggregationCounts = this._pendingAggregates[sessionStartedTrunc];
    if (!aggregationCounts.started) {
      aggregationCounts.started = new Date(sessionStartedTrunc).toISOString();
    }
    switch (status2) {
      case "errored":
        aggregationCounts.errored = (aggregationCounts.errored || 0) + 1;
        return aggregationCounts.errored;
      case "ok":
        aggregationCounts.exited = (aggregationCounts.exited || 0) + 1;
        return aggregationCounts.exited;
      default:
        aggregationCounts.crashed = (aggregationCounts.crashed || 0) + 1;
        return aggregationCounts.crashed;
    }
  }
};
__name(SessionFlusher, "SessionFlusher");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/api.js
init_import_meta_url();
var SENTRY_API_VERSION = "7";
function getBaseApiEndpoint(dsn) {
  const protocol = dsn.protocol ? `${dsn.protocol}:` : "";
  const port2 = dsn.port ? `:${dsn.port}` : "";
  return `${protocol}//${dsn.host}${port2}${dsn.path ? `/${dsn.path}` : ""}/api/`;
}
__name(getBaseApiEndpoint, "getBaseApiEndpoint");
function _getIngestEndpoint(dsn) {
  return `${getBaseApiEndpoint(dsn)}${dsn.projectId}/envelope/`;
}
__name(_getIngestEndpoint, "_getIngestEndpoint");
function _encodedAuth(dsn, sdkInfo) {
  return urlEncode({
    // We send only the minimum set of required information. See
    // https://github.com/getsentry/sentry-javascript/issues/2572.
    sentry_key: dsn.publicKey,
    sentry_version: SENTRY_API_VERSION,
    ...sdkInfo && { sentry_client: `${sdkInfo.name}/${sdkInfo.version}` }
  });
}
__name(_encodedAuth, "_encodedAuth");
function getEnvelopeEndpointWithUrlEncodedAuth(dsn, tunnelOrOptions = {}) {
  const tunnel = typeof tunnelOrOptions === "string" ? tunnelOrOptions : tunnelOrOptions.tunnel;
  const sdkInfo = typeof tunnelOrOptions === "string" || !tunnelOrOptions._metadata ? void 0 : tunnelOrOptions._metadata.sdk;
  return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, sdkInfo)}`;
}
__name(getEnvelopeEndpointWithUrlEncodedAuth, "getEnvelopeEndpointWithUrlEncodedAuth");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/baseclient.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/integration.js
init_import_meta_url();
var installedIntegrations = [];
function filterDuplicates(integrations) {
  const integrationsByName = {};
  integrations.forEach((currentInstance) => {
    const { name } = currentInstance;
    const existingInstance = integrationsByName[name];
    if (existingInstance && !existingInstance.isDefaultInstance && currentInstance.isDefaultInstance) {
      return;
    }
    integrationsByName[name] = currentInstance;
  });
  return Object.keys(integrationsByName).map((k2) => integrationsByName[k2]);
}
__name(filterDuplicates, "filterDuplicates");
function getIntegrationsToSetup(options29) {
  const defaultIntegrations2 = options29.defaultIntegrations || [];
  const userIntegrations = options29.integrations;
  defaultIntegrations2.forEach((integration) => {
    integration.isDefaultInstance = true;
  });
  let integrations;
  if (Array.isArray(userIntegrations)) {
    integrations = [...defaultIntegrations2, ...userIntegrations];
  } else if (typeof userIntegrations === "function") {
    integrations = arrayify(userIntegrations(defaultIntegrations2));
  } else {
    integrations = defaultIntegrations2;
  }
  const finalIntegrations = filterDuplicates(integrations);
  const debugIndex = findIndex(finalIntegrations, (integration) => integration.name === "Debug");
  if (debugIndex !== -1) {
    const [debugInstance] = finalIntegrations.splice(debugIndex, 1);
    finalIntegrations.push(debugInstance);
  }
  return finalIntegrations;
}
__name(getIntegrationsToSetup, "getIntegrationsToSetup");
function setupIntegrations(client, integrations) {
  const integrationIndex = {};
  integrations.forEach((integration) => {
    if (integration) {
      setupIntegration(client, integration, integrationIndex);
    }
  });
  return integrationIndex;
}
__name(setupIntegrations, "setupIntegrations");
function setupIntegration(client, integration, integrationIndex) {
  integrationIndex[integration.name] = integration;
  if (installedIntegrations.indexOf(integration.name) === -1) {
    integration.setupOnce(addGlobalEventProcessor, getCurrentHub);
    installedIntegrations.push(integration.name);
  }
  if (integration.setup && typeof integration.setup === "function") {
    integration.setup(client);
  }
  if (client.on && typeof integration.preprocessEvent === "function") {
    const callback = integration.preprocessEvent.bind(integration);
    client.on("preprocessEvent", (event, hint) => callback(event, hint, client));
  }
  if (client.addEventProcessor && typeof integration.processEvent === "function") {
    const callback = integration.processEvent.bind(integration);
    const processor = Object.assign((event, hint) => callback(event, hint, client), {
      id: integration.name
    });
    client.addEventProcessor(processor);
  }
  DEBUG_BUILD2 && logger2.log(`Integration installed: ${integration.name}`);
}
__name(setupIntegration, "setupIntegration");
function findIndex(arr, callback) {
  for (let i = 0; i < arr.length; i++) {
    if (callback(arr[i]) === true) {
      return i;
    }
  }
  return -1;
}
__name(findIndex, "findIndex");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/baseclient.js
var ALREADY_SEEN_ERROR = "Not capturing exception because it's already been captured.";
var BaseClient = class {
  /** Options passed to the SDK. */
  /** The client Dsn, if specified in options. Without this Dsn, the SDK will be disabled. */
  /** Array of set up integrations. */
  /** Indicates whether this client's integrations have been set up. */
  /** Number of calls being processed */
  /** Holds flushable  */
  // eslint-disable-next-line @typescript-eslint/ban-types
  /**
   * Initializes this client instance.
   *
   * @param options Options for the client.
   */
  constructor(options29) {
    this._options = options29;
    this._integrations = {};
    this._integrationsInitialized = false;
    this._numProcessing = 0;
    this._outcomes = {};
    this._hooks = {};
    this._eventProcessors = [];
    if (options29.dsn) {
      this._dsn = makeDsn(options29.dsn);
    } else {
      DEBUG_BUILD2 && logger2.warn("No DSN provided, client will not send events.");
    }
    if (this._dsn) {
      const url4 = getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, options29);
      this._transport = options29.transport({
        recordDroppedEvent: this.recordDroppedEvent.bind(this),
        ...options29.transportOptions,
        url: url4
      });
    }
  }
  /**
   * @inheritDoc
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
  captureException(exception, hint, scope) {
    if (checkOrSetAlreadyCaught(exception)) {
      DEBUG_BUILD2 && logger2.log(ALREADY_SEEN_ERROR);
      return;
    }
    let eventId = hint && hint.event_id;
    this._process(
      this.eventFromException(exception, hint).then((event) => this._captureEvent(event, hint, scope)).then((result) => {
        eventId = result;
      })
    );
    return eventId;
  }
  /**
   * @inheritDoc
   */
  captureMessage(message, level, hint, scope) {
    let eventId = hint && hint.event_id;
    const promisedEvent = isPrimitive(message) ? this.eventFromMessage(String(message), level, hint) : this.eventFromException(message, hint);
    this._process(
      promisedEvent.then((event) => this._captureEvent(event, hint, scope)).then((result) => {
        eventId = result;
      })
    );
    return eventId;
  }
  /**
   * @inheritDoc
   */
  captureEvent(event, hint, scope) {
    if (hint && hint.originalException && checkOrSetAlreadyCaught(hint.originalException)) {
      DEBUG_BUILD2 && logger2.log(ALREADY_SEEN_ERROR);
      return;
    }
    let eventId = hint && hint.event_id;
    this._process(
      this._captureEvent(event, hint, scope).then((result) => {
        eventId = result;
      })
    );
    return eventId;
  }
  /**
   * @inheritDoc
   */
  captureSession(session) {
    if (!(typeof session.release === "string")) {
      DEBUG_BUILD2 && logger2.warn("Discarded session because of missing or non-string release");
    } else {
      this.sendSession(session);
      updateSession(session, { init: false });
    }
  }
  /**
   * @inheritDoc
   */
  getDsn() {
    return this._dsn;
  }
  /**
   * @inheritDoc
   */
  getOptions() {
    return this._options;
  }
  /**
   * @see SdkMetadata in @sentry/types
   *
   * @return The metadata of the SDK
   */
  getSdkMetadata() {
    return this._options._metadata;
  }
  /**
   * @inheritDoc
   */
  getTransport() {
    return this._transport;
  }
  /**
   * @inheritDoc
   */
  flush(timeout) {
    const transport = this._transport;
    if (transport) {
      return this._isClientDoneProcessing(timeout).then((clientFinished) => {
        return transport.flush(timeout).then((transportFlushed) => clientFinished && transportFlushed);
      });
    } else {
      return resolvedSyncPromise(true);
    }
  }
  /**
   * @inheritDoc
   */
  close(timeout) {
    return this.flush(timeout).then((result) => {
      this.getOptions().enabled = false;
      return result;
    });
  }
  /** Get all installed event processors. */
  getEventProcessors() {
    return this._eventProcessors;
  }
  /** @inheritDoc */
  addEventProcessor(eventProcessor) {
    this._eventProcessors.push(eventProcessor);
  }
  /**
   * Sets up the integrations
   */
  setupIntegrations(forceInitialize) {
    if (forceInitialize && !this._integrationsInitialized || this._isEnabled() && !this._integrationsInitialized) {
      this._integrations = setupIntegrations(this, this._options.integrations);
      this._integrationsInitialized = true;
    }
  }
  /**
   * Gets an installed integration by its `id`.
   *
   * @returns The installed integration or `undefined` if no integration with that `id` was installed.
   */
  getIntegrationById(integrationId) {
    return this._integrations[integrationId];
  }
  /**
   * @inheritDoc
   */
  getIntegration(integration) {
    try {
      return this._integrations[integration.id] || null;
    } catch (_oO) {
      DEBUG_BUILD2 && logger2.warn(`Cannot retrieve integration ${integration.id} from the current Client`);
      return null;
    }
  }
  /**
   * @inheritDoc
   */
  addIntegration(integration) {
    setupIntegration(this, integration, this._integrations);
  }
  /**
   * @inheritDoc
   */
  sendEvent(event, hint = {}) {
    this.emit("beforeSendEvent", event, hint);
    let env5 = createEventEnvelope(event, this._dsn, this._options._metadata, this._options.tunnel);
    for (const attachment of hint.attachments || []) {
      env5 = addItemToEnvelope(
        env5,
        createAttachmentEnvelopeItem(
          attachment,
          this._options.transportOptions && this._options.transportOptions.textEncoder
        )
      );
    }
    const promise = this._sendEnvelope(env5);
    if (promise) {
      promise.then((sendResponse) => this.emit("afterSendEvent", event, sendResponse), null);
    }
  }
  /**
   * @inheritDoc
   */
  sendSession(session) {
    const env5 = createSessionEnvelope(session, this._dsn, this._options._metadata, this._options.tunnel);
    void this._sendEnvelope(env5);
  }
  /**
   * @inheritDoc
   */
  recordDroppedEvent(reason, category, _event) {
    if (this._options.sendClientReports) {
      const key = `${reason}:${category}`;
      DEBUG_BUILD2 && logger2.log(`Adding outcome: "${key}"`);
      this._outcomes[key] = this._outcomes[key] + 1 || 1;
    }
  }
  // Keep on() & emit() signatures in sync with types' client.ts interface
  /* eslint-disable @typescript-eslint/unified-signatures */
  /** @inheritdoc */
  /** @inheritdoc */
  on(hook, callback) {
    if (!this._hooks[hook]) {
      this._hooks[hook] = [];
    }
    this._hooks[hook].push(callback);
  }
  /** @inheritdoc */
  /** @inheritdoc */
  emit(hook, ...rest) {
    if (this._hooks[hook]) {
      this._hooks[hook].forEach((callback) => callback(...rest));
    }
  }
  /* eslint-enable @typescript-eslint/unified-signatures */
  /** Updates existing session based on the provided event */
  _updateSessionFromEvent(session, event) {
    let crashed = false;
    let errored = false;
    const exceptions = event.exception && event.exception.values;
    if (exceptions) {
      errored = true;
      for (const ex of exceptions) {
        const mechanism = ex.mechanism;
        if (mechanism && mechanism.handled === false) {
          crashed = true;
          break;
        }
      }
    }
    const sessionNonTerminal = session.status === "ok";
    const shouldUpdateAndSend = sessionNonTerminal && session.errors === 0 || sessionNonTerminal && crashed;
    if (shouldUpdateAndSend) {
      updateSession(session, {
        ...crashed && { status: "crashed" },
        errors: session.errors || Number(errored || crashed)
      });
      this.captureSession(session);
    }
  }
  /**
   * Determine if the client is finished processing. Returns a promise because it will wait `timeout` ms before saying
   * "no" (resolving to `false`) in order to give the client a chance to potentially finish first.
   *
   * @param timeout The time, in ms, after which to resolve to `false` if the client is still busy. Passing `0` (or not
   * passing anything) will make the promise wait as long as it takes for processing to finish before resolving to
   * `true`.
   * @returns A promise which will resolve to `true` if processing is already done or finishes before the timeout, and
   * `false` otherwise
   */
  _isClientDoneProcessing(timeout) {
    return new SyncPromise((resolve19) => {
      let ticked = 0;
      const tick = 1;
      const interval2 = setInterval(() => {
        if (this._numProcessing == 0) {
          clearInterval(interval2);
          resolve19(true);
        } else {
          ticked += tick;
          if (timeout && ticked >= timeout) {
            clearInterval(interval2);
            resolve19(false);
          }
        }
      }, tick);
    });
  }
  /** Determines whether this SDK is enabled and a transport is present. */
  _isEnabled() {
    return this.getOptions().enabled !== false && this._transport !== void 0;
  }
  /**
   * Adds common information to events.
   *
   * The information includes release and environment from `options`,
   * breadcrumbs and context (extra, tags and user) from the scope.
   *
   * Information that is already present in the event is never overwritten. For
   * nested objects, such as the context, keys are merged.
   *
   * @param event The original event.
   * @param hint May contain additional information about the original exception.
   * @param scope A scope containing event metadata.
   * @returns A new event with more information.
   */
  _prepareEvent(event, hint, scope) {
    const options29 = this.getOptions();
    const integrations = Object.keys(this._integrations);
    if (!hint.integrations && integrations.length > 0) {
      hint.integrations = integrations;
    }
    this.emit("preprocessEvent", event, hint);
    return prepareEvent(options29, event, hint, scope, this).then((evt) => {
      if (evt === null) {
        return evt;
      }
      const { propagationContext } = evt.sdkProcessingMetadata || {};
      const trace2 = evt.contexts && evt.contexts.trace;
      if (!trace2 && propagationContext) {
        const { traceId: trace_id, spanId, parentSpanId, dsc } = propagationContext;
        evt.contexts = {
          trace: {
            trace_id,
            span_id: spanId,
            parent_span_id: parentSpanId
          },
          ...evt.contexts
        };
        const dynamicSamplingContext = dsc ? dsc : getDynamicSamplingContextFromClient(trace_id, this, scope);
        evt.sdkProcessingMetadata = {
          dynamicSamplingContext,
          ...evt.sdkProcessingMetadata
        };
      }
      return evt;
    });
  }
  /**
   * Processes the event and logs an error in case of rejection
   * @param event
   * @param hint
   * @param scope
   */
  _captureEvent(event, hint = {}, scope) {
    return this._processEvent(event, hint, scope).then(
      (finalEvent) => {
        return finalEvent.event_id;
      },
      (reason) => {
        if (DEBUG_BUILD2) {
          const sentryError = reason;
          if (sentryError.logLevel === "log") {
            logger2.log(sentryError.message);
          } else {
            logger2.warn(sentryError);
          }
        }
        return void 0;
      }
    );
  }
  /**
   * Processes an event (either error or message) and sends it to Sentry.
   *
   * This also adds breadcrumbs and context information to the event. However,
   * platform specific meta data (such as the User's IP address) must be added
   * by the SDK implementor.
   *
   *
   * @param event The event to send to Sentry.
   * @param hint May contain additional information about the original exception.
   * @param scope A scope containing event metadata.
   * @returns A SyncPromise that resolves with the event or rejects in case event was/will not be send.
   */
  _processEvent(event, hint, scope) {
    const options29 = this.getOptions();
    const { sampleRate } = options29;
    const isTransaction = isTransactionEvent(event);
    const isError2 = isErrorEvent2(event);
    const eventType = event.type || "error";
    const beforeSendLabel = `before send for type \`${eventType}\``;
    if (isError2 && typeof sampleRate === "number" && Math.random() > sampleRate) {
      this.recordDroppedEvent("sample_rate", "error", event);
      return rejectedSyncPromise(
        new SentryError(
          `Discarding event because it's not included in the random sample (sampling rate = ${sampleRate})`,
          "log"
        )
      );
    }
    const dataCategory = eventType === "replay_event" ? "replay" : eventType;
    return this._prepareEvent(event, hint, scope).then((prepared) => {
      if (prepared === null) {
        this.recordDroppedEvent("event_processor", dataCategory, event);
        throw new SentryError("An event processor returned `null`, will not send event.", "log");
      }
      const isInternalException = hint.data && hint.data.__sentry__ === true;
      if (isInternalException) {
        return prepared;
      }
      const result = processBeforeSend(options29, prepared, hint);
      return _validateBeforeSendResult(result, beforeSendLabel);
    }).then((processedEvent) => {
      if (processedEvent === null) {
        this.recordDroppedEvent("before_send", dataCategory, event);
        throw new SentryError(`${beforeSendLabel} returned \`null\`, will not send event.`, "log");
      }
      const session = scope && scope.getSession();
      if (!isTransaction && session) {
        this._updateSessionFromEvent(session, processedEvent);
      }
      const transactionInfo = processedEvent.transaction_info;
      if (isTransaction && transactionInfo && processedEvent.transaction !== event.transaction) {
        const source = "custom";
        processedEvent.transaction_info = {
          ...transactionInfo,
          source
        };
      }
      this.sendEvent(processedEvent, hint);
      return processedEvent;
    }).then(null, (reason) => {
      if (reason instanceof SentryError) {
        throw reason;
      }
      this.captureException(reason, {
        data: {
          __sentry__: true
        },
        originalException: reason
      });
      throw new SentryError(
        `Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.
Reason: ${reason}`
      );
    });
  }
  /**
   * Occupies the client with processing and event
   */
  _process(promise) {
    this._numProcessing++;
    void promise.then(
      (value) => {
        this._numProcessing--;
        return value;
      },
      (reason) => {
        this._numProcessing--;
        return reason;
      }
    );
  }
  /**
   * @inheritdoc
   */
  _sendEnvelope(envelope) {
    this.emit("beforeEnvelope", envelope);
    if (this._isEnabled() && this._transport) {
      return this._transport.send(envelope).then(null, (reason) => {
        DEBUG_BUILD2 && logger2.error("Error while sending event:", reason);
      });
    } else {
      DEBUG_BUILD2 && logger2.error("Transport disabled");
    }
  }
  /**
   * Clears outcomes on this client and returns them.
   */
  _clearOutcomes() {
    const outcomes = this._outcomes;
    this._outcomes = {};
    return Object.keys(outcomes).map((key) => {
      const [reason, category] = key.split(":");
      return {
        reason,
        category,
        quantity: outcomes[key]
      };
    });
  }
  /**
   * @inheritDoc
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
};
__name(BaseClient, "BaseClient");
function _validateBeforeSendResult(beforeSendResult, beforeSendLabel) {
  const invalidValueError = `${beforeSendLabel} must return \`null\` or a valid event.`;
  if (isThenable(beforeSendResult)) {
    return beforeSendResult.then(
      (event) => {
        if (!isPlainObject(event) && event !== null) {
          throw new SentryError(invalidValueError);
        }
        return event;
      },
      (e3) => {
        throw new SentryError(`${beforeSendLabel} rejected with ${e3}`);
      }
    );
  } else if (!isPlainObject(beforeSendResult) && beforeSendResult !== null) {
    throw new SentryError(invalidValueError);
  }
  return beforeSendResult;
}
__name(_validateBeforeSendResult, "_validateBeforeSendResult");
function processBeforeSend(options29, event, hint) {
  const { beforeSend, beforeSendTransaction } = options29;
  if (isErrorEvent2(event) && beforeSend) {
    return beforeSend(event, hint);
  }
  if (isTransactionEvent(event) && beforeSendTransaction) {
    return beforeSendTransaction(event, hint);
  }
  return event;
}
__name(processBeforeSend, "processBeforeSend");
function isErrorEvent2(event) {
  return event.type === void 0;
}
__name(isErrorEvent2, "isErrorEvent");
function isTransactionEvent(event) {
  return event.type === "transaction";
}
__name(isTransactionEvent, "isTransactionEvent");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/server-runtime-client.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/checkin.js
init_import_meta_url();
function createCheckInEnvelope(checkIn, dynamicSamplingContext, metadata, tunnel, dsn) {
  const headers = {
    sent_at: (/* @__PURE__ */ new Date()).toISOString()
  };
  if (metadata && metadata.sdk) {
    headers.sdk = {
      name: metadata.sdk.name,
      version: metadata.sdk.version
    };
  }
  if (!!tunnel && !!dsn) {
    headers.dsn = dsnToString(dsn);
  }
  if (dynamicSamplingContext) {
    headers.trace = dropUndefinedKeys(dynamicSamplingContext);
  }
  const item = createCheckInEnvelopeItem(checkIn);
  return createEnvelope(headers, [item]);
}
__name(createCheckInEnvelope, "createCheckInEnvelope");
function createCheckInEnvelopeItem(checkIn) {
  const checkInHeaders = {
    type: "check_in"
  };
  return [checkInHeaders, checkIn];
}
__name(createCheckInEnvelopeItem, "createCheckInEnvelopeItem");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/server-runtime-client.js
var ServerRuntimeClient = class extends BaseClient {
  /**
   * Creates a new Edge SDK instance.
   * @param options Configuration options for this SDK.
   */
  constructor(options29) {
    addTracingExtensions();
    super(options29);
  }
  /**
   * @inheritDoc
   */
  eventFromException(exception, hint) {
    return resolvedSyncPromise(eventFromUnknownInput(getCurrentHub, this._options.stackParser, exception, hint));
  }
  /**
   * @inheritDoc
   */
  eventFromMessage(message, level = "info", hint) {
    return resolvedSyncPromise(
      eventFromMessage(this._options.stackParser, message, level, hint, this._options.attachStacktrace)
    );
  }
  /**
   * @inheritDoc
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
  captureException(exception, hint, scope) {
    if (this._options.autoSessionTracking && this._sessionFlusher && scope) {
      const requestSession = scope.getRequestSession();
      if (requestSession && requestSession.status === "ok") {
        requestSession.status = "errored";
      }
    }
    return super.captureException(exception, hint, scope);
  }
  /**
   * @inheritDoc
   */
  captureEvent(event, hint, scope) {
    if (this._options.autoSessionTracking && this._sessionFlusher && scope) {
      const eventType = event.type || "exception";
      const isException = eventType === "exception" && event.exception && event.exception.values && event.exception.values.length > 0;
      if (isException) {
        const requestSession = scope.getRequestSession();
        if (requestSession && requestSession.status === "ok") {
          requestSession.status = "errored";
        }
      }
    }
    return super.captureEvent(event, hint, scope);
  }
  /**
   *
   * @inheritdoc
   */
  close(timeout) {
    if (this._sessionFlusher) {
      this._sessionFlusher.close();
    }
    return super.close(timeout);
  }
  /** Method that initialises an instance of SessionFlusher on Client */
  initSessionFlusher() {
    const { release: release2, environment } = this._options;
    if (!release2) {
      DEBUG_BUILD2 && logger2.warn("Cannot initialise an instance of SessionFlusher if no release is provided!");
    } else {
      this._sessionFlusher = new SessionFlusher(this, {
        release: release2,
        environment
      });
    }
  }
  /**
   * Create a cron monitor check in and send it to Sentry.
   *
   * @param checkIn An object that describes a check in.
   * @param upsertMonitorConfig An optional object that describes a monitor config. Use this if you want
   * to create a monitor automatically when sending a check in.
   */
  captureCheckIn(checkIn, monitorConfig, scope) {
    const id = "checkInId" in checkIn && checkIn.checkInId ? checkIn.checkInId : uuid4();
    if (!this._isEnabled()) {
      DEBUG_BUILD2 && logger2.warn("SDK not enabled, will not capture checkin.");
      return id;
    }
    const options29 = this.getOptions();
    const { release: release2, environment, tunnel } = options29;
    const serializedCheckIn = {
      check_in_id: id,
      monitor_slug: checkIn.monitorSlug,
      status: checkIn.status,
      release: release2,
      environment
    };
    if ("duration" in checkIn) {
      serializedCheckIn.duration = checkIn.duration;
    }
    if (monitorConfig) {
      serializedCheckIn.monitor_config = {
        schedule: monitorConfig.schedule,
        checkin_margin: monitorConfig.checkinMargin,
        max_runtime: monitorConfig.maxRuntime,
        timezone: monitorConfig.timezone
      };
    }
    const [dynamicSamplingContext, traceContext] = this._getTraceInfoFromScope(scope);
    if (traceContext) {
      serializedCheckIn.contexts = {
        trace: traceContext
      };
    }
    const envelope = createCheckInEnvelope(
      serializedCheckIn,
      dynamicSamplingContext,
      this.getSdkMetadata(),
      tunnel,
      this.getDsn()
    );
    DEBUG_BUILD2 && logger2.info("Sending checkin:", checkIn.monitorSlug, checkIn.status);
    void this._sendEnvelope(envelope);
    return id;
  }
  /**
   * Method responsible for capturing/ending a request session by calling `incrementSessionStatusCount` to increment
   * appropriate session aggregates bucket
   */
  _captureRequestSession() {
    if (!this._sessionFlusher) {
      DEBUG_BUILD2 && logger2.warn("Discarded request mode session because autoSessionTracking option was disabled");
    } else {
      this._sessionFlusher.incrementSessionStatusCount();
    }
  }
  /**
   * @inheritDoc
   */
  _prepareEvent(event, hint, scope) {
    if (this._options.platform) {
      event.platform = event.platform || this._options.platform;
    }
    if (this._options.runtime) {
      event.contexts = {
        ...event.contexts,
        runtime: (event.contexts || {}).runtime || this._options.runtime
      };
    }
    if (this._options.serverName) {
      event.server_name = event.server_name || this._options.serverName;
    }
    return super._prepareEvent(event, hint, scope);
  }
  /** Extract trace information from scope */
  _getTraceInfoFromScope(scope) {
    if (!scope) {
      return [void 0, void 0];
    }
    const span = scope.getSpan();
    if (span) {
      const samplingContext = span.transaction ? span.transaction.getDynamicSamplingContext() : void 0;
      return [samplingContext, span.getTraceContext()];
    }
    const { traceId, spanId, parentSpanId, dsc } = scope.getPropagationContext();
    const traceContext = {
      trace_id: traceId,
      span_id: spanId,
      parent_span_id: parentSpanId
    };
    if (dsc) {
      return [dsc, traceContext];
    }
    return [getDynamicSamplingContextFromClient(traceId, this, scope), traceContext];
  }
};
__name(ServerRuntimeClient, "ServerRuntimeClient");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/sdk.js
init_import_meta_url();
function initAndBind(clientClass, options29) {
  if (options29.debug === true) {
    if (DEBUG_BUILD2) {
      logger2.enable();
    } else {
      consoleSandbox(() => {
        console.warn("[Sentry] Cannot initialize SDK with `debug` option using a non-debug bundle.");
      });
    }
  }
  const hub = getCurrentHub();
  const scope = hub.getScope();
  scope.update(options29.initialScope);
  const client = new clientClass(options29);
  hub.bindClient(client);
}
__name(initAndBind, "initAndBind");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/transports/base.js
init_import_meta_url();
var DEFAULT_TRANSPORT_BUFFER_SIZE = 30;
function createTransport(options29, makeRequest, buffer = makePromiseBuffer(
  options29.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE
)) {
  let rateLimits = {};
  const flush2 = /* @__PURE__ */ __name((timeout) => buffer.drain(timeout), "flush");
  function send(envelope) {
    const filteredEnvelopeItems = [];
    forEachEnvelopeItem(envelope, (item, type) => {
      const envelopeItemDataCategory = envelopeItemTypeToDataCategory(type);
      if (isRateLimited(rateLimits, envelopeItemDataCategory)) {
        const event = getEventForEnvelopeItem(item, type);
        options29.recordDroppedEvent("ratelimit_backoff", envelopeItemDataCategory, event);
      } else {
        filteredEnvelopeItems.push(item);
      }
    });
    if (filteredEnvelopeItems.length === 0) {
      return resolvedSyncPromise();
    }
    const filteredEnvelope = createEnvelope(envelope[0], filteredEnvelopeItems);
    const recordEnvelopeLoss = /* @__PURE__ */ __name((reason) => {
      forEachEnvelopeItem(filteredEnvelope, (item, type) => {
        const event = getEventForEnvelopeItem(item, type);
        options29.recordDroppedEvent(reason, envelopeItemTypeToDataCategory(type), event);
      });
    }, "recordEnvelopeLoss");
    const requestTask = /* @__PURE__ */ __name(() => makeRequest({ body: serializeEnvelope(filteredEnvelope, options29.textEncoder) }).then(
      (response) => {
        if (response.statusCode !== void 0 && (response.statusCode < 200 || response.statusCode >= 300)) {
          DEBUG_BUILD2 && logger2.warn(`Sentry responded with status code ${response.statusCode} to sent event.`);
        }
        rateLimits = updateRateLimits(rateLimits, response);
        return response;
      },
      (error2) => {
        recordEnvelopeLoss("network_error");
        throw error2;
      }
    ), "requestTask");
    return buffer.add(requestTask).then(
      (result) => result,
      (error2) => {
        if (error2 instanceof SentryError) {
          DEBUG_BUILD2 && logger2.error("Skipped sending event because buffer is full.");
          recordEnvelopeLoss("queue_overflow");
          return resolvedSyncPromise();
        } else {
          throw error2;
        }
      }
    );
  }
  __name(send, "send");
  send.__sentry__baseTransport__ = true;
  return {
    send,
    flush: flush2
  };
}
__name(createTransport, "createTransport");
function getEventForEnvelopeItem(item, type) {
  if (type !== "event" && type !== "transaction") {
    return void 0;
  }
  return Array.isArray(item) ? item[1] : void 0;
}
__name(getEventForEnvelopeItem, "getEventForEnvelopeItem");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/integrations/index.js
var integrations_exports = {};
__export(integrations_exports, {
  FunctionToString: () => FunctionToString,
  InboundFilters: () => InboundFilters,
  LinkedErrors: () => LinkedErrors
});
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/integrations/functiontostring.js
init_import_meta_url();
var originalFunctionToString;
var FunctionToString = class {
  /**
   * @inheritDoc
   */
  static __initStatic() {
    this.id = "FunctionToString";
  }
  /**
   * @inheritDoc
   */
  constructor() {
    this.name = FunctionToString.id;
  }
  /**
   * @inheritDoc
   */
  setupOnce() {
    originalFunctionToString = Function.prototype.toString;
    try {
      Function.prototype.toString = function(...args) {
        const context2 = getOriginalFunction(this) || this;
        return originalFunctionToString.apply(context2, args);
      };
    } catch (e3) {
    }
  }
};
__name(FunctionToString, "FunctionToString");
FunctionToString.__initStatic();

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/integrations/inboundfilters.js
init_import_meta_url();
var DEFAULT_IGNORE_ERRORS = [/^Script error\.?$/, /^Javascript error: Script error\.? on line 0$/];
var DEFAULT_IGNORE_TRANSACTIONS = [
  /^.*\/healthcheck$/,
  /^.*\/healthy$/,
  /^.*\/live$/,
  /^.*\/ready$/,
  /^.*\/heartbeat$/,
  /^.*\/health$/,
  /^.*\/healthz$/
];
var InboundFilters = class {
  /**
   * @inheritDoc
   */
  static __initStatic() {
    this.id = "InboundFilters";
  }
  /**
   * @inheritDoc
   */
  constructor(options29 = {}) {
    this.name = InboundFilters.id;
    this._options = options29;
  }
  /**
   * @inheritDoc
   */
  setupOnce(_addGlobalEventProcessor, _getCurrentHub) {
  }
  /** @inheritDoc */
  processEvent(event, _eventHint, client) {
    const clientOptions = client.getOptions();
    const options29 = _mergeOptions(this._options, clientOptions);
    return _shouldDropEvent(event, options29) ? null : event;
  }
};
__name(InboundFilters, "InboundFilters");
InboundFilters.__initStatic();
function _mergeOptions(internalOptions = {}, clientOptions = {}) {
  return {
    allowUrls: [...internalOptions.allowUrls || [], ...clientOptions.allowUrls || []],
    denyUrls: [...internalOptions.denyUrls || [], ...clientOptions.denyUrls || []],
    ignoreErrors: [
      ...internalOptions.ignoreErrors || [],
      ...clientOptions.ignoreErrors || [],
      ...internalOptions.disableErrorDefaults ? [] : DEFAULT_IGNORE_ERRORS
    ],
    ignoreTransactions: [
      ...internalOptions.ignoreTransactions || [],
      ...clientOptions.ignoreTransactions || [],
      ...internalOptions.disableTransactionDefaults ? [] : DEFAULT_IGNORE_TRANSACTIONS
    ],
    ignoreInternal: internalOptions.ignoreInternal !== void 0 ? internalOptions.ignoreInternal : true
  };
}
__name(_mergeOptions, "_mergeOptions");
function _shouldDropEvent(event, options29) {
  if (options29.ignoreInternal && _isSentryError(event)) {
    DEBUG_BUILD2 && logger2.warn(`Event dropped due to being internal Sentry Error.
Event: ${getEventDescription(event)}`);
    return true;
  }
  if (_isIgnoredError(event, options29.ignoreErrors)) {
    DEBUG_BUILD2 && logger2.warn(
      `Event dropped due to being matched by \`ignoreErrors\` option.
Event: ${getEventDescription(event)}`
    );
    return true;
  }
  if (_isIgnoredTransaction(event, options29.ignoreTransactions)) {
    DEBUG_BUILD2 && logger2.warn(
      `Event dropped due to being matched by \`ignoreTransactions\` option.
Event: ${getEventDescription(event)}`
    );
    return true;
  }
  if (_isDeniedUrl(event, options29.denyUrls)) {
    DEBUG_BUILD2 && logger2.warn(
      `Event dropped due to being matched by \`denyUrls\` option.
Event: ${getEventDescription(
        event
      )}.
Url: ${_getEventFilterUrl(event)}`
    );
    return true;
  }
  if (!_isAllowedUrl(event, options29.allowUrls)) {
    DEBUG_BUILD2 && logger2.warn(
      `Event dropped due to not being matched by \`allowUrls\` option.
Event: ${getEventDescription(
        event
      )}.
Url: ${_getEventFilterUrl(event)}`
    );
    return true;
  }
  return false;
}
__name(_shouldDropEvent, "_shouldDropEvent");
function _isIgnoredError(event, ignoreErrors) {
  if (event.type || !ignoreErrors || !ignoreErrors.length) {
    return false;
  }
  return _getPossibleEventMessages(event).some((message) => stringMatchesSomePattern(message, ignoreErrors));
}
__name(_isIgnoredError, "_isIgnoredError");
function _isIgnoredTransaction(event, ignoreTransactions) {
  if (event.type !== "transaction" || !ignoreTransactions || !ignoreTransactions.length) {
    return false;
  }
  const name = event.transaction;
  return name ? stringMatchesSomePattern(name, ignoreTransactions) : false;
}
__name(_isIgnoredTransaction, "_isIgnoredTransaction");
function _isDeniedUrl(event, denyUrls) {
  if (!denyUrls || !denyUrls.length) {
    return false;
  }
  const url4 = _getEventFilterUrl(event);
  return !url4 ? false : stringMatchesSomePattern(url4, denyUrls);
}
__name(_isDeniedUrl, "_isDeniedUrl");
function _isAllowedUrl(event, allowUrls) {
  if (!allowUrls || !allowUrls.length) {
    return true;
  }
  const url4 = _getEventFilterUrl(event);
  return !url4 ? true : stringMatchesSomePattern(url4, allowUrls);
}
__name(_isAllowedUrl, "_isAllowedUrl");
function _getPossibleEventMessages(event) {
  const possibleMessages = [];
  if (event.message) {
    possibleMessages.push(event.message);
  }
  let lastException;
  try {
    lastException = event.exception.values[event.exception.values.length - 1];
  } catch (e3) {
  }
  if (lastException) {
    if (lastException.value) {
      possibleMessages.push(lastException.value);
      if (lastException.type) {
        possibleMessages.push(`${lastException.type}: ${lastException.value}`);
      }
    }
  }
  if (DEBUG_BUILD2 && possibleMessages.length === 0) {
    logger2.error(`Could not extract message for event ${getEventDescription(event)}`);
  }
  return possibleMessages;
}
__name(_getPossibleEventMessages, "_getPossibleEventMessages");
function _isSentryError(event) {
  try {
    return event.exception.values[0].type === "SentryError";
  } catch (e3) {
  }
  return false;
}
__name(_isSentryError, "_isSentryError");
function _getLastValidUrl(frames = []) {
  for (let i = frames.length - 1; i >= 0; i--) {
    const frame = frames[i];
    if (frame && frame.filename !== "<anonymous>" && frame.filename !== "[native code]") {
      return frame.filename || null;
    }
  }
  return null;
}
__name(_getLastValidUrl, "_getLastValidUrl");
function _getEventFilterUrl(event) {
  try {
    let frames;
    try {
      frames = event.exception.values[0].stacktrace.frames;
    } catch (e3) {
    }
    return frames ? _getLastValidUrl(frames) : null;
  } catch (oO) {
    DEBUG_BUILD2 && logger2.error(`Cannot extract url for event ${getEventDescription(event)}`);
    return null;
  }
}
__name(_getEventFilterUrl, "_getEventFilterUrl");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/integrations/linkederrors.js
init_import_meta_url();
var DEFAULT_KEY = "cause";
var DEFAULT_LIMIT = 5;
var LinkedErrors = class {
  /**
   * @inheritDoc
   */
  static __initStatic() {
    this.id = "LinkedErrors";
  }
  /**
   * @inheritDoc
   */
  /**
   * @inheritDoc
   */
  /**
   * @inheritDoc
   */
  /**
   * @inheritDoc
   */
  constructor(options29 = {}) {
    this._key = options29.key || DEFAULT_KEY;
    this._limit = options29.limit || DEFAULT_LIMIT;
    this.name = LinkedErrors.id;
  }
  /** @inheritdoc */
  setupOnce() {
  }
  /**
   * @inheritDoc
   */
  preprocessEvent(event, hint, client) {
    const options29 = client.getOptions();
    applyAggregateErrorsToEvent(
      exceptionFromError,
      options29.stackParser,
      options29.maxValueLength,
      this._key,
      this._limit,
      event,
      hint
    );
  }
};
__name(LinkedErrors, "LinkedErrors");
LinkedErrors.__initStatic();

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/utils/isSentryRequestUrl.js
init_import_meta_url();
function isSentryRequestUrl(url4, hub) {
  const client = hub.getClient();
  const dsn = client && client.getDsn();
  const tunnel = client && client.getOptions().tunnel;
  return checkDsn(url4, dsn) || checkTunnel(url4, tunnel);
}
__name(isSentryRequestUrl, "isSentryRequestUrl");
function checkTunnel(url4, tunnel) {
  if (!tunnel) {
    return false;
  }
  return removeTrailingSlash(url4) === removeTrailingSlash(tunnel);
}
__name(checkTunnel, "checkTunnel");
function checkDsn(url4, dsn) {
  return dsn ? url4.includes(dsn.host) : false;
}
__name(checkDsn, "checkDsn");
function removeTrailingSlash(str) {
  return str[str.length - 1] === "/" ? str.slice(0, -1) : str;
}
__name(removeTrailingSlash, "removeTrailingSlash");

// ../../node_modules/.pnpm/@sentry+core@7.87.0/node_modules/@sentry/core/esm/integrations/requestdata.js
init_import_meta_url();
var DEFAULT_OPTIONS = {
  include: {
    cookies: true,
    data: true,
    headers: true,
    ip: false,
    query_string: true,
    url: true,
    user: {
      id: true,
      username: true,
      email: true
    }
  },
  transactionNamingScheme: "methodPath"
};
var RequestData = class {
  /**
   * @inheritDoc
   */
  static __initStatic() {
    this.id = "RequestData";
  }
  /**
   * @inheritDoc
   */
  /**
   * Function for adding request data to event. Defaults to `addRequestDataToEvent` from `@sentry/node` for now, but
   * left as a property so this integration can be moved to `@sentry/core` as a base class in case we decide to use
   * something similar in browser-based SDKs in the future.
   */
  /**
   * @inheritDoc
   */
  constructor(options29 = {}) {
    this.name = RequestData.id;
    this._addRequestData = addRequestDataToEvent;
    this._options = {
      ...DEFAULT_OPTIONS,
      ...options29,
      include: {
        // @ts-expect-error It's mad because `method` isn't a known `include` key. (It's only here and not set by default in
        // `addRequestDataToEvent` for legacy reasons. TODO (v8): Change that.)
        method: true,
        ...DEFAULT_OPTIONS.include,
        ...options29.include,
        user: options29.include && typeof options29.include.user === "boolean" ? options29.include.user : {
          ...DEFAULT_OPTIONS.include.user,
          // Unclear why TS still thinks `options.include.user` could be a boolean at this point
          ...(options29.include || {}).user
        }
      }
    };
  }
  /**
   * @inheritDoc
   */
  setupOnce(addGlobalEventProcessor2, getCurrentHub3) {
    const { transactionNamingScheme } = this._options;
    addGlobalEventProcessor2((event) => {
      const hub = getCurrentHub3();
      const self2 = hub.getIntegration(RequestData);
      const { sdkProcessingMetadata = {} } = event;
      const req = sdkProcessingMetadata.request;
      if (!self2 || !req) {
        return event;
      }
      const addRequestDataOptions = sdkProcessingMetadata.requestDataOptionsFromExpressHandler || sdkProcessingMetadata.requestDataOptionsFromGCPWrapper || convertReqDataIntegrationOptsToAddReqDataOpts(this._options);
      const processedEvent = this._addRequestData(event, req, addRequestDataOptions);
      if (event.type === "transaction" || transactionNamingScheme === "handler") {
        return processedEvent;
      }
      const reqWithTransaction = req;
      const transaction = reqWithTransaction._sentryTransaction;
      if (transaction) {
        const shouldIncludeMethodInTransactionName = getSDKName(hub) === "sentry.javascript.nextjs" ? transaction.name.startsWith("/api") : transactionNamingScheme !== "path";
        const [transactionValue] = extractPathForTransaction(req, {
          path: true,
          method: shouldIncludeMethodInTransactionName,
          customRoute: transaction.name
        });
        processedEvent.transaction = transactionValue;
      }
      return processedEvent;
    });
  }
};
__name(RequestData, "RequestData");
RequestData.__initStatic();
function convertReqDataIntegrationOptsToAddReqDataOpts(integrationOptions) {
  const {
    transactionNamingScheme,
    include: { ip: ip2, user, ...requestOptions }
  } = integrationOptions;
  const requestIncludeKeys = [];
  for (const [key, value] of Object.entries(requestOptions)) {
    if (value) {
      requestIncludeKeys.push(key);
    }
  }
  let addReqDataUserOpt;
  if (user === void 0) {
    addReqDataUserOpt = true;
  } else if (typeof user === "boolean") {
    addReqDataUserOpt = user;
  } else {
    const userIncludeKeys = [];
    for (const [key, value] of Object.entries(user)) {
      if (value) {
        userIncludeKeys.push(key);
      }
    }
    addReqDataUserOpt = userIncludeKeys;
  }
  return {
    include: {
      ip: ip2,
      user: addReqDataUserOpt,
      request: requestIncludeKeys.length !== 0 ? requestIncludeKeys : void 0,
      transaction: transactionNamingScheme
    }
  };
}
__name(convertReqDataIntegrationOptsToAddReqDataOpts, "convertReqDataIntegrationOptsToAddReqDataOpts");
function getSDKName(hub) {
  try {
    return hub.getClient().getOptions()._metadata.sdk.name;
  } catch (err) {
    return void 0;
  }
}
__name(getSDKName, "getSDKName");

// ../../node_modules/.pnpm/@sentry-internal+tracing@7.87.0/node_modules/@sentry-internal/tracing/esm/index.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry-internal+tracing@7.87.0/node_modules/@sentry-internal/tracing/esm/node/integrations/express.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry-internal+tracing@7.87.0/node_modules/@sentry-internal/tracing/esm/common/debug-build.js
init_import_meta_url();
var DEBUG_BUILD3 = typeof __SENTRY_DEBUG__ === "undefined" || __SENTRY_DEBUG__;

// ../../node_modules/.pnpm/@sentry-internal+tracing@7.87.0/node_modules/@sentry-internal/tracing/esm/node/integrations/utils/node-utils.js
init_import_meta_url();
function shouldDisableAutoInstrumentation(getCurrentHub3) {
  const clientOptions = _optionalChain([getCurrentHub3, "call", (_3) => _3(), "access", (_22) => _22.getClient, "call", (_3) => _3(), "optionalAccess", (_4) => _4.getOptions, "call", (_5) => _5()]);
  const instrumenter = _optionalChain([clientOptions, "optionalAccess", (_6) => _6.instrumenter]) || "sentry";
  return instrumenter !== "sentry";
}
__name(shouldDisableAutoInstrumentation, "shouldDisableAutoInstrumentation");

// ../../node_modules/.pnpm/@sentry-internal+tracing@7.87.0/node_modules/@sentry-internal/tracing/esm/node/integrations/express.js
var Express = class {
  /**
   * @inheritDoc
   */
  static __initStatic() {
    this.id = "Express";
  }
  /**
   * @inheritDoc
   */
  /**
   * Express App instance
   */
  /**
   * @inheritDoc
   */
  constructor(options29 = {}) {
    this.name = Express.id;
    this._router = options29.router || options29.app;
    this._methods = (Array.isArray(options29.methods) ? options29.methods : []).concat("use");
  }
  /**
   * @inheritDoc
   */
  setupOnce(_3, getCurrentHub3) {
    if (!this._router) {
      DEBUG_BUILD3 && logger2.error("ExpressIntegration is missing an Express instance");
      return;
    }
    if (shouldDisableAutoInstrumentation(getCurrentHub3)) {
      DEBUG_BUILD3 && logger2.log("Express Integration is skipped because of instrumenter configuration.");
      return;
    }
    instrumentMiddlewares(this._router, this._methods);
    instrumentRouter(this._router);
  }
};
__name(Express, "Express");
Express.__initStatic();
function wrap3(fn2, method) {
  const arity = fn2.length;
  switch (arity) {
    case 2: {
      return function(req, res) {
        const transaction = res.__sentry_transaction;
        if (transaction) {
          const span = transaction.startChild({
            description: fn2.name,
            op: `middleware.express.${method}`,
            origin: "auto.middleware.express"
          });
          res.once("finish", () => {
            span.finish();
          });
        }
        return fn2.call(this, req, res);
      };
    }
    case 3: {
      return function(req, res, next) {
        const transaction = res.__sentry_transaction;
        const span = _optionalChain([transaction, "optionalAccess", (_22) => _22.startChild, "call", (_3) => _3({
          description: fn2.name,
          op: `middleware.express.${method}`,
          origin: "auto.middleware.express"
        })]);
        fn2.call(this, req, res, function(...args) {
          _optionalChain([span, "optionalAccess", (_4) => _4.finish, "call", (_5) => _5()]);
          next.call(this, ...args);
        });
      };
    }
    case 4: {
      return function(err, req, res, next) {
        const transaction = res.__sentry_transaction;
        const span = _optionalChain([transaction, "optionalAccess", (_6) => _6.startChild, "call", (_7) => _7({
          description: fn2.name,
          op: `middleware.express.${method}`,
          origin: "auto.middleware.express"
        })]);
        fn2.call(this, err, req, res, function(...args) {
          _optionalChain([span, "optionalAccess", (_8) => _8.finish, "call", (_9) => _9()]);
          next.call(this, ...args);
        });
      };
    }
    default: {
      throw new Error(`Express middleware takes 2-4 arguments. Got: ${arity}`);
    }
  }
}
__name(wrap3, "wrap");
function wrapMiddlewareArgs(args, method) {
  return args.map((arg) => {
    if (typeof arg === "function") {
      return wrap3(arg, method);
    }
    if (Array.isArray(arg)) {
      return arg.map((a) => {
        if (typeof a === "function") {
          return wrap3(a, method);
        }
        return a;
      });
    }
    return arg;
  });
}
__name(wrapMiddlewareArgs, "wrapMiddlewareArgs");
function patchMiddleware(router, method) {
  const originalCallback = router[method];
  router[method] = function(...args) {
    return originalCallback.call(this, ...wrapMiddlewareArgs(args, method));
  };
  return router;
}
__name(patchMiddleware, "patchMiddleware");
function instrumentMiddlewares(router, methods = []) {
  methods.forEach((method) => patchMiddleware(router, method));
}
__name(instrumentMiddlewares, "instrumentMiddlewares");
function instrumentRouter(appOrRouter) {
  const isApp = "settings" in appOrRouter;
  if (isApp && appOrRouter._router === void 0 && appOrRouter.lazyrouter) {
    appOrRouter.lazyrouter();
  }
  const router = isApp ? appOrRouter._router : appOrRouter;
  if (!router) {
    DEBUG_BUILD3 && logger2.debug("Cannot instrument router for URL Parameterization (did not find a valid router).");
    DEBUG_BUILD3 && logger2.debug("Routing instrumentation is currently only supported in Express 4.");
    return;
  }
  const routerProto = Object.getPrototypeOf(router);
  const originalProcessParams = routerProto.process_params;
  routerProto.process_params = /* @__PURE__ */ __name(function process_params(layer, called, req, res, done) {
    if (!req._reconstructedRoute) {
      req._reconstructedRoute = "";
    }
    const { layerRoutePath, isRegex, isArray, numExtraSegments } = getLayerRoutePathInfo(layer);
    if (layerRoutePath || isRegex || isArray) {
      req._hasParameters = true;
    }
    let partialRoute;
    if (layerRoutePath) {
      partialRoute = layerRoutePath;
    } else {
      partialRoute = preventDuplicateSegments(req.originalUrl, req._reconstructedRoute, layer.path) || "";
    }
    const finalPartialRoute = partialRoute.split("/").filter((segment) => segment.length > 0 && (isRegex || isArray || !segment.includes("*"))).join("/");
    if (finalPartialRoute && finalPartialRoute.length > 0) {
      req._reconstructedRoute += `/${finalPartialRoute}${isRegex ? "/" : ""}`;
    }
    const urlLength = getNumberOfUrlSegments(stripUrlQueryAndFragment(req.originalUrl || "")) + numExtraSegments;
    const routeLength = getNumberOfUrlSegments(req._reconstructedRoute);
    if (urlLength === routeLength) {
      if (!req._hasParameters) {
        if (req._reconstructedRoute !== req.originalUrl) {
          req._reconstructedRoute = req.originalUrl ? stripUrlQueryAndFragment(req.originalUrl) : req.originalUrl;
        }
      }
      const transaction = res.__sentry_transaction;
      if (transaction && transaction.metadata.source !== "custom") {
        const finalRoute = req._reconstructedRoute || "/";
        transaction.setName(...extractPathForTransaction(req, { path: true, method: true, customRoute: finalRoute }));
      }
    }
    return originalProcessParams.call(this, layer, called, req, res, done);
  }, "process_params");
}
__name(instrumentRouter, "instrumentRouter");
var extractOriginalRoute = /* @__PURE__ */ __name((path67, regexp, keys) => {
  if (!path67 || !regexp || !keys || Object.keys(keys).length === 0 || !_optionalChain([keys, "access", (_10) => _10[0], "optionalAccess", (_11) => _11.offset])) {
    return void 0;
  }
  const orderedKeys = keys.sort((a, b2) => a.offset - b2.offset);
  const pathRegex = new RegExp(regexp, `${regexp.flags}d`);
  const execResult = pathRegex.exec(path67);
  if (!execResult || !execResult.indices) {
    return void 0;
  }
  const [, ...paramIndices] = execResult.indices;
  if (paramIndices.length !== orderedKeys.length) {
    return void 0;
  }
  let resultPath = path67;
  let indexShift = 0;
  paramIndices.forEach((item, index) => {
    if (item) {
      const [startOffset, endOffset] = item;
      const substr1 = resultPath.substring(0, startOffset - indexShift);
      const replacement = `:${orderedKeys[index].name}`;
      const substr2 = resultPath.substring(endOffset - indexShift);
      resultPath = substr1 + replacement + substr2;
      indexShift = indexShift + (endOffset - startOffset - replacement.length);
    }
  });
  return resultPath;
}, "extractOriginalRoute");
function getLayerRoutePathInfo(layer) {
  let lrp = _optionalChain([layer, "access", (_12) => _12.route, "optionalAccess", (_13) => _13.path]);
  const isRegex = isRegExp(lrp);
  const isArray = Array.isArray(lrp);
  if (!lrp) {
    const [major] = GLOBAL_OBJ.process.versions.node.split(".").map(Number);
    if (major >= 16) {
      lrp = extractOriginalRoute(layer.path, layer.regexp, layer.keys);
    }
  }
  if (!lrp) {
    return { isRegex, isArray, numExtraSegments: 0 };
  }
  const numExtraSegments = isArray ? Math.max(getNumberOfArrayUrlSegments(lrp) - getNumberOfUrlSegments(layer.path || ""), 0) : 0;
  const layerRoutePath = getLayerRoutePathString(isArray, lrp);
  return { layerRoutePath, isRegex, isArray, numExtraSegments };
}
__name(getLayerRoutePathInfo, "getLayerRoutePathInfo");
function getNumberOfArrayUrlSegments(routesArray) {
  return routesArray.reduce((accNumSegments, currentRoute) => {
    return accNumSegments + getNumberOfUrlSegments(currentRoute.toString());
  }, 0);
}
__name(getNumberOfArrayUrlSegments, "getNumberOfArrayUrlSegments");
function getLayerRoutePathString(isArray, lrp) {
  if (isArray) {
    return lrp.map((r3) => r3.toString()).join(",");
  }
  return lrp && lrp.toString();
}
__name(getLayerRoutePathString, "getLayerRoutePathString");
function preventDuplicateSegments(originalUrl, reconstructedRoute, layerPath) {
  const normalizeURL = stripUrlQueryAndFragment(originalUrl || "");
  const originalUrlSplit = _optionalChain([normalizeURL, "optionalAccess", (_14) => _14.split, "call", (_15) => _15("/"), "access", (_16) => _16.filter, "call", (_17) => _17((v2) => !!v2)]);
  let tempCounter = 0;
  const currentOffset = _optionalChain([reconstructedRoute, "optionalAccess", (_18) => _18.split, "call", (_19) => _19("/"), "access", (_20) => _20.filter, "call", (_21) => _21((v2) => !!v2), "access", (_22) => _22.length]) || 0;
  const result = _optionalChain([
    layerPath,
    "optionalAccess",
    (_23) => _23.split,
    "call",
    (_24) => _24("/"),
    "access",
    (_25) => _25.filter,
    "call",
    (_26) => _26((segment) => {
      if (_optionalChain([originalUrlSplit, "optionalAccess", (_27) => _27[currentOffset + tempCounter]]) === segment) {
        tempCounter += 1;
        return true;
      }
      return false;
    }),
    "access",
    (_28) => _28.join,
    "call",
    (_29) => _29("/")
  ]);
  return result;
}
__name(preventDuplicateSegments, "preventDuplicateSegments");

// ../../node_modules/.pnpm/@sentry-internal+tracing@7.87.0/node_modules/@sentry-internal/tracing/esm/node/integrations/postgres.js
init_import_meta_url();
var Postgres = class {
  /**
   * @inheritDoc
   */
  static __initStatic() {
    this.id = "Postgres";
  }
  /**
   * @inheritDoc
   */
  constructor(options29 = {}) {
    this.name = Postgres.id;
    this._usePgNative = !!options29.usePgNative;
    this._module = options29.module;
  }
  /** @inheritdoc */
  loadDependency() {
    return this._module = this._module || loadModule("pg");
  }
  /**
   * @inheritDoc
   */
  setupOnce(_3, getCurrentHub3) {
    if (shouldDisableAutoInstrumentation(getCurrentHub3)) {
      DEBUG_BUILD3 && logger2.log("Postgres Integration is skipped because of instrumenter configuration.");
      return;
    }
    const pkg = this.loadDependency();
    if (!pkg) {
      DEBUG_BUILD3 && logger2.error("Postgres Integration was unable to require `pg` package.");
      return;
    }
    const Client = this._usePgNative ? _optionalChain([pkg, "access", (_22) => _22.native, "optionalAccess", (_32) => _32.Client]) : pkg.Client;
    if (!Client) {
      DEBUG_BUILD3 && logger2.error("Postgres Integration was unable to access 'pg-native' bindings.");
      return;
    }
    fill(Client.prototype, "query", function(orig) {
      return function(config, values, callback) {
        const scope = getCurrentHub3().getScope();
        const parentSpan = scope.getSpan();
        const data = {
          "db.system": "postgresql"
        };
        try {
          if (this.database) {
            data["db.name"] = this.database;
          }
          if (this.host) {
            data["server.address"] = this.host;
          }
          if (this.port) {
            data["server.port"] = this.port;
          }
          if (this.user) {
            data["db.user"] = this.user;
          }
        } catch (e3) {
        }
        const span = _optionalChain([parentSpan, "optionalAccess", (_4) => _4.startChild, "call", (_5) => _5({
          description: typeof config === "string" ? config : config.text,
          op: "db",
          origin: "auto.db.postgres",
          data
        })]);
        if (typeof callback === "function") {
          return orig.call(this, config, values, function(err, result) {
            _optionalChain([span, "optionalAccess", (_6) => _6.finish, "call", (_7) => _7()]);
            callback(err, result);
          });
        }
        if (typeof values === "function") {
          return orig.call(this, config, function(err, result) {
            _optionalChain([span, "optionalAccess", (_8) => _8.finish, "call", (_9) => _9()]);
            values(err, result);
          });
        }
        const rv = typeof values !== "undefined" ? orig.call(this, config, values) : orig.call(this, config);
        if (isThenable(rv)) {
          return rv.then((res) => {
            _optionalChain([span, "optionalAccess", (_10) => _10.finish, "call", (_11) => _11()]);
            return res;
          });
        }
        _optionalChain([span, "optionalAccess", (_12) => _12.finish, "call", (_13) => _13()]);
        return rv;
      };
    });
  }
};
__name(Postgres, "Postgres");
Postgres.__initStatic();

// ../../node_modules/.pnpm/@sentry-internal+tracing@7.87.0/node_modules/@sentry-internal/tracing/esm/node/integrations/mysql.js
init_import_meta_url();
var Mysql = class {
  /**
   * @inheritDoc
   */
  static __initStatic() {
    this.id = "Mysql";
  }
  /**
   * @inheritDoc
   */
  constructor() {
    this.name = Mysql.id;
  }
  /** @inheritdoc */
  loadDependency() {
    return this._module = this._module || loadModule("mysql/lib/Connection.js");
  }
  /**
   * @inheritDoc
   */
  setupOnce(_3, getCurrentHub3) {
    if (shouldDisableAutoInstrumentation(getCurrentHub3)) {
      DEBUG_BUILD3 && logger2.log("Mysql Integration is skipped because of instrumenter configuration.");
      return;
    }
    const pkg = this.loadDependency();
    if (!pkg) {
      DEBUG_BUILD3 && logger2.error("Mysql Integration was unable to require `mysql` package.");
      return;
    }
    let mySqlConfig = void 0;
    try {
      pkg.prototype.connect = new Proxy(pkg.prototype.connect, {
        apply(wrappingTarget, thisArg, args) {
          if (!mySqlConfig) {
            mySqlConfig = thisArg.config;
          }
          return wrappingTarget.apply(thisArg, args);
        }
      });
    } catch (e3) {
      DEBUG_BUILD3 && logger2.error("Mysql Integration was unable to instrument `mysql` config.");
    }
    function spanDataFromConfig() {
      if (!mySqlConfig) {
        return {};
      }
      return {
        "server.address": mySqlConfig.host,
        "server.port": mySqlConfig.port,
        "db.user": mySqlConfig.user
      };
    }
    __name(spanDataFromConfig, "spanDataFromConfig");
    function finishSpan(span) {
      if (!span || span.endTimestamp) {
        return;
      }
      const data = spanDataFromConfig();
      Object.keys(data).forEach((key) => {
        span.setData(key, data[key]);
      });
      span.finish();
    }
    __name(finishSpan, "finishSpan");
    fill(pkg, "createQuery", function(orig) {
      return function(options29, values, callback) {
        const scope = getCurrentHub3().getScope();
        const parentSpan = scope.getSpan();
        const span = _optionalChain([parentSpan, "optionalAccess", (_22) => _22.startChild, "call", (_32) => _32({
          description: typeof options29 === "string" ? options29 : options29.sql,
          op: "db",
          origin: "auto.db.mysql",
          data: {
            "db.system": "mysql"
          }
        })]);
        if (typeof callback === "function") {
          return orig.call(this, options29, values, function(err, result, fields) {
            finishSpan(span);
            callback(err, result, fields);
          });
        }
        if (typeof values === "function") {
          return orig.call(this, options29, function(err, result, fields) {
            finishSpan(span);
            values(err, result, fields);
          });
        }
        const query = orig.call(this, options29, values);
        query.on("end", () => {
          finishSpan(span);
        });
        return query;
      };
    });
  }
};
__name(Mysql, "Mysql");
Mysql.__initStatic();

// ../../node_modules/.pnpm/@sentry-internal+tracing@7.87.0/node_modules/@sentry-internal/tracing/esm/node/integrations/mongo.js
init_import_meta_url();
var OPERATIONS = [
  "aggregate",
  // aggregate(pipeline, options, callback)
  "bulkWrite",
  // bulkWrite(operations, options, callback)
  "countDocuments",
  // countDocuments(query, options, callback)
  "createIndex",
  // createIndex(fieldOrSpec, options, callback)
  "createIndexes",
  // createIndexes(indexSpecs, options, callback)
  "deleteMany",
  // deleteMany(filter, options, callback)
  "deleteOne",
  // deleteOne(filter, options, callback)
  "distinct",
  // distinct(key, query, options, callback)
  "drop",
  // drop(options, callback)
  "dropIndex",
  // dropIndex(indexName, options, callback)
  "dropIndexes",
  // dropIndexes(options, callback)
  "estimatedDocumentCount",
  // estimatedDocumentCount(options, callback)
  "find",
  // find(query, options, callback)
  "findOne",
  // findOne(query, options, callback)
  "findOneAndDelete",
  // findOneAndDelete(filter, options, callback)
  "findOneAndReplace",
  // findOneAndReplace(filter, replacement, options, callback)
  "findOneAndUpdate",
  // findOneAndUpdate(filter, update, options, callback)
  "indexes",
  // indexes(options, callback)
  "indexExists",
  // indexExists(indexes, options, callback)
  "indexInformation",
  // indexInformation(options, callback)
  "initializeOrderedBulkOp",
  // initializeOrderedBulkOp(options, callback)
  "insertMany",
  // insertMany(docs, options, callback)
  "insertOne",
  // insertOne(doc, options, callback)
  "isCapped",
  // isCapped(options, callback)
  "mapReduce",
  // mapReduce(map, reduce, options, callback)
  "options",
  // options(options, callback)
  "parallelCollectionScan",
  // parallelCollectionScan(options, callback)
  "rename",
  // rename(newName, options, callback)
  "replaceOne",
  // replaceOne(filter, doc, options, callback)
  "stats",
  // stats(options, callback)
  "updateMany",
  // updateMany(filter, update, options, callback)
  "updateOne"
  // updateOne(filter, update, options, callback)
];
var OPERATION_SIGNATURES = {
  // aggregate intentionally not included because `pipeline` arguments are too complex to serialize well
  // see https://github.com/getsentry/sentry-javascript/pull/3102
  bulkWrite: ["operations"],
  countDocuments: ["query"],
  createIndex: ["fieldOrSpec"],
  createIndexes: ["indexSpecs"],
  deleteMany: ["filter"],
  deleteOne: ["filter"],
  distinct: ["key", "query"],
  dropIndex: ["indexName"],
  find: ["query"],
  findOne: ["query"],
  findOneAndDelete: ["filter"],
  findOneAndReplace: ["filter", "replacement"],
  findOneAndUpdate: ["filter", "update"],
  indexExists: ["indexes"],
  insertMany: ["docs"],
  insertOne: ["doc"],
  mapReduce: ["map", "reduce"],
  rename: ["newName"],
  replaceOne: ["filter", "doc"],
  updateMany: ["filter", "update"],
  updateOne: ["filter", "update"]
};
function isCursor(maybeCursor) {
  return maybeCursor && typeof maybeCursor === "object" && maybeCursor.once && typeof maybeCursor.once === "function";
}
__name(isCursor, "isCursor");
var Mongo = class {
  /**
   * @inheritDoc
   */
  static __initStatic() {
    this.id = "Mongo";
  }
  /**
   * @inheritDoc
   */
  /**
   * @inheritDoc
   */
  constructor(options29 = {}) {
    this.name = Mongo.id;
    this._operations = Array.isArray(options29.operations) ? options29.operations : OPERATIONS;
    this._describeOperations = "describeOperations" in options29 ? options29.describeOperations : true;
    this._useMongoose = !!options29.useMongoose;
  }
  /** @inheritdoc */
  loadDependency() {
    const moduleName = this._useMongoose ? "mongoose" : "mongodb";
    return this._module = this._module || loadModule(moduleName);
  }
  /**
   * @inheritDoc
   */
  setupOnce(_3, getCurrentHub3) {
    if (shouldDisableAutoInstrumentation(getCurrentHub3)) {
      DEBUG_BUILD3 && logger2.log("Mongo Integration is skipped because of instrumenter configuration.");
      return;
    }
    const pkg = this.loadDependency();
    if (!pkg) {
      const moduleName = this._useMongoose ? "mongoose" : "mongodb";
      DEBUG_BUILD3 && logger2.error(`Mongo Integration was unable to require \`${moduleName}\` package.`);
      return;
    }
    this._instrumentOperations(pkg.Collection, this._operations, getCurrentHub3);
  }
  /**
   * Patches original collection methods
   */
  _instrumentOperations(collection, operations, getCurrentHub3) {
    operations.forEach((operation) => this._patchOperation(collection, operation, getCurrentHub3));
  }
  /**
   * Patches original collection to utilize our tracing functionality
   */
  _patchOperation(collection, operation, getCurrentHub3) {
    if (!(operation in collection.prototype))
      return;
    const getSpanContext = this._getSpanContextFromOperationArguments.bind(this);
    fill(collection.prototype, operation, function(orig) {
      return function(...args) {
        const lastArg = args[args.length - 1];
        const scope = getCurrentHub3().getScope();
        const parentSpan = scope.getSpan();
        if (typeof lastArg !== "function" || operation === "mapReduce" && args.length === 2) {
          const span2 = _optionalChain([parentSpan, "optionalAccess", (_22) => _22.startChild, "call", (_3) => _3(getSpanContext(this, operation, args))]);
          const maybePromiseOrCursor = orig.call(this, ...args);
          if (isThenable(maybePromiseOrCursor)) {
            return maybePromiseOrCursor.then((res) => {
              _optionalChain([span2, "optionalAccess", (_4) => _4.finish, "call", (_5) => _5()]);
              return res;
            });
          } else if (isCursor(maybePromiseOrCursor)) {
            const cursor = maybePromiseOrCursor;
            try {
              cursor.once("close", () => {
                _optionalChain([span2, "optionalAccess", (_6) => _6.finish, "call", (_7) => _7()]);
              });
            } catch (e3) {
              _optionalChain([span2, "optionalAccess", (_8) => _8.finish, "call", (_9) => _9()]);
            }
            return cursor;
          } else {
            _optionalChain([span2, "optionalAccess", (_10) => _10.finish, "call", (_11) => _11()]);
            return maybePromiseOrCursor;
          }
        }
        const span = _optionalChain([parentSpan, "optionalAccess", (_12) => _12.startChild, "call", (_13) => _13(getSpanContext(this, operation, args.slice(0, -1)))]);
        return orig.call(this, ...args.slice(0, -1), function(err, result) {
          _optionalChain([span, "optionalAccess", (_14) => _14.finish, "call", (_15) => _15()]);
          lastArg(err, result);
        });
      };
    });
  }
  /**
   * Form a SpanContext based on the user input to a given operation.
   */
  _getSpanContextFromOperationArguments(collection, operation, args) {
    const data = {
      "db.system": "mongodb",
      "db.name": collection.dbName,
      "db.operation": operation,
      "db.mongodb.collection": collection.collectionName
    };
    const spanContext = {
      op: "db",
      // TODO v8: Use `${collection.collectionName}.${operation}`
      origin: "auto.db.mongo",
      description: operation,
      data
    };
    const signature = OPERATION_SIGNATURES[operation];
    const shouldDescribe = Array.isArray(this._describeOperations) ? this._describeOperations.includes(operation) : this._describeOperations;
    if (!signature || !shouldDescribe) {
      return spanContext;
    }
    try {
      if (operation === "mapReduce") {
        const [map, reduce] = args;
        data[signature[0]] = typeof map === "string" ? map : map.name || "<anonymous>";
        data[signature[1]] = typeof reduce === "string" ? reduce : reduce.name || "<anonymous>";
      } else {
        for (let i = 0; i < signature.length; i++) {
          data[`db.mongodb.${signature[i]}`] = JSON.stringify(args[i]);
        }
      }
    } catch (_oO) {
    }
    return spanContext;
  }
};
__name(Mongo, "Mongo");
Mongo.__initStatic();

// ../../node_modules/.pnpm/@sentry-internal+tracing@7.87.0/node_modules/@sentry-internal/tracing/esm/node/integrations/prisma.js
init_import_meta_url();
function isValidPrismaClient(possibleClient) {
  return !!possibleClient && !!possibleClient["$use"];
}
__name(isValidPrismaClient, "isValidPrismaClient");
var Prisma = class {
  /**
   * @inheritDoc
   */
  static __initStatic() {
    this.id = "Prisma";
  }
  /**
   * @inheritDoc
   */
  /**
   * @inheritDoc
   */
  constructor(options29 = {}) {
    this.name = Prisma.id;
    if (isValidPrismaClient(options29.client) && !options29.client._sentryInstrumented) {
      addNonEnumerableProperty(options29.client, "_sentryInstrumented", true);
      const clientData = {};
      try {
        const engineConfig = options29.client._engineConfig;
        if (engineConfig) {
          const { activeProvider, clientVersion } = engineConfig;
          if (activeProvider) {
            clientData["db.system"] = activeProvider;
          }
          if (clientVersion) {
            clientData["db.prisma.version"] = clientVersion;
          }
        }
      } catch (e3) {
      }
      options29.client.$use((params, next) => {
        if (shouldDisableAutoInstrumentation(getCurrentHub)) {
          return next(params);
        }
        const action = params.action;
        const model = params.model;
        return trace(
          {
            name: model ? `${model} ${action}` : action,
            op: "db.prisma",
            origin: "auto.db.prisma",
            data: { ...clientData, "db.operation": action }
          },
          () => next(params)
        );
      });
    } else {
      DEBUG_BUILD3 && logger2.warn("Unsupported Prisma client provided to PrismaIntegration. Provided client:", options29.client);
    }
  }
  /**
   * @inheritDoc
   */
  setupOnce() {
  }
};
__name(Prisma, "Prisma");
Prisma.__initStatic();

// ../../node_modules/.pnpm/@sentry-internal+tracing@7.87.0/node_modules/@sentry-internal/tracing/esm/node/integrations/graphql.js
init_import_meta_url();
var GraphQL = class {
  /**
   * @inheritDoc
   */
  static __initStatic() {
    this.id = "GraphQL";
  }
  /**
   * @inheritDoc
   */
  constructor() {
    this.name = GraphQL.id;
  }
  /** @inheritdoc */
  loadDependency() {
    return this._module = this._module || loadModule("graphql/execution/execute.js");
  }
  /**
   * @inheritDoc
   */
  setupOnce(_3, getCurrentHub3) {
    if (shouldDisableAutoInstrumentation(getCurrentHub3)) {
      DEBUG_BUILD3 && logger2.log("GraphQL Integration is skipped because of instrumenter configuration.");
      return;
    }
    const pkg = this.loadDependency();
    if (!pkg) {
      DEBUG_BUILD3 && logger2.error("GraphQL Integration was unable to require graphql/execution package.");
      return;
    }
    fill(pkg, "execute", function(orig) {
      return function(...args) {
        const scope = getCurrentHub3().getScope();
        const parentSpan = scope.getSpan();
        const span = _optionalChain([parentSpan, "optionalAccess", (_22) => _22.startChild, "call", (_32) => _32({
          description: "execute",
          op: "graphql.execute",
          origin: "auto.graphql.graphql"
        })]);
        _optionalChain([scope, "optionalAccess", (_4) => _4.setSpan, "call", (_5) => _5(span)]);
        const rv = orig.call(this, ...args);
        if (isThenable(rv)) {
          return rv.then((res) => {
            _optionalChain([span, "optionalAccess", (_6) => _6.finish, "call", (_7) => _7()]);
            _optionalChain([scope, "optionalAccess", (_8) => _8.setSpan, "call", (_9) => _9(parentSpan)]);
            return res;
          });
        }
        _optionalChain([span, "optionalAccess", (_10) => _10.finish, "call", (_11) => _11()]);
        _optionalChain([scope, "optionalAccess", (_12) => _12.setSpan, "call", (_13) => _13(parentSpan)]);
        return rv;
      };
    });
  }
};
__name(GraphQL, "GraphQL");
GraphQL.__initStatic();

// ../../node_modules/.pnpm/@sentry-internal+tracing@7.87.0/node_modules/@sentry-internal/tracing/esm/node/integrations/apollo.js
init_import_meta_url();
var Apollo = class {
  /**
   * @inheritDoc
   */
  static __initStatic() {
    this.id = "Apollo";
  }
  /**
   * @inheritDoc
   */
  /**
   * @inheritDoc
   */
  constructor(options29 = {
    useNestjs: false
  }) {
    this.name = Apollo.id;
    this._useNest = !!options29.useNestjs;
  }
  /** @inheritdoc */
  loadDependency() {
    if (this._useNest) {
      this._module = this._module || loadModule("@nestjs/graphql");
    } else {
      this._module = this._module || loadModule("apollo-server-core");
    }
    return this._module;
  }
  /**
   * @inheritDoc
   */
  setupOnce(_3, getCurrentHub3) {
    if (shouldDisableAutoInstrumentation(getCurrentHub3)) {
      DEBUG_BUILD3 && logger2.log("Apollo Integration is skipped because of instrumenter configuration.");
      return;
    }
    if (this._useNest) {
      const pkg = this.loadDependency();
      if (!pkg) {
        DEBUG_BUILD3 && logger2.error("Apollo-NestJS Integration was unable to require @nestjs/graphql package.");
        return;
      }
      fill(
        pkg.GraphQLFactory.prototype,
        "mergeWithSchema",
        function(orig) {
          return function(...args) {
            fill(this.resolversExplorerService, "explore", function(orig2) {
              return function() {
                const resolvers = arrayify(orig2.call(this));
                const instrumentedResolvers = instrumentResolvers(resolvers, getCurrentHub3);
                return instrumentedResolvers;
              };
            });
            return orig.call(this, ...args);
          };
        }
      );
    } else {
      const pkg = this.loadDependency();
      if (!pkg) {
        DEBUG_BUILD3 && logger2.error("Apollo Integration was unable to require apollo-server-core package.");
        return;
      }
      fill(pkg.ApolloServerBase.prototype, "constructSchema", function(orig) {
        return function() {
          if (!this.config.resolvers) {
            if (DEBUG_BUILD3) {
              if (this.config.schema) {
                logger2.warn(
                  "Apollo integration is not able to trace `ApolloServer` instances constructed via `schema` property.If you are using NestJS with Apollo, please use `Sentry.Integrations.Apollo({ useNestjs: true })` instead."
                );
                logger2.warn();
              } else if (this.config.modules) {
                logger2.warn(
                  "Apollo integration is not able to trace `ApolloServer` instances constructed via `modules` property."
                );
              }
              logger2.error("Skipping tracing as no resolvers found on the `ApolloServer` instance.");
            }
            return orig.call(this);
          }
          const resolvers = arrayify(this.config.resolvers);
          this.config.resolvers = instrumentResolvers(resolvers, getCurrentHub3);
          return orig.call(this);
        };
      });
    }
  }
};
__name(Apollo, "Apollo");
Apollo.__initStatic();
function instrumentResolvers(resolvers, getCurrentHub3) {
  return resolvers.map((model) => {
    Object.keys(model).forEach((resolverGroupName) => {
      Object.keys(model[resolverGroupName]).forEach((resolverName) => {
        if (typeof model[resolverGroupName][resolverName] !== "function") {
          return;
        }
        wrapResolver(model, resolverGroupName, resolverName, getCurrentHub3);
      });
    });
    return model;
  });
}
__name(instrumentResolvers, "instrumentResolvers");
function wrapResolver(model, resolverGroupName, resolverName, getCurrentHub3) {
  fill(model[resolverGroupName], resolverName, function(orig) {
    return function(...args) {
      const scope = getCurrentHub3().getScope();
      const parentSpan = scope.getSpan();
      const span = _optionalChain([parentSpan, "optionalAccess", (_22) => _22.startChild, "call", (_3) => _3({
        description: `${resolverGroupName}.${resolverName}`,
        op: "graphql.resolve",
        origin: "auto.graphql.apollo"
      })]);
      const rv = orig.call(this, ...args);
      if (isThenable(rv)) {
        return rv.then((res) => {
          _optionalChain([span, "optionalAccess", (_4) => _4.finish, "call", (_5) => _5()]);
          return res;
        });
      }
      _optionalChain([span, "optionalAccess", (_6) => _6.finish, "call", (_7) => _7()]);
      return rv;
    };
  });
}
__name(wrapResolver, "wrapResolver");

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/client.js
init_import_meta_url();
var os8 = __toESM(require("os"));
var import_util6 = require("util");
var NodeClient = class extends ServerRuntimeClient {
  /**
   * Creates a new Node SDK instance.
   * @param options Configuration options for this SDK.
   */
  constructor(options29) {
    options29._metadata = options29._metadata || {};
    options29._metadata.sdk = options29._metadata.sdk || {
      name: "sentry.javascript.node",
      packages: [
        {
          name: "npm:@sentry/node",
          version: SDK_VERSION
        }
      ],
      version: SDK_VERSION
    };
    options29.transportOptions = {
      textEncoder: new import_util6.TextEncoder(),
      ...options29.transportOptions
    };
    const clientOptions = {
      ...options29,
      platform: "node",
      runtime: { name: "node", version: global.process.version },
      serverName: options29.serverName || global.process.env.SENTRY_NAME || os8.hostname()
    };
    super(clientOptions);
  }
};
__name(NodeClient, "NodeClient");

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/transports/http.js
init_import_meta_url();
var http2 = __toESM(require("http"));
var https = __toESM(require("https"));
var import_stream3 = require("stream");
var import_url5 = require("url");
var import_zlib = require("zlib");
var import_https_proxy_agent2 = __toESM(require_dist7());
var GZIP_THRESHOLD = 1024 * 32;
function streamFromBody(body) {
  return new import_stream3.Readable({
    read() {
      this.push(body);
      this.push(null);
    }
  });
}
__name(streamFromBody, "streamFromBody");
function makeNodeTransport(options29) {
  let urlSegments;
  try {
    urlSegments = new import_url5.URL(options29.url);
  } catch (e3) {
    consoleSandbox(() => {
      console.warn(
        "[@sentry/node]: Invalid dsn or tunnel option, will not send any events. The tunnel option must be a full URL when used."
      );
    });
    return createTransport(options29, () => Promise.resolve({}));
  }
  const isHttps = urlSegments.protocol === "https:";
  const proxy2 = applyNoProxyOption(
    urlSegments,
    options29.proxy || (isHttps ? process.env.https_proxy : void 0) || process.env.http_proxy
  );
  const nativeHttpModule = isHttps ? https : http2;
  const keepAlive = options29.keepAlive === void 0 ? false : options29.keepAlive;
  const agent = proxy2 ? new import_https_proxy_agent2.HttpsProxyAgent(proxy2) : new nativeHttpModule.Agent({ keepAlive, maxSockets: 30, timeout: 2e3 });
  const requestExecutor = createRequestExecutor(options29, _nullishCoalesce(options29.httpModule, () => nativeHttpModule), agent);
  return createTransport(options29, requestExecutor);
}
__name(makeNodeTransport, "makeNodeTransport");
function applyNoProxyOption(transportUrlSegments, proxy2) {
  const { no_proxy } = process.env;
  const urlIsExemptFromProxy = no_proxy && no_proxy.split(",").some(
    (exemption) => transportUrlSegments.host.endsWith(exemption) || transportUrlSegments.hostname.endsWith(exemption)
  );
  if (urlIsExemptFromProxy) {
    return void 0;
  } else {
    return proxy2;
  }
}
__name(applyNoProxyOption, "applyNoProxyOption");
function createRequestExecutor(options29, httpModule, agent) {
  const { hostname: hostname2, pathname, port: port2, protocol, search } = new import_url5.URL(options29.url);
  return /* @__PURE__ */ __name(function makeRequest(request3) {
    return new Promise((resolve19, reject) => {
      let body = streamFromBody(request3.body);
      const headers = { ...options29.headers };
      if (request3.body.length > GZIP_THRESHOLD) {
        headers["content-encoding"] = "gzip";
        body = body.pipe((0, import_zlib.createGzip)());
      }
      const req = httpModule.request(
        {
          method: "POST",
          agent,
          headers,
          hostname: hostname2,
          path: `${pathname}${search}`,
          port: port2,
          protocol,
          ca: options29.caCerts
        },
        (res) => {
          res.on("data", () => {
          });
          res.on("end", () => {
          });
          res.setEncoding("utf8");
          const retryAfterHeader = _nullishCoalesce(res.headers["retry-after"], () => null);
          const rateLimitsHeader = _nullishCoalesce(res.headers["x-sentry-rate-limits"], () => null);
          resolve19({
            statusCode: res.statusCode,
            headers: {
              "retry-after": retryAfterHeader,
              "x-sentry-rate-limits": Array.isArray(rateLimitsHeader) ? rateLimitsHeader[0] : rateLimitsHeader
            }
          });
        }
      );
      req.on("error", reject);
      body.pipe(req);
    });
  }, "makeRequest");
}
__name(createRequestExecutor, "createRequestExecutor");

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/sdk.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/anr/index.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/module.js
init_import_meta_url();
var import_path13 = require("path");
var isWindowsPlatform = import_path13.sep === "\\";
function normalizeWindowsPath(path67) {
  return path67.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
}
__name(normalizeWindowsPath, "normalizeWindowsPath");
function getModuleFromFilename(filename, normalizeWindowsPathSeparator = isWindowsPlatform) {
  if (!filename) {
    return;
  }
  const normalizedFilename = normalizeWindowsPathSeparator ? normalizeWindowsPath(filename) : filename;
  let { root, dir, base: basename4, ext } = import_path13.posix.parse(normalizedFilename);
  const base = require && require.main && require.main.filename && dir || global.process.cwd();
  const normalizedBase = `${base}/`;
  let file = basename4;
  if (ext === ".js" || ext === ".mjs" || ext === ".cjs") {
    file = file.slice(0, ext.length * -1);
  }
  if (!root && !dir) {
    dir = ".";
  }
  let n2 = dir.lastIndexOf("/node_modules/");
  if (n2 > -1) {
    return `${dir.slice(n2 + 14).replace(/\//g, ".")}:${file}`;
  }
  n2 = `${dir}/`.lastIndexOf(normalizedBase, 0);
  if (n2 === 0) {
    let moduleName = dir.slice(normalizedBase.length).replace(/\//g, ".");
    if (moduleName) {
      moduleName += ":";
    }
    moduleName += file;
    return moduleName;
  }
  return file;
}
__name(getModuleFromFilename, "getModuleFromFilename");

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/anr/index.js
function isAnrChildProcess() {
  return !!process.send && !!process.env.SENTRY_ANR_CHILD_PROCESS;
}
__name(isAnrChildProcess, "isAnrChildProcess");

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/async/index.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/nodeVersion.js
init_import_meta_url();
var NODE_VERSION = parseSemver(process.versions.node);

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/async/domain.js
init_import_meta_url();
var domain = __toESM(require("domain"));
function getActiveDomain() {
  return domain.active;
}
__name(getActiveDomain, "getActiveDomain");
function getCurrentHub2() {
  const activeDomain = getActiveDomain();
  if (!activeDomain) {
    return void 0;
  }
  ensureHubOnCarrier(activeDomain);
  return getHubFromCarrier(activeDomain);
}
__name(getCurrentHub2, "getCurrentHub");
function createNewHub(parent) {
  const carrier = {};
  ensureHubOnCarrier(carrier, parent);
  return getHubFromCarrier(carrier);
}
__name(createNewHub, "createNewHub");
function runWithAsyncContext2(callback, options29) {
  const activeDomain = getActiveDomain();
  if (activeDomain && _optionalChain([options29, "optionalAccess", (_3) => _3.reuseExisting])) {
    return callback();
  }
  const local = domain.create();
  const parentHub = activeDomain ? getHubFromCarrier(activeDomain) : void 0;
  const newHub = createNewHub(parentHub);
  setHubOnCarrier(local, newHub);
  return local.bind(() => {
    return callback();
  })();
}
__name(runWithAsyncContext2, "runWithAsyncContext");
function setDomainAsyncContextStrategy() {
  setAsyncContextStrategy({ getCurrentHub: getCurrentHub2, runWithAsyncContext: runWithAsyncContext2 });
}
__name(setDomainAsyncContextStrategy, "setDomainAsyncContextStrategy");

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/async/hooks.js
init_import_meta_url();
var async_hooks = __toESM(require("async_hooks"));
var asyncStorage;
function setHooksAsyncContextStrategy() {
  if (!asyncStorage) {
    asyncStorage = new async_hooks.AsyncLocalStorage();
  }
  function getCurrentHub3() {
    return asyncStorage.getStore();
  }
  __name(getCurrentHub3, "getCurrentHub");
  function createNewHub2(parent) {
    const carrier = {};
    ensureHubOnCarrier(carrier, parent);
    return getHubFromCarrier(carrier);
  }
  __name(createNewHub2, "createNewHub");
  function runWithAsyncContext3(callback, options29) {
    const existingHub = getCurrentHub3();
    if (existingHub && _optionalChain([options29, "optionalAccess", (_3) => _3.reuseExisting])) {
      return callback();
    }
    const newHub = createNewHub2(existingHub);
    return asyncStorage.run(newHub, () => {
      return callback();
    });
  }
  __name(runWithAsyncContext3, "runWithAsyncContext");
  setAsyncContextStrategy({ getCurrentHub: getCurrentHub3, runWithAsyncContext: runWithAsyncContext3 });
}
__name(setHooksAsyncContextStrategy, "setHooksAsyncContextStrategy");

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/async/index.js
function setNodeAsyncContextStrategy() {
  if (NODE_VERSION.major && NODE_VERSION.major >= 14) {
    setHooksAsyncContextStrategy();
  } else {
    setDomainAsyncContextStrategy();
  }
}
__name(setNodeAsyncContextStrategy, "setNodeAsyncContextStrategy");

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/integrations/console.js
init_import_meta_url();
var util = __toESM(require("util"));
var Console = class {
  constructor() {
    Console.prototype.__init.call(this);
  }
  /**
   * @inheritDoc
   */
  static __initStatic() {
    this.id = "Console";
  }
  /**
   * @inheritDoc
   */
  __init() {
    this.name = Console.id;
  }
  /**
   * @inheritDoc
   */
  setupOnce() {
    addConsoleInstrumentationHandler(({ args, level }) => {
      const hub = getCurrentHub();
      if (!hub.getIntegration(Console)) {
        return;
      }
      hub.addBreadcrumb(
        {
          category: "console",
          level: severityLevelFromString(level),
          message: util.format.apply(void 0, args)
        },
        {
          input: [...args],
          level
        }
      );
    });
  }
};
__name(Console, "Console");
Console.__initStatic();

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/integrations/http.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/debug-build.js
init_import_meta_url();
var DEBUG_BUILD4 = typeof __SENTRY_DEBUG__ === "undefined" || __SENTRY_DEBUG__;

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/integrations/utils/http.js
init_import_meta_url();
var import_url6 = require("url");
function extractRawUrl(requestOptions) {
  const { protocol, hostname: hostname2, port: port2 } = parseRequestOptions(requestOptions);
  const path67 = requestOptions.path ? requestOptions.path : "/";
  return `${protocol}//${hostname2}${port2}${path67}`;
}
__name(extractRawUrl, "extractRawUrl");
function extractUrl(requestOptions) {
  const { protocol, hostname: hostname2, port: port2 } = parseRequestOptions(requestOptions);
  const path67 = requestOptions.pathname || "/";
  const authority = requestOptions.auth ? redactAuthority(requestOptions.auth) : "";
  return `${protocol}//${authority}${hostname2}${port2}${path67}`;
}
__name(extractUrl, "extractUrl");
function redactAuthority(auth) {
  const [user, password] = auth.split(":");
  return `${user ? "[Filtered]" : ""}:${password ? "[Filtered]" : ""}@`;
}
__name(redactAuthority, "redactAuthority");
function cleanSpanDescription(description, requestOptions, request3) {
  if (!description) {
    return description;
  }
  let [method, requestUrl] = description.split(" ");
  if (requestOptions.host && !requestOptions.protocol) {
    requestOptions.protocol = _optionalChain([request3, "optionalAccess", (_3) => _3.agent, "optionalAccess", (_22) => _22.protocol]);
    requestUrl = extractUrl(requestOptions);
  }
  if (_optionalChain([requestUrl, "optionalAccess", (_3) => _3.startsWith, "call", (_4) => _4("///")])) {
    requestUrl = requestUrl.slice(2);
  }
  return `${method} ${requestUrl}`;
}
__name(cleanSpanDescription, "cleanSpanDescription");
function urlToOptions(url4) {
  const options29 = {
    protocol: url4.protocol,
    hostname: typeof url4.hostname === "string" && url4.hostname.startsWith("[") ? url4.hostname.slice(1, -1) : url4.hostname,
    hash: url4.hash,
    search: url4.search,
    pathname: url4.pathname,
    path: `${url4.pathname || ""}${url4.search || ""}`,
    href: url4.href
  };
  if (url4.port !== "") {
    options29.port = Number(url4.port);
  }
  if (url4.username || url4.password) {
    options29.auth = `${url4.username}:${url4.password}`;
  }
  return options29;
}
__name(urlToOptions, "urlToOptions");
function normalizeRequestArgs(httpModule, requestArgs) {
  let callback, requestOptions;
  if (typeof requestArgs[requestArgs.length - 1] === "function") {
    callback = requestArgs.pop();
  }
  if (typeof requestArgs[0] === "string") {
    requestOptions = urlToOptions(new import_url6.URL(requestArgs[0]));
  } else if (requestArgs[0] instanceof import_url6.URL) {
    requestOptions = urlToOptions(requestArgs[0]);
  } else {
    requestOptions = requestArgs[0];
    try {
      const parsed = new import_url6.URL(
        requestOptions.path || "",
        `${requestOptions.protocol || "http:"}//${requestOptions.hostname}`
      );
      requestOptions = {
        pathname: parsed.pathname,
        search: parsed.search,
        hash: parsed.hash,
        ...requestOptions
      };
    } catch (e3) {
    }
  }
  if (requestArgs.length === 2) {
    requestOptions = { ...requestOptions, ...requestArgs[1] };
  }
  if (requestOptions.protocol === void 0) {
    if (NODE_VERSION.major && NODE_VERSION.major > 8) {
      requestOptions.protocol = _optionalChain([_optionalChain([httpModule, "optionalAccess", (_5) => _5.globalAgent]), "optionalAccess", (_6) => _6.protocol]) || _optionalChain([requestOptions.agent, "optionalAccess", (_7) => _7.protocol]) || _optionalChain([requestOptions._defaultAgent, "optionalAccess", (_8) => _8.protocol]);
    } else {
      requestOptions.protocol = _optionalChain([requestOptions.agent, "optionalAccess", (_9) => _9.protocol]) || _optionalChain([requestOptions._defaultAgent, "optionalAccess", (_10) => _10.protocol]) || _optionalChain([_optionalChain([httpModule, "optionalAccess", (_11) => _11.globalAgent]), "optionalAccess", (_12) => _12.protocol]);
    }
  }
  if (callback) {
    return [requestOptions, callback];
  } else {
    return [requestOptions];
  }
}
__name(normalizeRequestArgs, "normalizeRequestArgs");
function parseRequestOptions(requestOptions) {
  const protocol = requestOptions.protocol || "";
  const hostname2 = requestOptions.hostname || requestOptions.host || "";
  const port2 = !requestOptions.port || requestOptions.port === 80 || requestOptions.port === 443 || /^(.*):(\d+)$/.test(hostname2) ? "" : `:${requestOptions.port}`;
  return { protocol, hostname: hostname2, port: port2 };
}
__name(parseRequestOptions, "parseRequestOptions");

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/integrations/http.js
var Http = class {
  /**
   * @inheritDoc
   */
  static __initStatic() {
    this.id = "Http";
  }
  /**
   * @inheritDoc
   */
  __init() {
    this.name = Http.id;
  }
  /**
   * @inheritDoc
   */
  constructor(options29 = {}) {
    Http.prototype.__init.call(this);
    this._breadcrumbs = typeof options29.breadcrumbs === "undefined" ? true : options29.breadcrumbs;
    this._tracing = !options29.tracing ? void 0 : options29.tracing === true ? {} : options29.tracing;
  }
  /**
   * @inheritDoc
   */
  setupOnce(_addGlobalEventProcessor, setupOnceGetCurrentHub) {
    if (!this._breadcrumbs && !this._tracing) {
      return;
    }
    const clientOptions = _optionalChain([setupOnceGetCurrentHub, "call", (_3) => _3(), "access", (_22) => _22.getClient, "call", (_3) => _3(), "optionalAccess", (_4) => _4.getOptions, "call", (_5) => _5()]);
    if (clientOptions && clientOptions.instrumenter !== "sentry") {
      DEBUG_BUILD4 && logger2.log("HTTP Integration is skipped because of instrumenter configuration.");
      return;
    }
    const shouldCreateSpanForRequest = (
      // eslint-disable-next-line deprecation/deprecation
      _optionalChain([this, "access", (_6) => _6._tracing, "optionalAccess", (_7) => _7.shouldCreateSpanForRequest]) || _optionalChain([clientOptions, "optionalAccess", (_8) => _8.shouldCreateSpanForRequest])
    );
    const tracePropagationTargets = _optionalChain([clientOptions, "optionalAccess", (_9) => _9.tracePropagationTargets]) || _optionalChain([this, "access", (_10) => _10._tracing, "optionalAccess", (_11) => _11.tracePropagationTargets]);
    const httpModule = require("http");
    const wrappedHttpHandlerMaker = _createWrappedRequestMethodFactory(
      httpModule,
      this._breadcrumbs,
      shouldCreateSpanForRequest,
      tracePropagationTargets
    );
    fill(httpModule, "get", wrappedHttpHandlerMaker);
    fill(httpModule, "request", wrappedHttpHandlerMaker);
    if (NODE_VERSION.major && NODE_VERSION.major > 8) {
      const httpsModule = require("https");
      const wrappedHttpsHandlerMaker = _createWrappedRequestMethodFactory(
        httpsModule,
        this._breadcrumbs,
        shouldCreateSpanForRequest,
        tracePropagationTargets
      );
      fill(httpsModule, "get", wrappedHttpsHandlerMaker);
      fill(httpsModule, "request", wrappedHttpsHandlerMaker);
    }
  }
};
__name(Http, "Http");
Http.__initStatic();
function _createWrappedRequestMethodFactory(httpModule, breadcrumbsEnabled, shouldCreateSpanForRequest, tracePropagationTargets) {
  const createSpanUrlMap = new LRUMap(100);
  const headersUrlMap = new LRUMap(100);
  const shouldCreateSpan = /* @__PURE__ */ __name((url4) => {
    if (shouldCreateSpanForRequest === void 0) {
      return true;
    }
    const cachedDecision = createSpanUrlMap.get(url4);
    if (cachedDecision !== void 0) {
      return cachedDecision;
    }
    const decision = shouldCreateSpanForRequest(url4);
    createSpanUrlMap.set(url4, decision);
    return decision;
  }, "shouldCreateSpan");
  const shouldAttachTraceData = /* @__PURE__ */ __name((url4) => {
    if (tracePropagationTargets === void 0) {
      return true;
    }
    const cachedDecision = headersUrlMap.get(url4);
    if (cachedDecision !== void 0) {
      return cachedDecision;
    }
    const decision = stringMatchesSomePattern(url4, tracePropagationTargets);
    headersUrlMap.set(url4, decision);
    return decision;
  }, "shouldAttachTraceData");
  function addRequestBreadcrumb(event, requestSpanData, req, res) {
    if (!getCurrentHub().getIntegration(Http)) {
      return;
    }
    getCurrentHub().addBreadcrumb(
      {
        category: "http",
        data: {
          status_code: res && res.statusCode,
          ...requestSpanData
        },
        type: "http"
      },
      {
        event,
        request: req,
        response: res
      }
    );
  }
  __name(addRequestBreadcrumb, "addRequestBreadcrumb");
  return /* @__PURE__ */ __name(function wrappedRequestMethodFactory(originalRequestMethod) {
    return /* @__PURE__ */ __name(function wrappedMethod(...args) {
      const requestArgs = normalizeRequestArgs(httpModule, args);
      const requestOptions = requestArgs[0];
      const rawRequestUrl = extractRawUrl(requestOptions);
      const requestUrl = extractUrl(requestOptions);
      if (isSentryRequestUrl(requestUrl, getCurrentHub())) {
        return originalRequestMethod.apply(httpModule, requestArgs);
      }
      const hub = getCurrentHub();
      const scope = hub.getScope();
      const parentSpan = scope.getSpan();
      const data = getRequestSpanData(requestUrl, requestOptions);
      const requestSpan = shouldCreateSpan(rawRequestUrl) ? _optionalChain([parentSpan, "optionalAccess", (_12) => _12.startChild, "call", (_13) => _13({
        op: "http.client",
        origin: "auto.http.node.http",
        description: `${data["http.method"]} ${data.url}`,
        data
      })]) : void 0;
      if (shouldAttachTraceData(rawRequestUrl)) {
        if (requestSpan) {
          const sentryTraceHeader = requestSpan.toTraceparent();
          const dynamicSamplingContext = _optionalChain([requestSpan, "optionalAccess", (_14) => _14.transaction, "optionalAccess", (_15) => _15.getDynamicSamplingContext, "call", (_16) => _16()]);
          addHeadersToRequestOptions(requestOptions, requestUrl, sentryTraceHeader, dynamicSamplingContext);
        } else {
          const client = hub.getClient();
          const { traceId, sampled, dsc } = scope.getPropagationContext();
          const sentryTraceHeader = generateSentryTraceHeader(traceId, void 0, sampled);
          const dynamicSamplingContext = dsc || (client ? getDynamicSamplingContextFromClient(traceId, client, scope) : void 0);
          addHeadersToRequestOptions(requestOptions, requestUrl, sentryTraceHeader, dynamicSamplingContext);
        }
      } else {
        DEBUG_BUILD4 && logger2.log(
          `[Tracing] Not adding sentry-trace header to outgoing request (${requestUrl}) due to mismatching tracePropagationTargets option.`
        );
      }
      return originalRequestMethod.apply(httpModule, requestArgs).once("response", function(res) {
        const req = this;
        if (breadcrumbsEnabled) {
          addRequestBreadcrumb("response", data, req, res);
        }
        if (requestSpan) {
          if (res.statusCode) {
            requestSpan.setHttpStatus(res.statusCode);
          }
          requestSpan.description = cleanSpanDescription(requestSpan.description, requestOptions, req);
          requestSpan.finish();
        }
      }).once("error", function() {
        const req = this;
        if (breadcrumbsEnabled) {
          addRequestBreadcrumb("error", data, req);
        }
        if (requestSpan) {
          requestSpan.setHttpStatus(500);
          requestSpan.description = cleanSpanDescription(requestSpan.description, requestOptions, req);
          requestSpan.finish();
        }
      });
    }, "wrappedMethod");
  }, "wrappedRequestMethodFactory");
}
__name(_createWrappedRequestMethodFactory, "_createWrappedRequestMethodFactory");
function addHeadersToRequestOptions(requestOptions, requestUrl, sentryTraceHeader, dynamicSamplingContext) {
  const headers = requestOptions.headers || {};
  if (headers["sentry-trace"]) {
    return;
  }
  DEBUG_BUILD4 && logger2.log(`[Tracing] Adding sentry-trace header ${sentryTraceHeader} to outgoing request to "${requestUrl}": `);
  const sentryBaggage = dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext);
  const sentryBaggageHeader = sentryBaggage && sentryBaggage.length > 0 ? normalizeBaggageHeader(requestOptions, sentryBaggage) : void 0;
  requestOptions.headers = {
    ...requestOptions.headers,
    "sentry-trace": sentryTraceHeader,
    // Setting a header to `undefined` will crash in node so we only set the baggage header when it's defined
    ...sentryBaggageHeader && { baggage: sentryBaggageHeader }
  };
}
__name(addHeadersToRequestOptions, "addHeadersToRequestOptions");
function getRequestSpanData(requestUrl, requestOptions) {
  const method = requestOptions.method || "GET";
  const data = {
    url: requestUrl,
    "http.method": method
  };
  if (requestOptions.hash) {
    data["http.fragment"] = requestOptions.hash.substring(1);
  }
  if (requestOptions.search) {
    data["http.query"] = requestOptions.search.substring(1);
  }
  return data;
}
__name(getRequestSpanData, "getRequestSpanData");
function normalizeBaggageHeader(requestOptions, sentryBaggageHeader) {
  if (!requestOptions.headers || !requestOptions.headers.baggage) {
    return sentryBaggageHeader;
  } else if (!sentryBaggageHeader) {
    return requestOptions.headers.baggage;
  } else if (Array.isArray(requestOptions.headers.baggage)) {
    return [...requestOptions.headers.baggage, sentryBaggageHeader];
  }
  return [requestOptions.headers.baggage, sentryBaggageHeader];
}
__name(normalizeBaggageHeader, "normalizeBaggageHeader");

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/integrations/onuncaughtexception.js
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/integrations/utils/errorhandling.js
init_import_meta_url();
var DEFAULT_SHUTDOWN_TIMEOUT = 2e3;
function logAndExitProcess(error2) {
  consoleSandbox(() => {
    console.error(error2);
  });
  const client = getClient();
  if (client === void 0) {
    DEBUG_BUILD4 && logger2.warn("No NodeClient was defined, we are exiting the process now.");
    global.process.exit(1);
  }
  const options29 = client.getOptions();
  const timeout = options29 && options29.shutdownTimeout && options29.shutdownTimeout > 0 && options29.shutdownTimeout || DEFAULT_SHUTDOWN_TIMEOUT;
  client.close(timeout).then(
    (result) => {
      if (!result) {
        DEBUG_BUILD4 && logger2.warn("We reached the timeout for emptying the request buffer, still exiting now!");
      }
      global.process.exit(1);
    },
    (error3) => {
      DEBUG_BUILD4 && logger2.error(error3);
    }
  );
}
__name(logAndExitProcess, "logAndExitProcess");

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/integrations/onuncaughtexception.js
var OnUncaughtException = class {
  /**
   * @inheritDoc
   */
  static __initStatic() {
    this.id = "OnUncaughtException";
  }
  /**
   * @inheritDoc
   */
  __init() {
    this.name = OnUncaughtException.id;
  }
  /**
   * @inheritDoc
   */
  __init2() {
    this.handler = this._makeErrorHandler();
  }
  // CAREFUL: Please think twice before updating the way _options looks because the Next.js SDK depends on it in `index.server.ts`
  /**
   * @inheritDoc
   */
  constructor(options29 = {}) {
    OnUncaughtException.prototype.__init.call(this);
    OnUncaughtException.prototype.__init2.call(this);
    this._options = {
      exitEvenIfOtherHandlersAreRegistered: true,
      ...options29
    };
  }
  /**
   * @inheritDoc
   */
  setupOnce() {
    global.process.on("uncaughtException", this.handler);
  }
  /**
   * @hidden
   */
  _makeErrorHandler() {
    const timeout = 2e3;
    let caughtFirstError = false;
    let caughtSecondError = false;
    let calledFatalError = false;
    let firstError;
    return (error2) => {
      let onFatalError = logAndExitProcess;
      const client = getClient();
      if (this._options.onFatalError) {
        onFatalError = this._options.onFatalError;
      } else if (client && client.getOptions().onFatalError) {
        onFatalError = client.getOptions().onFatalError;
      }
      const userProvidedListenersCount = global.process.listeners("uncaughtException").reduce((acc, listener) => {
        if (
          // There are 3 listeners we ignore:
          listener.name === "domainUncaughtExceptionClear" || // as soon as we're using domains this listener is attached by node itself
          listener.tag && listener.tag === "sentry_tracingErrorCallback" || // the handler we register for tracing
          listener === this.handler
        ) {
          return acc;
        } else {
          return acc + 1;
        }
      }, 0);
      const processWouldExit = userProvidedListenersCount === 0;
      const shouldApplyFatalHandlingLogic = this._options.exitEvenIfOtherHandlersAreRegistered || processWouldExit;
      if (!caughtFirstError) {
        const hub = getCurrentHub();
        firstError = error2;
        caughtFirstError = true;
        if (hub.getIntegration(OnUncaughtException)) {
          hub.withScope((scope) => {
            scope.setLevel("fatal");
            hub.captureException(error2, {
              originalException: error2,
              data: { mechanism: { handled: false, type: "onuncaughtexception" } }
            });
            if (!calledFatalError && shouldApplyFatalHandlingLogic) {
              calledFatalError = true;
              onFatalError(error2);
            }
          });
        } else {
          if (!calledFatalError && shouldApplyFatalHandlingLogic) {
            calledFatalError = true;
            onFatalError(error2);
          }
        }
      } else {
        if (shouldApplyFatalHandlingLogic) {
          if (calledFatalError) {
            DEBUG_BUILD4 && logger2.warn(
              "uncaught exception after calling fatal error shutdown callback - this is bad! forcing shutdown"
            );
            logAndExitProcess(error2);
          } else if (!caughtSecondError) {
            caughtSecondError = true;
            setTimeout(() => {
              if (!calledFatalError) {
                calledFatalError = true;
                onFatalError(firstError, error2);
              }
            }, timeout);
          }
        }
      }
    };
  }
};
__name(OnUncaughtException, "OnUncaughtException");
OnUncaughtException.__initStatic();

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/integrations/onunhandledrejection.js
init_import_meta_url();
var OnUnhandledRejection = class {
  /**
   * @inheritDoc
   */
  static __initStatic() {
    this.id = "OnUnhandledRejection";
  }
  /**
   * @inheritDoc
   */
  __init() {
    this.name = OnUnhandledRejection.id;
  }
  /**
   * @inheritDoc
   */
  constructor(_options = { mode: "warn" }) {
    this._options = _options;
    OnUnhandledRejection.prototype.__init.call(this);
  }
  /**
   * @inheritDoc
   */
  setupOnce() {
    global.process.on("unhandledRejection", this.sendUnhandledPromise.bind(this));
  }
  /**
   * Send an exception with reason
   * @param reason string
   * @param promise promise
   */
  sendUnhandledPromise(reason, promise) {
    const hub = getCurrentHub();
    if (hub.getIntegration(OnUnhandledRejection)) {
      hub.withScope((scope) => {
        scope.setExtra("unhandledPromiseRejection", true);
        hub.captureException(reason, {
          originalException: promise,
          data: { mechanism: { handled: false, type: "onunhandledrejection" } }
        });
      });
    }
    this._handleRejection(reason);
  }
  /**
   * Handler for `mode` option
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  _handleRejection(reason) {
    const rejectionWarning = "This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). The promise rejected with the reason:";
    if (this._options.mode === "warn") {
      consoleSandbox(() => {
        console.warn(rejectionWarning);
        console.error(reason && reason.stack ? reason.stack : reason);
      });
    } else if (this._options.mode === "strict") {
      consoleSandbox(() => {
        console.warn(rejectionWarning);
      });
      logAndExitProcess(reason);
    }
  }
};
__name(OnUnhandledRejection, "OnUnhandledRejection");
OnUnhandledRejection.__initStatic();

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/integrations/modules.js
init_import_meta_url();
var import_fs9 = require("fs");
var import_path14 = require("path");
var moduleCache;
function getPaths() {
  try {
    return require.cache ? Object.keys(require.cache) : [];
  } catch (e3) {
    return [];
  }
}
__name(getPaths, "getPaths");
function collectModules() {
  const mainPaths = require.main && require.main.paths || [];
  const paths = getPaths();
  const infos = {};
  const seen = {};
  paths.forEach((path67) => {
    let dir = path67;
    const updir = /* @__PURE__ */ __name(() => {
      const orig = dir;
      dir = (0, import_path14.dirname)(orig);
      if (!dir || orig === dir || seen[orig]) {
        return void 0;
      }
      if (mainPaths.indexOf(dir) < 0) {
        return updir();
      }
      const pkgfile = (0, import_path14.join)(orig, "package.json");
      seen[orig] = true;
      if (!(0, import_fs9.existsSync)(pkgfile)) {
        return updir();
      }
      try {
        const info = JSON.parse((0, import_fs9.readFileSync)(pkgfile, "utf8"));
        infos[info.name] = info.version;
      } catch (_oO) {
      }
    }, "updir");
    updir();
  });
  return infos;
}
__name(collectModules, "collectModules");
var Modules = class {
  constructor() {
    Modules.prototype.__init.call(this);
  }
  /**
   * @inheritDoc
   */
  static __initStatic() {
    this.id = "Modules";
  }
  /**
   * @inheritDoc
   */
  __init() {
    this.name = Modules.id;
  }
  /**
   * @inheritDoc
   */
  setupOnce(addGlobalEventProcessor2, getCurrentHub3) {
    addGlobalEventProcessor2((event) => {
      if (!getCurrentHub3().getIntegration(Modules)) {
        return event;
      }
      return {
        ...event,
        modules: {
          ...event.modules,
          ...this._getModules()
        }
      };
    });
  }
  /** Fetches the list of modules and the versions loaded by the entry file for your node.js app. */
  _getModules() {
    if (!moduleCache) {
      moduleCache = collectModules();
    }
    return moduleCache;
  }
};
__name(Modules, "Modules");
Modules.__initStatic();

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/integrations/contextlines.js
init_import_meta_url();
var import_fs10 = require("fs");
var FILE_CONTENT_CACHE = new LRUMap(100);
var DEFAULT_LINES_OF_CONTEXT = 7;
function readTextFileAsync(path67) {
  return new Promise((resolve19, reject) => {
    (0, import_fs10.readFile)(path67, "utf8", (err, data) => {
      if (err)
        reject(err);
      else
        resolve19(data);
    });
  });
}
__name(readTextFileAsync, "readTextFileAsync");
var ContextLines = class {
  /**
   * @inheritDoc
   */
  static __initStatic() {
    this.id = "ContextLines";
  }
  /**
   * @inheritDoc
   */
  __init() {
    this.name = ContextLines.id;
  }
  constructor(_options = {}) {
    this._options = _options;
    ContextLines.prototype.__init.call(this);
  }
  /** Get's the number of context lines to add */
  get _contextLines() {
    return this._options.frameContextLines !== void 0 ? this._options.frameContextLines : DEFAULT_LINES_OF_CONTEXT;
  }
  /**
   * @inheritDoc
   */
  setupOnce(addGlobalEventProcessor2, getCurrentHub3) {
    addGlobalEventProcessor2((event) => {
      const self2 = getCurrentHub3().getIntegration(ContextLines);
      if (!self2) {
        return event;
      }
      return this.addSourceContext(event);
    });
  }
  /** Processes an event and adds context lines */
  async addSourceContext(event) {
    const enqueuedReadSourceFileTasks = {};
    const readSourceFileTasks = [];
    if (this._contextLines > 0 && _optionalChain([event, "access", (_22) => _22.exception, "optionalAccess", (_3) => _3.values])) {
      for (const exception of event.exception.values) {
        if (!_optionalChain([exception, "access", (_4) => _4.stacktrace, "optionalAccess", (_5) => _5.frames])) {
          continue;
        }
        for (let i = exception.stacktrace.frames.length - 1; i >= 0; i--) {
          const frame = exception.stacktrace.frames[i];
          if (frame.filename && !enqueuedReadSourceFileTasks[frame.filename] && !FILE_CONTENT_CACHE.get(frame.filename)) {
            readSourceFileTasks.push(_readSourceFile(frame.filename));
            enqueuedReadSourceFileTasks[frame.filename] = 1;
          }
        }
      }
    }
    if (readSourceFileTasks.length > 0) {
      await Promise.all(readSourceFileTasks);
    }
    if (this._contextLines > 0 && _optionalChain([event, "access", (_6) => _6.exception, "optionalAccess", (_7) => _7.values])) {
      for (const exception of event.exception.values) {
        if (exception.stacktrace && exception.stacktrace.frames) {
          await this.addSourceContextToFrames(exception.stacktrace.frames);
        }
      }
    }
    return event;
  }
  /** Adds context lines to frames */
  addSourceContextToFrames(frames) {
    for (const frame of frames) {
      if (frame.filename && frame.context_line === void 0) {
        const sourceFileLines = FILE_CONTENT_CACHE.get(frame.filename);
        if (sourceFileLines) {
          try {
            addContextToFrame(sourceFileLines, frame, this._contextLines);
          } catch (e3) {
          }
        }
      }
    }
  }
};
__name(ContextLines, "ContextLines");
ContextLines.__initStatic();
async function _readSourceFile(filename) {
  const cachedFile = FILE_CONTENT_CACHE.get(filename);
  if (cachedFile === null) {
    return null;
  }
  if (cachedFile !== void 0) {
    return cachedFile;
  }
  let content = null;
  try {
    const rawFileContents = await readTextFileAsync(filename);
    content = rawFileContents.split("\n");
  } catch (_3) {
  }
  FILE_CONTENT_CACHE.set(filename, content);
  return content;
}
__name(_readSourceFile, "_readSourceFile");

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/integrations/context.js
init_import_meta_url();
var import_child_process2 = require("child_process");
var import_fs11 = require("fs");
var os9 = __toESM(require("os"));
var import_path15 = require("path");
var import_util7 = require("util");
var readFileAsync = (0, import_util7.promisify)(import_fs11.readFile);
var readDirAsync = (0, import_util7.promisify)(import_fs11.readdir);
var Context = class {
  /**
   * @inheritDoc
   */
  static __initStatic() {
    this.id = "Context";
  }
  /**
   * @inheritDoc
   */
  __init() {
    this.name = Context.id;
  }
  /**
   * Caches context so it's only evaluated once
   */
  constructor(_options = {
    app: true,
    os: true,
    device: true,
    culture: true,
    cloudResource: true
  }) {
    this._options = _options;
    Context.prototype.__init.call(this);
  }
  /**
   * @inheritDoc
   */
  setupOnce(addGlobalEventProcessor2) {
    addGlobalEventProcessor2((event) => this.addContext(event));
  }
  /** Processes an event and adds context */
  async addContext(event) {
    if (this._cachedContext === void 0) {
      this._cachedContext = this._getContexts();
    }
    const updatedContext = this._updateContext(await this._cachedContext);
    event.contexts = {
      ...event.contexts,
      app: { ...updatedContext.app, ..._optionalChain([event, "access", (_3) => _3.contexts, "optionalAccess", (_22) => _22.app]) },
      os: { ...updatedContext.os, ..._optionalChain([event, "access", (_3) => _3.contexts, "optionalAccess", (_4) => _4.os]) },
      device: { ...updatedContext.device, ..._optionalChain([event, "access", (_5) => _5.contexts, "optionalAccess", (_6) => _6.device]) },
      culture: { ...updatedContext.culture, ..._optionalChain([event, "access", (_7) => _7.contexts, "optionalAccess", (_8) => _8.culture]) },
      cloud_resource: { ...updatedContext.cloud_resource, ..._optionalChain([event, "access", (_9) => _9.contexts, "optionalAccess", (_10) => _10.cloud_resource]) }
    };
    return event;
  }
  /**
   * Updates the context with dynamic values that can change
   */
  _updateContext(contexts) {
    if (_optionalChain([contexts, "optionalAccess", (_11) => _11.app, "optionalAccess", (_12) => _12.app_memory])) {
      contexts.app.app_memory = process.memoryUsage().rss;
    }
    if (_optionalChain([contexts, "optionalAccess", (_13) => _13.device, "optionalAccess", (_14) => _14.free_memory])) {
      contexts.device.free_memory = os9.freemem();
    }
    return contexts;
  }
  /**
   * Gets the contexts for the current environment
   */
  async _getContexts() {
    const contexts = {};
    if (this._options.os) {
      contexts.os = await getOsContext();
    }
    if (this._options.app) {
      contexts.app = getAppContext();
    }
    if (this._options.device) {
      contexts.device = getDeviceContext(this._options.device);
    }
    if (this._options.culture) {
      const culture = getCultureContext();
      if (culture) {
        contexts.culture = culture;
      }
    }
    if (this._options.cloudResource) {
      contexts.cloud_resource = getCloudResourceContext();
    }
    return contexts;
  }
};
__name(Context, "Context");
Context.__initStatic();
async function getOsContext() {
  const platformId = os9.platform();
  switch (platformId) {
    case "darwin":
      return getDarwinInfo();
    case "linux":
      return getLinuxInfo();
    default:
      return {
        name: PLATFORM_NAMES[platformId] || platformId,
        version: os9.release()
      };
  }
}
__name(getOsContext, "getOsContext");
function getCultureContext() {
  try {
    if (typeof process.versions.icu !== "string") {
      return;
    }
    const january = /* @__PURE__ */ new Date(9e8);
    const spanish = new Intl.DateTimeFormat("es", { month: "long" });
    if (spanish.format(january) === "enero") {
      const options29 = Intl.DateTimeFormat().resolvedOptions();
      return {
        locale: options29.locale,
        timezone: options29.timeZone
      };
    }
  } catch (err) {
  }
  return;
}
__name(getCultureContext, "getCultureContext");
function getAppContext() {
  const app_memory = process.memoryUsage().rss;
  const app_start_time = new Date(Date.now() - process.uptime() * 1e3).toISOString();
  return { app_start_time, app_memory };
}
__name(getAppContext, "getAppContext");
function getDeviceContext(deviceOpt) {
  const device = {};
  let uptime3;
  try {
    uptime3 = os9.uptime && os9.uptime();
  } catch (e3) {
  }
  if (typeof uptime3 === "number") {
    device.boot_time = new Date(Date.now() - uptime3 * 1e3).toISOString();
  }
  device.arch = os9.arch();
  if (deviceOpt === true || deviceOpt.memory) {
    device.memory_size = os9.totalmem();
    device.free_memory = os9.freemem();
  }
  if (deviceOpt === true || deviceOpt.cpu) {
    const cpuInfo = os9.cpus();
    if (cpuInfo && cpuInfo.length) {
      const firstCpu = cpuInfo[0];
      device.processor_count = cpuInfo.length;
      device.cpu_description = firstCpu.model;
      device.processor_frequency = firstCpu.speed;
    }
  }
  return device;
}
__name(getDeviceContext, "getDeviceContext");
var PLATFORM_NAMES = {
  aix: "IBM AIX",
  freebsd: "FreeBSD",
  openbsd: "OpenBSD",
  sunos: "SunOS",
  win32: "Windows"
};
var LINUX_DISTROS = [
  { name: "fedora-release", distros: ["Fedora"] },
  { name: "redhat-release", distros: ["Red Hat Linux", "Centos"] },
  { name: "redhat_version", distros: ["Red Hat Linux"] },
  { name: "SuSE-release", distros: ["SUSE Linux"] },
  { name: "lsb-release", distros: ["Ubuntu Linux", "Arch Linux"] },
  { name: "debian_version", distros: ["Debian"] },
  { name: "debian_release", distros: ["Debian"] },
  { name: "arch-release", distros: ["Arch Linux"] },
  { name: "gentoo-release", distros: ["Gentoo Linux"] },
  { name: "novell-release", distros: ["SUSE Linux"] },
  { name: "alpine-release", distros: ["Alpine Linux"] }
];
var LINUX_VERSIONS = {
  alpine: (content) => content,
  arch: (content) => matchFirst(/distrib_release=(.*)/, content),
  centos: (content) => matchFirst(/release ([^ ]+)/, content),
  debian: (content) => content,
  fedora: (content) => matchFirst(/release (..)/, content),
  mint: (content) => matchFirst(/distrib_release=(.*)/, content),
  red: (content) => matchFirst(/release ([^ ]+)/, content),
  suse: (content) => matchFirst(/VERSION = (.*)\n/, content),
  ubuntu: (content) => matchFirst(/distrib_release=(.*)/, content)
};
function matchFirst(regex2, text) {
  const match = regex2.exec(text);
  return match ? match[1] : void 0;
}
__name(matchFirst, "matchFirst");
async function getDarwinInfo() {
  const darwinInfo = {
    kernel_version: os9.release(),
    name: "Mac OS X",
    version: `10.${Number(os9.release().split(".")[0]) - 4}`
  };
  try {
    const output = await new Promise((resolve19, reject) => {
      (0, import_child_process2.execFile)("/usr/bin/sw_vers", (error2, stdout2) => {
        if (error2) {
          reject(error2);
          return;
        }
        resolve19(stdout2);
      });
    });
    darwinInfo.name = matchFirst(/^ProductName:\s+(.*)$/m, output);
    darwinInfo.version = matchFirst(/^ProductVersion:\s+(.*)$/m, output);
    darwinInfo.build = matchFirst(/^BuildVersion:\s+(.*)$/m, output);
  } catch (e3) {
  }
  return darwinInfo;
}
__name(getDarwinInfo, "getDarwinInfo");
function getLinuxDistroId(name) {
  return name.split(" ")[0].toLowerCase();
}
__name(getLinuxDistroId, "getLinuxDistroId");
async function getLinuxInfo() {
  const linuxInfo = {
    kernel_version: os9.release(),
    name: "Linux"
  };
  try {
    const etcFiles = await readDirAsync("/etc");
    const distroFile = LINUX_DISTROS.find((file) => etcFiles.includes(file.name));
    if (!distroFile) {
      return linuxInfo;
    }
    const distroPath = (0, import_path15.join)("/etc", distroFile.name);
    const contents = (await readFileAsync(distroPath, { encoding: "utf-8" })).toLowerCase();
    const { distros } = distroFile;
    linuxInfo.name = distros.find((d2) => contents.indexOf(getLinuxDistroId(d2)) >= 0) || distros[0];
    const id = getLinuxDistroId(linuxInfo.name);
    linuxInfo.version = LINUX_VERSIONS[id](contents);
  } catch (e3) {
  }
  return linuxInfo;
}
__name(getLinuxInfo, "getLinuxInfo");
function getCloudResourceContext() {
  if (process.env.VERCEL) {
    return {
      "cloud.provider": "vercel",
      "cloud.region": process.env.VERCEL_REGION
    };
  } else if (process.env.AWS_REGION) {
    return {
      "cloud.provider": "aws",
      "cloud.region": process.env.AWS_REGION,
      "cloud.platform": process.env.AWS_EXECUTION_ENV
    };
  } else if (process.env.GCP_PROJECT) {
    return {
      "cloud.provider": "gcp"
    };
  } else if (process.env.ALIYUN_REGION_ID) {
    return {
      "cloud.provider": "alibaba_cloud",
      "cloud.region": process.env.ALIYUN_REGION_ID
    };
  } else if (process.env.WEBSITE_SITE_NAME && process.env.REGION_NAME) {
    return {
      "cloud.provider": "azure",
      "cloud.region": process.env.REGION_NAME
    };
  } else if (process.env.IBM_CLOUD_REGION) {
    return {
      "cloud.provider": "ibm_cloud",
      "cloud.region": process.env.IBM_CLOUD_REGION
    };
  } else if (process.env.TENCENTCLOUD_REGION) {
    return {
      "cloud.provider": "tencent_cloud",
      "cloud.region": process.env.TENCENTCLOUD_REGION,
      "cloud.account.id": process.env.TENCENTCLOUD_APPID,
      "cloud.availability_zone": process.env.TENCENTCLOUD_ZONE
    };
  } else if (process.env.NETLIFY) {
    return {
      "cloud.provider": "netlify"
    };
  } else if (process.env.FLY_REGION) {
    return {
      "cloud.provider": "fly.io",
      "cloud.region": process.env.FLY_REGION
    };
  } else if (process.env.DYNO) {
    return {
      "cloud.provider": "heroku"
    };
  } else {
    return void 0;
  }
}
__name(getCloudResourceContext, "getCloudResourceContext");

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/integrations/localvariables.js
init_import_meta_url();
function createRateLimiter(maxPerSecond, enable, disable) {
  let count = 0;
  let retrySeconds = 5;
  let disabledTimeout = 0;
  setInterval(() => {
    if (disabledTimeout === 0) {
      if (count > maxPerSecond) {
        retrySeconds *= 2;
        disable(retrySeconds);
        if (retrySeconds > 86400) {
          retrySeconds = 86400;
        }
        disabledTimeout = retrySeconds;
      }
    } else {
      disabledTimeout -= 1;
      if (disabledTimeout === 0) {
        enable();
      }
    }
    count = 0;
  }, 1e3).unref();
  return () => {
    count += 1;
  };
}
__name(createRateLimiter, "createRateLimiter");
function createCallbackList(complete) {
  let callbacks = [];
  let completedCalled = false;
  function checkedComplete(result) {
    callbacks = [];
    if (completedCalled) {
      return;
    }
    completedCalled = true;
    complete(result);
  }
  __name(checkedComplete, "checkedComplete");
  callbacks.push(checkedComplete);
  function add(fn2) {
    callbacks.push(fn2);
  }
  __name(add, "add");
  function next(result) {
    const popped = callbacks.pop() || checkedComplete;
    try {
      popped(result);
    } catch (_3) {
      checkedComplete(result);
    }
  }
  __name(next, "next");
  return { add, next };
}
__name(createCallbackList, "createCallbackList");
var AsyncSession = class {
  /** Throws if inspector API is not available */
  constructor() {
    const { Session } = require("inspector");
    this._session = new Session();
  }
  /** @inheritdoc */
  configureAndConnect(onPause, captureAll) {
    this._session.connect();
    this._session.on("Debugger.paused", (event) => {
      onPause(event, () => {
        this._session.post("Debugger.resume");
      });
    });
    this._session.post("Debugger.enable");
    this._session.post("Debugger.setPauseOnExceptions", { state: captureAll ? "all" : "uncaught" });
  }
  setPauseOnExceptions(captureAll) {
    this._session.post("Debugger.setPauseOnExceptions", { state: captureAll ? "all" : "uncaught" });
  }
  /** @inheritdoc */
  getLocalVariables(objectId, complete) {
    this._getProperties(objectId, (props) => {
      const { add, next } = createCallbackList(complete);
      for (const prop of props) {
        if (_optionalChain([prop, "optionalAccess", (_22) => _22.value, "optionalAccess", (_3) => _3.objectId]) && _optionalChain([prop, "optionalAccess", (_4) => _4.value, "access", (_5) => _5.className]) === "Array") {
          const id = prop.value.objectId;
          add((vars) => this._unrollArray(id, prop.name, vars, next));
        } else if (_optionalChain([prop, "optionalAccess", (_6) => _6.value, "optionalAccess", (_7) => _7.objectId]) && _optionalChain([prop, "optionalAccess", (_8) => _8.value, "optionalAccess", (_9) => _9.className]) === "Object") {
          const id = prop.value.objectId;
          add((vars) => this._unrollObject(id, prop.name, vars, next));
        } else if (_optionalChain([prop, "optionalAccess", (_10) => _10.value, "optionalAccess", (_11) => _11.value]) || _optionalChain([prop, "optionalAccess", (_12) => _12.value, "optionalAccess", (_13) => _13.description])) {
          add((vars) => this._unrollOther(prop, vars, next));
        }
      }
      next({});
    });
  }
  /**
   * Gets all the PropertyDescriptors of an object
   */
  _getProperties(objectId, next) {
    this._session.post(
      "Runtime.getProperties",
      {
        objectId,
        ownProperties: true
      },
      (err, params) => {
        if (err) {
          next([]);
        } else {
          next(params.result);
        }
      }
    );
  }
  /**
   * Unrolls an array property
   */
  _unrollArray(objectId, name, vars, next) {
    this._getProperties(objectId, (props) => {
      vars[name] = props.filter((v2) => v2.name !== "length" && !isNaN(parseInt(v2.name, 10))).sort((a, b2) => parseInt(a.name, 10) - parseInt(b2.name, 10)).map((v2) => _optionalChain([v2, "optionalAccess", (_14) => _14.value, "optionalAccess", (_15) => _15.value]));
      next(vars);
    });
  }
  /**
   * Unrolls an object property
   */
  _unrollObject(objectId, name, vars, next) {
    this._getProperties(objectId, (props) => {
      vars[name] = props.map((v2) => [v2.name, _optionalChain([v2, "optionalAccess", (_16) => _16.value, "optionalAccess", (_17) => _17.value])]).reduce((obj, [key, val]) => {
        obj[key] = val;
        return obj;
      }, {});
      next(vars);
    });
  }
  /**
   * Unrolls other properties
   */
  _unrollOther(prop, vars, next) {
    if (_optionalChain([prop, "optionalAccess", (_18) => _18.value, "optionalAccess", (_19) => _19.value])) {
      vars[prop.name] = prop.value.value;
    } else if (_optionalChain([prop, "optionalAccess", (_20) => _20.value, "optionalAccess", (_21) => _21.description]) && _optionalChain([prop, "optionalAccess", (_22) => _22.value, "optionalAccess", (_23) => _23.type]) !== "function") {
      vars[prop.name] = `<${prop.value.description}>`;
    }
    next(vars);
  }
};
__name(AsyncSession, "AsyncSession");
function tryNewAsyncSession() {
  try {
    return new AsyncSession();
  } catch (e3) {
    return void 0;
  }
}
__name(tryNewAsyncSession, "tryNewAsyncSession");
function isAnonymous(name) {
  return name !== void 0 && ["", "?", "<anonymous>"].includes(name);
}
__name(isAnonymous, "isAnonymous");
function functionNamesMatch(a, b2) {
  return a === b2 || isAnonymous(a) && isAnonymous(b2);
}
__name(functionNamesMatch, "functionNamesMatch");
function hashFrames(frames) {
  if (frames === void 0) {
    return;
  }
  return frames.slice(-10).reduce((acc, frame) => `${acc},${frame.function},${frame.lineno},${frame.colno}`, "");
}
__name(hashFrames, "hashFrames");
function hashFromStack(stackParser, stack) {
  if (stack === void 0) {
    return void 0;
  }
  return hashFrames(stackParser(stack, 1));
}
__name(hashFromStack, "hashFromStack");
var LocalVariables = class {
  static __initStatic() {
    this.id = "LocalVariables";
  }
  __init() {
    this.name = LocalVariables.id;
  }
  __init2() {
    this._cachedFrames = new LRUMap(20);
  }
  constructor(_options = {}, _session = tryNewAsyncSession()) {
    this._options = _options;
    this._session = _session;
    LocalVariables.prototype.__init.call(this);
    LocalVariables.prototype.__init2.call(this);
  }
  /**
   * @inheritDoc
   */
  setupOnce(addGlobalEventProcessor2, getCurrentHub3) {
    this._setup(addGlobalEventProcessor2, _optionalChain([getCurrentHub3, "call", (_24) => _24(), "access", (_25) => _25.getClient, "call", (_26) => _26(), "optionalAccess", (_27) => _27.getOptions, "call", (_28) => _28()]));
  }
  /** Setup in a way that's easier to call from tests */
  _setup(addGlobalEventProcessor2, clientOptions) {
    if (this._session && _optionalChain([clientOptions, "optionalAccess", (_29) => _29.includeLocalVariables])) {
      const unsupportedNodeVersion = (NODE_VERSION.major || 0) < 18;
      if (unsupportedNodeVersion) {
        logger2.log("The `LocalVariables` integration is only supported on Node >= v18.");
        return;
      }
      const captureAll = this._options.captureAllExceptions !== false;
      this._session.configureAndConnect(
        (ev, complete) => this._handlePaused(clientOptions.stackParser, ev, complete),
        captureAll
      );
      if (captureAll) {
        const max = this._options.maxExceptionsPerSecond || 50;
        this._rateLimiter = createRateLimiter(
          max,
          () => {
            logger2.log("Local variables rate-limit lifted.");
            _optionalChain([this, "access", (_30) => _30._session, "optionalAccess", (_31) => _31.setPauseOnExceptions, "call", (_32) => _32(true)]);
          },
          (seconds) => {
            logger2.log(
              `Local variables rate-limit exceeded. Disabling capturing of caught exceptions for ${seconds} seconds.`
            );
            _optionalChain([this, "access", (_33) => _33._session, "optionalAccess", (_34) => _34.setPauseOnExceptions, "call", (_35) => _35(false)]);
          }
        );
      }
      addGlobalEventProcessor2(async (event) => this._addLocalVariables(event));
    }
  }
  /**
   * Handle the pause event
   */
  _handlePaused(stackParser, { params: { reason, data, callFrames } }, complete) {
    if (reason !== "exception" && reason !== "promiseRejection") {
      complete();
      return;
    }
    _optionalChain([this, "access", (_36) => _36._rateLimiter, "optionalCall", (_37) => _37()]);
    const exceptionHash = hashFromStack(stackParser, _optionalChain([data, "optionalAccess", (_38) => _38.description]));
    if (exceptionHash == void 0) {
      complete();
      return;
    }
    const { add, next } = createCallbackList((frames) => {
      this._cachedFrames.set(exceptionHash, frames);
      complete();
    });
    for (let i = 0; i < Math.min(callFrames.length, 5); i++) {
      const { scopeChain, functionName, this: obj } = callFrames[i];
      const localScope = scopeChain.find((scope) => scope.type === "local");
      const fn2 = obj.className === "global" || !obj.className ? functionName : `${obj.className}.${functionName}`;
      if (_optionalChain([localScope, "optionalAccess", (_39) => _39.object, "access", (_40) => _40.objectId]) === void 0) {
        add((frames) => {
          frames[i] = { function: fn2 };
          next(frames);
        });
      } else {
        const id = localScope.object.objectId;
        add(
          (frames) => _optionalChain([this, "access", (_41) => _41._session, "optionalAccess", (_42) => _42.getLocalVariables, "call", (_43) => _43(id, (vars) => {
            frames[i] = { function: fn2, vars };
            next(frames);
          })])
        );
      }
    }
    next([]);
  }
  /**
   * Adds local variables event stack frames.
   */
  _addLocalVariables(event) {
    for (const exception of _optionalChain([event, "optionalAccess", (_44) => _44.exception, "optionalAccess", (_45) => _45.values]) || []) {
      this._addLocalVariablesToException(exception);
    }
    return event;
  }
  /**
   * Adds local variables to the exception stack frames.
   */
  _addLocalVariablesToException(exception) {
    const hash = hashFrames(_optionalChain([exception, "optionalAccess", (_46) => _46.stacktrace, "optionalAccess", (_47) => _47.frames]));
    if (hash === void 0) {
      return;
    }
    const cachedFrames = this._cachedFrames.remove(hash);
    if (cachedFrames === void 0) {
      return;
    }
    const frameCount = _optionalChain([exception, "access", (_48) => _48.stacktrace, "optionalAccess", (_49) => _49.frames, "optionalAccess", (_50) => _50.length]) || 0;
    for (let i = 0; i < frameCount; i++) {
      const frameIndex = frameCount - i - 1;
      if (!_optionalChain([exception, "optionalAccess", (_51) => _51.stacktrace, "optionalAccess", (_52) => _52.frames, "optionalAccess", (_53) => _53[frameIndex]]) || !cachedFrames[i]) {
        break;
      }
      if (
        // We need to have vars to add
        cachedFrames[i].vars === void 0 || // We're not interested in frames that are not in_app because the vars are not relevant
        exception.stacktrace.frames[frameIndex].in_app === false || // The function names need to match
        !functionNamesMatch(exception.stacktrace.frames[frameIndex].function, cachedFrames[i].function)
      ) {
        continue;
      }
      exception.stacktrace.frames[frameIndex].vars = cachedFrames[i].vars;
    }
  }
};
__name(LocalVariables, "LocalVariables");
LocalVariables.__initStatic();

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/integrations/undici/index.js
init_import_meta_url();
var ChannelName;
(function(ChannelName2) {
  const RequestCreate = "undici:request:create";
  ChannelName2["RequestCreate"] = RequestCreate;
  const RequestEnd = "undici:request:headers";
  ChannelName2["RequestEnd"] = RequestEnd;
  const RequestError = "undici:request:error";
  ChannelName2["RequestError"] = RequestError;
})(ChannelName || (ChannelName = {}));
var Undici = class {
  /**
   * @inheritDoc
   */
  static __initStatic() {
    this.id = "Undici";
  }
  /**
   * @inheritDoc
   */
  __init() {
    this.name = Undici.id;
  }
  __init2() {
    this._createSpanUrlMap = new LRUMap(100);
  }
  __init3() {
    this._headersUrlMap = new LRUMap(100);
  }
  constructor(_options = {}) {
    Undici.prototype.__init.call(this);
    Undici.prototype.__init2.call(this);
    Undici.prototype.__init3.call(this);
    Undici.prototype.__init4.call(this);
    Undici.prototype.__init5.call(this);
    Undici.prototype.__init6.call(this);
    this._options = {
      breadcrumbs: _options.breadcrumbs === void 0 ? true : _options.breadcrumbs,
      shouldCreateSpanForRequest: _options.shouldCreateSpanForRequest
    };
  }
  /**
   * @inheritDoc
   */
  setupOnce(_addGlobalEventProcessor) {
    if (NODE_VERSION.major && NODE_VERSION.major < 16) {
      return;
    }
    let ds;
    try {
      ds = dynamicRequire(module, "diagnostics_channel");
    } catch (e3) {
    }
    if (!ds || !ds.subscribe) {
      return;
    }
    ds.subscribe(ChannelName.RequestCreate, this._onRequestCreate);
    ds.subscribe(ChannelName.RequestEnd, this._onRequestEnd);
    ds.subscribe(ChannelName.RequestError, this._onRequestError);
  }
  /** Helper that wraps shouldCreateSpanForRequest option */
  _shouldCreateSpan(url4) {
    if (this._options.shouldCreateSpanForRequest === void 0) {
      return true;
    }
    const cachedDecision = this._createSpanUrlMap.get(url4);
    if (cachedDecision !== void 0) {
      return cachedDecision;
    }
    const decision = this._options.shouldCreateSpanForRequest(url4);
    this._createSpanUrlMap.set(url4, decision);
    return decision;
  }
  __init4() {
    this._onRequestCreate = (message) => {
      const hub = getCurrentHub();
      if (!hub.getIntegration(Undici)) {
        return;
      }
      const { request: request3 } = message;
      const stringUrl = request3.origin ? request3.origin.toString() + request3.path : request3.path;
      if (isSentryRequestUrl(stringUrl, hub) || request3.__sentry_span__ !== void 0) {
        return;
      }
      const client = hub.getClient();
      if (!client) {
        return;
      }
      const clientOptions = client.getOptions();
      const scope = hub.getScope();
      const parentSpan = scope.getSpan();
      const span = this._shouldCreateSpan(stringUrl) ? createRequestSpan(parentSpan, request3, stringUrl) : void 0;
      if (span) {
        request3.__sentry_span__ = span;
      }
      const shouldAttachTraceData = /* @__PURE__ */ __name((url4) => {
        if (clientOptions.tracePropagationTargets === void 0) {
          return true;
        }
        const cachedDecision = this._headersUrlMap.get(url4);
        if (cachedDecision !== void 0) {
          return cachedDecision;
        }
        const decision = stringMatchesSomePattern(url4, clientOptions.tracePropagationTargets);
        this._headersUrlMap.set(url4, decision);
        return decision;
      }, "shouldAttachTraceData");
      if (shouldAttachTraceData(stringUrl)) {
        if (span) {
          const dynamicSamplingContext = _optionalChain([span, "optionalAccess", (_4) => _4.transaction, "optionalAccess", (_5) => _5.getDynamicSamplingContext, "call", (_6) => _6()]);
          const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext);
          setHeadersOnRequest(request3, span.toTraceparent(), sentryBaggageHeader);
        } else {
          const { traceId, sampled, dsc } = scope.getPropagationContext();
          const sentryTrace = generateSentryTraceHeader(traceId, void 0, sampled);
          const dynamicSamplingContext = dsc || getDynamicSamplingContextFromClient(traceId, client, scope);
          const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext);
          setHeadersOnRequest(request3, sentryTrace, sentryBaggageHeader);
        }
      }
    };
  }
  __init5() {
    this._onRequestEnd = (message) => {
      const hub = getCurrentHub();
      if (!hub.getIntegration(Undici)) {
        return;
      }
      const { request: request3, response } = message;
      const stringUrl = request3.origin ? request3.origin.toString() + request3.path : request3.path;
      if (isSentryRequestUrl(stringUrl, hub)) {
        return;
      }
      const span = request3.__sentry_span__;
      if (span) {
        span.setHttpStatus(response.statusCode);
        span.finish();
      }
      if (this._options.breadcrumbs) {
        hub.addBreadcrumb(
          {
            category: "http",
            data: {
              method: request3.method,
              status_code: response.statusCode,
              url: stringUrl
            },
            type: "http"
          },
          {
            event: "response",
            request: request3,
            response
          }
        );
      }
    };
  }
  __init6() {
    this._onRequestError = (message) => {
      const hub = getCurrentHub();
      if (!hub.getIntegration(Undici)) {
        return;
      }
      const { request: request3 } = message;
      const stringUrl = request3.origin ? request3.origin.toString() + request3.path : request3.path;
      if (isSentryRequestUrl(stringUrl, hub)) {
        return;
      }
      const span = request3.__sentry_span__;
      if (span) {
        span.setStatus("internal_error");
        span.finish();
      }
      if (this._options.breadcrumbs) {
        hub.addBreadcrumb(
          {
            category: "http",
            data: {
              method: request3.method,
              url: stringUrl
            },
            level: "error",
            type: "http"
          },
          {
            event: "error",
            request: request3
          }
        );
      }
    };
  }
};
__name(Undici, "Undici");
Undici.__initStatic();
function setHeadersOnRequest(request3, sentryTrace, sentryBaggageHeader) {
  const headerLines = request3.headers.split("\r\n");
  const hasSentryHeaders = headerLines.some((headerLine) => headerLine.startsWith("sentry-trace:"));
  if (hasSentryHeaders) {
    return;
  }
  request3.addHeader("sentry-trace", sentryTrace);
  if (sentryBaggageHeader) {
    request3.addHeader("baggage", sentryBaggageHeader);
  }
}
__name(setHeadersOnRequest, "setHeadersOnRequest");
function createRequestSpan(activeSpan, request3, stringUrl) {
  const url4 = parseUrl(stringUrl);
  const method = request3.method || "GET";
  const data = {
    "http.method": method
  };
  if (url4.search) {
    data["http.query"] = url4.search;
  }
  if (url4.hash) {
    data["http.fragment"] = url4.hash;
  }
  return _optionalChain([activeSpan, "optionalAccess", (_7) => _7.startChild, "call", (_8) => _8({
    op: "http.client",
    origin: "auto.http.node.undici",
    description: `${method} ${getSanitizedUrlString(url4)}`,
    data
  })]);
}
__name(createRequestSpan, "createRequestSpan");

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/integrations/spotlight.js
init_import_meta_url();
var http3 = __toESM(require("http"));
var import_url7 = require("url");
var Spotlight = class {
  static __initStatic() {
    this.id = "Spotlight";
  }
  __init() {
    this.name = Spotlight.id;
  }
  constructor(options29) {
    Spotlight.prototype.__init.call(this);
    this._options = {
      sidecarUrl: _optionalChain([options29, "optionalAccess", (_3) => _3.sidecarUrl]) || "http://localhost:8969/stream"
    };
  }
  /**
   * JSDoc
   */
  setupOnce() {
  }
  /**
   * Sets up forwarding envelopes to the Spotlight Sidecar
   */
  setup(client) {
    if (typeof process === "object" && process.env && true) {
      logger2.warn("[Spotlight] It seems you're not in dev mode. Do you really want to have Spotlight enabled?");
    }
    connectToSpotlight(client, this._options);
  }
};
__name(Spotlight, "Spotlight");
Spotlight.__initStatic();
function connectToSpotlight(client, options29) {
  const spotlightUrl = parseSidecarUrl(options29.sidecarUrl);
  if (!spotlightUrl) {
    return;
  }
  let failedRequests = 0;
  if (typeof client.on !== "function") {
    logger2.warn("[Spotlight] Cannot connect to spotlight due to missing method on SDK client (`client.on`)");
    return;
  }
  client.on("beforeEnvelope", (envelope) => {
    if (failedRequests > 3) {
      logger2.warn("[Spotlight] Disabled Sentry -> Spotlight integration due to too many failed requests");
      return;
    }
    const serializedEnvelope = serializeEnvelope(envelope);
    const req = http3.request(
      {
        method: "POST",
        path: spotlightUrl.pathname,
        hostname: spotlightUrl.hostname,
        port: spotlightUrl.port,
        headers: {
          "Content-Type": "application/x-sentry-envelope"
        }
      },
      (res) => {
        res.on("data", () => {
        });
        res.on("end", () => {
        });
        res.setEncoding("utf8");
      }
    );
    req.on("error", () => {
      failedRequests++;
      logger2.warn("[Spotlight] Failed to send envelope to Spotlight Sidecar");
    });
    req.write(serializedEnvelope);
    req.end();
  });
}
__name(connectToSpotlight, "connectToSpotlight");
function parseSidecarUrl(url4) {
  try {
    return new import_url7.URL(`${url4}`);
  } catch (e3) {
    logger2.warn(`[Spotlight] Invalid sidecar URL: ${url4}`);
    return void 0;
  }
}
__name(parseSidecarUrl, "parseSidecarUrl");

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/sdk.js
var defaultIntegrations = [
  // Common
  new integrations_exports.InboundFilters(),
  new integrations_exports.FunctionToString(),
  new integrations_exports.LinkedErrors(),
  // Native Wrappers
  new Console(),
  new Http(),
  new Undici(),
  // Global Handlers
  new OnUncaughtException(),
  new OnUnhandledRejection(),
  // Event Info
  new ContextLines(),
  new LocalVariables(),
  new Context(),
  new Modules(),
  new RequestData()
];
function init2(options29 = {}) {
  if (isAnrChildProcess()) {
    options29.autoSessionTracking = false;
    options29.tracesSampleRate = 0;
  }
  const carrier = getMainCarrier();
  setNodeAsyncContextStrategy();
  const autoloadedIntegrations = _optionalChain([carrier, "access", (_3) => _3.__SENTRY__, "optionalAccess", (_22) => _22.integrations]) || [];
  options29.defaultIntegrations = options29.defaultIntegrations === false ? [] : [
    ...Array.isArray(options29.defaultIntegrations) ? options29.defaultIntegrations : defaultIntegrations,
    ...autoloadedIntegrations
  ];
  if (options29.dsn === void 0 && process.env.SENTRY_DSN) {
    options29.dsn = process.env.SENTRY_DSN;
  }
  const sentryTracesSampleRate = process.env.SENTRY_TRACES_SAMPLE_RATE;
  if (options29.tracesSampleRate === void 0 && sentryTracesSampleRate) {
    const tracesSampleRate = parseFloat(sentryTracesSampleRate);
    if (isFinite(tracesSampleRate)) {
      options29.tracesSampleRate = tracesSampleRate;
    }
  }
  if (options29.release === void 0) {
    const detectedRelease = getSentryRelease();
    if (detectedRelease !== void 0) {
      options29.release = detectedRelease;
    } else {
      options29.autoSessionTracking = false;
    }
  }
  if (options29.environment === void 0 && process.env.SENTRY_ENVIRONMENT) {
    options29.environment = process.env.SENTRY_ENVIRONMENT;
  }
  if (options29.autoSessionTracking === void 0 && options29.dsn !== void 0) {
    options29.autoSessionTracking = true;
  }
  if (options29.instrumenter === void 0) {
    options29.instrumenter = "sentry";
  }
  const clientOptions = {
    ...options29,
    stackParser: stackParserFromStackParserOptions(options29.stackParser || defaultStackParser),
    integrations: getIntegrationsToSetup(options29),
    transport: options29.transport || makeNodeTransport
  };
  initAndBind(options29.clientClass || NodeClient, clientOptions);
  if (options29.autoSessionTracking) {
    startSessionTracking();
  }
  updateScopeFromEnvVariables();
  if (options29.spotlight) {
    const client = getCurrentHub().getClient();
    if (client && client.addIntegration) {
      client.setupIntegrations(true);
      client.addIntegration(
        new Spotlight({ sidecarUrl: typeof options29.spotlight === "string" ? options29.spotlight : void 0 })
      );
    }
  }
}
__name(init2, "init");
function getSentryRelease(fallback) {
  if (process.env.SENTRY_RELEASE) {
    return process.env.SENTRY_RELEASE;
  }
  if (GLOBAL_OBJ.SENTRY_RELEASE && GLOBAL_OBJ.SENTRY_RELEASE.id) {
    return GLOBAL_OBJ.SENTRY_RELEASE.id;
  }
  return (
    // GitHub Actions - https://help.github.com/en/actions/configuring-and-managing-workflows/using-environment-variables#default-environment-variables
    process.env.GITHUB_SHA || // Netlify - https://docs.netlify.com/configure-builds/environment-variables/#build-metadata
    process.env.COMMIT_REF || // Vercel - https://vercel.com/docs/v2/build-step#system-environment-variables
    process.env.VERCEL_GIT_COMMIT_SHA || process.env.VERCEL_GITHUB_COMMIT_SHA || process.env.VERCEL_GITLAB_COMMIT_SHA || process.env.VERCEL_BITBUCKET_COMMIT_SHA || // Zeit (now known as Vercel)
    process.env.ZEIT_GITHUB_COMMIT_SHA || process.env.ZEIT_GITLAB_COMMIT_SHA || process.env.ZEIT_BITBUCKET_COMMIT_SHA || // Cloudflare Pages - https://developers.cloudflare.com/pages/platform/build-configuration/#environment-variables
    process.env.CF_PAGES_COMMIT_SHA || fallback
  );
}
__name(getSentryRelease, "getSentryRelease");
var defaultStackParser = createStackParser(nodeStackLineParser(getModuleFromFilename));
function startSessionTracking() {
  const hub = getCurrentHub();
  hub.startSession();
  process.on("beforeExit", () => {
    const session = hub.getScope().getSession();
    const terminalStates = ["exited", "crashed"];
    if (session && !terminalStates.includes(session.status))
      hub.endSession();
  });
}
__name(startSessionTracking, "startSessionTracking");
function updateScopeFromEnvVariables() {
  const sentryUseEnvironment = (process.env.SENTRY_USE_ENVIRONMENT || "").toLowerCase();
  if (!["false", "n", "no", "off", "0"].includes(sentryUseEnvironment)) {
    const sentryTraceEnv = process.env.SENTRY_TRACE;
    const baggageEnv = process.env.SENTRY_BAGGAGE;
    const { propagationContext } = tracingContextFromHeaders(sentryTraceEnv, baggageEnv);
    getCurrentHub().getScope().setPropagationContext(propagationContext);
  }
}
__name(updateScopeFromEnvVariables, "updateScopeFromEnvVariables");

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/integrations/index.js
var integrations_exports2 = {};
__export(integrations_exports2, {
  Console: () => Console,
  Context: () => Context,
  ContextLines: () => ContextLines,
  Http: () => Http,
  LocalVariables: () => LocalVariables,
  Modules: () => Modules,
  OnUncaughtException: () => OnUncaughtException,
  OnUnhandledRejection: () => OnUnhandledRejection,
  RequestData: () => RequestData,
  Spotlight: () => Spotlight,
  Undici: () => Undici
});
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/tracing/integrations.js
var integrations_exports3 = {};
__export(integrations_exports3, {
  Apollo: () => Apollo,
  Express: () => Express,
  GraphQL: () => GraphQL,
  Mongo: () => Mongo,
  Mysql: () => Mysql,
  Postgres: () => Postgres,
  Prisma: () => Prisma
});
init_import_meta_url();

// ../../node_modules/.pnpm/@sentry+node@7.87.0_supports-color@9.2.2/node_modules/@sentry/node/esm/index.js
var INTEGRATIONS = {
  ...integrations_exports,
  ...integrations_exports2,
  ...integrations_exports3
};

// src/sentry/index.ts
var import_undici19 = __toESM(require_undici());
var sentryReportingAllowed = false;
var makeSentry10Transport = /* @__PURE__ */ __name((options29) => {
  let eventQueue = [];
  const transportSentry10 = /* @__PURE__ */ __name(async (request3) => {
    const sentryWorkerPayload = {
      envelope: request3.body,
      url: options29.url
    };
    try {
      if (sentryReportingAllowed) {
        const eventsToSend = [...eventQueue];
        eventQueue = [];
        for (const event of eventsToSend) {
          await (0, import_undici19.fetch)(event[0], event[1]);
        }
        const response = await (0, import_undici19.fetch)(
          `https://platform.dash.cloudflare.com/sentry/envelope`,
          {
            method: "POST",
            headers: {
              Accept: "*/*",
              "Content-Type": "application/json"
            },
            body: JSON.stringify(sentryWorkerPayload)
          }
        );
        return {
          statusCode: response.status,
          headers: {
            "x-sentry-rate-limits": response.headers.get(
              "X-Sentry-Rate-Limits"
            ),
            "retry-after": response.headers.get("Retry-After")
          }
        };
      } else {
        eventQueue.push([
          `https://platform.dash.cloudflare.com/sentry/envelope`,
          {
            method: "POST",
            headers: {
              Accept: "*/*",
              "Content-Type": "application/json"
            },
            body: JSON.stringify(sentryWorkerPayload)
          }
        ]);
        return {
          statusCode: 200
        };
      }
    } catch (err) {
      console.log(err);
      return rejectedSyncPromise(err);
    }
  }, "transportSentry10");
  return createTransport(options29, transportSentry10);
}, "makeSentry10Transport");
var disabledDefaultIntegrations = [
  "Console",
  // Console logs may contain PII
  "LocalVariables",
  // Local variables may contain tokens and PII
  "Http",
  // Only captures method/URL/response status, but URL may contain PII
  "Undici",
  // Same as "Http"
  "RequestData"
  // Request data to Wrangler's HTTP servers may contain PII
];
function setupSentry() {
  if (true) {
    init2({
      release: `wrangler@${version}`,
      dsn: "https://9edbb8417b284aa2bbead9b4c318918b@sentry10.cfdata.org/583",
      transport: makeSentry10Transport,
      integrations(defaultIntegrations2) {
        return defaultIntegrations2.filter(
          ({ name }) => !disabledDefaultIntegrations.includes(name)
        );
      },
      beforeSend(event) {
        delete event.server_name;
        if (event.contexts !== void 0)
          delete event.contexts.culture;
        const fakeInstallPath = process.platform === "win32" ? "C:\\Project\\" : "/project/";
        for (const exception of event.exception?.values ?? []) {
          for (const frame of exception.stacktrace?.frames ?? []) {
            if (frame.filename === void 0)
              continue;
            const nodeModulesIndex = frame.filename.indexOf("node_modules");
            if (nodeModulesIndex === -1)
              continue;
            frame.filename = fakeInstallPath + frame.filename.substring(nodeModulesIndex);
          }
        }
        return event;
      }
    });
  }
}
__name(setupSentry, "setupSentry");
function addBreadcrumb2(message, level = "log") {
  if (true) {
    addBreadcrumb({
      message,
      level
    });
  }
}
__name(addBreadcrumb2, "addBreadcrumb");
async function captureGlobalException(e3) {
  if (true) {
    sentryReportingAllowed = await confirm(
      "Would you like to report this error to Cloudflare?",
      { fallbackValue: false }
    );
    if (!sentryReportingAllowed) {
      logger.debug(`Sentry: Reporting disabled - would have sent ${e3}.`);
      return;
    }
    logger.debug(`Sentry: Capturing exception ${e3}`);
    captureException(e3);
  }
}
__name(captureGlobalException, "captureGlobalException");
async function closeSentry() {
  if (true) {
    await close();
  }
}
__name(closeSentry, "closeSentry");

// src/tail/index.ts
init_import_meta_url();
var import_promises19 = require("node:timers/promises");
var import_signal_exit7 = __toESM(require_signal_exit());

// src/zones.ts
init_import_meta_url();
function getHostFromRoute(route2) {
  let host;
  if (typeof route2 === "string") {
    host = getHostFromUrl(route2);
  } else if (typeof route2 === "object") {
    host = getHostFromUrl(route2.pattern);
    if (host === void 0 && "zone_name" in route2) {
      host = getHostFromUrl(route2.zone_name);
    }
  }
  return host;
}
__name(getHostFromRoute, "getHostFromRoute");
async function getZoneForRoute(route2) {
  const host = getHostFromRoute(route2);
  let id;
  if (typeof route2 === "object" && "zone_id" in route2) {
    id = route2.zone_id;
  } else if (typeof route2 === "object" && "zone_name" in route2) {
    id = await getZoneIdFromHost(route2.zone_name);
  } else if (host) {
    id = await getZoneIdFromHost(host);
  }
  return id && host ? { id, host } : void 0;
}
__name(getZoneForRoute, "getZoneForRoute");
function getHostFromUrl(urlLike) {
  if (urlLike.startsWith("*/") || urlLike.startsWith("http://*/") || urlLike.startsWith("https://*/")) {
    return void 0;
  }
  urlLike = urlLike.replace(/\*(\.)?/g, "");
  if (!(urlLike.startsWith("http://") || urlLike.startsWith("https://"))) {
    urlLike = "http://" + urlLike;
  }
  try {
    return new URL(urlLike).host;
  } catch {
    return void 0;
  }
}
__name(getHostFromUrl, "getHostFromUrl");
async function getZoneIdForPreview(host, routes) {
  let zoneId;
  if (host) {
    zoneId = await getZoneIdFromHost(host);
  }
  if (!zoneId && routes) {
    const firstRoute = routes[0];
    const zone = await getZoneForRoute(firstRoute);
    if (zone) {
      zoneId = zone.id;
    }
  }
  return zoneId;
}
__name(getZoneIdForPreview, "getZoneIdForPreview");
async function getZoneIdFromHost(host) {
  const hostPieces = host.split(".");
  while (hostPieces.length > 1) {
    const zones = await fetchListResult(
      `/zones`,
      {},
      new URLSearchParams({ name: hostPieces.join(".") })
    );
    if (zones.length > 0) {
      return zones[0].id;
    }
    hostPieces.shift();
  }
  throw new UserError(
    `Could not find zone for \`${host}\`. Make sure the domain is set up to be proxied by Cloudflare.
For more details, refer to https://developers.cloudflare.com/workers/configuration/routing/routes/#set-up-a-route`
  );
}
__name(getZoneIdFromHost, "getZoneIdFromHost");
async function getRoutesForZone(zone) {
  const routes = await fetchListResult(
    `/zones/${zone}/workers/routes`
  );
  return routes;
}
__name(getRoutesForZone, "getRoutesForZone");
function distanceBetween(a, b2, cache2 = /* @__PURE__ */ new Map()) {
  if (cache2.has(`${a}|${b2}`)) {
    return cache2.get(`${a}|${b2}`);
  }
  let result;
  if (b2 == "") {
    result = a.length;
  } else if (a == "") {
    result = b2.length;
  } else if (a[0] === b2[0]) {
    result = distanceBetween(a.slice(1), b2.slice(1), cache2);
  } else {
    result = 1 + Math.min(
      distanceBetween(a.slice(1), b2, cache2),
      distanceBetween(a, b2.slice(1), cache2),
      distanceBetween(a.slice(1), b2.slice(1), cache2)
    );
  }
  cache2.set(`${a}|${b2}`, result);
  return result;
}
__name(distanceBetween, "distanceBetween");
function findClosestRoute(providedRoute, assignedRoutes) {
  return assignedRoutes.sort((a, b2) => {
    const distanceA = distanceBetween(providedRoute, a.pattern);
    const distanceB = distanceBetween(providedRoute, b2.pattern);
    return distanceA - distanceB;
  });
}
__name(findClosestRoute, "findClosestRoute");
async function getWorkerForZone(worker) {
  const zone = await getZoneForRoute(worker);
  if (!zone) {
    throw new UserError(
      `The route '${worker}' is not part of one of your zones. Either add this zone from the Cloudflare dashboard, or try using a route within one of your existing zones.`
    );
  }
  const routes = await getRoutesForZone(zone.id);
  const scriptName = routes.find((route2) => route2.pattern === worker)?.script;
  if (!scriptName) {
    const closestRoute = findClosestRoute(worker, routes)?.[0];
    if (!closestRoute) {
      throw new UserError(
        `The route '${worker}' has no workers assigned. You can assign a worker to it from wrangler.toml or the Cloudflare dashboard`
      );
    } else {
      throw new UserError(
        `The route '${worker}' has no workers assigned. Did you mean to tail the route '${closestRoute.pattern}'?`
      );
    }
  }
  return scriptName;
}
__name(getWorkerForZone, "getWorkerForZone");

// src/tail/index.ts
function tailOptions(yargs) {
  return yargs.positional("worker", {
    describe: "Name or route of the worker to tail",
    type: "string"
  }).option("format", {
    default: process.stdout.isTTY ? "pretty" : "json",
    choices: ["json", "pretty"],
    describe: "The format of log entries"
  }).option("status", {
    choices: ["ok", "error", "canceled"],
    describe: "Filter by invocation status",
    array: true
  }).option("header", {
    type: "string",
    requiresArg: true,
    describe: "Filter by HTTP header"
  }).option("method", {
    type: "string",
    requiresArg: true,
    describe: "Filter by HTTP method",
    array: true
  }).option("sampling-rate", {
    type: "number",
    describe: "Adds a percentage of requests to log sampling rate"
  }).option("search", {
    type: "string",
    requiresArg: true,
    describe: "Filter by a text match in console.log messages"
  }).option("ip", {
    type: "string",
    requiresArg: true,
    describe: 'Filter by the IP address the request originates from. Use "self" to filter for your own IP',
    array: true
  }).option("version-id", {
    type: "string",
    requiresArg: true,
    describe: "Filter by Worker version"
  }).option("debug", {
    type: "boolean",
    hidden: true,
    default: false,
    describe: "If a log would have been filtered out, send it through anyway alongside the filter which would have blocked it."
  }).option("legacy-env", {
    type: "boolean",
    describe: "Use legacy environments",
    hidden: true
  });
}
__name(tailOptions, "tailOptions");
async function tailHandler(args) {
  if (args.format === "pretty") {
    await printWranglerBanner();
  }
  const config = readConfig(args.config, args);
  await sendMetricsEvent("begin log stream", {
    sendMetrics: config.send_metrics
  });
  let scriptName;
  if (args.worker?.includes(".")) {
    scriptName = await getWorkerForZone(args.worker);
    if (args.format === "pretty") {
      logger.log(`Connecting to worker ${scriptName} at route ${args.worker}`);
    }
  } else {
    scriptName = getLegacyScriptName({ name: args.worker, ...args }, config);
  }
  if (!scriptName) {
    throw new UserError(
      "Required Worker name missing. Please specify the Worker name in wrangler.toml, or pass it as an argument with `wrangler tail <worker-name>`"
    );
  }
  const accountId = await requireAuth(config);
  const cliFilters = {
    status: args.status,
    header: args.header,
    method: args.method,
    samplingRate: args.samplingRate,
    search: args.search,
    clientIp: args.ip,
    versionId: args.versionId
  };
  const scriptContent = await fetchScriptContent(
    (!isLegacyEnv(config) ? args.env : void 0) ? `/accounts/${accountId}/workers/services/${scriptName}/environments/${args.env}/content` : `/accounts/${accountId}/workers/scripts/${scriptName}`
  );
  const bindings = await fetchResult(
    (!isLegacyEnv(config) ? args.env : void 0) ? `/accounts/${accountId}/workers/services/${scriptName}/environments/${args.env}/bindings` : `/accounts/${accountId}/workers/scripts/${scriptName}/bindings`
  );
  if (scriptContent.toLowerCase().includes("websocket") && bindings.find((b2) => b2.type === "durable_object_namespace")) {
    logger.warn(
      `Beginning log collection requires restarting the Durable Objects associated with ${scriptName}. Any WebSocket connections or other non-persisted state will be lost as part of this restart.`
    );
    if (!await confirm("Would you like to continue?")) {
      return;
    }
  }
  const filters = translateCLICommandToFilterMessage(cliFilters);
  const { tail, expiration, deleteTail } = await createTail(
    accountId,
    scriptName,
    filters,
    args.debug,
    !isLegacyEnv(config) ? args.env : void 0
  );
  const scriptDisplayName = `${scriptName}${args.env && !isLegacyEnv(config) ? ` (${args.env})` : ""}`;
  if (args.format === "pretty") {
    logger.log(
      `Successfully created tail, expires at ${expiration.toLocaleString()}`
    );
  }
  const printLog = args.format === "pretty" ? prettyPrintLogs : jsonPrintLogs;
  tail.on("message", printLog);
  while (tail.readyState !== tail.OPEN) {
    switch (tail.readyState) {
      case tail.CONNECTING:
        await (0, import_promises19.setTimeout)(100);
        break;
      case tail.CLOSING:
        await (0, import_promises19.setTimeout)(100);
        break;
      case tail.CLOSED:
        await sendMetricsEvent("end log stream", {
          sendMetrics: config.send_metrics
        });
        throw new Error(
          `Connection to ${scriptDisplayName} closed unexpectedly.`
        );
    }
  }
  if (args.format === "pretty") {
    logger.log(`Connected to ${scriptDisplayName}, waiting for logs...`);
  }
  const cancelPing = startWebSocketPing();
  tail.on("close", exit6);
  (0, import_signal_exit7.default)(exit6);
  async function exit6() {
    cancelPing();
    tail.terminate();
    await deleteTail();
    await sendMetricsEvent("end log stream", {
      sendMetrics: config.send_metrics
    });
  }
  __name(exit6, "exit");
  function startWebSocketPing() {
    const PING_MESSAGE = Buffer.from("wrangler tail ping");
    const PING_INTERVAL = 1e4;
    let waitingForPong = false;
    const pingInterval = setInterval(() => {
      if (waitingForPong) {
        console.log(args.format);
        throw createFatalError(
          "Tail disconnected, exiting.",
          args.format === "json",
          1
        );
      }
      waitingForPong = true;
      tail.ping(PING_MESSAGE);
    }, PING_INTERVAL);
    tail.on("pong", (data) => {
      if (data.equals(PING_MESSAGE)) {
        waitingForPong = false;
      }
    });
    return () => clearInterval(pingInterval);
  }
  __name(startWebSocketPing, "startWebSocketPing");
}
__name(tailHandler, "tailHandler");

// src/triggers/index.ts
init_import_meta_url();

// src/triggers/deploy.ts
init_import_meta_url();
var import_chalk16 = __toESM(require_chalk());

// src/routes.ts
init_import_meta_url();
var import_chalk15 = __toESM(require_chalk());
async function getWorkersDevSubdomain(accountId) {
  try {
    const { subdomain } = await fetchResult(
      `/accounts/${accountId}/workers/subdomain`
    );
    return subdomain;
  } catch (e3) {
    const error2 = e3;
    if (typeof error2 === "object" && !!error2 && error2.code === 10007) {
      logger.warn(
        "You need to register a workers.dev subdomain before publishing to workers.dev"
      );
      const wantsToRegister = await confirm(
        "Would you like to register a workers.dev subdomain now?"
      );
      if (!wantsToRegister) {
        const solutionMessage = "You can either deploy your worker to one or more routes by specifying them in wrangler.toml, or register a workers.dev subdomain here:";
        const onboardingLink = `https://dash.cloudflare.com/${accountId}/workers/onboarding`;
        throw new UserError(`${solutionMessage}
${onboardingLink}`);
      }
      return await registerSubdomain(accountId);
    } else {
      throw e3;
    }
  }
}
__name(getWorkersDevSubdomain, "getWorkersDevSubdomain");
async function registerSubdomain(accountId) {
  let subdomain;
  while (subdomain === void 0) {
    const potentialName = await prompt(
      "What would you like your workers.dev subdomain to be? It will be accessible at https://<subdomain>.workers.dev"
    );
    if (!/^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/.test(potentialName)) {
      logger.warn(
        `${potentialName} is invalid, please choose another subdomain.`
      );
      continue;
    }
    try {
      await fetchResult(
        `/accounts/${accountId}/workers/subdomains/${potentialName}`
      );
    } catch (err) {
      const subdomainAvailabilityCheckError = err;
      if (typeof subdomainAvailabilityCheckError === "object" && !!subdomainAvailabilityCheckError) {
        if (subdomainAvailabilityCheckError.code === 10032) {
        } else if (subdomainAvailabilityCheckError.code === 10031) {
          logger.error(
            "Subdomain is unavailable, please try a different subdomain"
          );
          continue;
        } else {
          logger.error("An unexpected error occurred, please try again.");
          continue;
        }
      }
    }
    const ok = await confirm(
      `Creating a workers.dev subdomain for your account at ${import_chalk15.default.blue(
        import_chalk15.default.underline(`https://${potentialName}.workers.dev`)
      )}. Ok to proceed?`
    );
    if (!ok) {
      const solutionMessage = "You can either deploy your worker to one or more routes by specifying them in wrangler.toml, or register a workers.dev subdomain here:";
      const onboardingLink = `https://dash.cloudflare.com/${accountId}/workers/onboarding`;
      throw new UserError(`${solutionMessage}
${onboardingLink}`);
    }
    try {
      const result = await fetchResult(
        `/accounts/${accountId}/workers/subdomain`,
        {
          method: "PUT",
          body: JSON.stringify({ subdomain: potentialName })
        }
      );
      subdomain = result.subdomain;
    } catch (err) {
      const subdomainCreationError = err;
      if (typeof subdomainCreationError === "object" && !!subdomainCreationError && subdomainCreationError.code !== void 0) {
        switch (subdomainCreationError.code) {
          case 10031:
            logger.error(
              "Subdomain is unavailable, please try a different subdomain."
            );
            break;
          default:
            logger.error("An unexpected error occurred, please try again.");
            break;
        }
      }
    }
  }
  logger.log("Success! It may take a few minutes for DNS records to update.");
  logger.log(
    `Visit ${import_chalk15.default.blue(
      import_chalk15.default.underline(
        `https://dash.cloudflare.com/${accountId}/workers/subdomain`
      )
    )} to edit your workers.dev subdomain`
  );
  return subdomain;
}
__name(registerSubdomain, "registerSubdomain");

// src/triggers/deploy.ts
async function triggersDeploy(props) {
  const { config, accountId, name: scriptName } = props;
  const triggers = props.triggers || config.triggers?.crons;
  const routes = props.routes ?? config.routes ?? (config.route ? [config.route] : []) ?? [];
  const routesOnly = [];
  const customDomainsOnly = [];
  for (const route2 of routes) {
    if (typeof route2 !== "string" && route2.custom_domain) {
      if (route2.pattern.includes("*")) {
        throw new UserError(
          `Cannot use "${route2.pattern}" as a Custom Domain; wildcard operators (*) are not allowed`
        );
      }
      if (route2.pattern.includes("/")) {
        throw new UserError(
          `Cannot use "${route2.pattern}" as a Custom Domain; paths are not allowed`
        );
      }
      customDomainsOnly.push(route2);
    } else {
      routesOnly.push(route2);
    }
  }
  const deployToWorkersDev = config.workers_dev ?? routes.length === 0;
  if (!scriptName) {
    throw new UserError(
      'You need to provide a name when uploading a Worker Version. Either pass it as a cli arg with `--name <name>` or in your config file as `name = "<name>"`'
    );
  }
  const envName = props.env ?? "production";
  const start = Date.now();
  const notProd = Boolean(!props.legacyEnv && props.env);
  const workerName = notProd ? `${scriptName} (${envName})` : scriptName;
  const workerUrl = notProd ? `/accounts/${accountId}/workers/services/${scriptName}/environments/${envName}` : `/accounts/${accountId}/workers/scripts/${scriptName}`;
  const { enabled: available_on_subdomain } = await fetchResult(`${workerUrl}/subdomain`);
  if (!props.dryRun) {
    await ensureQueuesExistByConfig(config);
  }
  if (props.dryRun) {
    logger.log(`--dry-run: exiting now.`);
    return;
  }
  if (!accountId)
    throw new UserError("Missing accountId");
  const uploadMs = Date.now() - start;
  const deployments2 = [];
  if (deployToWorkersDev) {
    const userSubdomain = await getWorkersDevSubdomain(accountId);
    const scriptURL = props.legacyEnv || !props.env ? `${scriptName}.${userSubdomain}.workers.dev` : `${envName}.${scriptName}.${userSubdomain}.workers.dev`;
    if (!available_on_subdomain) {
      deployments2.push(
        fetchResult(`${workerUrl}/subdomain`, {
          method: "POST",
          body: JSON.stringify({ enabled: true }),
          headers: {
            "Content-Type": "application/json"
          }
        }).then(() => [scriptURL]).then(async (url4) => {
          await sleep2(3e3);
          return url4;
        })
      );
    } else {
      deployments2.push(Promise.resolve([scriptURL]));
    }
  } else {
    if (available_on_subdomain) {
      await fetchResult(`${workerUrl}/subdomain`, {
        method: "POST",
        body: JSON.stringify({ enabled: false }),
        headers: {
          "Content-Type": "application/json"
        }
      });
    } else if (routes.length !== 0) {
      const routesWithOtherBindings = {};
      for (const route2 of routes) {
        const zone = await getZoneForRoute(route2);
        if (!zone) {
          continue;
        }
        const routePattern = typeof route2 === "string" ? route2 : route2.pattern;
        const routesInZone = await fetchListResult(`/zones/${zone.id}/workers/routes`);
        routesInZone.forEach(({ script, pattern }) => {
          if (pattern === routePattern && script !== scriptName) {
            if (!(script in routesWithOtherBindings)) {
              routesWithOtherBindings[script] = [];
            }
            routesWithOtherBindings[script].push(pattern);
          }
        });
      }
      if (Object.keys(routesWithOtherBindings).length > 0) {
        let errorMessage = "Can't deploy routes that are assigned to another worker.\n";
        for (const worker in routesWithOtherBindings) {
          const assignedRoutes = routesWithOtherBindings[worker];
          errorMessage += `"${worker}" is already assigned to routes:
${assignedRoutes.map(
            (r3) => `  - ${import_chalk16.default.underline(r3)}
`
          )}`;
        }
        const resolution = "Unassign other workers from the routes you want to deploy to, and then try again.";
        const dashHref = import_chalk16.default.blue.underline(
          `https://dash.cloudflare.com/${accountId}/workers/overview`
        );
        const dashLink = `Visit ${dashHref} to unassign a worker from a route.`;
        throw new UserError(`${errorMessage}
${resolution}
${dashLink}`);
      }
    }
  }
  if (routesOnly.length > 0) {
    deployments2.push(
      publishRoutes(routesOnly, { workerUrl, scriptName, notProd }).then(() => {
        if (routesOnly.length > 10) {
          return routesOnly.slice(0, 9).map((route2) => renderRoute(route2)).concat([`...and ${routesOnly.length - 10} more routes`]);
        }
        return routesOnly.map((route2) => renderRoute(route2));
      })
    );
  }
  if (customDomainsOnly.length > 0) {
    deployments2.push(
      publishCustomDomains(workerUrl, accountId, customDomainsOnly)
    );
  }
  if (triggers && triggers.length) {
    deployments2.push(
      fetchResult(`${workerUrl}/schedules`, {
        // Note: PUT will override previous schedules on this script.
        method: "PUT",
        body: JSON.stringify(triggers.map((cron) => ({ cron }))),
        headers: {
          "Content-Type": "application/json"
        }
      }).then(() => triggers.map((trigger) => `schedule: ${trigger}`))
    );
  }
  if (config.queues.producers && config.queues.producers.length) {
    const updateProducers = await updateQueueProducers(config);
    deployments2.push(...updateProducers);
  }
  if (config.queues.consumers && config.queues.consumers.length) {
    const updateConsumers = await updateQueueConsumers(config);
    deployments2.push(...updateConsumers);
  }
  const targets = await Promise.all(deployments2);
  const deployMs = Date.now() - start - uploadMs;
  if (deployments2.length > 0) {
    const msg = props.experimentalVersions ? `Deployed ${workerName} triggers` : `Published ${workerName}`;
    logger.log(msg, formatTime2(deployMs));
    for (const target of targets.flat()) {
      logger.log(
        " ",
        (target.endsWith("workers.dev") ? "https://" : "") + target
      );
    }
  } else {
    logger.log("No deploy targets for", workerName, formatTime2(deployMs));
  }
}
__name(triggersDeploy, "triggersDeploy");

// src/triggers/index.ts
function registerTriggersSubcommands(triggersYargs) {
  triggersYargs.command(
    "deploy",
    "Updates the triggers of your current deployment [beta]",
    triggersDeployOptions,
    triggersDeployHandler
  );
}
__name(registerTriggersSubcommands, "registerTriggersSubcommands");
function triggersDeployOptions(yargs) {
  return yargs.option("name", {
    describe: "Name of the worker",
    type: "string",
    requiresArg: true
  }).option("triggers", {
    describe: "cron schedules to attach",
    alias: ["schedule", "schedules"],
    type: "string",
    requiresArg: true,
    array: true
  }).option("routes", {
    describe: "Routes to upload",
    alias: "route",
    type: "string",
    requiresArg: true,
    array: true
  }).option("dry-run", {
    describe: "Don't actually deploy",
    type: "boolean"
  }).option("legacy-env", {
    type: "boolean",
    describe: "Use legacy environments",
    hidden: true
  });
}
__name(triggersDeployOptions, "triggersDeployOptions");
async function triggersDeployHandler(args) {
  await printWranglerBanner();
  const config = readConfig(void 0, args);
  await sendMetricsEvent(
    "deploy worker triggers",
    {},
    {
      sendMetrics: config.send_metrics
    }
  );
  const accountId = args.dryRun ? void 0 : await requireAuth(config);
  await triggersDeploy({
    config,
    accountId,
    name: getScriptName(args, config),
    env: args.env,
    triggers: args.triggers,
    routes: args.routes,
    legacyEnv: isLegacyEnv(config),
    dryRun: args.dryRun,
    experimentalVersions: args.experimentalJsonConfig
  });
}
__name(triggersDeployHandler, "triggersDeployHandler");

// src/type-generation.ts
init_import_meta_url();
var fs24 = __toESM(require("node:fs"));

// src/dev/dev-vars.ts
init_import_meta_url();
var path52 = __toESM(require("node:path"));
function getVarsForDev(config, env5, silent = false) {
  const configDir = path52.resolve(path52.dirname(config.configPath ?? "."));
  const devVarsPath = path52.resolve(configDir, ".dev.vars");
  const loaded = loadDotEnv(devVarsPath, env5);
  if (loaded !== void 0) {
    const devVarsRelativePath = path52.relative(process.cwd(), loaded.path);
    if (!silent) {
      logger.log(`Using vars defined in ${devVarsRelativePath}`);
    }
    return {
      ...config.vars,
      ...loaded.parsed
    };
  } else {
    return config.vars;
  }
}
__name(getVarsForDev, "getVarsForDev");

// src/type-generation.ts
function typesOptions(yargs) {
  return yargs.positional("path", {
    describe: "The path to the declaration file to generate",
    type: "string",
    default: "worker-configuration.d.ts",
    demandOption: false
  }).option("env-interface", {
    type: "string",
    default: "Env",
    describe: "The name of the generated environment interface",
    requiresArg: true
  });
}
__name(typesOptions, "typesOptions");
async function typesHandler(args) {
  const { envInterface, path: outputPath } = args;
  const validInterfaceRegex = /^[a-zA-Z][a-zA-Z0-9_]*$/;
  if (!validInterfaceRegex.test(envInterface)) {
    throw new CommandLineArgsError(
      `The provided env-interface value ("${envInterface}") does not satisfy the validation regex: ${validInterfaceRegex}`
    );
  }
  if (!outputPath.endsWith(".d.ts")) {
    throw new CommandLineArgsError(
      `The provided path value ("${outputPath}") does not point to a declaration file (please use the 'd.ts' extension)`
    );
  }
  await printWranglerBanner();
  const configPath = args.config ?? findWranglerToml(process.cwd(), args.experimentalJsonConfig);
  if (!configPath || !fs24.existsSync(configPath) || fs24.statSync(configPath).isDirectory()) {
    logger.warn(
      `No config file detected${args.config ? ` (at ${args.config})` : ""}, aborting`
    );
    return;
  }
  const config = readConfig(configPath, args);
  const secrets = getVarsForDev(
    { configPath, vars: {} },
    args.env,
    true
  );
  const configBindingsWithSecrets = {
    kv_namespaces: config.kv_namespaces ?? [],
    vars: { ...config.vars },
    wasm_modules: config.wasm_modules,
    text_blobs: {
      ...config.text_blobs
    },
    data_blobs: config.data_blobs,
    durable_objects: config.durable_objects,
    r2_buckets: config.r2_buckets,
    d1_databases: config.d1_databases,
    services: config.services,
    analytics_engine_datasets: config.analytics_engine_datasets,
    dispatch_namespaces: config.dispatch_namespaces,
    logfwdr: config.logfwdr,
    unsafe: config.unsafe,
    rules: config.rules,
    queues: config.queues,
    constellation: config.constellation,
    send_email: config.send_email,
    vectorize: config.vectorize,
    hyperdrive: config.hyperdrive,
    mtls_certificates: config.mtls_certificates,
    browser: config.browser,
    ai: config.ai,
    version_metadata: config.version_metadata,
    secrets
  };
  await generateTypes(
    configBindingsWithSecrets,
    config,
    envInterface,
    outputPath
  );
}
__name(typesHandler, "typesHandler");
function isValidIdentifier2(key) {
  return /^[a-zA-Z_$][\w$]*$/.test(key);
}
__name(isValidIdentifier2, "isValidIdentifier");
function constructTypeKey(key) {
  if (isValidIdentifier2(key)) {
    return `${key}`;
  }
  return `"${key}"`;
}
__name(constructTypeKey, "constructTypeKey");
function constructType(key, value, useRawVal = true) {
  const typeKey = constructTypeKey(key);
  if (typeof value === "string") {
    if (useRawVal) {
      return `${typeKey}: ${value};`;
    }
    return `${typeKey}: "${value.replace(/"/g, '\\"')}";`;
  }
  if (typeof value === "number" || typeof value === "boolean") {
    return `${typeKey}: ${value};`;
  }
  return `${typeKey}: unknown;`;
}
__name(constructType, "constructType");
async function generateTypes(configToDTS, config, envInterface, outputPath) {
  const configContainsEntryPoint = config.main !== void 0 || !!config.site?.["entry-point"];
  const entrypointFormat = configContainsEntryPoint ? (await getEntry({}, config, "types")).format : "modules";
  const userProvidedEnvInterface = envInterface !== "Env";
  if (userProvidedEnvInterface && entrypointFormat === "service-worker") {
    throw new Error(
      "An env-interface value has been provided but the worker uses the incompatible Service Worker syntax"
    );
  }
  const envTypeStructure = [];
  if (configToDTS.kv_namespaces) {
    for (const kvNamespace2 of configToDTS.kv_namespaces) {
      envTypeStructure.push(constructType(kvNamespace2.binding, "KVNamespace"));
    }
  }
  if (configToDTS.vars) {
    const vars = Object.entries(configToDTS.vars).filter(
      ([key]) => !(key in configToDTS.secrets)
    );
    for (const [varName, varValue] of vars) {
      if (typeof varValue === "string" || typeof varValue === "number" || typeof varValue === "boolean") {
        envTypeStructure.push(constructType(varName, varValue, false));
      }
      if (typeof varValue === "object" && varValue !== null) {
        envTypeStructure.push(
          constructType(varName, JSON.stringify(varValue), true)
        );
      }
    }
  }
  for (const secretName in configToDTS.secrets) {
    envTypeStructure.push(constructType(secretName, "string", true));
  }
  if (configToDTS.durable_objects?.bindings) {
    for (const durableObject of configToDTS.durable_objects.bindings) {
      envTypeStructure.push(
        constructType(durableObject.name, "DurableObjectNamespace")
      );
    }
  }
  if (configToDTS.r2_buckets) {
    for (const R2Bucket of configToDTS.r2_buckets) {
      envTypeStructure.push(constructType(R2Bucket.binding, "R2Bucket"));
    }
  }
  if (configToDTS.d1_databases) {
    for (const d12 of configToDTS.d1_databases) {
      envTypeStructure.push(constructType(d12.binding, "D1Database"));
    }
  }
  if (configToDTS.services) {
    for (const service of configToDTS.services) {
      envTypeStructure.push(constructType(service.binding, "Fetcher"));
    }
  }
  if (configToDTS.constellation) {
    for (const service of configToDTS.constellation) {
      envTypeStructure.push(constructType(service.binding, "Fetcher"));
    }
  }
  if (configToDTS.analytics_engine_datasets) {
    for (const analyticsEngine of configToDTS.analytics_engine_datasets) {
      envTypeStructure.push(
        constructType(analyticsEngine.binding, "AnalyticsEngineDataset")
      );
    }
  }
  if (configToDTS.dispatch_namespaces) {
    for (const namespace of configToDTS.dispatch_namespaces) {
      envTypeStructure.push(
        constructType(namespace.binding, "DispatchNamespace")
      );
    }
  }
  if (configToDTS.logfwdr?.bindings?.length) {
    envTypeStructure.push(constructType("LOGFWDR_SCHEMA", "any"));
  }
  if (configToDTS.data_blobs) {
    for (const dataBlobs in configToDTS.data_blobs) {
      envTypeStructure.push(constructType(dataBlobs, "ArrayBuffer"));
    }
  }
  if (configToDTS.text_blobs) {
    for (const textBlobs in configToDTS.text_blobs) {
      envTypeStructure.push(constructType(textBlobs, "string"));
    }
  }
  if (configToDTS.unsafe?.bindings) {
    for (const unsafe of configToDTS.unsafe.bindings) {
      envTypeStructure.push(constructType(unsafe.name, "any"));
    }
  }
  if (configToDTS.queues) {
    if (configToDTS.queues.producers) {
      for (const queue of configToDTS.queues.producers) {
        envTypeStructure.push(constructType(queue.binding, "Queue"));
      }
    }
  }
  if (configToDTS.send_email) {
    for (const sendEmail of configToDTS.send_email) {
      envTypeStructure.push(constructType(sendEmail.name, "SendEmail"));
    }
  }
  if (configToDTS.vectorize) {
    for (const vectorize2 of configToDTS.vectorize) {
      envTypeStructure.push(constructType(vectorize2.binding, "VectorizeIndex"));
    }
  }
  if (configToDTS.hyperdrive) {
    for (const hyperdrive2 of configToDTS.hyperdrive) {
      envTypeStructure.push(constructType(hyperdrive2.binding, "Hyperdrive"));
    }
  }
  if (configToDTS.mtls_certificates) {
    for (const mtlsCertificate of configToDTS.mtls_certificates) {
      envTypeStructure.push(constructType(mtlsCertificate.binding, "Fetcher"));
    }
  }
  if (configToDTS.browser) {
    envTypeStructure.push(
      constructType(configToDTS.browser.binding, "Fetcher")
    );
  }
  if (configToDTS.ai) {
    envTypeStructure.push(constructType(configToDTS.ai.binding, "unknown"));
  }
  if (configToDTS.version_metadata) {
    envTypeStructure.push(
      `${configToDTS.version_metadata.binding}: { id: string; tag: string };`
    );
  }
  const modulesTypeStructure = [];
  if (configToDTS.rules) {
    const moduleTypeMap = {
      Text: "string",
      Data: "ArrayBuffer",
      CompiledWasm: "WebAssembly.Module"
    };
    for (const ruleObject of configToDTS.rules) {
      const typeScriptType = moduleTypeMap[ruleObject.type];
      if (typeScriptType !== void 0) {
        ruleObject.globs.forEach((glob) => {
          modulesTypeStructure.push(`declare module "*.${glob.split(".").at(-1)}" {
	const value: ${typeScriptType};
	export default value;
}`);
        });
      }
    }
  }
  writeDTSFile({
    envTypeStructure,
    modulesTypeStructure,
    formatType: entrypointFormat,
    envInterface,
    path: outputPath
  });
}
__name(generateTypes, "generateTypes");
function writeDTSFile({
  envTypeStructure,
  modulesTypeStructure,
  formatType,
  envInterface,
  path: path67
}) {
  const wranglerOverrideDTSPath = findUpSync(path67);
  try {
    if (wranglerOverrideDTSPath !== void 0 && !fs24.readFileSync(wranglerOverrideDTSPath, "utf8").includes("Generated by Wrangler")) {
      throw new UserError(
        `A non-wrangler ${path67} already exists, please rename and try again.`
      );
    }
  } catch (error2) {
    if (error2 instanceof Error && !error2.message.includes("not found")) {
      throw error2;
    }
  }
  let combinedTypeStrings = "";
  if (formatType === "modules") {
    combinedTypeStrings += `interface ${envInterface} {${envTypeStructure.map((value) => `
	${value}`).join("")}
}
${modulesTypeStructure.join("\n")}`;
  } else {
    combinedTypeStrings += `export {};
declare global {
${envTypeStructure.map((value) => `	const ${value}`).join("\n")}
}
${modulesTypeStructure.join("\n")}`;
  }
  const wranglerCommandUsed = ["wrangler", ...process.argv.slice(2)].join(" ");
  const typesHaveBeenFound = envTypeStructure.length || modulesTypeStructure.length;
  if (formatType === "modules" || typesHaveBeenFound) {
    fs24.writeFileSync(
      path67,
      [
        `// Generated by Wrangler on ${/* @__PURE__ */ new Date()}`,
        `// by running \`${wranglerCommandUsed}\``,
        "",
        combinedTypeStrings
      ].join("\n")
    );
    logger.log(combinedTypeStrings);
  }
}
__name(writeDTSFile, "writeDTSFile");

// src/vectorize/index.ts
init_import_meta_url();

// src/vectorize/common.ts
init_import_meta_url();
var vectorizeBetaWarning = `--------------------
\u{1F4E3} Vectorize is currently in open beta
\u{1F4E3} See the Vectorize docs for how to get started and known issues: https://developers.cloudflare.com/vectorize
\u{1F4E3} Please report any bugs to https://github.com/cloudflare/workers-sdk/issues/new/choose
\u{1F4E3} To give feedback, visit https://discord.cloudflare.com/
--------------------
`;

// src/vectorize/create.tsx
init_import_meta_url();
var import_ink10 = __toESM(require_build2());
var import_react15 = __toESM(require_react());

// src/vectorize/client.ts
init_import_meta_url();
var jsonContentType = "application/json; charset=utf-8;";
async function createIndex(config, body) {
  const accountId = await requireAuth(config);
  return await fetchResult(
    `/accounts/${accountId}/vectorize/indexes`,
    {
      method: "POST",
      headers: {
        "content-type": jsonContentType
      },
      body: JSON.stringify(body)
    }
  );
}
__name(createIndex, "createIndex");
async function deleteIndex(config, indexName) {
  const accountId = await requireAuth(config);
  return await fetchResult(
    `/accounts/${accountId}/vectorize/indexes/${indexName}`,
    {
      method: "DELETE"
    }
  );
}
__name(deleteIndex, "deleteIndex");
async function getIndex(config, indexName) {
  const accountId = await requireAuth(config);
  return await fetchResult(
    `/accounts/${accountId}/vectorize/indexes/${indexName}`,
    {
      method: "GET"
    }
  );
}
__name(getIndex, "getIndex");
async function listIndexes(config) {
  const accountId = await requireAuth(config);
  return await fetchListResult(
    `/accounts/${accountId}/vectorize/indexes`,
    {
      method: "GET"
    }
  );
}
__name(listIndexes, "listIndexes");
async function insertIntoIndex(config, indexName, body) {
  const accountId = await requireAuth(config);
  return await fetchResult(
    `/accounts/${accountId}/vectorize/indexes/${indexName}/insert`,
    {
      method: "POST",
      body
    }
  );
}
__name(insertIntoIndex, "insertIntoIndex");

// src/vectorize/create.tsx
function options24(yargs) {
  return yargs.positional("name", {
    type: "string",
    demandOption: true,
    description: "The name of the Vectorize index to create (must be unique)."
  }).options({
    dimensions: {
      type: "number",
      describe: "The dimension size to configure this index for, based on the output dimensions of your ML model."
    }
  }).options({
    metric: {
      type: "string",
      choices: ["euclidean", "cosine", "dot-product"],
      describe: "The distance metric to use for searching within the index."
    }
  }).options({
    preset: {
      type: "string",
      choices: [
        "@cf/baai/bge-small-en-v1.5",
        "@cf/baai/bge-base-en-v1.5",
        "@cf/baai/bge-large-en-v1.5",
        "openai/text-embedding-ada-002",
        "cohere/embed-multilingual-v2.0"
      ],
      describe: "The name of an preset representing an embeddings model: Vectorize will configure the dimensions and distance metric for you when provided."
    }
  }).options({
    description: {
      type: "string",
      describe: "An optional description for this index."
    }
  }).option("json", {
    describe: "return output as clean JSON",
    type: "boolean",
    default: false
  }).epilogue(vectorizeBetaWarning);
}
__name(options24, "options");
async function handler25(args) {
  const config = readConfig(args.config, args);
  let indexConfig;
  if (args.preset) {
    indexConfig = { preset: args.preset };
    logger.log(
      `Configuring index based for the embedding model ${args.preset}.`
    );
  } else if (args.dimensions && args.metric) {
    indexConfig = {
      metric: args.metric,
      dimensions: args.dimensions
    };
  } else {
    logger.error(
      "You must provide both dimensions and a metric, or a known model preset when creating an index."
    );
    return;
  }
  const index = {
    name: args.name,
    description: args.description,
    config: indexConfig
  };
  logger.log(`\u{1F6A7} Creating index: '${args.name}'`);
  const indexResult = await createIndex(config, index);
  if (args.json) {
    logger.log(JSON.stringify(index, null, 2));
    return;
  }
  logger.log(
    renderToString(
      /* @__PURE__ */ import_react15.default.createElement(import_ink10.Box, { flexDirection: "column" }, /* @__PURE__ */ import_react15.default.createElement(import_ink10.Text, null, "\u2705 Successfully created a new Vectorize index: '", indexResult.name, "'"), /* @__PURE__ */ import_react15.default.createElement(import_ink10.Text, null, "\u{1F4CB} To start querying from a Worker, add the following binding configuration into 'wrangler.toml':"), /* @__PURE__ */ import_react15.default.createElement(import_ink10.Text, null, "\xA0"), /* @__PURE__ */ import_react15.default.createElement(import_ink10.Text, null, "[[vectorize]]"), /* @__PURE__ */ import_react15.default.createElement(import_ink10.Text, null, 'binding = "VECTORIZE_INDEX" # available within your Worker on env.VECTORIZE_INDEX'), /* @__PURE__ */ import_react15.default.createElement(import_ink10.Text, null, 'index_name = "', indexResult.name, '"'))
    )
  );
}
__name(handler25, "handler");

// src/vectorize/delete.ts
init_import_meta_url();
function options25(yargs) {
  return yargs.positional("name", {
    type: "string",
    demandOption: true,
    description: "The name of the Vectorize index"
  }).option("force", {
    describe: "Skip confirmation",
    type: "boolean",
    alias: "y",
    default: false
  }).epilogue(vectorizeBetaWarning);
}
__name(options25, "options");
async function handler26(args) {
  const config = readConfig(args.config, args);
  logger.log(`Deleting Vectorize index ${args.name}`);
  if (!args.force) {
    const confirmedDeletion = await confirm(
      `OK to delete the index '${args.name}'?`
    );
    if (!confirmedDeletion) {
      logger.log("Deletion cancelled.");
      return;
    }
  }
  await deleteIndex(config, args.name);
  logger.log(`\u2705 Deleted index ${args.name}`);
}
__name(handler26, "handler");

// src/vectorize/get.ts
init_import_meta_url();
function options26(yargs) {
  return yargs.positional("name", {
    type: "string",
    demandOption: true,
    description: "The name of the Vectorize index."
  }).option("json", {
    describe: "return output as clean JSON",
    type: "boolean",
    default: false
  }).epilogue(vectorizeBetaWarning);
}
__name(options26, "options");
async function handler27(args) {
  const config = readConfig(args.config, args);
  const index = await getIndex(config, args.name);
  if (args.json) {
    logger.log(JSON.stringify(index, null, 2));
    return;
  }
  logger.table([
    {
      name: index.name,
      dimensions: index.config?.dimensions.toString(),
      metric: index.config?.metric,
      description: index.description || "",
      created: index.created_on,
      modified: index.modified_on
    }
  ]);
}
__name(handler27, "handler");

// src/vectorize/insert.ts
init_import_meta_url();
var import_node_fs32 = require("node:fs");
var import_node_readline4 = require("node:readline");
var import_undici20 = __toESM(require_undici());
var VECTORIZE_MAX_BATCH_SIZE = 1e3;
var VECTORIZE_UPSERT_BATCH_SIZE = VECTORIZE_MAX_BATCH_SIZE;
var VECTORIZE_MAX_UPSERT_VECTOR_RECORDS = 1e5;
function options27(yargs) {
  return yargs.positional("name", {
    type: "string",
    demandOption: true,
    description: "The name of the Vectorize index."
  }).options({
    file: {
      describe: "A file containing line separated json (ndjson) vector objects.",
      demandOption: true,
      type: "string"
    },
    "batch-size": {
      describe: "Number of vector records to include when sending to the Cloudflare API.",
      type: "number",
      default: VECTORIZE_UPSERT_BATCH_SIZE
    },
    json: {
      describe: "return output as clean JSON",
      type: "boolean",
      default: false
    }
  }).epilogue(vectorizeBetaWarning);
}
__name(options27, "options");
async function handler28(args) {
  const config = readConfig(args.config, args);
  const rl = (0, import_node_readline4.createInterface)({ input: (0, import_node_fs32.createReadStream)(args.file) });
  if (Number(args.batchSize) > VECTORIZE_MAX_BATCH_SIZE) {
    logger.error(
      `\u{1F6A8} Vectorize currently limits upload batches to ${VECTORIZE_MAX_BATCH_SIZE} records at a time.`
    );
  }
  let vectorInsertCount = 0;
  for await (const batch of getBatchFromFile(rl, args.batchSize)) {
    const formData = new import_undici20.FormData();
    formData.append(
      "vectors",
      new import_undici20.File([batch.join(`
`)], "vectors.ndjson", {
        type: "application/x-ndjson"
      })
    );
    logger.log(`\u2728 Uploading vector batch (${batch.length} vectors)`);
    const idxPart = await insertIntoIndex(config, args.name, formData);
    vectorInsertCount += idxPart.count;
    if (vectorInsertCount > VECTORIZE_MAX_UPSERT_VECTOR_RECORDS) {
      logger.warn(
        `\u{1F6A7} While Vectorize is in beta, we've limited uploads to 100k vectors per run. You may run this again with another batch to upload further`
      );
      break;
    }
  }
  if (args.json) {
    logger.log(
      JSON.stringify({ index: args.name, count: vectorInsertCount }, null, 2)
    );
    return;
  }
  logger.log(
    `\u2705 Successfully inserted ${vectorInsertCount} vectors into index '${args.name}'`
  );
}
__name(handler28, "handler");
async function* getBatchFromFile(rl, batchSize = VECTORIZE_UPSERT_BATCH_SIZE) {
  let batch = [];
  for await (const line of rl) {
    if (batch.push(line) >= batchSize) {
      yield batch;
      batch = [];
    }
  }
  yield batch;
}
__name(getBatchFromFile, "getBatchFromFile");

// src/vectorize/list.ts
init_import_meta_url();
function options28(yargs) {
  return yargs.option("json", {
    describe: "return output as clean JSON",
    type: "boolean",
    default: false
  }).epilogue(vectorizeBetaWarning);
}
__name(options28, "options");
async function handler29(args) {
  const config = readConfig(args.config, args);
  logger.log(`\u{1F4CB} Listing Vectorize indexes...`);
  const indexes = await listIndexes(config);
  if (indexes.length === 0) {
    logger.warn(`
You haven't created any indexes on this account.

Use 'wrangler vectorize create <name>' to create one, or visit
https://developers.cloudflare.com/vectorize/ to get started.
		`);
    return;
  }
  if (args.json) {
    logger.log(JSON.stringify(indexes, null, 2));
    return;
  }
  logger.table(
    indexes.map((index) => ({
      name: index.name,
      dimensions: index.config?.dimensions.toString(),
      metric: index.config?.metric,
      description: index.description ?? "",
      created: index.created_on,
      modified: index.modified_on
    }))
  );
}
__name(handler29, "handler");

// src/vectorize/index.ts
function vectorize(yargs) {
  return yargs.command(
    "create <name>",
    "Create a Vectorize index",
    options24,
    handler25
  ).command(
    "delete <name>",
    "Delete a Vectorize index",
    options25,
    handler26
  ).command(
    "get <name>",
    "Get a Vectorize index by name",
    options26,
    handler27
  ).command("list", "List your Vectorize indexes", options28, handler29).command(
    "insert <name>",
    "Insert vectors into a Vectorize index",
    options27,
    handler28
  ).epilogue(vectorizeBetaWarning);
}
__name(vectorize, "vectorize");

// src/versions/index.ts
init_import_meta_url();
var import_node_path51 = __toESM(require("node:path"));

// src/versions/deploy.ts
init_import_meta_url();
var import_assert3 = __toESM(require("assert"));
var import_path16 = __toESM(require("path"));

// src/utils/render-labelled-values.ts
init_import_meta_url();

// ../../node_modules/.pnpm/strip-ansi@7.0.1/node_modules/strip-ansi/index.js
init_import_meta_url();
function stripAnsi3(string) {
  if (typeof string !== "string") {
    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
  }
  return string.replace(ansiRegex(), "");
}
__name(stripAnsi3, "stripAnsi");

// src/utils/render-labelled-values.ts
function formatLabelledValues(view, {
  formatLabel = /* @__PURE__ */ __name((label) => white(label + ":"), "formatLabel"),
  formatValue = /* @__PURE__ */ __name((value) => gray(value), "formatValue"),
  spacerCount = 2,
  indentationCount = 0,
  valuesAlignmentColumn: valuesAlignment = Math.max(
    ...Object.keys(view).map((label) => stripAnsi3(formatLabel(label)).length)
  ),
  lineSeparator = "\n",
  labelJustification = "left"
} = {}) {
  const labelLengthsWithoutANSI = Object.keys(view).map(
    (label) => stripAnsi3(formatLabel(label)).length
  );
  const formattedLines = Object.entries(view).map(([label, value], i) => {
    const indentation = indentationCount ? " ".repeat(indentationCount) : "";
    const labelAlignment = labelJustification === "left" ? "" : " ".repeat(valuesAlignment - labelLengthsWithoutANSI[i]);
    const formattedAndAlignedLabel = labelAlignment + formatLabel(label);
    const formattedAndAlignedMultilineValue = formatValue(value).split("\n").map((line, lineNo) => {
      const prefixSpacing = " ".repeat(
        lineNo === 0 ? valuesAlignment + spacerCount - labelLengthsWithoutANSI[i] - labelAlignment.length : valuesAlignment + spacerCount + indentationCount
      );
      return prefixSpacing + line;
    }).join("\n");
    return indentation + formattedAndAlignedLabel + formattedAndAlignedMultilineValue;
  });
  const output = formattedLines.join(lineSeparator);
  return collapseWhiteSpaceLines(output);
}
__name(formatLabelledValues, "formatLabelledValues");
function collapseWhiteSpaceLines(input) {
  return input.replaceAll(/^\s+$/gm, "");
}
__name(collapseWhiteSpaceLines, "collapseWhiteSpaceLines");

// src/versions/api.ts
init_import_meta_url();
async function fetchVersion(accountId, workerName, versionId, versionCache) {
  const cachedVersion = versionCache?.get(versionId);
  if (cachedVersion)
    return cachedVersion;
  const version3 = await fetchResult(
    `/accounts/${accountId}/workers/scripts/${workerName}/versions/${versionId}`
  );
  versionCache?.set(version3.id, version3);
  return version3;
}
__name(fetchVersion, "fetchVersion");
async function fetchVersions(accountId, workerName, versionCache, ...versionIds) {
  return Promise.all(
    versionIds.map(
      (versionId) => fetchVersion(accountId, workerName, versionId, versionCache)
    )
  );
}
__name(fetchVersions, "fetchVersions");
async function fetchLatestDeployments(accountId, workerName) {
  const { deployments: deployments2 } = await fetchResult(`/accounts/${accountId}/workers/scripts/${workerName}/deployments`);
  return deployments2;
}
__name(fetchLatestDeployments, "fetchLatestDeployments");
async function fetchLatestDeployment(accountId, workerName) {
  const deployments2 = await fetchLatestDeployments(accountId, workerName);
  return deployments2.at(0);
}
__name(fetchLatestDeployment, "fetchLatestDeployment");
async function fetchLatestDeploymentVersions(accountId, workerName, versionCache) {
  const latestDeployment = await fetchLatestDeployment(accountId, workerName);
  if (!latestDeployment)
    return [[], /* @__PURE__ */ new Map()];
  const versionTraffic = new Map(
    latestDeployment.versions.map(({ version_id: versionId, percentage }) => [
      versionId,
      percentage
    ])
  );
  const versions = await fetchVersions(
    accountId,
    workerName,
    versionCache,
    ...versionTraffic.keys()
  );
  return [versions, versionTraffic];
}
__name(fetchLatestDeploymentVersions, "fetchLatestDeploymentVersions");
async function fetchLatestUploadedVersions(accountId, workerName, versionCache) {
  const { items: versions } = await fetchResult(
    `/accounts/${accountId}/workers/scripts/${workerName}/versions`
  );
  for (const version3 of versions) {
    versionCache.set(version3.id, version3);
  }
  return versions;
}
__name(fetchLatestUploadedVersions, "fetchLatestUploadedVersions");
async function createDeployment(accountId, workerName, versionTraffic, message) {
  const res = await fetchResult(
    `/accounts/${accountId}/workers/scripts/${workerName}/deployments`,
    {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        strategy: "percentage",
        versions: Array.from(versionTraffic).map(
          ([version_id, percentage]) => ({ version_id, percentage })
        ),
        annotations: {
          "workers/message": message
        }
      })
    }
  );
  return res;
}
__name(createDeployment, "createDeployment");
async function patchNonVersionedScriptSettings(accountId, workerName, settings) {
  const res = await fetchResult(
    `/accounts/${accountId}/workers/scripts/${workerName}/script-settings`,
    {
      method: "PATCH",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(settings)
    }
  );
  return res;
}
__name(patchNonVersionedScriptSettings, "patchNonVersionedScriptSettings");

// src/versions/deploy.ts
var EPSILON = 1e-3;
var BLANK_INPUT = "-";
var ZERO_WIDTH_SPACE = "\u200B";
function versionsDeployOptions(yargs) {
  return yargs.option("name", {
    describe: "Name of the worker",
    type: "string",
    requiresArg: true
  }).option("version-id", {
    describe: "Worker Version ID(s) to deploy",
    type: "array",
    string: true,
    requiresArg: true
  }).option("percentage", {
    describe: "Percentage of traffic to split between Worker Version(s) (0-100)",
    type: "array",
    number: true,
    requiresArg: true
  }).positional("version-specs", {
    describe: "Shorthand notation to deploy Worker Version(s) [<version-id>@<percentage>..]",
    type: "string",
    array: true
  }).option("message", {
    describe: "Description of this deployment (optional)",
    type: "string",
    requiresArg: true
  }).option("yes", {
    alias: "y",
    describe: "Automatically accept defaults to prompts",
    type: "boolean",
    default: false
  }).option("dry-run", {
    describe: "Don't actually deploy",
    type: "boolean",
    default: false
  }).option("max-versions", {
    hidden: true,
    // experimental, not supported long-term
    describe: "Maximum allowed versions to select",
    type: "number",
    default: 2
    // (when server-side limitation is lifted, we can update this default or just remove the option entirely)
  });
}
__name(versionsDeployOptions, "versionsDeployOptions");
async function versionsDeployHandler(args) {
  await printWranglerBanner();
  const config = getConfig2(args);
  await sendMetricsEvent(
    "deploy worker versions",
    {},
    {
      sendMetrics: config.send_metrics
    }
  );
  const accountId = await requireAuth(config);
  const workerName = args.name ?? config.name;
  if (workerName === void 0) {
    throw new UserError(
      'You need to provide a name of your worker. Either pass it as a cli arg with `--name <name>` or in your config file as `name = "<name>"`'
    );
  }
  const versionCache = /* @__PURE__ */ new Map();
  const optionalVersionTraffic = parseVersionSpecs(args);
  startSection(
    "Deploy Worker Versions",
    "by splitting traffic between multiple versions",
    true
  );
  await printLatestDeployment(accountId, workerName, versionCache);
  const confirmedVersionsToDeploy = await promptVersionsToDeploy(
    accountId,
    workerName,
    [...optionalVersionTraffic.keys()],
    versionCache,
    args.yes
  );
  if (confirmedVersionsToDeploy.length === 0) {
    throw new UserError("You must select at least 1 version to deploy.");
  }
  if (confirmedVersionsToDeploy.length > args.maxVersions) {
    throw new UserError(
      `You must select at most ${args.maxVersions} versions to deploy.`
    );
  }
  const confirmedVersionTraffic = await promptPercentages(
    confirmedVersionsToDeploy,
    optionalVersionTraffic,
    args.yes
  );
  const message = await inputPrompt({
    type: "text",
    label: "Deployment message",
    defaultValue: args.message,
    acceptDefault: args.yes,
    question: "Add a deployment message",
    helpText: "(optional)"
  });
  if (args.dryRun) {
    cancel("--dry-run: exiting");
    return;
  }
  const start = Date.now();
  await spinnerWhile({
    startMessage: `Deploying ${confirmedVersionsToDeploy.length} version(s)`,
    async promise() {
      await createDeployment(
        accountId,
        workerName,
        confirmedVersionTraffic,
        message
      );
    }
  });
  await maybePatchSettings(accountId, workerName, config);
  const elapsedMilliseconds = Date.now() - start;
  const elapsedSeconds = elapsedMilliseconds / 1e3;
  const elapsedString = `${elapsedSeconds.toFixed(2)} sec`;
  const trafficSummaryList = Array.from(confirmedVersionTraffic).map(
    ([versionId, percentage]) => `version ${versionId} at ${percentage}%`
  );
  const trafficSummaryString = new Intl.ListFormat("en-US").format(
    trafficSummaryList
  );
  success(
    `Deployed ${workerName} ${trafficSummaryString} (${elapsedString})`
  );
}
__name(versionsDeployHandler, "versionsDeployHandler");
function getConfig2(args) {
  const configPath = args.config || args.name && findWranglerToml(import_path16.default.dirname(args.name));
  const config = readConfig(configPath, args);
  return config;
}
__name(getConfig2, "getConfig");
async function printLatestDeployment(accountId, workerName, versionCache) {
  const [versions, traffic] = await spinnerWhile({
    startMessage: "Fetching latest deployment",
    async promise() {
      return fetchLatestDeploymentVersions(accountId, workerName, versionCache);
    }
  });
  logRaw(
    `${leftT} Your current deployment has ${versions.length} version(s):`
  );
  printVersions(versions, traffic);
}
__name(printLatestDeployment, "printLatestDeployment");
function printVersions(versions, traffic) {
  for (const version3 of versions) {
    const trafficString = brandColor(`(${traffic.get(version3.id)}%)`);
    const versionIdString = white(version3.id);
    log(
      gray(`
${trafficString} ${versionIdString}
      Created:  ${version3.metadata.created_on}
          Tag:  ${version3.annotations?.["workers/tag"] ?? BLANK_INPUT}
      Message:  ${version3.annotations?.["workers/message"] ?? BLANK_INPUT}`)
    );
  }
  newline();
}
__name(printVersions, "printVersions");
async function promptVersionsToDeploy(accountId, workerName, defaultSelectedVersionIds, versionCache, yesFlag) {
  await spinnerWhile({
    startMessage: "Fetching deployable versions",
    async promise() {
      await fetchLatestUploadedVersions(accountId, workerName, versionCache);
      await fetchVersions(
        accountId,
        workerName,
        versionCache,
        ...defaultSelectedVersionIds
      );
    }
  });
  const selectableVersions = Array.from(versionCache.values()).sort(
    (a, b2) => b2.metadata.created_on.localeCompare(a.metadata.created_on)
    // String#localeCompare should work because they are ISO strings
  );
  const question = "Which version(s) do you want to deploy?";
  const result = await inputPrompt({
    type: "multiselect",
    question,
    options: selectableVersions.map((version3) => ({
      value: version3.id,
      label: version3.id,
      sublabel: gray(`
${ZERO_WIDTH_SPACE}       Created:  ${version3.metadata.created_on}
${ZERO_WIDTH_SPACE}           Tag:  ${version3.annotations?.["workers/tag"] ?? BLANK_INPUT}
${ZERO_WIDTH_SPACE}       Message:  ${version3.annotations?.["workers/message"] ?? BLANK_INPUT}
            `)
    })),
    label: "",
    helpText: "Use SPACE to select/unselect version(s) and ENTER to submit.",
    defaultValue: defaultSelectedVersionIds,
    acceptDefault: yesFlag,
    validate(versionIds) {
      if (versionIds === void 0) {
        return `You must select at least 1 version to deploy.`;
      }
    },
    renderers: {
      submit({ value: versionIds }) {
        (0, import_assert3.default)(Array.isArray(versionIds));
        const label = brandColor(
          `${versionIds.length} Worker Version(s) selected`
        );
        const versions = versionIds?.map((versionId, i) => {
          const version3 = versionCache.get(versionId);
          (0, import_assert3.default)(version3);
          return `${grayBar}
${leftT} ${white(`    Worker Version ${i + 1}: `, version3.id)}
${grayBar} ${gray("             Created: ", version3.metadata.created_on)}
${grayBar} ${gray(
            "                 Tag: ",
            version3.annotations?.["workers/tag"] ?? BLANK_INPUT
          )}
${grayBar} ${gray(
            "             Message: ",
            version3.annotations?.["workers/message"] ?? BLANK_INPUT
          )}`;
        });
        return [
          `${leftT} ${question}`,
          `${leftT} ${label}`,
          ...versions,
          grayBar
        ];
      }
    }
  });
  return result;
}
__name(promptVersionsToDeploy, "promptVersionsToDeploy");
async function promptPercentages(versionIds, optionalVersionTraffic, yesFlag, confirmedVersionTraffic = /* @__PURE__ */ new Map()) {
  let n2 = 0;
  for (const versionId of versionIds) {
    n2++;
    const defaultVersionTraffic = assignAndDistributePercentages(
      versionIds,
      new Map([...optionalVersionTraffic, ...confirmedVersionTraffic])
    );
    const defaultValue = defaultVersionTraffic.get(versionId)?.toFixed(3).replace(/\.?0+$/, "");
    const question = `What percentage of traffic should Worker Version ${n2} receive?`;
    const answer = await inputPrompt({
      type: "text",
      question,
      helpText: "(0-100)",
      label: `Traffic`,
      defaultValue,
      initialValue: confirmedVersionTraffic.get(versionId)?.toString(),
      // if the user already entered a value, override the default
      acceptDefault: yesFlag,
      format: (val) => `${val}%`,
      validate: (val) => {
        const input = val !== "" ? val : defaultValue;
        const percentage2 = parseFloat(input?.toString() ?? "");
        if (isNaN(percentage2) || percentage2 < 0 || percentage2 > 100)
          return "Please enter a number between 0 and 100.";
      },
      renderers: {
        submit({ value }) {
          const percentage2 = parseFloat(value?.toString() ?? "");
          return [
            leftT + space() + white(question),
            leftT + space() + brandColor(`${percentage2}%`) + gray(" of traffic"),
            leftT
          ];
        }
      }
    });
    const percentage = parseFloat(answer);
    confirmedVersionTraffic.set(versionId, percentage);
  }
  try {
    const { subtotal } = summariseVersionTraffic(
      confirmedVersionTraffic,
      versionIds
    );
    validateTrafficSubtotal(subtotal);
  } catch (err) {
    if (err instanceof UserError) {
      if (yesFlag)
        throw err;
      error(err.message, void 0, leftT);
      return promptPercentages(
        versionIds,
        optionalVersionTraffic,
        yesFlag,
        confirmedVersionTraffic
      );
    }
    throw err;
  }
  return confirmedVersionTraffic;
}
__name(promptPercentages, "promptPercentages");
async function maybePatchSettings(accountId, workerName, config) {
  const maybeUndefinedSettings = {
    logpush: config.logpush,
    tail_consumers: config.tail_consumers
  };
  const definedSettings = Object.fromEntries(
    Object.entries(maybeUndefinedSettings).filter(
      ([, value]) => value !== void 0
    )
  );
  const hasZeroSettingsToSync = Object.keys(definedSettings).length === 0;
  if (hasZeroSettingsToSync) {
    log("No non-versioned settings to sync. Skipping...");
    return;
  }
  const patchedSettings = await spinnerWhile({
    startMessage: `Syncing non-versioned settings`,
    async promise() {
      return await patchNonVersionedScriptSettings(
        accountId,
        workerName,
        definedSettings
      );
    }
  });
  const formattedSettings = formatLabelledValues(
    {
      logpush: String(patchedSettings.logpush ?? "<skipped>"),
      tail_consumers: patchedSettings.tail_consumers?.map(
        (tc) => tc.environment ? `${tc.service} (${tc.environment})` : tc.service
      ).join("\n") ?? "<skipped>"
    },
    {
      labelJustification: "right",
      indentationCount: 4
    }
  );
  log("Synced non-versioned settings:\n" + formattedSettings);
}
__name(maybePatchSettings, "maybePatchSettings");
function parseVersionSpecs(args) {
  const versionIds = [];
  const percentages = [];
  for (const spec of args.versionSpecs ?? []) {
    const [versionId, percentageString] = spec.split("@");
    const percentage = percentageString === void 0 || percentageString === "" ? null : parseFloat(percentageString);
    if (percentage !== null) {
      if (isNaN(percentage)) {
        throw new UserError(
          `Could not parse percentage value from version-spec positional arg "${spec}"`
        );
      }
      if (percentage < 0 || percentage > 100) {
        throw new UserError(
          `Percentage value (${percentage}%) parsed from version-spec positional arg "${spec}" must be between 0 and 100.`
        );
      }
    }
    versionIds.push(versionId);
    percentages.push(percentage);
  }
  const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
  for (const versionId of args.versionId ?? []) {
    if (!UUID_REGEX.test(versionId)) {
      throw new UserError(`Version ID must be a valid UUID (${versionId}).`);
    }
    versionIds.push(versionId);
  }
  for (const percentage of args.percentage ?? []) {
    if (percentage < 0 || percentage > 100) {
      throw new UserError(
        `Percentage value (${percentage}%) must be between 0 and 100.`
      );
    }
    percentages.push(percentage);
  }
  const optionalVersionTraffic = new Map(
    versionIds.map((_3, i) => [versionIds[i], percentages[i] ?? null])
  );
  return optionalVersionTraffic;
}
__name(parseVersionSpecs, "parseVersionSpecs");
function assignAndDistributePercentages(versionIds, optionalVersionTraffic) {
  const { subtotal, unspecifiedCount } = summariseVersionTraffic(
    optionalVersionTraffic,
    versionIds
  );
  const unspecifiedPercentageReplacement = unspecifiedCount === 0 || subtotal > 100 ? 0 : (100 - subtotal) / unspecifiedCount;
  const versionTraffic = new Map(
    versionIds.map((versionId) => [
      versionId,
      optionalVersionTraffic.get(versionId) ?? unspecifiedPercentageReplacement
    ])
  );
  return versionTraffic;
}
__name(assignAndDistributePercentages, "assignAndDistributePercentages");
function summariseVersionTraffic(optionalVersionTraffic, versionIds = Array.from(optionalVersionTraffic.keys())) {
  const versionsWithoutPercentage = versionIds.filter(
    (versionId) => optionalVersionTraffic.get(versionId) == null
  );
  const percentages = versionIds.map(
    (versionId) => optionalVersionTraffic.get(versionId) ?? null
  );
  const percentagesSubtotal = percentages.reduce(
    (sum, x2) => sum + (x2 ?? 0),
    0
  );
  return {
    subtotal: percentagesSubtotal,
    unspecifiedCount: versionsWithoutPercentage.length
  };
}
__name(summariseVersionTraffic, "summariseVersionTraffic");
function validateTrafficSubtotal(subtotal, { max = 100, min = 100, epsilon = EPSILON } = {}) {
  const isAbove = subtotal > max + epsilon;
  const isBelow = subtotal < min - epsilon;
  if (max === min && (isAbove || isBelow)) {
    throw new UserError(
      `Sum of specified percentages (${subtotal}%) must be ${max}%`
    );
  }
  if (isAbove) {
    throw new UserError(
      `Sum of specified percentages (${subtotal}%) must be at most ${max}%`
    );
  }
  if (isBelow) {
    throw new UserError(
      `Sum of specified percentages (${subtotal}%) must be at least ${min}%`
    );
  }
}
__name(validateTrafficSubtotal, "validateTrafficSubtotal");

// src/versions/list.ts
init_import_meta_url();
var import_path17 = __toESM(require("path"));
var BLANK_INPUT2 = "-";
function versionsListOptions(yargs) {
  return yargs.option("name", {
    describe: "Name of the worker",
    type: "string",
    requiresArg: true
  }).option("json", {
    describe: "Display output as clean JSON",
    type: "boolean",
    default: false
  });
}
__name(versionsListOptions, "versionsListOptions");
async function versionsListHandler(args) {
  if (!args.json) {
    await printWranglerBanner();
  }
  const config = getConfig3(args);
  await sendMetricsEvent(
    "list worker versions",
    { json: args.json },
    {
      sendMetrics: config.send_metrics
    }
  );
  const accountId = await requireAuth(config);
  const workerName = args.name ?? config.name;
  if (workerName === void 0) {
    throw new UserError(
      'You need to provide a name of your worker. Either pass it as a cli arg with `--name <name>` or in your config file as `name = "<name>"`'
    );
  }
  const versionCache = /* @__PURE__ */ new Map();
  const versions = await fetchLatestUploadedVersions(
    accountId,
    workerName,
    versionCache
  );
  if (args.json) {
    logRaw(JSON.stringify(versions, null, 2));
    return;
  }
  for (const version3 of versions) {
    const formattedVersion = formatLabelledValues({
      "Version ID": version3.id,
      Created: new Date(version3.metadata["created_on"]).toISOString(),
      Author: version3.metadata.author_email,
      Source: getVersionSource(version3),
      Tag: version3.annotations?.["workers/tag"] || BLANK_INPUT2,
      Message: version3.annotations?.["workers/message"] || BLANK_INPUT2
    });
    logRaw(formattedVersion);
    logRaw(``);
  }
}
__name(versionsListHandler, "versionsListHandler");
function getConfig3(args) {
  const configPath = args.config || args.name && findWranglerToml(import_path17.default.dirname(args.name));
  const config = readConfig(configPath, args);
  return config;
}
__name(getConfig3, "getConfig");
function getVersionSource(version3) {
  return version3.annotations?.["workers/triggered_by"] === void 0 ? formatSource(version3.metadata.source) : formatTrigger(version3.annotations["workers/triggered_by"]);
}
__name(getVersionSource, "getVersionSource");
function formatSource(source) {
  switch (source) {
    case "api":
      return "API \u{1F4E1}";
    case "dash":
      return "Dashboard \u{1F5A5}\uFE0F";
    case "wrangler":
      return "Wrangler \u{1F920}";
    case "terraform":
      return "Terraform \u{1F3D7}\uFE0F";
    default:
      return `Other (${source})`;
  }
}
__name(formatSource, "formatSource");
function formatTrigger(trigger) {
  switch (trigger) {
    case "upload":
      return "Upload";
    case "secret":
      return "Secret Change";
    case "rollback":
      return "Rollback";
    case "promotion":
      return "Promotion";
    default:
      return `Unknown (${trigger})`;
  }
}
__name(formatTrigger, "formatTrigger");

// src/versions/upload.ts
init_import_meta_url();
var import_node_fs33 = require("node:fs");
var import_node_path50 = __toESM(require("node:path"));
var import_node_url14 = require("node:url");

// src/durable.ts
init_import_meta_url();
var import_node_assert16 = __toESM(require("node:assert"));
async function getMigrationsToUpload(scriptName, props) {
  const { config, accountId } = props;
  (0, import_node_assert16.default)(accountId, "Missing accountId");
  let migrations;
  if (config.migrations.length > 0) {
    let script;
    if (!props.legacyEnv) {
      try {
        if (props.env) {
          const scriptData = await fetchResult(
            `/accounts/${accountId}/workers/services/${scriptName}/environments/${props.env}`
          );
          script = scriptData.script;
        } else {
          const scriptData = await fetchResult(`/accounts/${accountId}/workers/services/${scriptName}`);
          script = scriptData.default_environment.script;
        }
      } catch (err) {
        if (![
          10090,
          // corresponds to workers.api.error.service_not_found, so the script wasn't previously published at all
          10092
          // workers.api.error.environment_not_found, so the script wasn't published to this environment yet
        ].includes(err.code)) {
          throw err;
        }
      }
    } else {
      const scripts = await fetchResult(
        `/accounts/${accountId}/workers/scripts`
      );
      script = scripts.find(({ id }) => id === scriptName);
    }
    if (script?.migration_tag) {
      const scriptMigrationTag = script.migration_tag;
      const foundIndex = config.migrations.findIndex(
        (migration) => migration.tag === scriptMigrationTag
      );
      if (foundIndex === -1) {
        logger.warn(
          `The published script ${scriptName} has a migration tag "${script.migration_tag}, which was not found in wrangler.toml. You may have already deleted it. Applying all available migrations to the script...`
        );
        migrations = {
          old_tag: script.migration_tag,
          new_tag: config.migrations[config.migrations.length - 1].tag,
          steps: config.migrations.map(({ tag: _tag, ...rest }) => rest)
        };
      } else {
        if (foundIndex !== config.migrations.length - 1) {
          migrations = {
            old_tag: script.migration_tag,
            new_tag: config.migrations[config.migrations.length - 1].tag,
            steps: config.migrations.slice(foundIndex + 1).map(({ tag: _tag, ...rest }) => rest)
          };
        }
      }
    } else {
      migrations = {
        new_tag: config.migrations[config.migrations.length - 1].tag,
        steps: config.migrations.map(({ tag: _tag, ...rest }) => rest)
      };
    }
  }
  return migrations;
}
__name(getMigrationsToUpload, "getMigrationsToUpload");

// src/versions/upload.ts
var scriptStartupErrorRegex = /startup/i;
function errIsScriptSize(err) {
  if (!err)
    return false;
  if (err.code === 10027) {
    return true;
  }
  return false;
}
__name(errIsScriptSize, "errIsScriptSize");
function errIsStartupErr(err) {
  if (!err)
    return false;
  if (err.code === 10021 && err instanceof ParseError && scriptStartupErrorRegex.test(err.notes[0]?.text)) {
    return true;
  }
  return false;
}
__name(errIsStartupErr, "errIsStartupErr");
async function versionsUpload(props) {
  const { config, accountId, name } = props;
  if (accountId && name) {
    try {
      const serviceMetaData = await fetchResult(
        `/accounts/${accountId}/workers/services/${name}`
        // TODO(consider): should this be a /versions endpoint?
      );
      const { default_environment } = serviceMetaData;
      if (default_environment.script.last_deployed_from === "dash") {
        logger.warn(
          `You are about to upload a Worker Version that was last published via the Cloudflare Dashboard.
Edits that have been made via the dashboard will be overridden by your local code and config.`
        );
        if (!await confirm("Would you like to continue?")) {
          return;
        }
      } else if (default_environment.script.last_deployed_from === "api") {
        logger.warn(
          `You are about to upload a Workers Version that was last updated via the API.
Edits that have been made via the API will be overridden by your local code and config.`
        );
        if (!await confirm("Would you like to continue?")) {
          return;
        }
      }
    } catch (e3) {
      if (e3.code !== 10090) {
        throw e3;
      }
    }
  }
  if (!(props.compatibilityDate || config.compatibility_date)) {
    const compatibilityDateStr = `${(/* @__PURE__ */ new Date()).getFullYear()}-${((/* @__PURE__ */ new Date()).getMonth() + 1 + "").padStart(2, "0")}-${((/* @__PURE__ */ new Date()).getDate() + "").padStart(2, "0")}`;
    throw new UserError(`A compatibility_date is required when uploading a Worker Version. Add the following to your wrangler.toml file:.
    \`\`\`
    compatibility_date = "${compatibilityDateStr}"
    \`\`\`
    Or you could pass it in your terminal as \`--compatibility-date ${compatibilityDateStr}\`
See https://developers.cloudflare.com/workers/platform/compatibility-dates for more information.`);
  }
  const jsxFactory = props.jsxFactory || config.jsx_factory;
  const jsxFragment = props.jsxFragment || config.jsx_fragment;
  const minify = props.minify ?? config.minify;
  const legacyNodeCompat = props.nodeCompat ?? config.node_compat;
  if (legacyNodeCompat) {
    logger.warn(
      "Enabling Node.js compatibility mode for built-ins and globals. This is experimental and has serious tradeoffs. Please see https://github.com/ionic-team/rollup-plugin-node-polyfills/ for more details."
    );
  }
  const compatibilityFlags = props.compatibilityFlags ?? config.compatibility_flags;
  const nodejsCompat = compatibilityFlags.includes("nodejs_compat");
  if (legacyNodeCompat && nodejsCompat) {
    throw new UserError(
      "The `nodejs_compat` compatibility flag cannot be used in conjunction with the legacy `--node-compat` flag. If you want to use the Workers runtime Node.js compatibility features, please remove the `--node-compat` argument from your CLI command or `node_compat = true` from your config file."
    );
  }
  if (props.noBundle && minify) {
    logger.warn(
      "`--minify` and `--no-bundle` can't be used together. If you want to minify your Worker and disable Wrangler's bundling, please minify as part of your own bundling process."
    );
  }
  if (props.noBundle && legacyNodeCompat) {
    logger.warn(
      "`--node-compat` and `--no-bundle` can't be used together. If you want to polyfill Node.js built-ins and disable Wrangler's bundling, please polyfill as part of your own bundling process."
    );
  }
  const scriptName = props.name;
  if (!scriptName) {
    throw new UserError(
      'You need to provide a name when uploading a Worker Version. Either pass it as a cli arg with `--name <name>` or in your config file as `name = "<name>"`'
    );
  }
  if (config.site && !config.site.bucket) {
    throw new UserError(
      "A [site] definition requires a `bucket` field with a path to the site's assets directory."
    );
  }
  if (props.outDir) {
    (0, import_node_fs33.mkdirSync)(props.outDir, { recursive: true });
    const readmePath = import_node_path50.default.join(props.outDir, "README.md");
    (0, import_node_fs33.writeFileSync)(
      readmePath,
      `This folder contains the built output assets for the worker "${scriptName}" generated at ${(/* @__PURE__ */ new Date()).toISOString()}.`
    );
  }
  const destination = props.outDir ?? getWranglerTmpDir(props.projectRoot, "deploy");
  const start = Date.now();
  const workerName = scriptName;
  const workerUrl = `/accounts/${accountId}/workers/scripts/${scriptName}/versions`;
  const { format: format10 } = props.entry;
  if (config.wasm_modules && format10 === "modules") {
    throw new UserError(
      "You cannot configure [wasm_modules] with an ES module worker. Instead, import the .wasm module directly in your code"
    );
  }
  if (config.text_blobs && format10 === "modules") {
    throw new UserError(
      "You cannot configure [text_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure `[rules]` in your wrangler.toml"
    );
  }
  if (config.data_blobs && format10 === "modules") {
    throw new UserError(
      "You cannot configure [data_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure `[rules]` in your wrangler.toml"
    );
  }
  try {
    if (props.noBundle) {
      const destinationDir = typeof destination === "string" ? destination : destination.path;
      (0, import_node_fs33.mkdirSync)(destinationDir, { recursive: true });
      (0, import_node_fs33.writeFileSync)(
        import_node_path50.default.join(destinationDir, import_node_path50.default.basename(props.entry.file)),
        (0, import_node_fs33.readFileSync)(props.entry.file, "utf-8")
      );
    }
    const entryDirectory = import_node_path50.default.dirname(props.entry.file);
    const moduleCollector = createModuleCollector({
      wrangler1xLegacyModuleReferences: getWrangler1xLegacyModuleReferences(
        entryDirectory,
        props.entry.file
      ),
      entry: props.entry,
      // `moduleCollector` doesn't get used when `props.noBundle` is set, so
      // `findAdditionalModules` always defaults to `false`
      findAdditionalModules: config.find_additional_modules ?? false,
      rules: props.rules
    });
    const uploadSourceMaps = props.uploadSourceMaps ?? config.upload_source_maps;
    const {
      modules,
      dependencies,
      resolvedEntryPointPath,
      bundleType,
      ...bundle
    } = props.noBundle ? await noBundleWorker(props.entry, props.rules, props.outDir) : await bundleWorker(
      props.entry,
      typeof destination === "string" ? destination : destination.path,
      {
        bundle: true,
        additionalModules: [],
        moduleCollector,
        serveAssetsFromWorker: false,
        doBindings: config.durable_objects.bindings,
        jsxFactory,
        jsxFragment,
        tsconfig: props.tsconfig ?? config.tsconfig,
        minify,
        sourcemap: uploadSourceMaps,
        legacyNodeCompat,
        nodejsCompat,
        define: { ...config.define, ...props.defines },
        checkFetch: false,
        assets: config.assets,
        // enable the cache when publishing
        bypassAssetCache: false,
        // We want to know if the build is for development or publishing
        // This could potentially cause issues as we no longer have identical behaviour between dev and deploy?
        targetConsumer: "deploy",
        local: false,
        projectRoot: props.projectRoot,
        defineNavigatorUserAgent: isNavigatorDefined(
          props.compatibilityDate ?? config.compatibility_date,
          props.compatibilityFlags ?? config.compatibility_flags
        )
      }
    );
    for (const module3 of modules) {
      const modulePath = module3.filePath === void 0 ? module3.name : import_node_path50.default.relative("", module3.filePath);
      const bytesInOutput = typeof module3.content === "string" ? Buffer.byteLength(module3.content) : module3.content.byteLength;
      dependencies[modulePath] = { bytesInOutput };
    }
    const content = (0, import_node_fs33.readFileSync)(resolvedEntryPointPath, {
      encoding: "utf-8"
    });
    const migrations = !props.dryRun ? await getMigrationsToUpload(scriptName, {
      accountId,
      config,
      legacyEnv: props.legacyEnv,
      env: props.env
    }) : void 0;
    const bindings = {
      kv_namespaces: config.kv_namespaces || [],
      send_email: config.send_email,
      vars: { ...config.vars, ...props.vars },
      wasm_modules: config.wasm_modules,
      browser: config.browser,
      ai: config.ai,
      version_metadata: config.version_metadata,
      text_blobs: config.text_blobs,
      data_blobs: config.data_blobs,
      durable_objects: config.durable_objects,
      queues: config.queues.producers?.map((producer) => {
        return { binding: producer.binding, queue_name: producer.queue };
      }),
      r2_buckets: config.r2_buckets,
      d1_databases: config.d1_databases,
      vectorize: config.vectorize,
      constellation: config.constellation,
      hyperdrive: config.hyperdrive,
      services: config.services,
      analytics_engine_datasets: config.analytics_engine_datasets,
      dispatch_namespaces: config.dispatch_namespaces,
      mtls_certificates: config.mtls_certificates,
      logfwdr: config.logfwdr,
      unsafe: {
        bindings: config.unsafe.bindings,
        metadata: config.unsafe.metadata,
        capnp: config.unsafe.capnp
      }
    };
    const placement = config.placement?.mode === "smart" ? { mode: "smart" } : void 0;
    const entryPointName = import_node_path50.default.basename(resolvedEntryPointPath);
    const main2 = {
      name: entryPointName,
      filePath: resolvedEntryPointPath,
      content,
      type: bundleType
    };
    const worker = {
      name: scriptName,
      main: main2,
      bindings,
      migrations,
      modules,
      sourceMaps: uploadSourceMaps ? loadSourceMaps(main2, modules, bundle) : void 0,
      compatibility_date: props.compatibilityDate ?? config.compatibility_date,
      compatibility_flags: compatibilityFlags,
      usage_model: config.usage_model,
      keepVars: false,
      // the wrangler.toml should be the source-of-truth for vars
      keepSecrets: true,
      // until wrangler.toml specifies secret bindings, we need to inherit from the previous Worker Version
      logpush: void 0,
      placement,
      tail_consumers: config.tail_consumers,
      limits: config.limits,
      annotations: {
        "workers/message": props.message,
        "workers/tag": props.tag
      }
    };
    const bundleSizePromise = printBundleSize(
      { name: import_node_path50.default.basename(resolvedEntryPointPath), content },
      modules
    );
    if (process.env.JEST_WORKER_ID !== void 0)
      await bundleSizePromise;
    else
      ;
    const withoutStaticAssets = {
      ...bindings,
      kv_namespaces: config.kv_namespaces,
      text_blobs: config.text_blobs
    };
    const maskedVars = { ...withoutStaticAssets.vars };
    for (const key of Object.keys(maskedVars)) {
      if (maskedVars[key] !== config.vars[key]) {
        maskedVars[key] = "(hidden)";
      }
    }
    printBindings({ ...withoutStaticAssets, vars: maskedVars });
    if (!props.dryRun) {
      await ensureQueuesExistByConfig(config);
      try {
        const body = createWorkerUploadForm(worker);
        const result = await fetchResult(
          workerUrl,
          {
            method: "POST",
            body,
            headers: await getMetricsUsageHeaders(config.send_metrics)
          },
          new import_node_url14.URLSearchParams({
            include_subdomain_availability: "true",
            // pass excludeScript so the whole body of the
            // script doesn't get included in the response
            excludeScript: "true"
          })
        );
        logger.log("Worker Version ID:", result.id);
      } catch (err) {
        helpIfErrorIsSizeOrScriptStartup(err, dependencies);
        if (err instanceof ParseError && "code" in err && err.code === 10021 && err.notes.length > 0) {
          const maybeNameToFilePath = /* @__PURE__ */ __name((moduleName) => {
            if (bundleType === "commonjs")
              return resolvedEntryPointPath;
            if (moduleName === entryPointName)
              return resolvedEntryPointPath;
            for (const module3 of modules) {
              if (moduleName === module3.name)
                return module3.filePath;
            }
          }, "maybeNameToFilePath");
          const retrieveSourceMap = /* @__PURE__ */ __name((moduleName) => maybeRetrieveFileSourceMap(maybeNameToFilePath(moduleName)), "retrieveSourceMap");
          err.notes[0].text = getSourceMappedString(
            err.notes[0].text,
            retrieveSourceMap
          );
        }
        throw err;
      }
    }
  } finally {
    if (typeof destination !== "string") {
      destination.remove();
    }
  }
  if (props.dryRun) {
    logger.log(`--dry-run: exiting now.`);
    return;
  }
  if (!accountId)
    throw new UserError("Missing accountId");
  const uploadMs = Date.now() - start;
  logger.log("Uploaded", workerName, formatTime3(uploadMs));
  const cmdVersionsDeploy = blue(
    "wrangler versions deploy --experimental-versions"
  );
  const cmdTriggersDeploy = blue(
    "wrangler triggers deploy --experimental-versions"
  );
  logger.info(
    gray(`
To deploy this version to production traffic use the command ${cmdVersionsDeploy}

Changes to non-versioned settings (config properties 'logpush' or 'tail_consumers') take effect after your next deployment using the command ${cmdVersionsDeploy}

Changes to triggers (routes, custom domains, cron schedules, etc) must be applied with the command ${cmdTriggersDeploy}
`)
  );
}
__name(versionsUpload, "versionsUpload");
function helpIfErrorIsSizeOrScriptStartup(err, dependencies) {
  if (errIsScriptSize(err)) {
    printOffendingDependencies(dependencies);
  } else if (errIsStartupErr(err)) {
    const youFailed = "Your Worker failed validation because it exceeded startup limits.";
    const heresWhy = "To ensure fast responses, we place constraints on Worker startup -- like how much CPU it can use, or how long it can take.";
    const heresTheProblem = "Your Worker failed validation, which means it hit one of these startup limits.";
    const heresTheSolution = "Try reducing the amount of work done during startup (outside the event handler), either by removing code or relocating it inside the event handler.";
    logger.warn(
      [youFailed, heresWhy, heresTheProblem, heresTheSolution].join("\n")
    );
  }
}
__name(helpIfErrorIsSizeOrScriptStartup, "helpIfErrorIsSizeOrScriptStartup");
function formatTime3(duration) {
  return `(${(duration / 1e3).toFixed(2)} sec)`;
}
__name(formatTime3, "formatTime");
async function noBundleWorker(entry, rules, outDir) {
  const modules = await findAdditionalModules(entry, rules);
  if (outDir) {
    await writeAdditionalModules(modules, outDir);
  }
  return {
    modules,
    dependencies: {},
    resolvedEntryPointPath: entry.file,
    bundleType: getBundleType(entry.format)
  };
}
__name(noBundleWorker, "noBundleWorker");

// src/versions/view.ts
init_import_meta_url();
var BLANK_INPUT3 = "-";
function versionsViewOptions(yargs) {
  return yargs.positional("version-id", {
    describe: "The Worker Version ID to view",
    type: "string",
    requiresArg: true,
    demandOption: true
  }).option("name", {
    describe: "Name of the worker",
    type: "string",
    requiresArg: true
  }).option("json", {
    describe: "Display output as clean JSON",
    type: "boolean",
    default: false
  });
}
__name(versionsViewOptions, "versionsViewOptions");
async function versionsViewHandler(args) {
  if (!args.json) {
    await printWranglerBanner();
  }
  const config = getConfig3(args);
  await sendMetricsEvent(
    "view worker version",
    {},
    {
      sendMetrics: config.send_metrics
    }
  );
  const accountId = await requireAuth(config);
  const workerName = args.name ?? config.name;
  if (workerName === void 0) {
    throw new UserError(
      'You need to provide a name of your worker. Either pass it as a cli arg with `--name <name>` or in your config file as `name = "<name>"`'
    );
  }
  const version3 = await fetchVersion(accountId, workerName, args.versionId);
  if (args.json) {
    logRaw(JSON.stringify(version3, null, 2));
    return;
  }
  const formattedVersion = formatLabelledValues({
    "Version ID": version3.id,
    Created: new Date(version3.metadata["created_on"]).toISOString(),
    Author: version3.metadata.author_email,
    Source: getVersionSource(version3),
    Tag: version3.annotations?.["workers/tag"] || BLANK_INPUT3,
    Message: version3.annotations?.["workers/message"] || BLANK_INPUT3
  });
  logRaw(formattedVersion);
}
__name(versionsViewHandler, "versionsViewHandler");

// src/versions/index.ts
async function standardPricingWarning2(config) {
  if (config.usage_model !== void 0) {
    logger.warn(
      "The `usage_model` defined in wrangler.toml is deprecated and no longer used. Visit our developer docs for details: https://developers.cloudflare.com/workers/wrangler/configuration/#usage-model"
    );
  }
}
__name(standardPricingWarning2, "standardPricingWarning");
function versionsUploadOptions(yargs) {
  return yargs.positional("script", {
    describe: "The path to an entry point for your worker",
    type: "string",
    requiresArg: true
  }).option("name", {
    describe: "Name of the worker",
    type: "string",
    requiresArg: true
  }).option("bundle", {
    describe: "Run wrangler's compilation step before publishing",
    type: "boolean",
    hidden: true
  }).option("no-bundle", {
    describe: "Skip internal build steps and directly deploy Worker",
    type: "boolean",
    default: false
  }).option("outdir", {
    describe: "Output directory for the bundled worker",
    type: "string",
    requiresArg: true
  }).option("format", {
    choices: ["modules", "service-worker"],
    describe: "Choose an entry type",
    deprecated: true,
    hidden: true
  }).option("compatibility-date", {
    describe: "Date to use for compatibility checks",
    type: "string",
    requiresArg: true
  }).option("compatibility-flags", {
    describe: "Flags to use for compatibility checks",
    alias: "compatibility-flag",
    type: "string",
    requiresArg: true,
    array: true
  }).option("latest", {
    describe: "Use the latest version of the worker runtime",
    type: "boolean",
    default: false
  }).option("site", {
    describe: "Root folder of static assets for Workers Sites",
    type: "string",
    requiresArg: true
  }).option("site-include", {
    describe: "Array of .gitignore-style patterns that match file or directory names from the sites directory. Only matched items will be uploaded.",
    type: "string",
    requiresArg: true,
    array: true
  }).option("site-exclude", {
    describe: "Array of .gitignore-style patterns that match file or directory names from the sites directory. Matched items will not be uploaded.",
    type: "string",
    requiresArg: true,
    array: true
  }).option("var", {
    describe: "A key-value pair to be injected into the script as a variable",
    type: "string",
    requiresArg: true,
    array: true
  }).option("define", {
    describe: "A key-value pair to be substituted in the script",
    type: "string",
    requiresArg: true,
    array: true
  }).option("jsx-factory", {
    describe: "The function that is called for each JSX element",
    type: "string",
    requiresArg: true
  }).option("jsx-fragment", {
    describe: "The function that is called for each JSX fragment",
    type: "string",
    requiresArg: true
  }).option("tsconfig", {
    describe: "Path to a custom tsconfig.json file",
    type: "string",
    requiresArg: true
  }).option("minify", {
    describe: "Minify the Worker",
    type: "boolean"
  }).option("upload-source-maps", {
    describe: "Include source maps when uploading this Worker Gradual Rollouts Version.",
    type: "boolean"
  }).option("node-compat", {
    describe: "Enable Node.js compatibility",
    type: "boolean"
  }).option("dry-run", {
    describe: "Don't actually deploy",
    type: "boolean"
  }).option("tag", {
    describe: "A tag for this Worker Gradual Rollouts Version",
    type: "string",
    requiresArg: true
  }).option("message", {
    describe: "A descriptive message for this Worker Gradual Rollouts Version",
    type: "string",
    requiresArg: true
  });
}
__name(versionsUploadOptions, "versionsUploadOptions");
async function versionsUploadHandler(args) {
  await printWranglerBanner();
  const configPath = args.config || args.script && findWranglerToml(import_node_path51.default.dirname(args.script));
  const projectRoot = configPath && import_node_path51.default.dirname(configPath);
  const config = readConfig(configPath, args);
  const entry = await getEntry(args, config, "deploy");
  await sendMetricsEvent(
    "upload worker version",
    {
      usesTypeScript: /\.tsx?$/.test(entry.file)
    },
    {
      sendMetrics: config.send_metrics
    }
  );
  if (args.latest) {
    logger.warn(
      "Using the latest version of the Workers runtime. To silence this warning, please choose a specific version of the runtime with --compatibility-date, or add a compatibility_date to your wrangler.toml.\n"
    );
  }
  const cliVars = collectKeyValues(args.var);
  const cliDefines = collectKeyValues(args.define);
  const accountId = args.dryRun ? void 0 : await requireAuth(config);
  await standardPricingWarning2(config);
  await versionsUpload({
    config,
    accountId,
    name: getScriptName(args, config),
    rules: getRules(config),
    entry,
    legacyEnv: isLegacyEnv(config),
    env: args.env,
    compatibilityDate: args.latest ? (/* @__PURE__ */ new Date()).toISOString().substring(0, 10) : args.compatibilityDate,
    compatibilityFlags: args.compatibilityFlags,
    vars: cliVars,
    defines: cliDefines,
    jsxFactory: args.jsxFactory,
    jsxFragment: args.jsxFragment,
    tsconfig: args.tsconfig,
    minify: args.minify,
    uploadSourceMaps: args.uploadSourceMaps,
    nodeCompat: args.nodeCompat,
    isWorkersSite: Boolean(args.site || config.site),
    outDir: args.outdir,
    dryRun: args.dryRun,
    noBundle: !(args.bundle ?? !config.no_bundle),
    keepVars: false,
    projectRoot,
    tag: args.tag,
    message: args.message
  });
}
__name(versionsUploadHandler, "versionsUploadHandler");
function registerVersionsSubcommands(versionYargs) {
  versionYargs.command(
    "view <version-id>",
    "View the details of a specific version of your Worker [beta]",
    versionsViewOptions,
    versionsViewHandler
  ).command(
    "list",
    "List the 10 most recent Versions of your Worker [beta]",
    versionsListOptions,
    versionsListHandler
  ).command(
    "upload",
    "Uploads your Worker code and config as a new Version [beta]",
    versionsUploadOptions,
    versionsUploadHandler
  ).command(
    "deploy [version-specs..]",
    "Safely roll out new Versions of your Worker by splitting traffic between multiple Versions [beta]",
    versionsDeployOptions,
    versionsDeployHandler
  );
}
__name(registerVersionsSubcommands, "registerVersionsSubcommands");

// src/versions/deployments/index.ts
init_import_meta_url();

// src/versions/deployments/list.ts
init_import_meta_url();
var import_assert4 = __toESM(require("assert"));
var BLANK_INPUT4 = "-";
function versionsDeploymentsListOptions(yargs) {
  return yargs.option("name", {
    describe: "Name of the worker",
    type: "string",
    requiresArg: true
  }).option("json", {
    describe: "Display output as clean JSON",
    type: "boolean",
    default: false
  });
}
__name(versionsDeploymentsListOptions, "versionsDeploymentsListOptions");
async function versionsDeploymentsListHandler(args) {
  if (!args.json) {
    await printWranglerBanner();
  }
  const config = getConfig3(args);
  await sendMetricsEvent(
    "list versioned deployments",
    { json: args.json },
    {
      sendMetrics: config.send_metrics
    }
  );
  const accountId = await requireAuth(config);
  const workerName = args.name ?? config.name;
  if (workerName === void 0) {
    throw new UserError(
      'You need to provide a name of your worker. Either pass it as a cli arg with `--name <name>` or in your config file as `name = "<name>"`'
    );
  }
  const deployments2 = await fetchLatestDeployments(accountId, workerName);
  if (args.json) {
    logRaw(JSON.stringify(deployments2, null, 2));
    return;
  }
  const versionCache = /* @__PURE__ */ new Map();
  const versionIds = deployments2.flatMap(
    (d2) => d2.versions.map((v2) => v2.version_id)
  );
  await fetchVersions(accountId, workerName, versionCache, ...versionIds);
  const formattedDeployments = deployments2.map((deployment) => {
    const formattedVersions = deployment.versions.map((traffic) => {
      const version3 = versionCache.get(traffic.version_id);
      (0, import_assert4.default)(version3);
      const percentage = brandColor(`(${traffic.percentage}%)`);
      const details = formatLabelledValues(
        {
          Created: new Date(version3.metadata["created_on"]).toISOString(),
          Tag: version3.annotations?.["workers/tag"] || BLANK_INPUT4,
          Message: version3.annotations?.["workers/message"] || BLANK_INPUT4
        },
        {
          indentationCount: 4,
          labelJustification: "right",
          formatLabel: (label) => gray(label + ":"),
          formatValue: (value) => gray(value)
        }
      );
      return `${percentage} ${version3.id}
${details}`;
    });
    return formatLabelledValues({
      // explicitly not outputting Deployment ID
      Created: new Date(deployment.created_on).toISOString(),
      Author: deployment.author_email,
      Source: getDeploymentSource(deployment),
      Message: deployment.annotations?.["workers/message"] || BLANK_INPUT4,
      "Version(s)": formattedVersions.join("\n\n")
    });
  });
  logRaw(formattedDeployments.join("\n\n"));
}
__name(versionsDeploymentsListHandler, "versionsDeploymentsListHandler");
function getDeploymentSource(deployment) {
  return getVersionSource({
    metadata: { source: deployment.source },
    annotations: deployment.annotations
  });
}
__name(getDeploymentSource, "getDeploymentSource");

// src/versions/deployments/status.ts
init_import_meta_url();
var import_assert5 = __toESM(require("assert"));
var BLANK_INPUT5 = "-";
function versionsDeploymentsStatusOptions(yargs) {
  return yargs.option("name", {
    describe: "Name of the worker",
    type: "string",
    requiresArg: true
  }).option("json", {
    describe: "Display output as clean JSON",
    type: "boolean",
    default: false
  });
}
__name(versionsDeploymentsStatusOptions, "versionsDeploymentsStatusOptions");
async function versionsDeploymentsStatusHandler(args) {
  if (!args.json) {
    await printWranglerBanner();
  }
  const config = getConfig3(args);
  await sendMetricsEvent(
    "view latest versioned deployment",
    {},
    {
      sendMetrics: config.send_metrics
    }
  );
  const accountId = await requireAuth(config);
  const workerName = args.name ?? config.name;
  if (workerName === void 0) {
    throw new UserError(
      'You need to provide a name of your worker. Either pass it as a cli arg with `--name <name>` or in your config file as `name = "<name>"`'
    );
  }
  const latestDeployment = await fetchLatestDeployment(accountId, workerName);
  if (!latestDeployment) {
    throw new UserError(`The worker ${workerName} has no deployments.`);
  }
  if (args.json) {
    logRaw(JSON.stringify(latestDeployment, null, 2));
    return;
  }
  const versionCache = /* @__PURE__ */ new Map();
  const versionIds = latestDeployment.versions.map((v2) => v2.version_id);
  await fetchVersions(accountId, workerName, versionCache, ...versionIds);
  const formattedVersions = latestDeployment.versions.map((traffic) => {
    const version3 = versionCache.get(traffic.version_id);
    (0, import_assert5.default)(version3);
    const percentage = brandColor(`(${traffic.percentage}%)`);
    const details = formatLabelledValues(
      {
        Created: new Date(version3.metadata["created_on"]).toISOString(),
        Tag: version3.annotations?.["workers/tag"] || BLANK_INPUT5,
        Message: version3.annotations?.["workers/message"] || BLANK_INPUT5
      },
      {
        indentationCount: 4,
        labelJustification: "right",
        formatLabel: (label) => gray(label + ":"),
        formatValue: (value) => gray(value)
      }
    );
    return `${percentage} ${version3.id}
${details}`;
  });
  const formattedDeployment = formatLabelledValues({
    // explicitly not outputting Deployment ID
    Created: new Date(latestDeployment.created_on).toISOString(),
    Author: latestDeployment.author_email,
    Source: getDeploymentSource(latestDeployment),
    Message: latestDeployment.annotations?.["workers/message"] || BLANK_INPUT5,
    "Version(s)": formattedVersions.join("\n\n")
  });
  logRaw(formattedDeployment);
}
__name(versionsDeploymentsStatusHandler, "versionsDeploymentsStatusHandler");

// src/versions/deployments/view.ts
init_import_meta_url();
function versionsDeploymentsViewOptions(yargs) {
  return yargs.option("name", {
    describe: "Name of the worker",
    type: "string",
    requiresArg: true
  }).positional("deployment-id", {
    describe: "Deprecated. Deployment ID is now referred to as Version ID. Please use `wrangler versions view [version-id]` instead.",
    type: "string",
    requiresArg: true
  });
}
__name(versionsDeploymentsViewOptions, "versionsDeploymentsViewOptions");
async function versionsDeploymentsViewHandler(args) {
  await printWranglerBanner();
  if (args.deploymentId === void 0) {
    throw new UserError(
      "`wrangler deployments view` has been renamed `wrangler deployments status --x-versions`. Please use that command instead."
    );
  } else {
    throw new UserError(
      "`wrangler deployments view <deployment-id>` has been renamed `wrangler versions view [version-id] --x-versions`. Please use that command instead."
    );
  }
}
__name(versionsDeploymentsViewHandler, "versionsDeploymentsViewHandler");

// src/versions/deployments/index.ts
function registerVersionsDeploymentsSubcommands(versionDeploymentsYargs) {
  versionDeploymentsYargs.command(
    "list",
    "Displays the 10 most recent deployments of your Worker [beta]",
    versionsDeploymentsListOptions,
    versionsDeploymentsListHandler
  ).command(
    "status",
    "See the current state of your production [beta]",
    versionsDeploymentsStatusOptions,
    versionsDeploymentsStatusHandler
  ).command(
    "view [deployment-id]",
    false,
    versionsDeploymentsViewOptions,
    versionsDeploymentsViewHandler
  );
}
__name(registerVersionsDeploymentsSubcommands, "registerVersionsDeploymentsSubcommands");

// src/versions/rollback/index.ts
init_import_meta_url();
function registerVersionsRollbackCommand(yargs, epilogue, subHelp) {
  return yargs.command(
    "rollback [version-id]",
    "\u{1F519} Rollback to a Worker Version",
    versionsRollbackOptions,
    versionsRollbackHandler
  ).command(subHelp).epilogue(epilogue);
}
__name(registerVersionsRollbackCommand, "registerVersionsRollbackCommand");
function versionsRollbackOptions(rollbackYargs) {
  return rollbackYargs.positional("version-id", {
    describe: "The ID of the Worker Version to rollback to",
    type: "string",
    demandOption: false
  }).option("name", {
    describe: "The name of your worker",
    type: "string"
  }).option("message", {
    alias: "m",
    describe: "The reason for this rollback (optional)",
    type: "string",
    default: void 0
  }).option("yes", {
    alias: "y",
    describe: "Automatically accept defaults to prompts",
    type: "boolean",
    default: false
  });
}
__name(versionsRollbackOptions, "versionsRollbackOptions");
async function versionsRollbackHandler(args) {
  const config = getConfig3(args);
  const accountId = await requireAuth(config);
  const workerName = args.name ?? config.name;
  if (workerName === void 0) {
    throw new UserError(
      'You need to provide a name of your worker. Either pass it as a cli arg with `--name <name>` or in your config file as `name = "<name>"`'
    );
  }
  await printLatestDeployment(accountId, workerName, /* @__PURE__ */ new Map());
  const versionId = args.versionId ?? await spinnerWhile({
    promise: fetchDefaultRollbackVersionId(accountId, workerName),
    startMessage: "Finding latest stable Worker Version to rollback to",
    endMessage: ""
  });
  const message = await inputPrompt({
    type: "text",
    label: "Message",
    question: "Please provide a message for this rollback (120 characters max, optional)?",
    defaultValue: args.message ?? "Rollback",
    acceptDefault: args.yes
  });
  const version3 = await fetchVersion(accountId, workerName, versionId);
  warn(
    `You are about to rollback to Worker Version ${versionId}.
This will immediately replace the current deployment and become the active deployment across all your deployed triggers.
However, your local development environment will not be affected by this rollback.
Rolling back to a previous deployment will not rollback any of the bound resources (Durable Object, D1, R2, KV, etc).`,
    { multiline: true, shape: shapes.leftT }
  );
  const rollbackTraffic = /* @__PURE__ */ new Map([[versionId, 100]]);
  printVersions([version3], rollbackTraffic);
  const confirm2 = await inputPrompt({
    type: "confirm",
    label: "Rollback",
    question: "Are you sure you want to deploy this Worker Version to 100% of traffic?",
    defaultValue: args.yes,
    // defaultValue: false.    if --yes, defaultValue: true
    acceptDefault: args.yes
  });
  if (!confirm2) {
    cancel("Aborting rollback...");
    return;
  }
  await spinnerWhile({
    async promise() {
      await createDeployment(accountId, workerName, rollbackTraffic, message);
    },
    startMessage: `Performing rollback`,
    endMessage: ""
  });
  success(
    `Worker Version ${versionId} has been deployed to 100% of traffic.`
  );
}
__name(versionsRollbackHandler, "versionsRollbackHandler");
async function fetchDefaultRollbackVersionId(accountId, workerName) {
  const deployments2 = await fetchLatestDeployments(accountId, workerName);
  deployments2.sort((a, b2) => b2.created_on.localeCompare(a.created_on));
  deployments2.shift();
  for (const deployment of deployments2) {
    const stableVersion = deployment.versions.find(
      ({ percentage }) => percentage === 100
    );
    if (stableVersion)
      return stableVersion.version_id;
  }
  throw new Error(
    "Could not find stable Worker Version to rollback to. Please try again with an explicit Version ID."
  );
}
__name(fetchDefaultRollbackVersionId, "fetchDefaultRollbackVersionId");

// src/whoami.ts
init_import_meta_url();
var import_chalk17 = __toESM(require_chalk());
async function whoami() {
  logger.log("Getting User settings...");
  const user = await getUserInfo();
  if (user === void 0) {
    return void logger.log(
      "You are not authenticated. Please run `wrangler login`."
    );
  }
  if (user.email !== void 0) {
    logger.log(
      `\u{1F44B} You are logged in with an ${user.authType}, associated with the email ${import_chalk17.default.blue(user.email)}!`
    );
  } else {
    logger.log(
      `\u{1F44B} You are logged in with an ${user.authType}. Unable to retrieve email for this user. Are you missing the \`User->User Details->Read\` permission?`
    );
  }
  logger.table(
    user.accounts.map((account) => ({
      "Account Name": account.name,
      "Account ID": account.id
    }))
  );
  const permissions = user.tokenPermissions?.map((scope) => scope.split(":")) ?? [];
  if (user.authType !== "OAuth Token") {
    return void logger.log(
      `\u{1F513} To see token permissions visit https://dash.cloudflare.com/profile/api-tokens`
    );
  }
  logger.log(
    `\u{1F513} Token Permissions: If scopes are missing, you may need to logout and re-login.`
  );
  logger.log(`Scope (Access)`);
  for (const [scope, access3] of permissions) {
    logger.log(`- ${scope} ${access3 ? `(${access3})` : ``}`);
  }
}
__name(whoami, "whoami");
async function getUserInfo() {
  const apiToken = getAPIToken();
  if (!apiToken)
    return;
  const tokenPermissions = await getTokenPermissions();
  const usingEnvAuth = !!getAuthFromEnv();
  const usingGlobalAuthKey = "authKey" in apiToken;
  return {
    apiToken: usingGlobalAuthKey ? apiToken.authKey : apiToken.apiToken,
    authType: usingGlobalAuthKey ? "Global API Key" : usingEnvAuth ? "API Token" : "OAuth Token",
    email: "authEmail" in apiToken ? apiToken.authEmail : await getEmail(),
    accounts: await getAccounts(),
    tokenPermissions
  };
}
__name(getUserInfo, "getUserInfo");
async function getEmail() {
  try {
    const { email } = await fetchResult("/user");
    return email;
  } catch (e3) {
    if (e3.code === 9109) {
      return void 0;
    } else {
      throw e3;
    }
  }
}
__name(getEmail, "getEmail");
async function getAccounts() {
  return await fetchPagedListResult("/accounts");
}
__name(getAccounts, "getAccounts");
async function getTokenPermissions() {
  return getScopes();
}
__name(getTokenPermissions, "getTokenPermissions");

// src/index.ts
var resetColor = "\x1B[0m";
var fgGreenColor = "\x1B[32m";
var DEFAULT_LOCAL_PORT = 8787;
var DEFAULT_INSPECTOR_PORT = 9229;
var proxy = process.env.https_proxy || process.env.HTTPS_PROXY || process.env.http_proxy || process.env.HTTP_PROXY || void 0;
if (proxy) {
  (0, import_undici21.setGlobalDispatcher)(new import_undici21.ProxyAgent(proxy));
  logger.log(
    `Proxy environment variables detected. We'll use your proxy for fetch requests.`
  );
}
function getRules(config) {
  const rules = config.rules ?? config.build?.upload?.rules ?? [];
  if (config.rules && config.build?.upload?.rules) {
    throw new UserError(
      `You cannot configure both [rules] and [build.upload.rules] in your wrangler.toml. Delete the \`build.upload\` section.`
    );
  }
  if (config.build?.upload?.rules) {
    logger.warn(
      `Deprecation: The \`build.upload.rules\` config field is no longer used, the rules should be specified via the \`rules\` config field. Delete the \`build.upload\` field from the configuration file, and add this:

${import_toml5.default.stringify({ rules: config.build.upload.rules })}`
    );
  }
  return rules;
}
__name(getRules, "getRules");
function isLegacyEnv(config) {
  return config.legacy_env;
}
__name(isLegacyEnv, "isLegacyEnv");
function getScriptName(args, config) {
  if (args.name && isLegacyEnv(config) && args.env) {
    throw new CommandLineArgsError(
      `In legacy environment mode you cannot use --name and --env together. If you want to specify a Worker name for a specific environment you can add the following to your wrangler.toml config:
    [env.${args.env}]
    name = "${args.name}"
    `
    );
  }
  return args.name ?? config.name;
}
__name(getScriptName, "getScriptName");
function getLegacyScriptName(args, config) {
  return args.name && args.env && isLegacyEnv(config) ? `${args.name}-${args.env}` : args.name ?? config.name;
}
__name(getLegacyScriptName, "getLegacyScriptName");
function demandOneOfOption(...options29) {
  return function(argv) {
    const count = options29.filter((option) => argv[option]).length;
    const lastOption = options29.pop();
    if (count === 0) {
      throw new CommandLineArgsError(
        `Exactly one of the arguments ${options29.join(
          ", "
        )} and ${lastOption} is required`
      );
    } else if (count > 1) {
      throw new CommandLineArgsError(
        `Arguments ${options29.join(
          ", "
        )} and ${lastOption} are mutually exclusive`
      );
    }
    return true;
  };
}
__name(demandOneOfOption, "demandOneOfOption");
var CommandLineArgsError = class extends UserError {
};
__name(CommandLineArgsError, "CommandLineArgsError");
function createCLIParser(argv) {
  const experimentalGradualRollouts = (
    // original flag -- using internal product name (Gradual Rollouts) -- kept for temp back-compat
    argv.includes("--experimental-gradual-rollouts") || // new flag -- using external product name (Versions)
    argv.includes("--experimental-versions") || // new flag -- shorthand
    argv.includes("--x-versions")
  );
  const wrangler = yargs_default(argv).strict().showHelpOnFail(false).fail((msg, error2) => {
    if (!error2 || error2.name === "YError") {
      error2 = new CommandLineArgsError(msg);
    }
    throw error2;
  }).scriptName("wrangler").wrap(null).version(false).option("v", {
    describe: "Show version number",
    alias: "version",
    type: "boolean"
  }).option("config", {
    alias: "c",
    describe: "Path to .toml configuration file",
    type: "string",
    requiresArg: true
  }).option("env", {
    alias: "e",
    describe: "Environment to use for operations and .env files",
    type: "string",
    requiresArg: true
  }).option("experimental-json-config", {
    alias: "j",
    describe: `Experimental: Support wrangler.json`,
    type: "boolean"
  }).option("experimental-versions", {
    describe: `Experimental: Support Worker Versions`,
    type: "boolean",
    hidden: true,
    alias: ["x-versions", "experimental-gradual-rollouts"]
  }).check((args) => {
    if (Object.keys(LOGGER_LEVELS).includes(args.logLevel)) {
      logger.loggerLevel = args.logLevel;
    }
    const loaded = loadDotEnv(".env", args.env);
    for (const [key, value] of Object.entries(loaded?.parsed ?? {})) {
      if (!(key in process.env))
        process.env[key] = value;
    }
    return true;
  });
  wrangler.group(
    ["experimental-json-config", "config", "env", "help", "version"],
    "Flags:"
  );
  wrangler.help().alias("h", "help");
  const subHelp = {
    command: ["*"],
    handler: async (args) => {
      setImmediate(
        () => wrangler.parse([...args._.map((a) => `${a}`), "--help"])
      );
    }
  };
  wrangler.command(
    ["*"],
    false,
    () => {
    },
    async (args) => {
      if (args._.length > 0) {
        throw new CommandLineArgsError(`Unknown command: ${args._}.`);
      } else {
        if (args.v) {
          if (process.stdout.isTTY) {
            await printWranglerBanner();
          } else {
            logger.log(version);
          }
        } else {
          wrangler.showHelp("log");
        }
      }
    }
  );
  wrangler.command(
    "docs [command..]",
    "\u{1F4DA} Open wrangler's docs in your browser",
    docsOptions,
    docsHandler
  );
  wrangler.command(
    "init [name]",
    "\u{1F4E5} Initialize a basic Worker project, including a wrangler.toml file",
    initOptions,
    initHandler
  );
  wrangler.command(
    "generate [name] [template]",
    "\u2728 Generate a new Worker project from an existing Worker template. See https://github.com/cloudflare/workers-sdk/tree/main/templates",
    generateOptions,
    generateHandler2
  );
  wrangler.command("build", false, buildOptions, buildHandler);
  wrangler.command("config", false, noOpOptions, configHandler);
  wrangler.command(
    "dev [script]",
    "\u{1F442} Start a local server for developing your worker",
    devOptions,
    devHandler
  );
  wrangler.command(
    ["deploy [script]", "publish [script]"],
    "\u{1F199} Deploy your Worker to Cloudflare.",
    deployOptions,
    deployHandler
  );
  wrangler.command(
    "delete [script]",
    "\u{1F5D1}  Delete your Worker from Cloudflare.",
    deleteOptions,
    deleteHandler
  );
  wrangler.command(
    "tail [worker]",
    "\u{1F99A} Starts a log tailing session for a published Worker.",
    tailOptions,
    tailHandler
  );
  wrangler.command(
    "preview [method] [body]",
    false,
    previewOptions,
    previewHandler
  );
  wrangler.command(
    "route",
    false,
    // I think we want to hide this command
    // "➡️  List or delete worker routes",
    (routeYargs) => {
      return route(routeYargs);
    },
    routeHandler
  );
  wrangler.command(
    "subdomain [name]",
    false,
    // "👷 Create or change your workers.dev subdomain.",
    subdomainOptions,
    subdomainHandler
  );
  wrangler.command(
    "secret",
    "\u{1F92B} Generate a secret that can be referenced in a Worker",
    (secretYargs) => {
      return secret2(secretYargs.command(subHelp));
    }
  );
  wrangler.command(
    "secret:bulk [json]",
    "\u{1F5C4}\uFE0F  Bulk upload secrets for a Worker",
    secretBulkOptions,
    secretBulkHandler
  );
  wrangler.command(
    "kv:namespace",
    "\u{1F5C2}\uFE0F  Interact with your Workers KV Namespaces",
    (namespaceYargs) => {
      return kvNamespace(namespaceYargs.command(subHelp));
    }
  );
  wrangler.command(
    "kv:key",
    "\u{1F511} Individually manage Workers KV key-value pairs",
    (keyYargs) => {
      return kvKey(keyYargs.command(subHelp));
    }
  );
  wrangler.command(
    "kv:bulk",
    "\u{1F4AA} Interact with multiple Workers KV key-value pairs at once",
    (bulkYargs) => {
      return kvBulk(bulkYargs.command(subHelp));
    }
  );
  wrangler.command("pages", "\u26A1\uFE0F Configure Cloudflare Pages", (pagesYargs) => {
    return pages(pagesYargs, subHelp);
  });
  wrangler.command("queues", "\u{1F1F6} Configure Workers Queues", (queuesYargs) => {
    return queues(queuesYargs.command(subHelp));
  });
  wrangler.command("r2", "\u{1F4E6} Interact with an R2 store", (r2Yargs) => {
    return r22(r2Yargs.command(subHelp));
  });
  wrangler.command(
    "dispatch-namespace",
    "\u{1F4E6} Interact with a dispatch namespace",
    (workerNamespaceYargs) => {
      return workerNamespaceCommands(workerNamespaceYargs, subHelp);
    }
  );
  wrangler.command("d1", "\u{1F5C4}  Interact with a D1 database", (d1Yargs) => {
    return d1(d1Yargs.command(subHelp));
  });
  wrangler.command(
    "hyperdrive",
    "\u{1F680} Configure Hyperdrive databases",
    (hyperdriveYargs) => {
      return hyperdrive(hyperdriveYargs.command(subHelp));
    }
  );
  wrangler.command("ai", "\u{1F916} Interact with AI models", (aiYargs) => {
    return ai(aiYargs.command(subHelp));
  });
  wrangler.command("cloudchamber", false, (cloudchamberArgs) => {
    return cloudchamber(asJson(cloudchamberArgs.command(subHelp)), subHelp);
  });
  wrangler.command("constellation", false, (aiYargs) => {
    return constellation(aiYargs.command(subHelp));
  });
  wrangler.command(
    "vectorize",
    "\u{1F9EE} Interact with Vectorize indexes",
    (vectorYargs) => {
      return vectorize(vectorYargs.command(subHelp));
    }
  );
  wrangler.command(
    "pubsub",
    "\u{1F4EE} Interact and manage Pub/Sub Brokers",
    (pubsubYargs) => {
      return pubSubCommands(pubsubYargs, subHelp);
    }
  );
  wrangler.command(
    "mtls-certificate",
    "\u{1FAAA} Manage certificates used for mTLS connections",
    (mtlsYargs) => {
      return mTlsCertificateCommands(mtlsYargs.command(subHelp));
    }
  );
  wrangler.command(
    // this needs scopes as an option?
    "login",
    "\u{1F513} Login to Cloudflare",
    (yargs) => {
      return yargs.option("scopes-list", {
        describe: "List all the available OAuth scopes with descriptions"
      }).option("browser", {
        default: true,
        type: "boolean",
        describe: "Automatically open the OAuth link in a browser"
      }).option("scopes", {
        describe: "Pick the set of applicable OAuth scopes when logging in",
        array: true,
        type: "string",
        requiresArg: true
      });
    },
    async (args) => {
      await printWranglerBanner();
      if (args["scopes-list"]) {
        listScopes();
        return;
      }
      if (args.scopes) {
        if (args.scopes.length === 0) {
          listScopes();
          return;
        }
        if (!validateScopeKeys(args.scopes)) {
          throw new CommandLineArgsError(
            `One of ${args.scopes} is not a valid authentication scope. Run "wrangler login --scopes-list" to see the valid scopes.`
          );
        }
        await login({ scopes: args.scopes, browser: args.browser });
        return;
      }
      await login({ browser: args.browser });
      const config = readConfig(args.config, args);
      await sendMetricsEvent("login user", {
        sendMetrics: config.send_metrics
      });
    }
  );
  wrangler.command(
    // this needs scopes as an option?
    "logout",
    "\u{1F6AA} Logout from Cloudflare",
    () => {
    },
    async (args) => {
      await printWranglerBanner();
      await logout();
      const config = readConfig(void 0, args);
      await sendMetricsEvent("logout user", {
        sendMetrics: config.send_metrics
      });
    }
  );
  wrangler.command(
    "whoami",
    "\u{1F575}\uFE0F  Retrieve your user info and test your auth config",
    () => {
    },
    async (args) => {
      await printWranglerBanner();
      await whoami();
      const config = readConfig(void 0, args);
      await sendMetricsEvent("view accounts", {
        sendMetrics: config.send_metrics
      });
    }
  );
  wrangler.command(
    "types [path]",
    "\u{1F4DD} Generate types from bindings & module rules in config",
    typesOptions,
    typesHandler
  );
  const deploymentsWarning = "\u{1F6A7}`wrangler deployments` is a beta command. Please report any issues to https://github.com/cloudflare/workers-sdk/issues/new/choose";
  if (experimentalGradualRollouts) {
    wrangler.command(
      "deployments",
      "List and view the current and past deployments for your Worker",
      registerVersionsDeploymentsSubcommands
    ).command(subHelp).epilogue(deploymentsWarning);
  } else {
    wrangler.command(
      "deployments",
      "\u{1F6A2} List and view details for deployments",
      (yargs) => yargs.option("name", {
        describe: "The name of your worker",
        type: "string"
      }).command(
        "list",
        "\u{1F6A2} Displays the 10 most recent deployments for a worker",
        async (listYargs) => listYargs,
        async (listYargs) => {
          const { accountId, scriptName, config } = await commonDeploymentCMDSetup(listYargs, deploymentsWarning);
          await deployments(accountId, scriptName, config);
        }
      ).command(
        "view [deployment-id]",
        "\u{1F50D} View a deployment",
        async (viewYargs) => viewYargs.positional("deployment-id", {
          describe: "The ID of the deployment you want to inspect",
          type: "string",
          demandOption: false
        }),
        async (viewYargs) => {
          const { accountId, scriptName, config } = await commonDeploymentCMDSetup(viewYargs, deploymentsWarning);
          await viewDeployment(
            accountId,
            scriptName,
            config,
            viewYargs.deploymentId
          );
        }
      ).command(subHelp).epilogue(deploymentsWarning)
    );
  }
  const rollbackWarning = "\u{1F6A7}`wrangler rollback` is a beta command. Please report any issues to https://github.com/cloudflare/workers-sdk/issues/new/choose";
  if (experimentalGradualRollouts) {
    registerVersionsRollbackCommand(wrangler, rollbackWarning, subHelp);
  } else {
    wrangler.command(
      "rollback [deployment-id]",
      "\u{1F519} Rollback a deployment",
      (rollbackYargs) => rollbackYargs.positional("deployment-id", {
        describe: "The ID of the deployment to rollback to",
        type: "string",
        demandOption: false
      }).option("message", {
        alias: "m",
        describe: "Skip confirmation and message prompts, uses provided argument as message",
        type: "string",
        default: void 0
      }).option("name", {
        describe: "The name of your worker",
        type: "string"
      }).epilogue(rollbackWarning),
      async (rollbackYargs) => {
        const { accountId, scriptName, config } = await commonDeploymentCMDSetup(rollbackYargs, rollbackWarning);
        await rollbackDeployment(
          accountId,
          scriptName,
          config,
          rollbackYargs.deploymentId,
          rollbackYargs.message
        );
      }
    );
  }
  wrangler.version(false);
  wrangler.command(
    "version",
    false,
    () => {
    },
    async () => {
      if (process.stdout.isTTY) {
        await printWranglerBanner();
      } else {
        logger.log(version);
      }
      logger.warn(
        "`wrangler version` is deprecated and will be removed in a future major version. Please use `wrangler --version` instead."
      );
    }
  );
  if (experimentalGradualRollouts) {
    wrangler.command(
      "versions",
      "List, view, upload and deploy Versions of your Worker to Cloudflare [beta]",
      (yargs) => {
        return registerVersionsSubcommands(yargs.command(subHelp));
      }
    );
  }
  if (experimentalGradualRollouts) {
    wrangler.command(
      "triggers",
      "Updates the triggers of your current deployment [beta]",
      (yargs) => {
        return registerTriggersSubcommands(yargs.command(subHelp));
      }
    );
  }
  wrangler.exitProcess(false);
  return wrangler;
}
__name(createCLIParser, "createCLIParser");
async function main(argv) {
  setupSentry();
  const wrangler = createCLIParser(argv);
  let recordedCommand = false;
  const wranglerWithMiddleware = wrangler.middleware(
    (args) => {
      if (recordedCommand)
        return;
      recordedCommand = true;
      addBreadcrumb2(`wrangler ${args._.join(" ")}`);
    },
    /* applyBeforeValidation */
    true
  );
  let cliHandlerThrew = false;
  try {
    await wranglerWithMiddleware.parse();
  } catch (e3) {
    cliHandlerThrew = true;
    let mayReport = true;
    logger.log("");
    if (e3 instanceof CommandLineArgsError) {
      logger.error(e3.message);
      await createCLIParser([...argv, "--help"]).parse();
    } else if (isAuthenticationError(e3)) {
      mayReport = false;
      logger.log(formatMessage(e3));
      const envAuth = getAuthFromEnv();
      if (envAuth !== void 0 && "apiToken" in envAuth) {
        const message = "\u{1F4CE} It looks like you are authenticating Wrangler via a custom API token set in an environment variable.\nPlease ensure it has the correct permissions for this operation.\n";
        logger.log(import_chalk18.default.yellow(message));
      }
      await whoami();
    } else if (e3 instanceof ParseError) {
      e3.notes.push({
        text: "\nIf you think this is a bug, please open an issue at: https://github.com/cloudflare/workers-sdk/issues/new/choose"
      });
      logger.log(formatMessage(e3));
    } else if (e3 instanceof JsonFriendlyFatalError) {
      logger.log(e3.message);
    } else if (e3 instanceof Error && e3.message.includes("Raw mode is not supported on")) {
      mayReport = false;
      const currentPlatform = import_node_os8.default.platform();
      const thisTerminalIsUnsupported = "This terminal doesn't support raw mode.";
      const soWranglerWontWork = "Wrangler uses raw mode to read user input and write output to the terminal, and won't function correctly without it.";
      const tryRunningItIn = "Try running your previous command in a terminal that supports raw mode";
      const oneOfThese = currentPlatform === "win32" ? ", such as Command Prompt or Powershell." : currentPlatform === "darwin" ? ", such as Terminal.app or iTerm." : ".";
      logger.error(
        `${thisTerminalIsUnsupported}
${soWranglerWontWork}
${tryRunningItIn}${oneOfThese}`
      );
    } else if (isBuildFailure(e3)) {
      mayReport = false;
      logBuildFailure(e3.errors, e3.warnings);
      logger.error(e3.message);
    } else {
      logger.error(e3 instanceof Error ? e3.message : e3);
      if (!(e3 instanceof UserError)) {
        await logPossibleBugMessage();
      }
    }
    if (
      // Only report the error if we didn't just handle it
      mayReport && // ...and it's not a user error
      !(e3 instanceof UserError) && // ...and it's not an un-reportable API error
      !(e3 instanceof APIError && !e3.reportable)
    ) {
      await captureGlobalException(e3);
    }
    throw e3;
  } finally {
    try {
      if (typeof jest === "undefined")
        process.disconnect?.();
      await closeSentry();
    } catch (e3) {
      logger.error(e3);
      if (!cliHandlerThrew)
        throw e3;
    }
  }
}
__name(main, "main");
function getDevCompatibilityDate(config, compatibilityDate = config.compatibility_date) {
  const miniflareEntry = require.resolve("miniflare");
  const miniflareRequire = import_node_module3.default.createRequire(miniflareEntry);
  const miniflareWorkerd = miniflareRequire("workerd");
  const currentDate = miniflareWorkerd.compatibilityDate;
  if (config.configPath !== void 0 && compatibilityDate === void 0) {
    logger.warn(
      `No compatibility_date was specified. Using the installed Workers runtime's latest supported date: ${currentDate}.
Add one to your wrangler.toml file:
\`\`\`
compatibility_date = "${currentDate}"
\`\`\`
or pass it in your terminal:
\`\`\`
--compatibility-date=${currentDate}
\`\`\`
See https://developers.cloudflare.com/workers/platform/compatibility-dates/ for more information.`
    );
  }
  return compatibilityDate ?? currentDate;
}
__name(getDevCompatibilityDate, "getDevCompatibilityDate");
async function logPossibleBugMessage() {
  logger.log(
    `${fgGreenColor}%s${resetColor}`,
    "If you think this is a bug then please create an issue at https://github.com/cloudflare/workers-sdk/issues/new/choose"
  );
  const latestVersion = await updateCheck();
  if (latestVersion) {
    logger.log(
      `Note that there is a newer version of Wrangler available (${latestVersion}). Consider checking whether upgrading resolves this error.`
    );
  }
}
__name(logPossibleBugMessage, "logPossibleBugMessage");

// src/init.ts
function initOptions(yargs) {
  return yargs.positional("name", {
    describe: "The name of your worker",
    type: "string"
  }).option("type", {
    describe: "The type of worker to create",
    type: "string",
    choices: ["rust", "javascript", "webpack"],
    hidden: true,
    deprecated: true
  }).option("site", {
    hidden: true,
    type: "boolean",
    deprecated: true
  }).option("yes", {
    describe: 'Answer "yes" to any prompts for new projects',
    type: "boolean",
    alias: "y"
  }).option("from-dash", {
    describe: "The name of the Worker you wish to download from the Cloudflare dashboard for local development.",
    type: "string",
    requiresArg: true
  }).option("delegate-c3", {
    describe: "Delegate to Create Cloudflare CLI (C3)",
    type: "boolean",
    hidden: true,
    default: true
  });
}
__name(initOptions, "initOptions");
function isNpm(packageManager) {
  return packageManager.type === "npm";
}
__name(isNpm, "isNpm");
async function initHandler(args) {
  await printWranglerBanner();
  const yesFlag = args.yes ?? false;
  const devDepsToInstall = [];
  const instructions = [];
  let shouldRunPackageManagerInstall = false;
  const fromDashWorkerName = args.fromDash;
  const creationDirectory = import_node_path52.default.resolve(
    process.cwd(),
    (args.name ? args.name : fromDashWorkerName) ?? ""
  );
  assertNoTypeArg(args);
  assertNoSiteArg(args, creationDirectory);
  const workerName = import_node_path52.default.basename(creationDirectory).toLowerCase().replaceAll(/[^a-z0-9\-_]/gm, "-");
  const packageManager = await getPackageManager2(creationDirectory);
  const wranglerTomlDestination = import_node_path52.default.join(
    creationDirectory,
    "./wrangler.toml"
  );
  let justCreatedWranglerToml = false;
  let accountId = "";
  if (fromDashWorkerName) {
    const c3Arguments = [
      ...parse6(getC3CommandFromEnv()),
      fromDashWorkerName,
      ...yesFlag && isNpm(packageManager) ? ["-y"] : [],
      // --yes arg for npx
      ...isNpm(packageManager) ? ["--"] : [],
      "--existing-script",
      fromDashWorkerName
    ];
    if (yesFlag) {
      c3Arguments.push("--wrangler-defaults");
    }
    const replacementC3Command = `\`${packageManager.type} ${c3Arguments.join(
      " "
    )}\``;
    logger.warn(
      `The \`init --from-dash\` command is no longer supported. Please use ${replacementC3Command} instead.
The \`init\` command will be removed in a future version.`
    );
    if (args.delegateC3) {
      logger.log(`Running ${replacementC3Command}...`);
      await execa(packageManager.type, c3Arguments, { stdio: "inherit" });
      return;
    } else {
      const config = readConfig(args.config, args);
      accountId = await requireAuth(config);
      try {
        await fetchResult(
          `/accounts/${accountId}/workers/services/${fromDashWorkerName}`
        );
      } catch (err) {
        if (err.code === 10090) {
          throw new UserError(
            "wrangler couldn't find a Worker script with that name in your account.\nRun `wrangler whoami` to confirm you're logged into the correct account."
          );
        }
        throw err;
      }
    }
  }
  if (fs25.existsSync(wranglerTomlDestination)) {
    let shouldContinue = false;
    logger.warn(
      `${import_node_path52.default.relative(process.cwd(), wranglerTomlDestination)} already exists!`
    );
    if (!fromDashWorkerName) {
      shouldContinue = await confirm(
        "Do you want to continue initializing this project?"
      );
    }
    if (!shouldContinue) {
      return;
    }
  } else {
    if (!fromDashWorkerName) {
      const c3Arguments = [];
      if (args.name) {
        c3Arguments.push(args.name);
      }
      if (yesFlag) {
        c3Arguments.push("--wrangler-defaults");
      }
      if (c3Arguments.length > 0 && isNpm(packageManager)) {
        c3Arguments.unshift("--");
      }
      if (yesFlag && isNpm(packageManager)) {
        c3Arguments.unshift("-y");
      }
      c3Arguments.unshift(...parse6(getC3CommandFromEnv()));
      const replacementC3Command = `\`${packageManager.type} ${quote(
        c3Arguments
      )}\``;
      logger.warn(
        `The \`init\` command is no longer supported. Please use ${replacementC3Command} instead.
The \`init\` command will be removed in a future version.`
      );
      if (args.delegateC3) {
        logger.log(`Running ${replacementC3Command}...`);
        await execa(packageManager.type, c3Arguments, {
          stdio: "inherit"
        });
        return;
      }
    }
    await (0, import_promises20.mkdir)(creationDirectory, { recursive: true });
    const compatibilityDate = (/* @__PURE__ */ new Date()).toISOString().substring(0, 10);
    try {
      await (0, import_promises20.writeFile)(
        wranglerTomlDestination,
        import_toml6.default.stringify({
          name: workerName,
          compatibility_date: compatibilityDate
        }) + "\n"
      );
      logger.log(
        `\u2728 Created ${import_node_path52.default.relative(process.cwd(), wranglerTomlDestination)}`
      );
      justCreatedWranglerToml = true;
    } catch (err) {
      throw new Error(
        `Failed to create ${import_node_path52.default.relative(
          process.cwd(),
          wranglerTomlDestination
        )}.
${err.message ?? err}`
      );
    }
  }
  if (!await isInsideGitRepo(creationDirectory) && await getGitVersioon()) {
    const shouldInitGit = yesFlag || await confirm("Would you like to use git to manage this Worker?");
    if (shouldInitGit) {
      await initializeGit(creationDirectory);
      await (0, import_promises20.writeFile)(
        import_node_path52.default.join(creationDirectory, ".gitignore"),
        readFileSync5(import_node_path52.default.join(getBasePath(), "templates/gitignore"))
      );
      logger.log(
        args.name && args.name !== "." ? `\u2728 Initialized git repository at ${import_node_path52.default.relative(
          process.cwd(),
          creationDirectory
        )}` : `\u2728 Initialized git repository`
      );
    }
  }
  const isolatedInit = !!args.name;
  let pathToPackageJson = await findPath(
    isolatedInit,
    creationDirectory,
    "package.json"
  );
  let shouldCreatePackageJson = false;
  let shouldCreateTests = false;
  let newWorkerTestType = "jest";
  if (!pathToPackageJson) {
    shouldCreatePackageJson = yesFlag || await confirm("No package.json found. Would you like to create one?");
    if (shouldCreatePackageJson) {
      await (0, import_promises20.writeFile)(
        import_node_path52.default.join(creationDirectory, "./package.json"),
        JSON.stringify(
          {
            name: workerName,
            version: "0.0.0",
            devDependencies: {
              wrangler: version
            },
            private: true
          },
          null,
          "  "
        ) + "\n"
      );
      shouldRunPackageManagerInstall = true;
      pathToPackageJson = import_node_path52.default.join(creationDirectory, "package.json");
      logger.log(
        `\u2728 Created ${import_node_path52.default.relative(process.cwd(), pathToPackageJson)}`
      );
    } else {
      return;
    }
  } else {
    const packageJson = parsePackageJSON(
      readFileSync5(pathToPackageJson),
      pathToPackageJson
    );
    if (!(packageJson.devDependencies?.wrangler || packageJson.dependencies?.wrangler)) {
      const shouldInstall = yesFlag || await confirm(
        `Would you like to install wrangler into ${import_node_path52.default.relative(
          process.cwd(),
          pathToPackageJson
        )}?`
      );
      if (shouldInstall) {
        devDepsToInstall.push(`wrangler@${version}`);
      }
    }
  }
  let isTypescriptProject = false;
  let pathToTSConfig = await findPath(
    isolatedInit,
    creationDirectory,
    "tsconfig.json"
  );
  if (!fromDashWorkerName) {
    if (!pathToTSConfig) {
      if (yesFlag || await confirm("Would you like to use TypeScript?")) {
        isTypescriptProject = true;
        await (0, import_promises20.writeFile)(
          import_node_path52.default.join(creationDirectory, "./tsconfig.json"),
          readFileSync5(import_node_path52.default.join(getBasePath(), "templates/tsconfig.init.json"))
        );
        devDepsToInstall.push("@cloudflare/workers-types");
        devDepsToInstall.push("typescript");
        pathToTSConfig = import_node_path52.default.join(creationDirectory, "tsconfig.json");
        logger.log(
          `\u2728 Created ${import_node_path52.default.relative(process.cwd(), pathToTSConfig)}`
        );
      }
    } else {
      isTypescriptProject = true;
      const packageJson = parsePackageJSON(
        readFileSync5(pathToPackageJson),
        pathToPackageJson
      );
      if (!(packageJson.devDependencies?.["@cloudflare/workers-types"] || packageJson.dependencies?.["@cloudflare/workers-types"])) {
        const shouldInstall = await confirm(
          "Would you like to install the type definitions for Workers into your package.json?"
        );
        if (shouldInstall) {
          devDepsToInstall.push("@cloudflare/workers-types");
          instructions.push(
            `\u{1F6A8} Please add "@cloudflare/workers-types" to compilerOptions.types in ${import_node_path52.default.relative(
              process.cwd(),
              pathToTSConfig
            )}`
          );
        }
      }
    }
  }
  const packageJsonContent = parsePackageJSON(
    readFileSync5(pathToPackageJson),
    pathToPackageJson
  );
  const shouldWritePackageJsonScripts = !packageJsonContent.scripts?.start && !packageJsonContent.scripts?.publish && shouldCreatePackageJson;
  async function writePackageJsonScriptsAndUpdateWranglerToml({
    isWritingScripts,
    isAddingTests,
    testRunner,
    isCreatingWranglerToml,
    packagePath,
    scriptPath: scriptPath3,
    extraToml
  }) {
    if (isAddingTests && !testRunner) {
      logger.error("testRunner is required if isAddingTests");
    }
    if (isCreatingWranglerToml) {
      const parsedWranglerToml = parseTOML(
        readFileSync5(wranglerTomlDestination)
      );
      const newToml = {
        name: parsedWranglerToml.name,
        main: scriptPath3,
        compatibility_date: parsedWranglerToml.compatibility_date,
        ...extraToml
      };
      fs25.writeFileSync(wranglerTomlDestination, import_toml6.default.stringify(newToml));
    }
    const isNamedWorker = isCreatingWranglerToml && import_node_path52.default.dirname(packagePath) !== process.cwd();
    const isAddingTestScripts = isAddingTests && !packageJsonContent.scripts?.test;
    if (isWritingScripts) {
      await (0, import_promises20.writeFile)(
        packagePath,
        JSON.stringify(
          {
            ...packageJsonContent,
            scripts: {
              ...packageJsonContent.scripts,
              start: isCreatingWranglerToml ? `wrangler dev` : `wrangler dev ${scriptPath3}`,
              deploy: isCreatingWranglerToml ? `wrangler deploy` : `wrangler deploy ${scriptPath3}`,
              ...isAddingTestScripts && { test: testRunner }
            }
          },
          null,
          2
        ) + "\n"
      );
      instructions.push(
        `
To start developing your Worker, run \`${isNamedWorker ? `cd ${args.name || fromDashWorkerName} && ` : ""}npm start\``
      );
      if (isAddingTestScripts) {
        instructions.push(`To start testing your Worker, run \`npm test\``);
      }
      instructions.push(
        `To publish your Worker to the Internet, run \`npm run deploy\``
      );
    } else {
      instructions.push(
        `
To start developing your Worker, run \`npx wrangler dev\`${isCreatingWranglerToml ? "" : ` ${scriptPath3}`}`
      );
      instructions.push(
        `To publish your Worker to the Internet, run \`npx wrangler deploy\`${isCreatingWranglerToml ? "" : ` ${scriptPath3}`}`
      );
    }
  }
  __name(writePackageJsonScriptsAndUpdateWranglerToml, "writePackageJsonScriptsAndUpdateWranglerToml");
  if (isTypescriptProject) {
    if (!fs25.existsSync(import_node_path52.default.join(creationDirectory, "./src/index.ts"))) {
      const newWorkerFilename = import_node_path52.default.relative(
        process.cwd(),
        import_node_path52.default.join(creationDirectory, "./src/index.ts")
      );
      const newWorkerType = yesFlag ? "fetch" : await getNewWorkerType(newWorkerFilename);
      if (newWorkerType !== "none") {
        const template = getNewWorkerTemplate("ts", newWorkerType);
        await (0, import_promises20.mkdir)(import_node_path52.default.join(creationDirectory, "./src"), {
          recursive: true
        });
        await (0, import_promises20.writeFile)(
          import_node_path52.default.join(creationDirectory, "./src/index.ts"),
          readFileSync5(import_node_path52.default.join(getBasePath(), `templates/${template}`))
        );
        logger.log(
          `\u2728 Created ${import_node_path52.default.relative(
            process.cwd(),
            import_node_path52.default.join(creationDirectory, "./src/index.ts")
          )}`
        );
        shouldCreateTests = yesFlag || await confirm(
          "Would you like us to write your first test with Vitest?"
        );
        if (shouldCreateTests) {
          if (yesFlag) {
            logger.info("Your project will use Vitest to run your tests.");
          }
          newWorkerTestType = "vitest";
          devDepsToInstall.push(newWorkerTestType);
          await (0, import_promises20.writeFile)(
            import_node_path52.default.join(creationDirectory, "./src/index.test.ts"),
            readFileSync5(
              import_node_path52.default.join(
                getBasePath(),
                `templates/init-tests/test-${newWorkerTestType}-new-worker.ts`
              )
            )
          );
          logger.log(
            `\u2728 Created ${import_node_path52.default.relative(
              process.cwd(),
              import_node_path52.default.join(creationDirectory, "./src/index.test.ts")
            )}`
          );
        }
        await writePackageJsonScriptsAndUpdateWranglerToml({
          isWritingScripts: shouldWritePackageJsonScripts,
          isAddingTests: shouldCreateTests,
          isCreatingWranglerToml: justCreatedWranglerToml,
          packagePath: pathToPackageJson,
          testRunner: newWorkerTestType,
          scriptPath: "src/index.ts",
          extraToml: getNewWorkerToml(newWorkerType)
        });
      }
    }
  } else {
    if (!fs25.existsSync(import_node_path52.default.join(creationDirectory, "./src/index.js"))) {
      const newWorkerFilename = import_node_path52.default.relative(
        process.cwd(),
        import_node_path52.default.join(creationDirectory, "./src/index.js")
      );
      if (fromDashWorkerName) {
        logger.warn(
          "After running `wrangler init --from-dash`, modifying your worker via the Cloudflare dashboard is discouraged.\nEdits made via the Dashboard will not be synchronized locally and will be overridden by your local code and config when you deploy."
        );
        const { modules, config } = await downloadWorker(
          accountId,
          fromDashWorkerName
        );
        await (0, import_promises20.mkdir)(import_node_path52.default.join(creationDirectory, "./src"), {
          recursive: true
        });
        config.main = `src/${config.main}`;
        config.name = workerName;
        for (const files of createBatches(modules, 10)) {
          await Promise.all(
            files.map(async (file) => {
              const filepath = import_node_path52.default.join(
                creationDirectory,
                `./src/${file.name}`
              );
              const directory = (0, import_node_path52.dirname)(filepath);
              await (0, import_promises20.mkdir)(directory, { recursive: true });
              await (0, import_promises20.writeFile)(filepath, file.stream());
            })
          );
        }
        await writePackageJsonScriptsAndUpdateWranglerToml({
          isWritingScripts: shouldWritePackageJsonScripts,
          isCreatingWranglerToml: justCreatedWranglerToml,
          packagePath: pathToPackageJson,
          scriptPath: "src/index.js",
          //? Should we have Environment argument for `wrangler init --from-dash` - Jacob
          extraToml: config
        });
      } else {
        const newWorkerType = yesFlag ? "fetch" : await getNewWorkerType(newWorkerFilename);
        if (newWorkerType !== "none") {
          const template = getNewWorkerTemplate("js", newWorkerType);
          await (0, import_promises20.mkdir)(import_node_path52.default.join(creationDirectory, "./src"), {
            recursive: true
          });
          await (0, import_promises20.writeFile)(
            import_node_path52.default.join(creationDirectory, "./src/index.js"),
            readFileSync5(import_node_path52.default.join(getBasePath(), `templates/${template}`))
          );
          logger.log(
            `\u2728 Created ${import_node_path52.default.relative(
              process.cwd(),
              import_node_path52.default.join(creationDirectory, "./src/index.js")
            )}`
          );
          shouldCreateTests = yesFlag || await confirm("Would you like us to write your first test?");
          if (shouldCreateTests) {
            newWorkerTestType = await getNewWorkerTestType(yesFlag);
            devDepsToInstall.push(newWorkerTestType);
            await (0, import_promises20.writeFile)(
              import_node_path52.default.join(creationDirectory, "./src/index.test.js"),
              readFileSync5(
                import_node_path52.default.join(
                  getBasePath(),
                  `templates/init-tests/test-${newWorkerTestType}-new-worker.js`
                )
              )
            );
            logger.log(
              `\u2728 Created ${import_node_path52.default.relative(
                process.cwd(),
                import_node_path52.default.join(creationDirectory, "./src/index.test.js")
              )}`
            );
          }
          await writePackageJsonScriptsAndUpdateWranglerToml({
            isWritingScripts: shouldWritePackageJsonScripts,
            isAddingTests: shouldCreateTests,
            testRunner: newWorkerTestType,
            isCreatingWranglerToml: justCreatedWranglerToml,
            packagePath: pathToPackageJson,
            scriptPath: "src/index.js",
            extraToml: getNewWorkerToml(newWorkerType)
          });
        }
      }
    }
  }
  try {
    await installPackages(
      shouldRunPackageManagerInstall,
      devDepsToInstall,
      packageManager
    );
  } catch (e3) {
    logger.error(e3 instanceof Error ? e3.message : e3);
    instructions.push(
      "\n\u{1F6A8} wrangler was unable to fetch your npm packages, but your project is ready to go"
    );
  }
  instructions.forEach((instruction) => logger.log(instruction));
}
__name(initHandler, "initHandler");
async function installPackages(shouldRunInstall, depsToInstall, packageManager) {
  if (depsToInstall.length > 0) {
    const formatter = new Intl.ListFormat("en-US", {
      style: "long",
      type: "conjunction"
    });
    await packageManager.addDevDeps(...depsToInstall);
    const versionlessPackages = depsToInstall.map(
      (dep) => dep === `wrangler@${version}` ? "wrangler" : dep
    );
    logger.log(
      `\u2728 Installed ${formatter.format(
        versionlessPackages
      )} into devDependencies`
    );
  } else {
    if (shouldRunInstall) {
      await packageManager.install();
    }
  }
}
__name(installPackages, "installPackages");
async function getNewWorkerType(newWorkerFilename) {
  return select(`Would you like to create a Worker at ${newWorkerFilename}?`, {
    choices: [
      {
        value: "none",
        title: "None"
      },
      {
        value: "fetch",
        title: "Fetch handler"
      },
      {
        value: "scheduled",
        title: "Scheduled handler"
      }
    ],
    defaultOption: 1
  });
}
__name(getNewWorkerType, "getNewWorkerType");
async function getNewWorkerTestType(yesFlag) {
  return yesFlag ? "jest" : select(`Which test runner would you like to use?`, {
    choices: [
      {
        value: "vitest",
        title: "Vitest"
      },
      {
        value: "jest",
        title: "Jest"
      }
    ],
    defaultOption: 1
  });
}
__name(getNewWorkerTestType, "getNewWorkerTestType");
function getNewWorkerTemplate(lang, workerType) {
  const templates = {
    "js-fetch": "new-worker.js",
    "js-scheduled": "new-worker-scheduled.js",
    "ts-fetch": "new-worker.ts",
    "ts-scheduled": "new-worker-scheduled.ts"
  };
  return templates[`${lang}-${workerType}`];
}
__name(getNewWorkerTemplate, "getNewWorkerTemplate");
function getNewWorkerToml(workerType) {
  if (workerType === "scheduled") {
    return {
      triggers: {
        crons: ["1 * * * *"]
      }
    };
  }
  return {};
}
__name(getNewWorkerToml, "getNewWorkerToml");
async function findPath(isolatedInit, cwd2, basename4) {
  if (isolatedInit) {
    return fs25.existsSync(import_node_path52.default.resolve(cwd2, basename4)) ? import_node_path52.default.resolve(cwd2, basename4) : void 0;
  } else {
    return await findUp(basename4, {
      cwd: cwd2
    });
  }
}
__name(findPath, "findPath");
async function getWorkerConfig(accountId, workerName, entrypoint, serviceEnvironment) {
  const [
    bindings,
    routes,
    customDomains,
    workersDev,
    serviceEnvMetadata,
    cronTriggers
  ] = await Promise.all([
    fetchResult(
      `/accounts/${accountId}/workers/services/${workerName}/environments/${serviceEnvironment}/bindings`
    ),
    fetchResult(
      `/accounts/${accountId}/workers/services/${workerName}/environments/${serviceEnvironment}/routes?show_zonename=true`
    ),
    fetchResult(
      `/accounts/${accountId}/workers/domains/records?page=0&per_page=5&service=${workerName}&environment=${serviceEnvironment}`
    ),
    fetchResult(
      `/accounts/${accountId}/workers/services/${workerName}/environments/${serviceEnvironment}/subdomain`
    ),
    fetchResult(
      `/accounts/${accountId}/workers/services/${workerName}/environments/${serviceEnvironment}`
    ),
    fetchResult(
      `/accounts/${accountId}/workers/scripts/${workerName}/schedules`
    )
  ]).catch((e3) => {
    throw new Error(
      `Error Occurred ${e3}: Unable to fetch bindings, routes, or services metadata from the dashboard. Please try again later.`
    );
  });
  const mappedBindings = mapBindings(bindings);
  const durableObjectClassNames = bindings.filter((binding) => binding.type === "durable_object_namespace").map(
    (durableObject) => durableObject.class_name
  );
  const allRoutes = [
    ...routes.map(
      (r3) => ({ pattern: r3.pattern, zone_name: r3.zone_name })
    ),
    ...customDomains.map(
      (c2) => ({
        pattern: c2.hostname,
        zone_name: c2.zone_name,
        custom_domain: true
      })
    )
  ];
  return {
    name: workerName,
    main: entrypoint,
    workers_dev: workersDev.enabled,
    compatibility_date: serviceEnvMetadata.script.compatibility_date ?? (/* @__PURE__ */ new Date()).toISOString().substring(0, 10),
    compatibility_flags: serviceEnvMetadata.script.compatibility_flags,
    ...allRoutes.length ? { routes: allRoutes } : {},
    placement: serviceEnvMetadata.script.placement_mode === "smart" ? { mode: "smart" } : void 0,
    limits: serviceEnvMetadata.script.limits,
    ...durableObjectClassNames.length ? {
      migrations: [
        {
          tag: serviceEnvMetadata.script.migration_tag,
          new_classes: durableObjectClassNames
        }
      ]
    } : {},
    ...cronTriggers.schedules.length ? {
      triggers: {
        crons: cronTriggers.schedules.map((scheduled) => scheduled.cron)
      }
    } : {},
    tail_consumers: serviceEnvMetadata.script.tail_consumers,
    ...mappedBindings
  };
}
__name(getWorkerConfig, "getWorkerConfig");
function mapBindings(bindings) {
  return bindings.filter((binding) => binding.type !== "secret_text").reduce((configObj, binding) => {
    switch (binding.type) {
      case "plain_text":
        {
          configObj.vars = {
            ...configObj.vars ?? {},
            [binding.name]: binding.text
          };
        }
        break;
      case "json":
        {
          configObj.vars = {
            ...configObj.vars ?? {},
            name: binding.name,
            json: binding.json
          };
        }
        break;
      case "kv_namespace":
        {
          configObj.kv_namespaces = [
            ...configObj.kv_namespaces ?? [],
            { id: binding.namespace_id, binding: binding.name }
          ];
        }
        break;
      case "durable_object_namespace":
        {
          configObj.durable_objects = {
            bindings: [
              ...configObj.durable_objects?.bindings ?? [],
              {
                name: binding.name,
                class_name: binding.class_name,
                script_name: binding.script_name,
                environment: binding.environment
              }
            ]
          };
        }
        break;
      case "browser":
        {
          configObj.browser = {
            binding: binding.name
          };
        }
        break;
      case "ai":
        {
          configObj.ai = {
            binding: binding.name
          };
        }
        break;
      case "r2_bucket":
        {
          configObj.r2_buckets = [
            ...configObj.r2_buckets ?? [],
            {
              binding: binding.name,
              bucket_name: binding.bucket_name,
              jurisdiction: binding.jurisdiction
            }
          ];
        }
        break;
      case "service":
        {
          configObj.services = [
            ...configObj.services ?? [],
            {
              binding: binding.name,
              service: binding.service,
              environment: binding.environment,
              entrypoint: binding.entrypoint
            }
          ];
        }
        break;
      case "analytics_engine":
        {
          configObj.analytics_engine_datasets = [
            ...configObj.analytics_engine_datasets ?? [],
            { binding: binding.name, dataset: binding.dataset }
          ];
        }
        break;
      case "dispatch_namespace":
        {
          configObj.dispatch_namespaces = [
            ...configObj.dispatch_namespaces ?? [],
            {
              binding: binding.name,
              namespace: binding.namespace,
              ...binding.outbound && {
                outbound: {
                  service: binding.outbound.worker.service,
                  environment: binding.outbound.worker.environment,
                  parameters: binding.outbound.params?.map((p2) => p2.name) ?? []
                }
              }
            }
          ];
        }
        break;
      case "logfwdr":
        {
          configObj.logfwdr = {
            bindings: [
              ...configObj.logfwdr?.bindings ?? [],
              { name: binding.name, destination: binding.destination }
            ]
          };
        }
        break;
      case "wasm_module":
        {
          configObj.wasm_modules = {
            ...configObj.wasm_modules ?? {},
            [binding.name]: binding.part
          };
        }
        break;
      case "text_blob":
        {
          configObj.text_blobs = {
            ...configObj.text_blobs ?? {},
            [binding.name]: binding.part
          };
        }
        break;
      case "data_blob":
        {
          configObj.data_blobs = {
            ...configObj.data_blobs ?? {},
            [binding.name]: binding.part
          };
        }
        break;
      default: {
        if (!binding?.type)
          break;
        configObj.unsafe = {
          bindings: [...configObj.unsafe?.bindings ?? [], binding],
          metadata: configObj.unsafe?.metadata ?? void 0
        };
      }
    }
    return configObj;
  }, {});
}
__name(mapBindings, "mapBindings");
function* createBatches(array, size) {
  for (let i = 0; i < array.length; i += size) {
    yield array.slice(i, i + size);
  }
}
__name(createBatches, "createBatches");
function assertNoTypeArg(args) {
  if (args.type) {
    let message = "The --type option is no longer supported.";
    if (args.type === "webpack") {
      message += "\nIf you wish to use webpack then you will need to create a custom build.";
    }
    throw new CommandLineArgsError(message);
  }
}
__name(assertNoTypeArg, "assertNoTypeArg");
function assertNoSiteArg(args, creationDirectory) {
  if (args.site) {
    const gitDirectory = creationDirectory !== process.cwd() ? import_node_path52.default.basename(creationDirectory) : "my-site";
    const message = `The --site option is no longer supported.
If you wish to create a brand new Worker Sites project then clone the \`worker-sites-template\` starter repository:

\`\`\`
git clone --depth=1 --branch=wrangler2 https://github.com/cloudflare/worker-sites-template ${gitDirectory}
cd ${gitDirectory}
\`\`\`

Find out more about how to create and maintain Sites projects at https://developers.cloudflare.com/workers/platform/sites.
Have you considered using Cloudflare Pages instead? See https://pages.cloudflare.com/.`;
    throw new CommandLineArgsError(message);
  }
}
__name(assertNoSiteArg, "assertNoSiteArg");
async function downloadWorker(accountId, workerName) {
  const serviceMetadata = await fetchResult(
    `/accounts/${accountId}/workers/services/${workerName}`
  );
  const defaultEnvironment = serviceMetadata?.default_environment.environment;
  const { entrypoint, modules } = await fetchWorker(
    `/accounts/${accountId}/workers/services/${workerName}/environments/${defaultEnvironment}/content/v2`
  );
  const config = await getWorkerConfig(
    accountId,
    workerName,
    entrypoint,
    defaultEnvironment
  );
  return {
    modules,
    config
  };
}
__name(downloadWorker, "downloadWorker");

// src/utils/deployment-id-version-id-change.ts
init_import_meta_url();
function logVersionIdChange() {
  const docsLink = "https://developers.cloudflare.com/workers/configuration/versions-and-deployments";
  logger.log(
    `

Note: Deployment ID has been renamed to Version ID. Deployment ID is present to maintain compatibility with the previous behavior of this command. This output will change in a future version of Wrangler. To learn more visit: ${docsLink}`
  );
}
__name(logVersionIdChange, "logVersionIdChange");

// src/deployments.ts
async function deployments(accountId, scriptName, { send_metrics: sendMetrics } = {}) {
  await sendMetricsEvent(
    "view deployments",
    { view: scriptName ? "single" : "all" },
    {
      sendMetrics
    }
  );
  const scriptTag = (await fetchResult(
    `/accounts/${accountId}/workers/services/${scriptName}`
  )).default_environment.script.tag;
  const params = new import_url8.URLSearchParams({ order: "asc" });
  const { items: deploys } = await fetchResult(
    `/accounts/${accountId}/workers/deployments/by-script/${scriptTag}`,
    void 0,
    params
  );
  const versionMessages = deploys.map((versions) => {
    const triggerStr = versions.annotations?.["workers/triggered_by"] ? `${formatTrigger2(
      versions.annotations["workers/triggered_by"]
    )} from ${formatSource2(versions.metadata.source)}` : `${formatSource2(versions.metadata.source)}`;
    let version3 = `
Deployment ID: ${versions.id}
Version ID:    ${versions.id}
Created on:    ${versions.metadata.created_on}
Author:        ${versions.metadata.author_email}
Source:        ${triggerStr}`;
    if (versions.annotations?.["workers/rollback_from"]) {
      version3 += `
Rollback from: ${versions.annotations["workers/rollback_from"]}`;
    }
    if (versions.annotations?.["workers/message"]) {
      version3 += `
Message:       ${versions.annotations["workers/message"]}`;
    }
    return version3 + `
`;
  });
  versionMessages[versionMessages.length - 1] += "\u{1F7E9} Active";
  logger.log(...versionMessages);
  logVersionIdChange();
}
__name(deployments, "deployments");
function formatSource2(source) {
  switch (source) {
    case "api":
      return "API \u{1F4E1}";
    case "dash":
      return "Dashboard \u{1F5A5}\uFE0F";
    case "wrangler":
      return "Wrangler \u{1F920}";
    case "terraform":
      return "Terraform \u{1F3D7}\uFE0F";
    default:
      return "Other";
  }
}
__name(formatSource2, "formatSource");
function formatTrigger2(trigger) {
  switch (trigger) {
    case "upload":
      return "Upload";
    case "secret":
      return "Secret Change";
    case "rollback":
      return "Rollback";
    case "promotion":
      return "Promotion";
    default:
      return "Unknown";
  }
}
__name(formatTrigger2, "formatTrigger");
async function rollbackDeployment(accountId, scriptName, { send_metrics: sendMetrics } = {}, deploymentId, message) {
  if (deploymentId === void 0) {
    const scriptTag = (await fetchResult(
      `/accounts/${accountId}/workers/services/${scriptName}`
    )).default_environment.script.tag;
    const params = new import_url8.URLSearchParams({ order: "asc" });
    const { items: deploys } = await fetchResult(
      `/accounts/${accountId}/workers/deployments/by-script/${scriptTag}`,
      void 0,
      params
    );
    if (deploys.length < 2) {
      throw new UserError(
        "Cannot rollback to previous deployment since there are less than 2 deployments"
      );
    }
    deploymentId = deploys.at(-2)?.id;
    if (deploymentId === void 0) {
      throw new UserError("Cannot find previous deployment");
    }
  }
  const firstHash = deploymentId.substring(0, deploymentId.indexOf("-"));
  let rollbackMessage = "";
  if (message !== void 0) {
    rollbackMessage = message;
  } else {
    if (!await confirm(
      `This deployment ${import_chalk19.default.underline(
        firstHash
      )} will immediately replace the current deployment and become the active deployment across all your deployed routes and domains. However, your local development environment will not be affected by this rollback. ${import_chalk19.default.blue.bold(
        "Note:"
      )} Rolling back to a previous deployment will not rollback any of the bound resources (Durable Object, D1, R2, KV, etc).`
    )) {
      return;
    }
    rollbackMessage = await prompt(
      "Please provide a message for this rollback (120 characters max)",
      { defaultValue: "" }
    );
  }
  let rollbackVersion = await rollbackRequest(
    accountId,
    scriptName,
    deploymentId,
    rollbackMessage
  );
  await sendMetricsEvent(
    "rollback deployments",
    { view: scriptName ? "single" : "all" },
    {
      sendMetrics
    }
  );
  deploymentId = addHyphens(deploymentId) ?? deploymentId;
  rollbackVersion = addHyphens(rollbackVersion) ?? rollbackVersion;
  logger.log(`
Successfully rolled back to Deployment ID: ${deploymentId}`);
  logger.log("Current Deployment ID:", rollbackVersion);
  logger.log("Current Version ID:", rollbackVersion);
  logVersionIdChange();
}
__name(rollbackDeployment, "rollbackDeployment");
async function rollbackRequest(accountId, scriptName, deploymentId, rollbackReason) {
  const body = new import_undici22.FormData();
  body.set("message", rollbackReason);
  const { deployment_id } = await fetchResult(
    `/accounts/${accountId}/workers/scripts/${scriptName}?rollback_to=${deploymentId}`,
    {
      method: "PUT",
      body
    }
  );
  return deployment_id;
}
__name(rollbackRequest, "rollbackRequest");
async function viewDeployment(accountId, scriptName, { send_metrics: sendMetrics } = {}, deploymentId) {
  await sendMetricsEvent(
    "view deployments",
    { view: scriptName ? "single" : "all" },
    {
      sendMetrics
    }
  );
  const scriptTag = (await fetchResult(
    `/accounts/${accountId}/workers/services/${scriptName}`
  )).default_environment.script.tag;
  if (deploymentId === void 0) {
    const params = new import_url8.URLSearchParams({ order: "asc" });
    const { latest } = await fetchResult(
      `/accounts/${accountId}/workers/deployments/by-script/${scriptTag}`,
      void 0,
      params
    );
    deploymentId = latest.id;
    if (deploymentId === void 0) {
      throw new UserError("Cannot find previous deployment");
    }
  }
  const deploymentDetails = await fetchResult(
    `/accounts/${accountId}/workers/deployments/by-script/${scriptTag}/detail/${deploymentId}`
  );
  const triggerStr = deploymentDetails.annotations?.["workers/triggered_by"] ? `${formatTrigger2(
    deploymentDetails.annotations["workers/triggered_by"]
  )} from ${formatSource2(deploymentDetails.metadata.source)}` : `${formatSource2(deploymentDetails.metadata.source)}`;
  const rollbackStr = deploymentDetails.annotations?.["workers/rollback_from"] ? `
Rollback from:       ${deploymentDetails.annotations["workers/rollback_from"]}` : ``;
  const reasonStr = deploymentDetails.annotations?.["workers/message"] ? `
Message:             ${deploymentDetails.annotations["workers/message"]}` : ``;
  const compatDateStr = deploymentDetails.resources.script_runtime?.compatibility_date ? `
Compatibility Date:  ${deploymentDetails.resources.script_runtime?.compatibility_date}` : ``;
  const compatFlagsStr = deploymentDetails.resources.script_runtime?.compatibility_flags ? `
Compatibility Flags: ${deploymentDetails.resources.script_runtime?.compatibility_flags}` : ``;
  const bindings = deploymentDetails.resources.bindings;
  const version3 = `
Deployment ID:       ${deploymentDetails.id}
Version ID:          ${deploymentDetails.id}
Created on:          ${deploymentDetails.metadata.created_on}
Author:              ${deploymentDetails.metadata.author_email}
Source:              ${triggerStr}${rollbackStr}${reasonStr}
------------------------------------------------------------
Author ID:           ${deploymentDetails.metadata.author_id}
Usage Model:         ${deploymentDetails.resources.script_runtime.usage_model}
Handlers:            ${deploymentDetails.resources.script.handlers}${compatDateStr}${compatFlagsStr}
--------------------------bindings--------------------------
${bindings.length > 0 ? import_toml7.default.stringify(mapBindings(bindings)) : `None`}
`;
  logger.log(version3);
  logVersionIdChange();
}
__name(viewDeployment, "viewDeployment");
async function commonDeploymentCMDSetup(yargs, deploymentsWarning) {
  await printWranglerBanner();
  const config = readConfig(yargs.config, yargs);
  const accountId = await requireAuth(config);
  const scriptName = getScriptName(
    { name: yargs.name, env: void 0 },
    config
  );
  logger.log(`${deploymentsWarning}
`);
  if (!scriptName) {
    throw new UserError(
      "Required Worker name missing. Please specify the Worker name in wrangler.toml, or pass it as an argument with `--name`"
    );
  }
  return { accountId, scriptName, config };
}
__name(commonDeploymentCMDSetup, "commonDeploymentCMDSetup");
function addHyphens(uuid) {
  if (uuid == null) {
    return uuid;
  }
  if (uuid.length != 32) {
    return null;
  }
  const uuid_parts = [];
  uuid_parts.push(uuid.slice(0, 8));
  uuid_parts.push(uuid.slice(8, 12));
  uuid_parts.push(uuid.slice(12, 16));
  uuid_parts.push(uuid.slice(16, 20));
  uuid_parts.push(uuid.slice(20));
  let hyphenated = "";
  uuid_parts.forEach((part) => hyphenated += part + "-");
  return hyphenated.slice(0, 36);
}
__name(addHyphens, "addHyphens");

// src/deploy/deploy.ts
function sleep2(ms) {
  return new Promise((resolve19) => setTimeout(resolve19, ms));
}
__name(sleep2, "sleep");
var scriptStartupErrorRegex2 = /startup/i;
function errIsScriptSize2(err) {
  if (!err)
    return false;
  if (err.code === 10027) {
    return true;
  }
  return false;
}
__name(errIsScriptSize2, "errIsScriptSize");
function errIsStartupErr2(err) {
  if (!err)
    return false;
  if (err.code === 10021 && err instanceof ParseError && scriptStartupErrorRegex2.test(err.notes[0]?.text)) {
    return true;
  }
  return false;
}
__name(errIsStartupErr2, "errIsStartupErr");
function renderRoute(route2) {
  let result = "";
  if (typeof route2 === "string") {
    result = route2;
  } else {
    result = route2.pattern;
    const isCustomDomain = Boolean(
      "custom_domain" in route2 && route2.custom_domain
    );
    if (isCustomDomain && "zone_id" in route2) {
      result += ` (custom domain - zone id: ${route2.zone_id})`;
    } else if (isCustomDomain && "zone_name" in route2) {
      result += ` (custom domain - zone name: ${route2.zone_name})`;
    } else if (isCustomDomain) {
      result += ` (custom domain)`;
    } else if ("zone_id" in route2) {
      result += ` (zone id: ${route2.zone_id})`;
    } else if ("zone_name" in route2) {
      result += ` (zone name: ${route2.zone_name})`;
    }
  }
  return result;
}
__name(renderRoute, "renderRoute");
async function publishCustomDomains(workerUrl, accountId, domains) {
  const config = {
    override_scope: true,
    override_existing_origin: false,
    override_existing_dns_record: false
  };
  const origins = domains.map((domainRoute) => {
    return {
      hostname: domainRoute.pattern,
      zone_id: "zone_id" in domainRoute ? domainRoute.zone_id : void 0,
      zone_name: "zone_name" in domainRoute ? domainRoute.zone_name : void 0
    };
  });
  const fail = /* @__PURE__ */ __name(() => {
    return [
      domains.length > 1 ? `Publishing to ${domains.length} Custom Domains was skipped, fix conflicts and try again` : `Publishing to Custom Domain "${domains[0].pattern}" was skipped, fix conflict and try again`
    ];
  }, "fail");
  if (!process.stdout.isTTY) {
    config.override_existing_origin = true;
    config.override_existing_dns_record = true;
  } else {
    const changeset = await fetchResult(
      `${workerUrl}/domains/changeset?replace_state=true`,
      {
        method: "POST",
        body: JSON.stringify(origins),
        headers: {
          "Content-Type": "application/json"
        }
      }
    );
    const updatesRequired = changeset.updated.filter(
      (domain2) => domain2.modified
    );
    if (updatesRequired.length > 0) {
      const existing = await Promise.all(
        updatesRequired.map(
          (domain2) => fetchResult(
            `/accounts/${accountId}/workers/domains/records/${domain2.id}`
          )
        )
      );
      const existingRendered = existing.map(
        (domain2) => `	\u2022 ${domain2.hostname} (used as a domain for "${domain2.service}")`
      ).join("\n");
      const message = `Custom Domains already exist for these domains:
${existingRendered}
Update them to point to this script instead?`;
      if (!await confirm(message))
        return fail();
      config.override_existing_origin = true;
    }
    if (changeset.conflicting.length > 0) {
      const conflicitingRendered = changeset.conflicting.map((domain2) => `	\u2022 ${domain2.hostname}`).join("\n");
      const message = `You already have DNS records that conflict for these Custom Domains:
${conflicitingRendered}
Update them to point to this script instead?`;
      if (!await confirm(message))
        return fail();
      config.override_existing_dns_record = true;
    }
  }
  await fetchResult(`${workerUrl}/domains/records`, {
    method: "PUT",
    body: JSON.stringify({ ...config, origins }),
    headers: {
      "Content-Type": "application/json"
    }
  });
  return domains.map((domain2) => renderRoute(domain2));
}
__name(publishCustomDomains, "publishCustomDomains");
async function deploy(props) {
  const { config, accountId, name } = props;
  if (!props.dispatchNamespace && accountId && name) {
    try {
      const serviceMetaData = await fetchResult(
        `/accounts/${accountId}/workers/services/${name}`
      );
      const { default_environment } = serviceMetaData;
      if (default_environment.script.last_deployed_from === "dash") {
        logger.warn(
          `You are about to publish a Workers Service that was last published via the Cloudflare Dashboard.
Edits that have been made via the dashboard will be overridden by your local code and config.`
        );
        if (!await confirm("Would you like to continue?")) {
          return;
        }
      } else if (default_environment.script.last_deployed_from === "api") {
        logger.warn(
          `You are about to publish a Workers Service that was last updated via the script API.
Edits that have been made via the script API will be overridden by your local code and config.`
        );
        if (!await confirm("Would you like to continue?")) {
          return;
        }
      }
    } catch (e3) {
      if (e3.code !== 10090) {
        throw e3;
      }
    }
  }
  if (!(props.compatibilityDate || config.compatibility_date)) {
    const compatibilityDateStr = `${(/* @__PURE__ */ new Date()).getFullYear()}-${((/* @__PURE__ */ new Date()).getMonth() + 1 + "").padStart(2, "0")}-${((/* @__PURE__ */ new Date()).getDate() + "").padStart(2, "0")}`;
    throw new UserError(`A compatibility_date is required when publishing. Add the following to your wrangler.toml file:.
    \`\`\`
    compatibility_date = "${compatibilityDateStr}"
    \`\`\`
    Or you could pass it in your terminal as \`--compatibility-date ${compatibilityDateStr}\`
See https://developers.cloudflare.com/workers/platform/compatibility-dates for more information.`);
  }
  const routes = props.routes ?? config.routes ?? (config.route ? [config.route] : []) ?? [];
  for (const route2 of routes) {
    if (typeof route2 !== "string" && route2.custom_domain) {
      if (route2.pattern.includes("*")) {
        throw new UserError(
          `Cannot use "${route2.pattern}" as a Custom Domain; wildcard operators (*) are not allowed`
        );
      }
      if (route2.pattern.includes("/")) {
        throw new UserError(
          `Cannot use "${route2.pattern}" as a Custom Domain; paths are not allowed`
        );
      }
    }
  }
  const jsxFactory = props.jsxFactory || config.jsx_factory;
  const jsxFragment = props.jsxFragment || config.jsx_fragment;
  const keepVars = props.keepVars || config.keep_vars;
  const minify = props.minify ?? config.minify;
  const legacyNodeCompat = props.nodeCompat ?? config.node_compat;
  if (legacyNodeCompat) {
    logger.warn(
      "Enabling Node.js compatibility mode for built-ins and globals. This is experimental and has serious tradeoffs. Please see https://github.com/ionic-team/rollup-plugin-node-polyfills/ for more details."
    );
  }
  const compatibilityFlags = props.compatibilityFlags ?? config.compatibility_flags;
  const nodejsCompat = compatibilityFlags.includes("nodejs_compat");
  (0, import_node_assert17.default)(
    !(legacyNodeCompat && nodejsCompat),
    "The `nodejs_compat` compatibility flag cannot be used in conjunction with the legacy `--node-compat` flag. If you want to use the Workers runtime Node.js compatibility features, please remove the `--node-compat` argument from your CLI command or `node_compat = true` from your config file."
  );
  if (props.noBundle && minify) {
    logger.warn(
      "`--minify` and `--no-bundle` can't be used together. If you want to minify your Worker and disable Wrangler's bundling, please minify as part of your own bundling process."
    );
  }
  if (props.noBundle && legacyNodeCompat) {
    logger.warn(
      "`--node-compat` and `--no-bundle` can't be used together. If you want to polyfill Node.js built-ins and disable Wrangler's bundling, please polyfill as part of your own bundling process."
    );
  }
  const scriptName = props.name;
  (0, import_node_assert17.default)(
    scriptName,
    'You need to provide a name when publishing a worker. Either pass it as a cli arg with `--name <name>` or in your config file as `name = "<name>"`'
  );
  (0, import_node_assert17.default)(
    !config.site || config.site.bucket,
    "A [site] definition requires a `bucket` field with a path to the site's assets directory."
  );
  if (props.outDir) {
    (0, import_node_fs34.mkdirSync)(props.outDir, { recursive: true });
    const readmePath = import_node_path53.default.join(props.outDir, "README.md");
    (0, import_node_fs34.writeFileSync)(
      readmePath,
      `This folder contains the built output assets for the worker "${scriptName}" generated at ${(/* @__PURE__ */ new Date()).toISOString()}.`
    );
  }
  const destination = props.outDir ?? getWranglerTmpDir(props.projectRoot, "deploy");
  const envName = props.env ?? "production";
  const start = Date.now();
  const notProd = Boolean(!props.legacyEnv && props.env);
  const workerName = notProd ? `${scriptName} (${envName})` : scriptName;
  const workerUrl = props.dispatchNamespace ? `/accounts/${accountId}/workers/dispatch/namespaces/${props.dispatchNamespace}/scripts/${scriptName}` : notProd ? `/accounts/${accountId}/workers/services/${scriptName}/environments/${envName}` : `/accounts/${accountId}/workers/scripts/${scriptName}`;
  let deploymentId = null;
  const { format: format10 } = props.entry;
  if (!props.isWorkersSite && Boolean(props.assetPaths) && format10 === "service-worker") {
    throw new UserError(
      "You cannot use the service-worker format with an `assets` directory yet. For information on how to migrate to the module-worker format, see: https://developers.cloudflare.com/workers/learning/migrating-to-module-workers/"
    );
  }
  if (config.wasm_modules && format10 === "modules") {
    throw new UserError(
      "You cannot configure [wasm_modules] with an ES module worker. Instead, import the .wasm module directly in your code"
    );
  }
  if (config.text_blobs && format10 === "modules") {
    throw new UserError(
      "You cannot configure [text_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure `[rules]` in your wrangler.toml"
    );
  }
  if (config.data_blobs && format10 === "modules") {
    throw new UserError(
      "You cannot configure [data_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure `[rules]` in your wrangler.toml"
    );
  }
  try {
    if (props.noBundle) {
      const destinationDir = typeof destination === "string" ? destination : destination.path;
      (0, import_node_fs34.mkdirSync)(destinationDir, { recursive: true });
      (0, import_node_fs34.writeFileSync)(
        import_node_path53.default.join(destinationDir, import_node_path53.default.basename(props.entry.file)),
        (0, import_node_fs34.readFileSync)(props.entry.file, "utf-8")
      );
    }
    const entryDirectory = import_node_path53.default.dirname(props.entry.file);
    const moduleCollector = createModuleCollector({
      wrangler1xLegacyModuleReferences: getWrangler1xLegacyModuleReferences(
        entryDirectory,
        props.entry.file
      ),
      entry: props.entry,
      // `moduleCollector` doesn't get used when `props.noBundle` is set, so
      // `findAdditionalModules` always defaults to `false`
      findAdditionalModules: config.find_additional_modules ?? false,
      rules: props.rules,
      preserveFileNames: config.preserve_file_names ?? false
    });
    const uploadSourceMaps = props.uploadSourceMaps ?? config.upload_source_maps;
    const {
      modules,
      dependencies,
      resolvedEntryPointPath,
      bundleType,
      ...bundle
    } = props.noBundle ? await noBundleWorker2(props.entry, props.rules, props.outDir) : await bundleWorker(
      props.entry,
      typeof destination === "string" ? destination : destination.path,
      {
        bundle: true,
        additionalModules: [],
        moduleCollector,
        serveAssetsFromWorker: !props.isWorkersSite && Boolean(props.assetPaths),
        doBindings: config.durable_objects.bindings,
        jsxFactory,
        jsxFragment,
        tsconfig: props.tsconfig ?? config.tsconfig,
        minify,
        sourcemap: uploadSourceMaps,
        legacyNodeCompat,
        nodejsCompat,
        define: { ...config.define, ...props.defines },
        checkFetch: false,
        assets: config.assets,
        // enable the cache when publishing
        bypassAssetCache: false,
        // We want to know if the build is for development or publishing
        // This could potentially cause issues as we no longer have identical behaviour between dev and deploy?
        targetConsumer: "deploy",
        local: false,
        projectRoot: props.projectRoot,
        defineNavigatorUserAgent: isNavigatorDefined(
          props.compatibilityDate ?? config.compatibility_date,
          props.compatibilityFlags ?? config.compatibility_flags
        )
      }
    );
    for (const module3 of modules) {
      const modulePath = module3.filePath === void 0 ? module3.name : import_node_path53.default.relative("", module3.filePath);
      const bytesInOutput = typeof module3.content === "string" ? Buffer.byteLength(module3.content) : module3.content.byteLength;
      dependencies[modulePath] = { bytesInOutput };
    }
    for (const module3 of modules) {
      const modulePath = module3.filePath === void 0 ? module3.name : import_node_path53.default.relative("", module3.filePath);
      const bytesInOutput = typeof module3.content === "string" ? Buffer.byteLength(module3.content) : module3.content.byteLength;
      dependencies[modulePath] = { bytesInOutput };
    }
    const content = (0, import_node_fs34.readFileSync)(resolvedEntryPointPath, {
      encoding: "utf-8"
    });
    const migrations = !props.dryRun ? await getMigrationsToUpload(scriptName, {
      accountId,
      config,
      legacyEnv: props.legacyEnv,
      env: props.env
    }) : void 0;
    const assets = await syncAssets(
      accountId,
      // When we're using the newer service environments, we wouldn't
      // have added the env name on to the script name. However, we must
      // include it in the kv namespace name regardless (since there's no
      // concept of service environments for kv namespaces yet).
      scriptName + (!props.legacyEnv && props.env ? `-${props.env}` : ""),
      props.assetPaths,
      false,
      props.dryRun,
      props.oldAssetTtl
    );
    const bindings = {
      kv_namespaces: (config.kv_namespaces || []).concat(
        assets.namespace ? { binding: "__STATIC_CONTENT", id: assets.namespace } : []
      ),
      send_email: config.send_email,
      vars: { ...config.vars, ...props.vars },
      wasm_modules: config.wasm_modules,
      browser: config.browser,
      ai: config.ai,
      version_metadata: config.version_metadata,
      text_blobs: {
        ...config.text_blobs,
        ...assets.manifest && format10 === "service-worker" && {
          __STATIC_CONTENT_MANIFEST: "__STATIC_CONTENT_MANIFEST"
        }
      },
      data_blobs: config.data_blobs,
      durable_objects: config.durable_objects,
      queues: config.queues.producers?.map((producer) => {
        return { binding: producer.binding, queue_name: producer.queue };
      }),
      r2_buckets: config.r2_buckets,
      d1_databases: config.d1_databases,
      vectorize: config.vectorize,
      constellation: config.constellation,
      hyperdrive: config.hyperdrive,
      services: config.services,
      analytics_engine_datasets: config.analytics_engine_datasets,
      dispatch_namespaces: config.dispatch_namespaces,
      mtls_certificates: config.mtls_certificates,
      logfwdr: config.logfwdr,
      unsafe: {
        bindings: config.unsafe.bindings,
        metadata: config.unsafe.metadata,
        capnp: config.unsafe.capnp
      }
    };
    if (assets.manifest) {
      modules.push({
        name: "__STATIC_CONTENT_MANIFEST",
        filePath: void 0,
        content: JSON.stringify(assets.manifest),
        type: "text"
      });
    }
    const placement = config.placement?.mode === "smart" ? { mode: "smart" } : void 0;
    const entryPointName = import_node_path53.default.basename(resolvedEntryPointPath);
    const main2 = {
      name: entryPointName,
      filePath: resolvedEntryPointPath,
      content,
      type: bundleType
    };
    const worker = {
      name: scriptName,
      main: main2,
      bindings,
      migrations,
      modules,
      sourceMaps: uploadSourceMaps ? loadSourceMaps(main2, modules, bundle) : void 0,
      compatibility_date: props.compatibilityDate ?? config.compatibility_date,
      compatibility_flags: compatibilityFlags,
      usage_model: config.usage_model,
      keepVars,
      keepSecrets: keepVars,
      // keepVars implies keepSecrets
      logpush: props.logpush !== void 0 ? props.logpush : config.logpush,
      placement,
      tail_consumers: config.tail_consumers,
      limits: config.limits
    };
    const bundleSizePromise = printBundleSize(
      { name: import_node_path53.default.basename(resolvedEntryPointPath), content },
      modules
    );
    if (process.env.JEST_WORKER_ID !== void 0)
      await bundleSizePromise;
    else
      ;
    const withoutStaticAssets = {
      ...bindings,
      kv_namespaces: config.kv_namespaces,
      text_blobs: config.text_blobs
    };
    const maskedVars = { ...withoutStaticAssets.vars };
    for (const key of Object.keys(maskedVars)) {
      if (maskedVars[key] !== config.vars[key]) {
        maskedVars[key] = "(hidden)";
      }
    }
    printBindings({ ...withoutStaticAssets, vars: maskedVars });
    if (!props.dryRun) {
      await ensureQueuesExistByConfig(config);
      try {
        const result = await fetchResult(
          workerUrl,
          {
            method: "PUT",
            body: createWorkerUploadForm(worker),
            headers: await getMetricsUsageHeaders(config.send_metrics)
          },
          new import_node_url15.URLSearchParams({
            include_subdomain_availability: "true",
            // pass excludeScript so the whole body of the
            // script doesn't get included in the response
            excludeScript: "true"
          })
        );
        deploymentId = addHyphens(result.deployment_id) ?? result.deployment_id;
        if (config.first_party_worker) {
          if (result.id)
            logger.log("Worker ID: ", result.id);
          if (result.etag)
            logger.log("Worker ETag: ", result.etag);
          if (result.pipeline_hash)
            logger.log("Worker PipelineHash: ", result.pipeline_hash);
          if (result.mutable_pipeline_id)
            logger.log(
              "Worker Mutable PipelineID (Development ONLY!):",
              result.mutable_pipeline_id
            );
        }
      } catch (err) {
        helpIfErrorIsSizeOrScriptStartup2(err, dependencies);
        if (err instanceof APIError && "code" in err && err.code === 10021 && err.notes.length > 0) {
          err.preventReport();
          if (err.notes[0].text === "binding DB of type d1 must have a valid `id` specified [code: 10021]") {
            throw new UserError(
              "You must use a real database in the database_id configuration. You can find your databases using 'wrangler d1 list', or read how to develop locally with D1 here: https://developers.cloudflare.com/d1/configuration/local-development"
            );
          }
          const maybeNameToFilePath = /* @__PURE__ */ __name((moduleName) => {
            if (bundleType === "commonjs")
              return resolvedEntryPointPath;
            if (moduleName === entryPointName)
              return resolvedEntryPointPath;
            for (const module3 of modules) {
              if (moduleName === module3.name)
                return module3.filePath;
            }
          }, "maybeNameToFilePath");
          const retrieveSourceMap = /* @__PURE__ */ __name((moduleName) => maybeRetrieveFileSourceMap(maybeNameToFilePath(moduleName)), "retrieveSourceMap");
          err.notes[0].text = getSourceMappedString(
            err.notes[0].text,
            retrieveSourceMap
          );
        }
        throw err;
      }
    }
  } finally {
    if (typeof destination !== "string") {
      destination.remove();
    }
  }
  if (props.dryRun) {
    logger.log(`--dry-run: exiting now.`);
    return;
  }
  (0, import_node_assert17.default)(accountId, "Missing accountId");
  const uploadMs = Date.now() - start;
  logger.log("Uploaded", workerName, formatTime2(uploadMs));
  if (props.dispatchNamespace !== void 0) {
    deployWfpUserWorker(props.dispatchNamespace, deploymentId);
    return;
  }
  await triggersDeploy(props);
  logger.log("Current Deployment ID:", deploymentId);
  logger.log("Current Version ID:", deploymentId);
  logVersionIdChange();
}
__name(deploy, "deploy");
function deployWfpUserWorker(dispatchNamespace, deploymentId) {
  logger.log("  Dispatch Namespace:", dispatchNamespace);
  logger.log("Current Deployment ID:", deploymentId);
  logger.log("Current Version ID:", deploymentId);
  logVersionIdChange();
}
__name(deployWfpUserWorker, "deployWfpUserWorker");
function helpIfErrorIsSizeOrScriptStartup2(err, dependencies) {
  if (errIsScriptSize2(err)) {
    printOffendingDependencies(dependencies);
  } else if (errIsStartupErr2(err)) {
    const youFailed = "Your Worker failed validation because it exceeded startup limits.";
    const heresWhy = "To ensure fast responses, we place constraints on Worker startup -- like how much CPU it can use, or how long it can take.";
    const heresTheProblem = "Your Worker failed validation, which means it hit one of these startup limits.";
    const heresTheSolution = "Try reducing the amount of work done during startup (outside the event handler), either by removing code or relocating it inside the event handler.";
    logger.warn(
      [youFailed, heresWhy, heresTheProblem, heresTheSolution].join("\n")
    );
  }
}
__name(helpIfErrorIsSizeOrScriptStartup2, "helpIfErrorIsSizeOrScriptStartup");
function formatTime2(duration) {
  return `(${(duration / 1e3).toFixed(2)} sec)`;
}
__name(formatTime2, "formatTime");
async function publishRoutes(routes, {
  workerUrl,
  scriptName,
  notProd
}) {
  try {
    return await fetchResult(`${workerUrl}/routes`, {
      // Note: PUT will delete previous routes on this script.
      method: "PUT",
      body: JSON.stringify(
        routes.map(
          (route2) => typeof route2 !== "object" ? { pattern: route2 } : route2
        )
      ),
      headers: {
        "Content-Type": "application/json"
      }
    });
  } catch (e3) {
    if (isAuthenticationError(e3)) {
      return await publishRoutesFallback(routes, { scriptName, notProd });
    } else {
      throw e3;
    }
  }
}
__name(publishRoutes, "publishRoutes");
async function publishRoutesFallback(routes, { scriptName, notProd }) {
  if (notProd) {
    throw new UserError(
      "Service environments combined with an API token that doesn't have 'All Zones' permissions is not supported.\nEither turn off service environments by setting `legacy_env = true`, creating an API token with 'All Zones' permissions, or logging in via OAuth"
    );
  }
  logger.warn(
    "The current authentication token does not have 'All Zones' permissions.\nFalling back to using the zone-based API endpoint to update each route individually.\nNote that there is no access to routes associated with zones that the API token does not have permission for.\nExisting routes for this Worker in such zones will not be deleted."
  );
  const deployedRoutes = [];
  const activeZones = /* @__PURE__ */ new Map();
  const routesToDeploy = /* @__PURE__ */ new Map();
  for (const route2 of routes) {
    const zone = await getZoneForRoute(route2);
    if (zone) {
      activeZones.set(zone.id, zone.host);
      routesToDeploy.set(
        typeof route2 === "string" ? route2 : route2.pattern,
        zone.id
      );
    }
  }
  const allRoutes = /* @__PURE__ */ new Map();
  const alreadyDeployedRoutes = /* @__PURE__ */ new Set();
  for (const [zone, host] of activeZones) {
    try {
      for (const { pattern, script } of await fetchListResult(`/zones/${zone}/workers/routes`)) {
        allRoutes.set(pattern, script);
        if (script === scriptName) {
          alreadyDeployedRoutes.add(pattern);
        }
      }
    } catch (e3) {
      if (isAuthenticationError(e3)) {
        e3.notes.push({
          text: `This could be because the API token being used does not have permission to access the zone "${host}" (${zone}).`
        });
      }
      throw e3;
    }
  }
  for (const [routePattern, zoneId] of routesToDeploy.entries()) {
    if (allRoutes.has(routePattern)) {
      const knownScript = allRoutes.get(routePattern);
      if (knownScript === scriptName) {
        alreadyDeployedRoutes.delete(routePattern);
        continue;
      } else {
        throw new UserError(
          `The route with pattern "${routePattern}" is already associated with another worker called "${knownScript}".`
        );
      }
    }
    const { pattern } = await fetchResult(
      `/zones/${zoneId}/workers/routes`,
      {
        method: "POST",
        body: JSON.stringify({
          pattern: routePattern,
          script: scriptName
        }),
        headers: {
          "Content-Type": "application/json"
        }
      }
    );
    deployedRoutes.push(pattern);
  }
  if (alreadyDeployedRoutes.size) {
    logger.warn(
      "Previously deployed routes:\nThe following routes were already associated with this worker, and have not been deleted:\n" + [...alreadyDeployedRoutes.values()].map((route2) => ` - "${route2}"
`) + "If these routes are not wanted then you can remove them in the dashboard."
    );
  }
  return deployedRoutes;
}
__name(publishRoutesFallback, "publishRoutesFallback");
function isAuthenticationError(e3) {
  return e3 instanceof ParseError && e3.code === 1e4;
}
__name(isAuthenticationError, "isAuthenticationError");
async function updateQueueProducers(config) {
  const producers = config.queues.producers || [];
  const updateProducers = [];
  for (const producer of producers) {
    const body = {
      queue_name: producer.queue,
      settings: {
        delivery_delay: producer.delivery_delay
      }
    };
    updateProducers.push(
      putQueue(config, producer.queue, body).then(() => [
        `Producer for ${producer.queue}`
      ])
    );
  }
  return updateProducers;
}
__name(updateQueueProducers, "updateQueueProducers");
async function updateQueueConsumers(config) {
  const consumers2 = config.queues.consumers || [];
  const updateConsumers = [];
  for (const consumer of consumers2) {
    const queue = await getQueue(config, consumer.queue);
    if (consumer.type === "http_pull") {
      const body = {
        type: consumer.type,
        dead_letter_queue: consumer.dead_letter_queue,
        settings: {
          batch_size: consumer.max_batch_size,
          max_retries: consumer.max_retries,
          visibility_timeout_ms: consumer.visibility_timeout_ms,
          retry_delay: consumer.retry_delay
        }
      };
      const existingConsumer = queue.consumers && queue.consumers[0];
      if (existingConsumer) {
        updateConsumers.push(
          putConsumerById(
            config,
            queue.queue_id,
            existingConsumer.consumer_id,
            body
          ).then(() => [`Consumer for ${consumer.queue}`])
        );
        continue;
      }
      updateConsumers.push(
        postConsumer(config, consumer.queue, body).then(() => [
          `Consumer for ${consumer.queue}`
        ])
      );
    } else {
      if (config.name === void 0) {
        throw new UserError(
          "Script name is required to update queue consumers"
        );
      }
      const body = {
        type: "worker",
        dead_letter_queue: consumer.dead_letter_queue,
        script_name: config.name,
        settings: {
          batch_size: consumer.max_batch_size,
          max_retries: consumer.max_retries,
          max_wait_time_ms: consumer.max_batch_timeout ? 1e3 * consumer.max_batch_timeout : void 0,
          max_concurrency: consumer.max_concurrency,
          retry_delay: consumer.retry_delay
        }
      };
      const existingConsumer = queue.consumers.filter(
        (c2) => c2.script === config.name || c2.service === config.name
      ).length > 0;
      const envName = void 0;
      if (existingConsumer) {
        updateConsumers.push(
          putConsumer(config, consumer.queue, config.name, envName, body).then(
            () => [`Consumer for ${consumer.queue}`]
          )
        );
        continue;
      }
      updateConsumers.push(
        postConsumer(config, consumer.queue, body).then(() => [
          `Consumer for ${consumer.queue}`
        ])
      );
    }
  }
  return updateConsumers;
}
__name(updateQueueConsumers, "updateQueueConsumers");
async function noBundleWorker2(entry, rules, outDir) {
  const modules = await findAdditionalModules(entry, rules);
  if (outDir) {
    await writeAdditionalModules(modules, outDir);
  }
  const bundleType = getBundleType(entry.format, entry.file);
  return {
    modules,
    dependencies: {},
    resolvedEntryPointPath: entry.file,
    bundleType
  };
}
__name(noBundleWorker2, "noBundleWorker");

// src/dev/create-worker-preview.ts
init_import_meta_url();
var import_node_url16 = require("node:url");
var import_undici23 = __toESM(require_undici());
function randomId() {
  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c2) {
    const r3 = Math.random() * 16 | 0, v2 = c2 == "x" ? r3 : r3 & 3 | 8;
    return v2.toString(16);
  });
}
__name(randomId, "randomId");
function switchHost(originalUrl, host, zonePreview) {
  const url4 = new import_node_url16.URL(originalUrl);
  url4.hostname = zonePreview ? host ?? url4.hostname : url4.hostname;
  return url4;
}
__name(switchHost, "switchHost");
async function createPreviewSession(account, ctx, abortSignal) {
  const { accountId } = account;
  const initUrl = ctx.zone ? `/zones/${ctx.zone}/workers/edge-preview` : `/accounts/${accountId}/workers/subdomain/edge-preview`;
  const { exchange_url } = await fetchResult(
    initUrl,
    void 0,
    void 0,
    abortSignal
  );
  const switchedExchangeUrl = switchHost(
    exchange_url,
    ctx.host,
    !!ctx.zone
  ).toString();
  logger.debugWithSanitization(
    "-- START EXCHANGE API REQUEST:",
    ` GET ${switchedExchangeUrl}`
  );
  logger.debug("-- END EXCHANGE API REQUEST");
  const exchangeResponse = await (0, import_undici23.fetch)(switchedExchangeUrl, {
    signal: abortSignal
  });
  const bodyText = await exchangeResponse.text();
  logger.debug(
    "-- START EXCHANGE API RESPONSE:",
    exchangeResponse.statusText,
    exchangeResponse.status
  );
  logger.debug("HEADERS:", JSON.stringify(exchangeResponse.headers, null, 2));
  logger.debugWithSanitization("RESPONSE:", bodyText);
  logger.debug("-- END EXCHANGE API RESPONSE");
  try {
    const { inspector_websocket, prewarm, token } = parseJSON(bodyText);
    const inspector = new import_node_url16.URL(inspector_websocket);
    inspector.searchParams.append("cf_workers_preview_token", token);
    return {
      id: randomId(),
      value: token,
      host: ctx.host ?? inspector.host,
      inspectorUrl: switchHost(inspector.href, ctx.host, !!ctx.zone),
      prewarmUrl: switchHost(prewarm, ctx.host, !!ctx.zone)
    };
  } catch (e3) {
    if (!(e3 instanceof ParseError)) {
      throw e3;
    } else {
      throw new UserError(
        `Could not create remote preview session on ${ctx.zone ? ` host \`${ctx.host}\` on zone \`${ctx.zone}\`` : `your account`}.`
      );
    }
  }
}
__name(createPreviewSession, "createPreviewSession");
async function createPreviewToken(account, worker, ctx, session, abortSignal) {
  const { value, host, inspectorUrl, prewarmUrl } = session;
  const { accountId } = account;
  const scriptId = worker.name || (ctx.zone ? session.id : host.split(".")[0]);
  const url4 = ctx.env && !ctx.legacyEnv ? `/accounts/${accountId}/workers/services/${scriptId}/environments/${ctx.env}/edge-preview` : `/accounts/${accountId}/workers/scripts/${scriptId}/edge-preview`;
  const mode = ctx.zone ? {
    routes: ctx.routes ? (
      // extract all the route patterns
      ctx.routes.map((route2) => {
        if (typeof route2 === "string") {
          return route2;
        }
        if (route2.custom_domain) {
          return `${route2.pattern}/*`;
        }
        return route2.pattern;
      })
    ) : (
      // if there aren't any patterns, then just match on all routes
      ["*/*"]
    )
  } : { workers_dev: true };
  const formData = createWorkerUploadForm(worker);
  formData.set("wrangler-session-config", JSON.stringify(mode));
  const { preview_token } = await fetchResult(
    url4,
    {
      method: "POST",
      body: formData,
      headers: {
        "cf-preview-upload-config-token": value
      }
    },
    void 0,
    abortSignal
  );
  return {
    value: preview_token,
    host: ctx.host ?? (worker.name ? `${worker.name}.${host.split(".").slice(1).join(".")}` : host),
    inspectorUrl,
    prewarmUrl
  };
}
__name(createPreviewToken, "createPreviewToken");
async function createWorkerPreview(init3, account, ctx, session, abortSignal) {
  const token = await createPreviewToken(
    account,
    init3,
    ctx,
    session,
    abortSignal
  );
  const accessToken = await getAccessToken(token.prewarmUrl.hostname);
  const headers = { "cf-workers-preview-token": token.value };
  if (accessToken) {
    headers.cookie = `CF_Authorization=${accessToken}`;
  }
  (0, import_undici23.fetch)(token.prewarmUrl.href, {
    method: "POST",
    signal: abortSignal,
    headers
  }).then(
    (response) => {
      if (!response.ok) {
        logger.warn("worker failed to prewarm: ", response.statusText);
      }
    },
    (err) => {
      if (err.code !== "ABORT_ERR") {
        logger.warn("worker failed to prewarm: ", err);
      }
    }
  );
  return token;
}
__name(createWorkerPreview, "createWorkerPreview");

// src/dev/proxy.ts
init_import_meta_url();
var import_node_http3 = require("node:http");
var import_node_http22 = require("node:http2");
var import_node_https = __toESM(require("node:https"));
var import_http_terminator2 = __toESM(require_src5());
var import_miniflare13 = require("miniflare");
var import_react16 = __toESM(require_react());
var import_serve_static = __toESM(require_serve_static());
function addCfPreviewTokenHeader(headers, previewTokenValue) {
  headers["cf-workers-preview-token"] = previewTokenValue;
}
__name(addCfPreviewTokenHeader, "addCfPreviewTokenHeader");
async function addCfAccessToken(headers, domain2, accessTokenRef) {
  if (accessTokenRef.current === null) {
    return;
  }
  if (typeof accessTokenRef.current === "string") {
    headers["cookie"] = `${headers["cookie"]};CF_Authorization=${accessTokenRef.current}`;
    return;
  }
  const token = await getAccessToken(domain2);
  accessTokenRef.current = token;
  if (token)
    headers["cookie"] = `${headers["cookie"]};CF_Authorization=${accessTokenRef.current}`;
}
__name(addCfAccessToken, "addCfAccessToken");
function rewriteRemoteHostToLocalHostInHeaders(headers, remoteHost, localPort, localProtocol) {
  for (const [name, value] of Object.entries(headers)) {
    if (typeof value === "string" && value.includes(remoteHost)) {
      headers[name] = value.replaceAll(
        `https://${remoteHost}`,
        `${localProtocol}://localhost:${localPort}`
      ).replaceAll(remoteHost, `localhost:${localPort}`);
    }
  }
}
__name(rewriteRemoteHostToLocalHostInHeaders, "rewriteRemoteHostToLocalHostInHeaders");
function writeHead(socket, res) {
  socket.write(
    `HTTP/${res.httpVersion} ${res.statusCode} ${res.statusMessage}\r
`
  );
  for (const [key, values] of Object.entries(res.headers)) {
    if (Array.isArray(values)) {
      for (const value of values)
        socket.write(`${key}: ${value}\r
`);
    } else {
      socket.write(`${key}: ${values}\r
`);
    }
  }
  socket.write("\r\n");
}
__name(writeHead, "writeHead");
async function startPreviewServer({
  previewToken,
  assetDirectory,
  localProtocol,
  customHttpsKeyPath,
  customHttpsCertPath,
  localPort: port2,
  ip: ip2,
  onReady
}) {
  try {
    const abortController = new AbortController();
    const server = await createProxyServer(
      localProtocol,
      customHttpsKeyPath,
      customHttpsCertPath
    );
    const proxy2 = {
      server,
      terminator: (0, import_http_terminator2.createHttpTerminator)({
        server,
        gracefulTerminationTimeout: 0
      })
    };
    const streamBufferRef = { current: [] };
    const requestResponseBufferRef = { current: [] };
    const accessTokenRef = { current: void 0 };
    const cleanupListeners = configureProxyServer({
      proxy: proxy2,
      previewToken,
      streamBufferRef,
      requestResponseBufferRef,
      retryServerSetup: () => {
      },
      // no-op outside of React
      assetDirectory,
      localProtocol,
      port: port2,
      accessTokenRef
    });
    await waitForPortToBeAvailable(port2, ip2, {
      retryPeriod: 200,
      timeout: 2e3,
      abortSignal: abortController.signal
    });
    proxy2.server.on("listening", () => {
      const address = proxy2.server.address();
      const usedPort = address && typeof address === "object" ? address.port : port2;
      logger.log(`\u2B23 Listening at ${localProtocol}://${ip2}:${usedPort}`);
      const accessibleHosts = [];
      if (ip2 === "::" || ip2 === "*" || ip2 === "0.0.0.0") {
        accessibleHosts.push(...(0, import_miniflare13.getAccessibleHosts)(true));
        if (ip2 !== "0.0.0.0") {
          accessibleHosts.push("localhost");
          accessibleHosts.push("[::1]");
        }
      }
      for (const accessibleHost of accessibleHosts) {
        logger.log(`- ${localProtocol}://${accessibleHost}:${usedPort}`);
      }
      onReady?.(ip2, usedPort);
    });
    proxy2.server.listen(port2, ip2);
    return {
      stop: () => {
        abortController.abort();
        cleanupListeners?.forEach((cleanup) => cleanup());
      }
    };
  } catch (err) {
    if (err.code !== "ABORT_ERR") {
      logger.error(`Failed to start server: ${err}`);
    }
    logger.error("Failed to create proxy server:", err);
  }
}
__name(startPreviewServer, "startPreviewServer");
function configureProxyServer({
  proxy: proxy2,
  previewToken,
  streamBufferRef,
  requestResponseBufferRef,
  retryServerSetup,
  port: port2,
  localProtocol,
  assetDirectory,
  accessTokenRef
}) {
  if (proxy2 === void 0) {
    return;
  }
  if (!previewToken) {
    const cleanupListeners2 = [];
    const bufferStream = /* @__PURE__ */ __name((stream2, headers) => {
      streamBufferRef.current.push({ stream: stream2, headers });
    }, "bufferStream");
    proxy2.server.on("stream", bufferStream);
    cleanupListeners2.push(() => proxy2.server.off("stream", bufferStream));
    const bufferRequestResponse = /* @__PURE__ */ __name((request3, response) => {
      requestResponseBufferRef.current.push({ request: request3, response });
    }, "bufferRequestResponse");
    proxy2.server.on("request", bufferRequestResponse);
    cleanupListeners2.push(
      () => proxy2.server.off("request", bufferRequestResponse)
    );
    return cleanupListeners2;
  }
  const cleanupListeners = [];
  logger.debug("PREVIEW URL:", `https://${previewToken.host}`);
  const remote = (0, import_node_http22.connect)(`https://${previewToken.host}`);
  cleanupListeners.push(() => remote.destroy());
  remote.on("close", retryServerSetup);
  cleanupListeners.push(() => remote.off("close", retryServerSetup));
  const handleStream = createStreamHandler(
    previewToken,
    remote,
    port2,
    localProtocol,
    accessTokenRef
  );
  proxy2.server.on("stream", handleStream);
  cleanupListeners.push(() => proxy2.server.off("stream", handleStream));
  streamBufferRef.current.forEach(
    (buffer) => handleStream(buffer.stream, buffer.headers)
  );
  streamBufferRef.current = [];
  const handleRequest = /* @__PURE__ */ __name(async (message, response) => {
    const { httpVersionMajor, headers, method, url: url4 } = message;
    if (httpVersionMajor >= 2) {
      return;
    }
    await addCfAccessToken(headers, previewToken.host, accessTokenRef);
    addCfPreviewTokenHeader(headers, previewToken.value);
    headers[":method"] = method;
    headers[":path"] = url4;
    headers[":authority"] = previewToken.host;
    headers[":scheme"] = "https";
    for (const name of Object.keys(headers)) {
      if (HTTP1_HEADERS.has(name.toLowerCase())) {
        delete headers[name];
      }
    }
    const request3 = message.pipe(remote.request(headers));
    logger.debug(
      "WORKER REQUEST",
      (/* @__PURE__ */ new Date()).toLocaleTimeString(),
      method,
      url4
    );
    logger.debugWithSanitization("HEADERS", JSON.stringify(headers, null, 2));
    logger.debugWithSanitization("PREVIEW TOKEN", previewToken);
    request3.on("response", (responseHeaders) => {
      const status2 = responseHeaders[":status"] ?? 500;
      logger.log((/* @__PURE__ */ new Date()).toLocaleTimeString(), method, url4, status2);
      rewriteRemoteHostToLocalHostInHeaders(
        responseHeaders,
        previewToken.host,
        port2,
        localProtocol
      );
      for (const name of Object.keys(responseHeaders)) {
        if (name.startsWith(":")) {
          delete responseHeaders[name];
        }
      }
      response.writeHead(status2, responseHeaders);
      request3.pipe(response, { end: true });
    });
  }, "handleRequest");
  const actualHandleRequest = assetDirectory ? createHandleAssetsRequest(assetDirectory, handleRequest) : handleRequest;
  proxy2.server.on("request", actualHandleRequest);
  cleanupListeners.push(() => proxy2.server.off("request", actualHandleRequest));
  requestResponseBufferRef.current.forEach(
    ({
      request: request3,
      response
    }) => actualHandleRequest(request3, response)
  );
  requestResponseBufferRef.current = [];
  const handleUpgrade = /* @__PURE__ */ __name(async (originalMessage, originalSocket, originalHead) => {
    const { headers, method, url: url4 } = originalMessage;
    await addCfAccessToken(headers, previewToken.host, accessTokenRef);
    addCfPreviewTokenHeader(headers, previewToken.value);
    headers["host"] = previewToken.host;
    if (originalHead?.byteLength)
      originalSocket.unshift(originalHead);
    const runtimeRequest = import_node_https.default.request(
      {
        hostname: previewToken.host,
        path: url4,
        method,
        headers
      },
      (runtimeResponse) => {
        if (!runtimeResponse.upgrade) {
          writeHead(originalSocket, runtimeResponse);
          runtimeResponse.pipe(originalSocket);
        }
      }
    );
    runtimeRequest.on(
      "upgrade",
      (runtimeResponse, runtimeSocket, runtimeHead) => {
        if (runtimeHead?.byteLength)
          runtimeSocket.unshift(runtimeHead);
        writeHead(originalSocket, {
          httpVersion: "1.1",
          statusCode: 101,
          statusMessage: "Switching Protocols",
          headers: runtimeResponse.headers
        });
        runtimeSocket.pipe(originalSocket).pipe(runtimeSocket);
      }
    );
    originalMessage.pipe(runtimeRequest);
  }, "handleUpgrade");
  proxy2.server.on("upgrade", handleUpgrade);
  cleanupListeners.push(() => proxy2.server.off("upgrade", handleUpgrade));
  return cleanupListeners;
}
__name(configureProxyServer, "configureProxyServer");
function createHandleAssetsRequest(assetDirectory, handleRequest) {
  const handleAsset = (0, import_serve_static.default)(assetDirectory, {
    cacheControl: false
  });
  return (request3, response) => {
    handleAsset(request3, response, () => {
      handleRequest(request3, response);
    });
  };
}
__name(createHandleAssetsRequest, "createHandleAssetsRequest");
var HTTP1_HEADERS = /* @__PURE__ */ new Set([
  "host",
  "connection",
  "upgrade",
  "keep-alive",
  "proxy-connection",
  "transfer-encoding",
  "http2-settings"
]);
async function createProxyServer(localProtocol, customHttpsKeyPath, customHttpsCertPath) {
  const server = localProtocol === "https" ? (0, import_node_https.createServer)(
    await getHttpsOptions(customHttpsKeyPath, customHttpsCertPath)
  ) : (0, import_node_http3.createServer)();
  return server.on("upgrade", (req) => {
    logger.log(
      (/* @__PURE__ */ new Date()).toLocaleTimeString(),
      req.method,
      req.url,
      101,
      "(WebSocket)"
    );
  }).on("error", (err) => {
    logger.error((/* @__PURE__ */ new Date()).toLocaleTimeString(), err);
  });
}
__name(createProxyServer, "createProxyServer");
function createStreamHandler(previewToken, remote, localPort, localProtocol, accessTokenRef) {
  return /* @__PURE__ */ __name(async function handleStream(stream2, headers) {
    await addCfAccessToken(headers, previewToken.host, accessTokenRef);
    addCfPreviewTokenHeader(headers, previewToken.value);
    headers[":authority"] = previewToken.host;
    const request3 = stream2.pipe(remote.request(headers));
    request3.on("response", (responseHeaders) => {
      rewriteRemoteHostToLocalHostInHeaders(
        responseHeaders,
        previewToken.host,
        localPort,
        localProtocol
      );
      stream2.respond(responseHeaders);
      request3.pipe(stream2, { end: true });
    });
  }, "handleStream");
}
__name(createStreamHandler, "createStreamHandler");
async function waitForPortToBeAvailable(port2, host, options29) {
  return new Promise((resolve19, reject) => {
    if (host === "*") {
      host = "0.0.0.0";
    }
    options29.abortSignal.addEventListener("abort", () => {
      const abortError = new Error("waitForPortToBeAvailable() aborted");
      abortError.code = "ABORT_ERR";
      doReject(abortError);
    });
    const timeout = setTimeout(() => {
      doReject(new Error(`Timed out waiting for port ${port2}`));
    }, options29.timeout);
    const interval2 = setInterval(checkPort, options29.retryPeriod);
    checkPort();
    function doResolve() {
      clearTimeout(timeout);
      clearInterval(interval2);
      resolve19();
    }
    __name(doResolve, "doResolve");
    function doReject(err) {
      clearInterval(interval2);
      clearTimeout(timeout);
      reject(err);
    }
    __name(doReject, "doReject");
    function checkPort() {
      if (port2 === 0) {
        doResolve();
        return;
      }
      const server = (0, import_node_http3.createServer)();
      const terminator = (0, import_http_terminator2.createHttpTerminator)({
        server,
        gracefulTerminationTimeout: 0
        // default 1000
      });
      server.on("error", (err) => {
        if (err.code !== "EADDRINUSE") {
          doReject(err);
        }
      });
      server.listen(
        port2,
        host,
        () => terminator.terminate().then(
          doResolve,
          () => logger.error("Failed to terminate the port checker.")
        )
      );
    }
    __name(checkPort, "checkPort");
  });
}
__name(waitForPortToBeAvailable, "waitForPortToBeAvailable");

// src/dev/remote.tsx
function Remote(props) {
  const [accountId, setAccountId] = (0, import_react17.useState)(props.accountId);
  const accountChoicesRef = (0, import_react17.useRef)();
  const [accountChoices, setAccountChoices] = (0, import_react17.useState)();
  useWorker({
    name: props.name,
    bundle: props.bundle,
    format: props.format,
    modules: props.bundle ? props.bundle.modules : [],
    accountId,
    bindings: props.bindings,
    assetPaths: props.assetPaths,
    isWorkersSite: props.isWorkersSite,
    compatibilityDate: props.compatibilityDate,
    compatibilityFlags: props.compatibilityFlags,
    usageModel: props.usageModel,
    env: props.env,
    legacyEnv: props.legacyEnv,
    host: props.host,
    routes: props.routes,
    onReady: props.onReady,
    sendMetrics: props.sendMetrics,
    port: props.port
  });
  const errorHandler = useErrorHandler();
  (0, import_react17.useEffect)(() => {
    if (accountChoicesRef.current !== void 0 || props.accountId !== void 0) {
      return;
    }
    accountChoicesRef.current = getAccountChoices();
    accountChoicesRef.current.then(
      (accounts) => {
        if (accounts.length === 1) {
          saveAccountToCache({
            id: accounts[0].id,
            name: accounts[0].name
          });
          setAccountId(accounts[0].id);
        } else {
          setAccountChoices(accounts);
        }
      },
      (err) => {
        errorHandler(err);
      }
    );
  });
  return accountId === void 0 && accountChoices !== void 0 ? /* @__PURE__ */ import_react17.default.createElement(
    ChooseAccount,
    {
      accounts: accountChoices,
      onSelect: (selectedAccount) => {
        saveAccountToCache(selectedAccount);
        setAccountId(selectedAccount.id);
      },
      onError: (err) => errorHandler(err)
    }
  ) : null;
}
__name(Remote, "Remote");
function useWorker(props) {
  const [session, setSession] = (0, import_react17.useState)();
  const [token, setToken] = (0, import_react17.useState)();
  const [restartCounter, setRestartCounter] = (0, import_react17.useState)(0);
  const startedRef = (0, import_react17.useRef)(false);
  const { onReady } = props;
  (0, import_react17.useEffect)(() => {
    const abortController = new AbortController();
    async function start() {
      if (props.accountId === void 0) {
        return;
      }
      const { workerAccount, workerContext } = await getWorkerAccountAndContext(
        {
          accountId: props.accountId,
          env: props.env,
          legacyEnv: props.legacyEnv,
          host: props.host,
          routes: props.routes,
          sendMetrics: props.sendMetrics
        }
      );
      setSession(
        await createPreviewSession(
          workerAccount,
          workerContext,
          abortController.signal
        )
      );
    }
    __name(start, "start");
    start().catch((err) => {
      if (err.code === 10063) {
        const errorMessage = "Error: You need to register a workers.dev subdomain before running the dev command in remote mode";
        const solutionMessage = "You can either enable local mode by pressing l, or register a workers.dev subdomain here:";
        const onboardingLink = `https://dash.cloudflare.com/${props.accountId}/workers/onboarding`;
        logger.error(`${errorMessage}
${solutionMessage}
${onboardingLink}`);
      } else if (err.cause?.code === "ENOTFOUND") {
        logger.error(
          `Could not access \`${err.cause.hostname}\`. Make sure the domain is set up to be proxied by Cloudflare.
For more details, refer to https://developers.cloudflare.com/workers/configuration/routing/routes/#set-up-a-route`
        );
      } else if (err instanceof UserError) {
        logger.error(err.message);
      } else if (err.code !== "ABORT_ERR") {
        logger.error("Error while creating remote dev session:", err);
      }
    });
    return () => {
      abortController.abort();
    };
  }, [
    props.accountId,
    props.env,
    props.host,
    props.legacyEnv,
    props.routes,
    props.sendMetrics,
    restartCounter
  ]);
  (0, import_react17.useEffect)(() => {
    const abortController = new AbortController();
    async function start() {
      if (props.accountId === void 0) {
        return;
      }
      if (session === void 0) {
        return;
      }
      setToken(void 0);
      if (!props.bundle || !props.format)
        return;
      if (!startedRef.current) {
        startedRef.current = true;
      } else {
        logger.log("\u2394 Detected changes, restarted server.");
      }
      const init3 = await createRemoteWorkerInit({
        bundle: props.bundle,
        modules: props.modules,
        accountId: props.accountId,
        name: props.name,
        legacyEnv: props.legacyEnv,
        env: props.env,
        isWorkersSite: props.isWorkersSite,
        assetPaths: props.assetPaths,
        format: props.format,
        bindings: props.bindings,
        compatibilityDate: props.compatibilityDate,
        compatibilityFlags: props.compatibilityFlags,
        usageModel: props.usageModel
      });
      const { workerAccount, workerContext } = await getWorkerAccountAndContext(
        {
          accountId: props.accountId,
          env: props.env,
          legacyEnv: props.legacyEnv,
          host: props.host,
          routes: props.routes,
          sendMetrics: props.sendMetrics
        }
      );
      const workerPreviewToken = await createWorkerPreview(
        init3,
        workerAccount,
        workerContext,
        session,
        abortController.signal
      );
      setToken(workerPreviewToken);
      const accessToken = await getAccessToken(workerPreviewToken.host);
      const proxyData = {
        userWorkerUrl: {
          protocol: "https:",
          hostname: workerPreviewToken.host,
          port: "443"
        },
        userWorkerInspectorUrl: {
          protocol: workerPreviewToken.inspectorUrl.protocol,
          hostname: workerPreviewToken.inspectorUrl.hostname,
          port: workerPreviewToken.inspectorUrl.port.toString(),
          pathname: workerPreviewToken.inspectorUrl.pathname
        },
        userWorkerInnerUrlOverrides: {
          hostname: props.host ?? getInferredHost(props.routes),
          port: props.port.toString()
        },
        headers: {
          "cf-workers-preview-token": workerPreviewToken.value,
          ...accessToken ? { Cookie: `CF_Authorization=${accessToken}` } : {}
        },
        liveReload: false,
        // liveReload currently disabled in remote-mode, but will be supported with startDevWorker
        proxyLogsToController: true,
        entrypointAddresses: void 0
      };
      onReady?.(
        props.host ?? getInferredHost(props.routes) ?? "localhost",
        props.port,
        proxyData
      );
    }
    __name(start, "start");
    start().catch((err) => {
      if (err.code !== "ABORT_ERR") {
        if (err.code === 10049) {
          logger.log("Preview token expired, fetching a new one");
          setRestartCounter((prevCount) => prevCount + 1);
        } else if (!handleUserFriendlyError(err, props.accountId)) {
          logger.error("Error on remote worker:", err);
        }
      }
    });
    return () => {
      abortController.abort();
    };
  }, [
    props.name,
    props.bundle,
    props.format,
    props.accountId,
    props.assetPaths,
    props.isWorkersSite,
    props.compatibilityDate,
    props.compatibilityFlags,
    props.usageModel,
    props.bindings,
    props.modules,
    props.env,
    props.legacyEnv,
    props.host,
    props.routes,
    session,
    onReady,
    props.sendMetrics,
    props.port
  ]);
  return token;
}
__name(useWorker, "useWorker");
async function startRemoteServer(props) {
  let accountId = props.accountId;
  if (accountId === void 0) {
    const accountChoices = await getAccountChoices();
    if (accountChoices.length === 1) {
      saveAccountToCache({
        id: accountChoices[0].id,
        name: accountChoices[0].name
      });
      accountId = accountChoices[0].id;
    } else {
      const error2 = new UserError(
        "In a non-interactive environment, it is mandatory to specify an account ID, either by assigning its value to CLOUDFLARE_ACCOUNT_ID, or as `account_id` in your `wrangler.toml` file."
      );
      logger.error(error2.message);
      throw error2;
    }
  }
  const previewToken = await getRemotePreviewToken({
    ...props,
    accountId
  });
  if (previewToken === void 0) {
    const error2 = new Error("Failed to get a previewToken");
    logger.error(error2.message);
    throw error2;
  }
  const previewServer = await startPreviewServer({
    previewToken,
    assetDirectory: props.isWorkersSite ? void 0 : props.assetPaths?.assetDirectory,
    localProtocol: props.localProtocol,
    customHttpsKeyPath: props.httpsKeyPath,
    customHttpsCertPath: props.httpsCertPath,
    localPort: props.port,
    ip: props.ip,
    onReady: async (ip2, port2) => {
      const accessToken = await getAccessToken(previewToken.host);
      const proxyData = {
        userWorkerUrl: {
          protocol: "https:",
          hostname: previewToken.host,
          port: "443"
        },
        userWorkerInspectorUrl: {
          protocol: previewToken.inspectorUrl.protocol,
          hostname: previewToken.inspectorUrl.hostname,
          port: previewToken.inspectorUrl.port.toString(),
          pathname: previewToken.inspectorUrl.pathname
        },
        userWorkerInnerUrlOverrides: {
          hostname: props.host,
          port: props.port.toString()
        },
        headers: {
          "cf-workers-preview-token": previewToken.value,
          ...accessToken ? { Cookie: `CF_Authorization=${accessToken}` } : {}
        },
        liveReload: false,
        // liveReload currently disabled in remote-mode, but will be supported with startDevWorker
        proxyLogsToController: true,
        entrypointAddresses: void 0
      };
      props.onReady?.(ip2, port2, proxyData);
    }
  });
  if (!previewServer) {
    const error2 = new Error("Failed to start remote server");
    logger.error(error2);
    throw error2;
  }
  return { stop: previewServer.stop };
}
__name(startRemoteServer, "startRemoteServer");
async function getRemotePreviewToken(props) {
  async function start() {
    if (props.accountId === void 0) {
      const error2 = new Error("no accountId provided");
      logger.error(error2.message);
      throw error2;
    }
    const abortController = new AbortController();
    const { workerAccount, workerContext } = await getWorkerAccountAndContext({
      accountId: props.accountId,
      env: props.env,
      legacyEnv: props.legacyEnv,
      host: props.host,
      routes: props.routes,
      sendMetrics: props.sendMetrics
    });
    const session = await createPreviewSession(
      workerAccount,
      workerContext,
      abortController.signal
    );
    if (session === void 0) {
      const error2 = new Error("Failed to start a session");
      logger.error(error2.message);
      throw error2;
    }
    if (!props.bundle || !props.format)
      return;
    const init3 = await createRemoteWorkerInit({
      bundle: props.bundle,
      modules: props.bundle ? props.bundle.modules : [],
      accountId: props.accountId,
      name: props.name,
      legacyEnv: props.legacyEnv,
      env: props.env,
      isWorkersSite: props.isWorkersSite,
      assetPaths: props.assetPaths,
      format: props.format,
      bindings: props.bindings,
      compatibilityDate: props.compatibilityDate,
      compatibilityFlags: props.compatibilityFlags,
      usageModel: props.usageModel
    });
    const workerPreviewToken = await createWorkerPreview(
      init3,
      workerAccount,
      workerContext,
      session,
      abortController.signal
    );
    return workerPreviewToken;
  }
  __name(start, "start");
  return start().catch((err) => {
    if (err?.code !== "ABORT_ERR") {
      if (err.code === 10049) {
        logger.log("Preview token expired, restart server to fetch a new one");
      } else if (!handleUserFriendlyError(err, props.accountId)) {
        helpIfErrorIsSizeOrScriptStartup2(err, props.bundle?.dependencies || {});
        logger.error("Error on remote worker:", err);
      }
    }
  });
}
__name(getRemotePreviewToken, "getRemotePreviewToken");
async function createRemoteWorkerInit(props) {
  const { entrypointSource: content, modules } = withSourceURLs(
    props.bundle.path,
    props.modules
  );
  void printBundleSize(
    { name: import_node_path54.default.basename(props.bundle.path), content },
    props.modules
  );
  const assets = await syncAssets(
    props.accountId,
    // When we're using the newer service environments, we wouldn't
    // have added the env name on to the script name. However, we must
    // include it in the kv namespace name regardless (since there's no
    // concept of service environments for kv namespaces yet).
    props.name + (!props.legacyEnv && props.env ? `-${props.env}` : ""),
    props.isWorkersSite ? props.assetPaths : void 0,
    true,
    false,
    void 0
  );
  if (assets.manifest) {
    modules.push({
      name: "__STATIC_CONTENT_MANIFEST",
      filePath: void 0,
      content: JSON.stringify(assets.manifest),
      type: "text"
    });
  }
  const init3 = {
    name: props.name,
    main: {
      name: import_node_path54.default.basename(props.bundle.path),
      filePath: props.bundle.path,
      type: getBundleType(props.format, import_node_path54.default.basename(props.bundle.path)),
      content
    },
    modules,
    bindings: {
      ...props.bindings,
      kv_namespaces: (props.bindings.kv_namespaces || []).concat(
        assets.namespace ? { binding: "__STATIC_CONTENT", id: assets.namespace } : []
      ),
      text_blobs: {
        ...props.bindings.text_blobs,
        ...assets.manifest && props.format === "service-worker" && {
          __STATIC_CONTENT_MANIFEST: "__STATIC_CONTENT_MANIFEST"
        }
      }
    },
    migrations: void 0,
    // no migrations in dev
    compatibility_date: props.compatibilityDate,
    compatibility_flags: props.compatibilityFlags,
    usage_model: props.usageModel,
    keepVars: true,
    keepSecrets: true,
    logpush: false,
    sourceMaps: void 0,
    placement: void 0,
    // no placement in dev
    tail_consumers: void 0,
    // no tail consumers in dev - TODO revisit?
    limits: void 0
    // no limits in preview - not supported yet but can be added
  };
  return init3;
}
__name(createRemoteWorkerInit, "createRemoteWorkerInit");
async function getWorkerAccountAndContext(props) {
  const workerAccount = {
    accountId: props.accountId,
    apiToken: requireApiToken()
  };
  const zoneId = await getZoneIdForPreview(props.host, props.routes);
  const workerContext = {
    env: props.env,
    legacyEnv: props.legacyEnv,
    zone: zoneId,
    host: props.host ?? getInferredHost(props.routes),
    routes: props.routes,
    sendMetrics: props.sendMetrics
  };
  return { workerAccount, workerContext };
}
__name(getWorkerAccountAndContext, "getWorkerAccountAndContext");
function ChooseAccount(props) {
  return /* @__PURE__ */ import_react17.default.createElement(import_react17.default.Fragment, null, /* @__PURE__ */ import_react17.default.createElement(import_ink11.Text, { bold: true }, "Select an account from below:"), /* @__PURE__ */ import_react17.default.createElement(
    import_ink_select_input3.default,
    {
      items: props.accounts.map((item) => ({
        key: item.id,
        label: item.name,
        value: item
      })),
      onSelect: (item) => {
        logger.log(`Using account: "${item.value.name} - ${item.value.id}"`);
        props.onSelect({ id: item.value.id, name: item.value.name });
      }
    }
  ));
}
__name(ChooseAccount, "ChooseAccount");
function handleUserFriendlyError(error2, accountId) {
  switch (error2.code) {
    case 10021: {
      if (error2.notes[0].text === "binding DB of type d1 must have a valid `id` specified [code: 10021]") {
        const errorMessage = "Error: You must use a real database in the preview_database_id configuration.";
        const solutionMessage = "You can find your databases using 'wrangler d1 list', or read how to develop locally with D1 here:";
        const documentationLink = `https://developers.cloudflare.com/d1/configuration/local-development`;
        logger.error(
          `${errorMessage}
${solutionMessage}
${documentationLink}`
        );
        return true;
      }
      return false;
    }
    case 10063: {
      const errorMessage = "Error: You need to register a workers.dev subdomain before running the dev command in remote mode";
      const solutionMessage = "You can either enable local mode by pressing l, or register a workers.dev subdomain here:";
      const onboardingLink = accountId ? `https://dash.cloudflare.com/${accountId}/workers/onboarding` : "https://dash.cloudflare.com/?to=/:account/workers/onboarding";
      logger.error(`${errorMessage}
${solutionMessage}
${onboardingLink}`);
      return true;
    }
    default: {
      return false;
    }
  }
}
__name(handleUserFriendlyError, "handleUserFriendlyError");

// src/dev/use-esbuild.ts
init_import_meta_url();
var import_node_assert18 = __toESM(require("node:assert"));
var import_node_path55 = __toESM(require("node:path"));
var import_chokidar3 = require("chokidar");
var import_ink12 = __toESM(require_build2());
var import_react18 = __toESM(require_react());
function useEsbuild({
  entry,
  destination,
  jsxFactory,
  jsxFragment,
  processEntrypoint,
  additionalModules,
  rules,
  assets,
  serveAssetsFromWorker,
  tsconfig,
  minify,
  legacyNodeCompat,
  nodejsCompat,
  define: define2,
  noBundle,
  findAdditionalModules: findAdditionalModules2,
  workerDefinitions,
  services,
  durableObjects,
  local,
  targetConsumer,
  testScheduled,
  experimentalLocal,
  projectRoot,
  onStart,
  defineNavigatorUserAgent
}) {
  const [bundle, setBundle] = (0, import_react18.useState)();
  const { exit: exit6 } = (0, import_ink12.useApp)();
  (0, import_react18.useEffect)(() => {
    let stopWatching = void 0;
    const entryDirectory = import_node_path55.default.dirname(entry.file);
    const moduleCollector = noBundle ? noopModuleCollector : createModuleCollector({
      wrangler1xLegacyModuleReferences: getWrangler1xLegacyModuleReferences(
        entryDirectory,
        entry.file
      ),
      entry,
      findAdditionalModules: findAdditionalModules2 ?? false,
      rules
    });
    async function getAdditionalModules() {
      return noBundle ? dedupeModulesByName([
        ...await findAdditionalModules(entry, rules) ?? [],
        ...additionalModules
      ]) : additionalModules;
    }
    __name(getAdditionalModules, "getAdditionalModules");
    async function updateBundle() {
      const newAdditionalModules = await getAdditionalModules();
      setBundle((previousBundle) => {
        (0, import_node_assert18.default)(
          previousBundle,
          "Rebuild triggered with no previous build available"
        );
        previousBundle.modules = dedupeModulesByName([
          ...moduleCollector?.modules ?? [],
          ...newAdditionalModules
        ]);
        return { ...previousBundle, id: previousBundle.id + 1 };
      });
    }
    __name(updateBundle, "updateBundle");
    let bundled = false;
    const onEnd = {
      name: "on-end",
      setup(b2) {
        b2.onStart(() => {
          onStart();
        });
        b2.onEnd(async (result) => {
          const errors = result.errors;
          const warnings = result.warnings;
          if (errors.length > 0) {
            if (!legacyNodeCompat)
              rewriteNodeCompatBuildFailure(result.errors);
            logBuildFailure(errors, warnings);
            return;
          }
          if (warnings.length > 0) {
            logBuildWarnings(warnings);
          }
          if (!bundled) {
            bundled = true;
          } else {
            await updateBundle();
          }
        });
      }
    };
    async function build5() {
      if (!destination)
        return;
      const newAdditionalModules = await getAdditionalModules();
      const bundleResult = processEntrypoint || !noBundle ? await bundleWorker(entry, destination, {
        bundle: !noBundle,
        moduleCollector,
        additionalModules: newAdditionalModules,
        serveAssetsFromWorker,
        jsxFactory,
        jsxFragment,
        watch: true,
        tsconfig,
        minify,
        legacyNodeCompat,
        nodejsCompat,
        doBindings: durableObjects.bindings,
        define: define2,
        checkFetch: true,
        assets,
        // disable the cache in dev
        bypassAssetCache: true,
        targetConsumer,
        testScheduled,
        plugins: [onEnd],
        local,
        projectRoot,
        defineNavigatorUserAgent
      }) : void 0;
      stopWatching = bundleResult?.stop;
      if (noBundle) {
        const watching = [import_node_path55.default.resolve(entry.moduleRoot)];
        const watchPythonRequirements = getBundleType(entry.format, entry.file) === "python" ? import_node_path55.default.resolve(entry.directory, "requirements.txt") : void 0;
        if (watchPythonRequirements) {
          watching.push(watchPythonRequirements);
        }
        const watcher = (0, import_chokidar3.watch)(watching, {
          persistent: true,
          ignored: [".git", "node_modules"]
        }).on("change", async (_event) => {
          await updateBundle();
        });
        stopWatching = /* @__PURE__ */ __name(() => {
          void watcher.close();
        }, "stopWatching");
      }
      setBundle({
        id: 0,
        entry,
        path: bundleResult?.resolvedEntryPointPath ?? entry.file,
        type: bundleResult?.bundleType ?? getBundleType(entry.format, entry.file),
        modules: bundleResult ? bundleResult.modules : newAdditionalModules,
        dependencies: bundleResult?.dependencies ?? {},
        sourceMapPath: bundleResult?.sourceMapPath,
        sourceMapMetadata: bundleResult?.sourceMapMetadata
      });
    }
    __name(build5, "build");
    build5().catch((err) => {
      exit6(err);
    });
    return () => {
      stopWatching?.();
    };
  }, [
    entry,
    destination,
    jsxFactory,
    jsxFragment,
    serveAssetsFromWorker,
    processEntrypoint,
    additionalModules,
    rules,
    tsconfig,
    exit6,
    noBundle,
    findAdditionalModules2,
    minify,
    legacyNodeCompat,
    nodejsCompat,
    define2,
    assets,
    services,
    durableObjects,
    workerDefinitions,
    local,
    targetConsumer,
    testScheduled,
    experimentalLocal,
    projectRoot,
    onStart,
    defineNavigatorUserAgent
  ]);
  return bundle;
}
__name(useEsbuild, "useEsbuild");

// src/dev/validate-dev-props.ts
init_import_meta_url();
function validateDevProps(props) {
  if (!props.isWorkersSite && props.assetPaths && props.entry.format === "service-worker") {
    throw new UserError(
      "You cannot use the service-worker format with an `assets` directory yet. For information on how to migrate to the module-worker format, see: https://developers.cloudflare.com/workers/learning/migrating-to-module-workers/"
    );
  }
  if (props.bindings.wasm_modules && props.entry.format === "modules") {
    throw new UserError(
      "You cannot configure [wasm_modules] with an ES module worker. Instead, import the .wasm module directly in your code"
    );
  }
  if (props.bindings.text_blobs && props.entry.format === "modules") {
    throw new UserError(
      "You cannot configure [text_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure `[rules]` in your wrangler.toml"
    );
  }
  if (props.bindings.data_blobs && props.entry.format === "modules") {
    throw new UserError(
      "You cannot configure [data_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure `[rules]` in your wrangler.toml"
    );
  }
  if (props.compatibilityFlags?.includes("nodejs_compat") && props.legacyNodeCompat) {
    throw new UserError(
      "You cannot use the `nodejs_compat` compatibility flag in conjunction with the legacy `--node-compat` flag. If you want to use the new runtime Node.js compatibility features, please remove the `--node-compat` argument from your CLI command or your config file."
    );
  }
}
__name(validateDevProps, "validateDevProps");

// src/dev/dev.tsx
function useDevRegistry(name, services, durableObjects, mode) {
  const [workers, setWorkers] = (0, import_react19.useState)({});
  const hasFailedToFetch = (0, import_react19.useRef)(false);
  (0, import_react19.useEffect)(() => {
    startWorkerRegistry().catch((err) => {
      logger.error("failed to start worker registry", err);
    });
    const interval2 = (
      // TODO: enable this for remote mode as well
      // https://github.com/cloudflare/workers-sdk/issues/1182
      mode === "local" ? setInterval(() => {
        getBoundRegisteredWorkers({
          name,
          services,
          durableObjects
        }).then(
          (boundRegisteredWorkers) => {
            setWorkers((prevWorkers) => {
              if (!util2.isDeepStrictEqual(boundRegisteredWorkers, prevWorkers)) {
                return boundRegisteredWorkers || {};
              }
              return prevWorkers;
            });
          },
          (err) => {
            if (!hasFailedToFetch.current) {
              hasFailedToFetch.current = true;
              logger.warn("Failed to get worker definitions", err);
            }
          }
        );
      }, 300) : void 0
    );
    return () => {
      interval2 && clearInterval(interval2);
      Promise.allSettled([
        name ? unregisterWorker(name) : Promise.resolve(),
        stopWorkerRegistry()
      ]).then(
        ([unregisterResult, stopRegistryResult]) => {
          if (unregisterResult.status === "rejected") {
            logger.error(
              "Failed to unregister worker",
              unregisterResult.reason
            );
          }
          if (stopRegistryResult.status === "rejected") {
            logger.error(
              "Failed to stop worker registry",
              stopRegistryResult.reason
            );
          }
        },
        (err) => {
          logger.error("Failed to clear dev registry effect", err);
        }
      );
    };
  }, [name, services, durableObjects, mode]);
  return workers;
}
__name(useDevRegistry, "useDevRegistry");
function DevImplementation(props) {
  validateDevProps(props);
  const { isRawModeSupported } = (0, import_ink13.useStdin)();
  return props.showInteractiveDevSession ?? isRawModeSupported ? /* @__PURE__ */ import_react19.default.createElement(InteractiveDevSession, { ...props }) : /* @__PURE__ */ import_react19.default.createElement(DevSession, { ...props, local: props.initialMode === "local" });
}
__name(DevImplementation, "DevImplementation");
var ip;
var port;
var portUsable = false;
var portUsablePromiseResolve;
var portUsablePromise = new Promise(
  (resolve19) => portUsablePromiseResolve = resolve19
);
var blockBrowserOpen = false;
function InteractiveDevSession(props) {
  const toggles = useHotkeys({
    initial: {
      local: props.initialMode === "local",
      tunnel: false
    },
    inspectorPort: props.inspectorPort,
    inspect: props.inspect,
    localProtocol: props.localProtocol,
    forceLocal: props.forceLocal,
    worker: props.name
  });
  ip = props.initialIp;
  port = props.initialPort;
  useTunnel(toggles.tunnel);
  const onReady = /* @__PURE__ */ __name((newIp, newPort, proxyData) => {
    portUsable = true;
    portUsablePromiseResolve();
    ip = newIp;
    port = newPort;
    props.onReady?.(newIp, newPort, proxyData);
  }, "onReady");
  return /* @__PURE__ */ import_react19.default.createElement(import_react19.default.Fragment, null, /* @__PURE__ */ import_react19.default.createElement(DevSession, { ...props, local: toggles.local, onReady }), /* @__PURE__ */ import_react19.default.createElement(import_ink13.Box, { borderStyle: "round", paddingLeft: 1, paddingRight: 1 }, /* @__PURE__ */ import_react19.default.createElement(import_ink13.Text, { bold: true }, "[b]"), /* @__PURE__ */ import_react19.default.createElement(import_ink13.Text, null, " open a browser, "), props.inspect ? /* @__PURE__ */ import_react19.default.createElement(import_react19.default.Fragment, null, /* @__PURE__ */ import_react19.default.createElement(import_ink13.Text, { bold: true }, "[d]"), /* @__PURE__ */ import_react19.default.createElement(import_ink13.Text, null, " open Devtools, ")) : null, !props.forceLocal ? /* @__PURE__ */ import_react19.default.createElement(import_react19.default.Fragment, null, /* @__PURE__ */ import_react19.default.createElement(import_ink13.Text, { bold: true }, "[l]"), /* @__PURE__ */ import_react19.default.createElement(import_ink13.Text, null, " ", toggles.local ? "turn off" : "turn on", " local mode, ")) : null, /* @__PURE__ */ import_react19.default.createElement(import_ink13.Text, { bold: true }, "[c]"), /* @__PURE__ */ import_react19.default.createElement(import_ink13.Text, null, " clear console, "), /* @__PURE__ */ import_react19.default.createElement(import_ink13.Text, { bold: true }, "[x]"), /* @__PURE__ */ import_react19.default.createElement(import_ink13.Text, null, " to exit")));
}
__name(InteractiveDevSession, "InteractiveDevSession");
function DevSession(props) {
  const [devEnv] = (0, import_react19.useState)(() => new DevEnv());
  (0, import_react19.useEffect)(() => {
    return () => {
      void devEnv.teardown();
    };
  }, [devEnv]);
  const startDevWorkerOptions = (0, import_react19.useMemo)(
    () => ({
      name: props.name ?? "worker",
      script: { contents: "" },
      dev: {
        server: {
          hostname: props.initialIp,
          port: props.initialPort,
          secure: props.localProtocol === "https",
          httpsKeyPath: props.httpsKeyPath,
          httpsCertPath: props.httpsCertPath
        },
        inspector: {
          port: props.inspectorPort
        },
        urlOverrides: {
          secure: props.localProtocol === "https",
          hostname: props.localUpstream
        },
        liveReload: props.liveReload
      }
    }),
    [
      props.name,
      props.initialIp,
      props.initialPort,
      props.localProtocol,
      props.httpsKeyPath,
      props.httpsCertPath,
      props.localUpstream,
      props.inspectorPort,
      props.liveReload
    ]
  );
  const onBundleStart = (0, import_react19.useCallback)(() => {
    devEnv.proxy.onBundleStart({
      type: "bundleStart",
      config: startDevWorkerOptions
    });
  }, [devEnv, startDevWorkerOptions]);
  const esbuildStartTimeoutRef = (0, import_react19.useRef)();
  const latestReloadCompleteEvent = (0, import_react19.useRef)();
  const bundle = (0, import_react19.useRef)();
  const onCustomBuildEnd = (0, import_react19.useCallback)(() => {
    const TIMEOUT = 300;
    clearTimeout(esbuildStartTimeoutRef.current);
    esbuildStartTimeoutRef.current = setTimeout(() => {
      if (latestReloadCompleteEvent.current) {
        devEnv.proxy.onReloadComplete(latestReloadCompleteEvent.current);
      }
    }, TIMEOUT);
    return () => {
      clearTimeout(esbuildStartTimeoutRef.current);
    };
  }, [devEnv, latestReloadCompleteEvent]);
  const onEsbuildStart = (0, import_react19.useCallback)(() => {
    clearTimeout(esbuildStartTimeoutRef.current);
    onBundleStart();
  }, [esbuildStartTimeoutRef, onBundleStart]);
  const onReloadStart = (0, import_react19.useCallback)(
    (esbuildBundle) => {
      devEnv.proxy.onReloadStart({
        type: "reloadStart",
        config: startDevWorkerOptions,
        bundle: esbuildBundle
      });
    },
    [devEnv, startDevWorkerOptions]
  );
  useCustomBuild(props.entry, props.build, onBundleStart, onCustomBuildEnd);
  const directory = useTmpDir(props.projectRoot);
  const workerDefinitions = useDevRegistry(
    props.name,
    props.bindings.services,
    props.bindings.durable_objects,
    props.local ? "local" : "remote"
  );
  (0, import_react19.useEffect)(() => {
    devEnv.proxy.onConfigUpdate({
      type: "configUpdate",
      config: startDevWorkerOptions
    });
  }, [devEnv, startDevWorkerOptions]);
  bundle.current = useEsbuild({
    entry: props.entry,
    destination: directory,
    jsxFactory: props.jsxFactory,
    processEntrypoint: props.processEntrypoint,
    additionalModules: props.additionalModules,
    rules: props.rules,
    jsxFragment: props.jsxFragment,
    serveAssetsFromWorker: Boolean(
      props.assetPaths && !props.isWorkersSite && props.local
    ),
    tsconfig: props.tsconfig,
    minify: props.minify,
    legacyNodeCompat: props.legacyNodeCompat,
    nodejsCompat: props.nodejsCompat,
    define: props.define,
    noBundle: props.noBundle,
    findAdditionalModules: props.findAdditionalModules,
    assets: props.assetsConfig,
    workerDefinitions,
    services: props.bindings.services,
    durableObjects: props.bindings.durable_objects || { bindings: [] },
    local: props.local,
    // Enable the bundling to know whether we are using dev or deploy
    targetConsumer: "dev",
    testScheduled: props.testScheduled ?? false,
    experimentalLocal: props.experimentalLocal,
    projectRoot: props.projectRoot,
    onStart: onEsbuildStart,
    defineNavigatorUserAgent: isNavigatorDefined(
      props.compatibilityDate,
      props.compatibilityFlags
    )
  });
  (0, import_react19.useEffect)(() => {
    if (bundle.current)
      onReloadStart(bundle.current);
  }, [onReloadStart, bundle]);
  if (!props.local && (props.bindings.queues?.length || props.queueConsumers?.length)) {
    logger.warn(
      "Queues are currently in Beta and are not supported in wrangler dev remote mode."
    );
  }
  if (props.local && props.bindings.hyperdrive?.length) {
    logger.warn(
      "Hyperdrive does not currently support 'wrangler dev' in local mode at this stage of the beta. Use the '--remote' flag to test a Hyperdrive configuration before deploying."
    );
  }
  const announceAndOnReady = /* @__PURE__ */ __name(async (finalIp, finalPort, proxyData) => {
    const { proxyWorker } = await devEnv.proxy.ready.promise;
    const url4 = await proxyWorker.ready;
    finalIp = url4.hostname;
    finalPort = parseInt(url4.port);
    if (props.local) {
      await maybeRegisterLocalWorker(
        url4,
        props.name,
        proxyData.internalDurableObjects,
        proxyData.entrypointAddresses
      );
    }
    if (process.send) {
      process.send(
        JSON.stringify({
          event: "DEV_SERVER_READY",
          ip: finalIp,
          port: finalPort
        })
      );
    }
    if (bundle.current) {
      latestReloadCompleteEvent.current = {
        type: "reloadComplete",
        config: startDevWorkerOptions,
        bundle: bundle.current,
        proxyData
      };
      devEnv.proxy.onReloadComplete(latestReloadCompleteEvent.current);
    }
    if (props.onReady) {
      props.onReady(finalIp, finalPort, proxyData);
    }
  }, "announceAndOnReady");
  return props.local ? /* @__PURE__ */ import_react19.default.createElement(
    Local,
    {
      name: props.name,
      bundle: bundle.current,
      format: props.entry.format,
      compatibilityDate: props.compatibilityDate,
      compatibilityFlags: props.compatibilityFlags,
      usageModel: props.usageModel,
      bindings: props.bindings,
      workerDefinitions,
      assetPaths: props.assetPaths,
      initialPort: void 0,
      initialIp: "127.0.0.1",
      rules: props.rules,
      inspectorPort: props.inspectorPort,
      runtimeInspectorPort: props.runtimeInspectorPort,
      localPersistencePath: props.localPersistencePath,
      liveReload: props.liveReload,
      crons: props.crons,
      queueConsumers: props.queueConsumers,
      localProtocol: "http",
      httpsKeyPath: props.httpsKeyPath,
      httpsCertPath: props.httpsCertPath,
      localUpstream: props.localUpstream,
      upstreamProtocol: props.upstreamProtocol,
      inspect: props.inspect,
      onReady: announceAndOnReady,
      enablePagesAssetsServiceBinding: props.enablePagesAssetsServiceBinding,
      sourceMapPath: bundle.current?.sourceMapPath,
      services: props.bindings.services
    }
  ) : /* @__PURE__ */ import_react19.default.createElement(
    Remote,
    {
      name: props.name,
      bundle: bundle.current,
      format: props.entry.format,
      accountId: props.accountId,
      bindings: props.bindings,
      assetPaths: props.assetPaths,
      isWorkersSite: props.isWorkersSite,
      port: props.initialPort,
      ip: props.initialIp,
      localProtocol: props.localProtocol,
      httpsKeyPath: props.httpsKeyPath,
      httpsCertPath: props.httpsCertPath,
      inspectorPort: props.inspectorPort,
      inspect: props.inspect,
      compatibilityDate: props.compatibilityDate,
      compatibilityFlags: props.compatibilityFlags,
      usageModel: props.usageModel,
      env: props.env,
      legacyEnv: props.legacyEnv,
      host: props.host,
      routes: props.routes,
      onReady: announceAndOnReady,
      sourceMapPath: bundle.current?.sourceMapPath,
      sendMetrics: props.sendMetrics
    }
  );
}
__name(DevSession, "DevSession");
function useTmpDir(projectRoot) {
  const [directory, setDirectory] = (0, import_react19.useState)();
  const handleError = useErrorHandler();
  (0, import_react19.useEffect)(() => {
    let dir;
    try {
      dir = getWranglerTmpDir(projectRoot, "dev");
      setDirectory(dir.path);
      return;
    } catch (err) {
      logger.error(
        "Failed to create temporary directory to store built files."
      );
      handleError(err);
    }
    return () => dir?.remove();
  }, [projectRoot, handleError]);
  return directory;
}
__name(useTmpDir, "useTmpDir");
function useCustomBuild(expectedEntry, build5, onStart, onEnd) {
  (0, import_react19.useEffect)(() => {
    if (!build5.command)
      return;
    let watcher;
    if (build5.watch_dir) {
      watcher = (0, import_chokidar4.watch)(build5.watch_dir, {
        persistent: true,
        ignoreInitial: true
      }).on("all", (_event, filePath) => {
        const relativeFile = path61.relative(expectedEntry.directory, expectedEntry.file) || ".";
        logger.log(`The file ${filePath} changed, restarting build...`);
        onStart();
        runCustomBuild(expectedEntry.file, relativeFile, build5).catch((err) => {
          logger.error("Custom build failed:", err);
        }).finally(() => {
          onEnd();
        });
      });
    }
    return () => {
      void watcher?.close();
    };
  }, [build5, expectedEntry, onStart, onEnd]);
}
__name(useCustomBuild, "useCustomBuild");
function sleep3(period) {
  return new Promise((resolve19) => setTimeout(resolve19, period));
}
__name(sleep3, "sleep");
var SLEEP_DURATION = 2e3;
var hostNameRegex = /userHostname="(.*)"/g;
async function findTunnelHostname() {
  let hostName;
  while (!hostName) {
    try {
      const resp = await (0, import_undici24.fetch)("http://localhost:8789/metrics");
      const data = await resp.text();
      const matches = Array.from(data.matchAll(hostNameRegex));
      hostName = matches[0][1];
    } catch (err) {
      await sleep3(SLEEP_DURATION);
    }
  }
  return hostName;
}
__name(findTunnelHostname, "findTunnelHostname");
function useTunnel(toggle) {
  const tunnel = (0, import_react19.useRef)();
  const removeSignalExitListener = (0, import_react19.useRef)();
  (0, import_react19.useEffect)(() => {
    async function startTunnel() {
      if (toggle) {
        try {
          await (0, import_command_exists2.default)("cloudflared");
        } catch (e3) {
          logger.warn(
            "To share your worker on the Internet, please install `cloudflared` from https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/install-and-setup/installation"
          );
          return;
        }
        logger.log("\u2394 Starting a tunnel...");
        tunnel.current = (0, import_node_child_process6.spawn)("cloudflared", [
          "tunnel",
          "--url",
          "http://localhost:8787",
          "--metrics",
          "localhost:8789"
        ]);
        tunnel.current.on("close", (code) => {
          if (code) {
            logger.log(`Tunnel process exited with code ${code}`);
          }
        });
        removeSignalExitListener.current = (0, import_signal_exit8.default)((_code, _signal) => {
          logger.log("\u2394 Shutting down local tunnel.");
          tunnel.current?.kill();
          tunnel.current = void 0;
        });
        const hostName = await findTunnelHostname();
        await clipboardy_default.write(hostName);
        logger.log(`\u2B23 Sharing at ${hostName}, copied to clipboard.`);
      }
    }
    __name(startTunnel, "startTunnel");
    startTunnel().catch(async (err) => {
      logger.error("tunnel:", err);
    });
    return () => {
      if (tunnel.current) {
        logger.log("\u2394 Shutting down tunnel.");
        tunnel.current?.kill();
        tunnel.current = void 0;
        removeSignalExitListener.current && removeSignalExitListener.current();
        removeSignalExitListener.current = void 0;
      }
    };
  }, [toggle]);
}
__name(useTunnel, "useTunnel");
function useHotkeys(props) {
  const { initial, inspectorPort, inspect: inspect2, localProtocol, forceLocal } = props;
  const [toggles, setToggles] = (0, import_react19.useState)(initial);
  const { exit: exit6 } = (0, import_ink13.useApp)();
  (0, import_ink13.useInput)(
    async (input, key) => {
      switch (input.toLowerCase()) {
        case "c":
          console.clear();
          console.log();
          break;
        case "b": {
          if (port === 0) {
            if (!portUsable)
              logger.info("Waiting for port...");
            if (blockBrowserOpen)
              return;
            blockBrowserOpen = true;
            await portUsablePromise;
            blockBrowserOpen = false;
          }
          if (ip === "0.0.0.0" || ip === "*") {
            await openInBrowser(`${localProtocol}://127.0.0.1:${port}`);
            return;
          }
          await openInBrowser(`${localProtocol}://${ip}:${port}`);
          break;
        }
        case "d": {
          if (inspect2) {
            await openInspector(inspectorPort, props.worker);
          }
          break;
        }
        case "l":
          if (forceLocal)
            return;
          setToggles((previousToggles) => ({
            ...previousToggles,
            local: !previousToggles.local
          }));
          break;
        case "q":
        case "x":
          exit6();
          break;
        default:
          break;
      }
    }
  );
  return toggles;
}
__name(useHotkeys, "useHotkeys");
function ErrorFallback(props) {
  const { exit: exit6 } = (0, import_ink13.useApp)();
  (0, import_react19.useEffect)(() => exit6(props.error));
  return /* @__PURE__ */ import_react19.default.createElement(import_react19.default.Fragment, null, /* @__PURE__ */ import_react19.default.createElement(import_ink13.Text, null, "Something went wrong:"), /* @__PURE__ */ import_react19.default.createElement(import_ink13.Text, null, props.error.stack));
}
__name(ErrorFallback, "ErrorFallback");
var dev_default = withErrorBoundary(DevImplementation, {
  FallbackComponent: ErrorFallback
});

// src/dev/start-server.ts
init_import_meta_url();
var path62 = __toESM(require("node:path"));
var util3 = __toESM(require("node:util"));
var import_chalk20 = __toESM(require_chalk());
var import_signal_exit9 = __toESM(require_signal_exit());
async function startDevServer(props) {
  let workerDefinitions = {};
  validateDevProps(props);
  if (props.build.command) {
    const relativeFile = path62.relative(props.entry.directory, props.entry.file) || ".";
    await runCustomBuild(props.entry.file, relativeFile, props.build).catch(
      (err) => {
        logger.error("Custom build failed:", err);
      }
    );
  }
  const directory = setupTempDir(props.projectRoot);
  if (!directory) {
    throw new Error("Failed to create temporary directory.");
  }
  logger.log("disableDevRegistry: ", props.disableDevRegistry);
  if (!props.disableDevRegistry) {
    try {
      await startWorkerRegistry();
      if (props.local) {
        const boundRegisteredWorkers = await getBoundRegisteredWorkers({
          name: props.name,
          services: props.bindings.services,
          durableObjects: props.bindings.durable_objects
        });
        if (!util3.isDeepStrictEqual(boundRegisteredWorkers, workerDefinitions)) {
          workerDefinitions = boundRegisteredWorkers || {};
        }
      }
    } catch (err) {
      logger.error("failed to start worker registry", err);
    }
  }
  const devEnv = new DevEnv();
  const startDevWorkerOptions = {
    name: props.name ?? "worker",
    script: { contents: "" },
    dev: {
      server: {
        hostname: props.initialIp,
        port: props.initialPort,
        secure: props.localProtocol === "https",
        httpsKeyPath: props.httpsKeyPath,
        httpsCertPath: props.httpsCertPath
      },
      inspector: {
        port: props.inspectorPort
      },
      urlOverrides: {
        secure: props.upstreamProtocol === "https",
        hostname: props.localUpstream
      },
      liveReload: props.liveReload,
      remote: !props.local
    }
  };
  devEnv.proxy.onConfigUpdate({
    type: "configUpdate",
    config: startDevWorkerOptions
  });
  devEnv.proxy.onBundleStart({
    type: "bundleStart",
    config: startDevWorkerOptions
  });
  const bundle = await runEsbuild({
    entry: props.entry,
    destination: directory,
    jsxFactory: props.jsxFactory,
    processEntrypoint: props.processEntrypoint,
    additionalModules: props.additionalModules,
    rules: props.rules,
    jsxFragment: props.jsxFragment,
    serveAssetsFromWorker: Boolean(
      props.assetPaths && !props.isWorkersSite && props.local
    ),
    tsconfig: props.tsconfig,
    minify: props.minify,
    legacyNodeCompat: props.legacyNodeCompat,
    nodejsCompat: props.nodejsCompat,
    define: props.define,
    noBundle: props.noBundle,
    findAdditionalModules: props.findAdditionalModules,
    assets: props.assetsConfig,
    testScheduled: props.testScheduled,
    local: props.local,
    doBindings: props.bindings.durable_objects?.bindings ?? [],
    projectRoot: props.projectRoot,
    defineNavigatorUserAgent: isNavigatorDefined(
      props.compatibilityDate,
      props.compatibilityFlags
    )
  });
  if (props.local) {
    devEnv.proxy.onReloadStart({
      type: "reloadStart",
      config: startDevWorkerOptions,
      bundle
    });
    const { stop } = await startLocalServer({
      name: props.name,
      bundle,
      format: props.entry.format,
      compatibilityDate: props.compatibilityDate,
      compatibilityFlags: props.compatibilityFlags,
      bindings: props.bindings,
      assetPaths: props.assetPaths,
      initialPort: void 0,
      // hard-code for userworker, DevEnv-ProxyWorker now uses this prop value
      initialIp: "127.0.0.1",
      // hard-code for userworker, DevEnv-ProxyWorker now uses this prop value
      rules: props.rules,
      inspectorPort: props.inspectorPort,
      runtimeInspectorPort: props.runtimeInspectorPort,
      localPersistencePath: props.localPersistencePath,
      liveReload: props.liveReload,
      crons: props.crons,
      queueConsumers: props.queueConsumers,
      localProtocol: props.localProtocol,
      httpsKeyPath: props.httpsKeyPath,
      httpsCertPath: props.httpsCertPath,
      localUpstream: props.localUpstream,
      upstreamProtocol: props.upstreamProtocol,
      inspect: true,
      onReady: async (ip2, port2, proxyData) => {
        const { proxyWorker } = await devEnv.proxy.ready.promise;
        const url4 = await proxyWorker.ready;
        ip2 = url4.hostname;
        port2 = parseInt(url4.port);
        await maybeRegisterLocalWorker(
          url4,
          props.name,
          proxyData.internalDurableObjects,
          proxyData.entrypointAddresses
        );
        props.onReady?.(ip2, port2, proxyData);
        devEnv.proxy.onReloadComplete({
          type: "reloadComplete",
          config: startDevWorkerOptions,
          bundle,
          proxyData
        });
      },
      enablePagesAssetsServiceBinding: props.enablePagesAssetsServiceBinding,
      usageModel: props.usageModel,
      workerDefinitions,
      sourceMapPath: bundle?.sourceMapPath,
      services: props.bindings.services
    });
    return {
      stop: async () => {
        await Promise.all([stop(), stopWorkerRegistry(), devEnv.teardown()]);
      }
      // TODO: inspectorUrl,
    };
  } else {
    const { stop } = await startRemoteServer({
      name: props.name,
      bundle,
      format: props.entry.format,
      accountId: props.accountId,
      bindings: props.bindings,
      assetPaths: props.assetPaths,
      isWorkersSite: props.isWorkersSite,
      port: props.initialPort,
      ip: props.initialIp,
      localProtocol: props.localProtocol,
      httpsKeyPath: props.httpsKeyPath,
      httpsCertPath: props.httpsCertPath,
      inspectorPort: props.inspectorPort,
      inspect: props.inspect,
      compatibilityDate: props.compatibilityDate,
      compatibilityFlags: props.compatibilityFlags,
      usageModel: props.usageModel,
      env: props.env,
      legacyEnv: props.legacyEnv,
      host: props.host,
      routes: props.routes,
      onReady: async (ip2, port2, proxyData) => {
        const { proxyWorker } = await devEnv.proxy.ready.promise;
        const url4 = await proxyWorker.ready;
        ip2 = url4.hostname;
        port2 = parseInt(url4.port);
        props.onReady?.(ip2, port2, proxyData);
        devEnv.proxy.onReloadComplete({
          type: "reloadComplete",
          config: startDevWorkerOptions,
          bundle,
          proxyData
        });
      },
      sourceMapPath: bundle?.sourceMapPath,
      sendMetrics: props.sendMetrics
    });
    return {
      stop: async () => {
        await Promise.all([stop(), stopWorkerRegistry(), devEnv.teardown()]);
      }
      // TODO: inspectorUrl,
    };
  }
}
__name(startDevServer, "startDevServer");
function setupTempDir(projectRoot) {
  try {
    const dir = getWranglerTmpDir(projectRoot, "dev");
    return dir.path;
  } catch (err) {
    logger.error("Failed to create temporary directory to store built files.");
  }
}
__name(setupTempDir, "setupTempDir");
async function runEsbuild({
  entry,
  destination,
  jsxFactory,
  jsxFragment,
  processEntrypoint,
  additionalModules,
  rules,
  assets,
  serveAssetsFromWorker,
  tsconfig,
  minify,
  legacyNodeCompat,
  nodejsCompat,
  define: define2,
  noBundle,
  findAdditionalModules: findAdditionalModules2,
  testScheduled,
  local,
  doBindings,
  projectRoot,
  defineNavigatorUserAgent
}) {
  if (noBundle) {
    additionalModules = dedupeModulesByName([
      ...await findAdditionalModules(entry, rules) ?? [],
      ...additionalModules
    ]);
  }
  const entryDirectory = path62.dirname(entry.file);
  const moduleCollector = noBundle ? noopModuleCollector : createModuleCollector({
    wrangler1xLegacyModuleReferences: getWrangler1xLegacyModuleReferences(
      entryDirectory,
      entry.file
    ),
    entry,
    findAdditionalModules: findAdditionalModules2 ?? false,
    rules
  });
  const bundleResult = processEntrypoint || !noBundle ? await bundleWorker(entry, destination, {
    bundle: !noBundle,
    additionalModules,
    moduleCollector,
    serveAssetsFromWorker,
    jsxFactory,
    jsxFragment,
    tsconfig,
    minify,
    legacyNodeCompat,
    nodejsCompat,
    define: define2,
    checkFetch: true,
    assets,
    // disable the cache in dev
    bypassAssetCache: true,
    targetConsumer: "dev",
    // We are starting a dev server
    local,
    testScheduled,
    doBindings,
    projectRoot,
    defineNavigatorUserAgent
  }) : void 0;
  return {
    id: 0,
    entry,
    path: bundleResult?.resolvedEntryPointPath ?? entry.file,
    type: bundleResult?.bundleType ?? getBundleType(entry.format),
    modules: bundleResult ? bundleResult.modules : additionalModules,
    dependencies: bundleResult?.dependencies ?? {},
    sourceMapPath: bundleResult?.sourceMapPath,
    sourceMapMetadata: bundleResult?.sourceMapMetadata
  };
}
__name(runEsbuild, "runEsbuild");
async function startLocalServer(props) {
  if (!props.bundle || !props.format)
    return { async stop() {
    } };
  if (props.bindings.services && props.bindings.services.length > 0) {
    logger.warn(
      "\u2394 Support for service bindings in local mode is experimental and may change."
    );
  }
  const externalDurableObjects = (props.bindings.durable_objects?.bindings || []).filter((binding) => binding.script_name);
  if (externalDurableObjects.length > 0) {
    logger.warn(
      "\u2394 Support for external Durable Objects in local mode is experimental and may change."
    );
  }
  logger.log(import_chalk20.default.dim("\u2394 Starting local server..."));
  const config = await localPropsToConfigBundle(props);
  return new Promise((resolve19, reject) => {
    const server = new MiniflareServer();
    server.addEventListener("reloaded", async (event) => {
      const proxyData = {
        userWorkerUrl: {
          protocol: event.url.protocol,
          hostname: event.url.hostname,
          port: event.url.port
        },
        userWorkerInspectorUrl: {
          protocol: "ws:",
          hostname: "127.0.0.1",
          port: props.runtimeInspectorPort.toString(),
          pathname: `/core:user:${props.name ?? DEFAULT_WORKER_NAME}`
        },
        userWorkerInnerUrlOverrides: {
          protocol: props.upstreamProtocol,
          hostname: props.localUpstream,
          port: props.localUpstream ? "" : void 0
          // `localUpstream` was essentially `host`, not `hostname`, so if it was set delete the `port`
        },
        headers: {
          // Passing this signature from Proxy Worker allows the User Worker to trust the request.
          "MF-Proxy-Shared-Secret": event.proxyToUserWorkerAuthenticationSecret
        },
        liveReload: props.liveReload,
        // in local mode, the logs are already being printed to the console by workerd but only for workers written in "module" format
        // workers written in "service-worker" format still need to proxy logs to the ProxyController
        proxyLogsToController: props.format === "service-worker",
        internalDurableObjects: event.internalDurableObjects,
        entrypointAddresses: event.entrypointAddresses
      };
      props.onReady?.(event.url.hostname, parseInt(event.url.port), proxyData);
      resolve19({
        stop: async () => {
          abortController.abort();
          logger.log("\u2394 Shutting down local server...");
          removeMiniflareServerExitListener();
          await server.onDispose();
        }
      });
    });
    server.addEventListener("error", ({ error: error2 }) => {
      logger.error("Error reloading local server:", error2);
      reject(error2);
    });
    const removeMiniflareServerExitListener = (0, import_signal_exit9.default)(() => {
      logger.log(import_chalk20.default.dim("\u2394 Shutting down local server..."));
      void server.onDispose();
    });
    const abortController = new AbortController();
    void server.onBundleUpdate(config, { signal: abortController.signal });
  });
}
__name(startLocalServer, "startLocalServer");

// src/utils/mergeWithOverride.ts
init_import_meta_url();
function mergeWithOverride(source, override, keyProperty) {
  const sourceMap = /* @__PURE__ */ new Map();
  source.forEach((el) => sourceMap.set(el[keyProperty], el));
  override.forEach((el) => sourceMap.set(el[keyProperty], el));
  return Array.from(sourceMap.values());
}
__name(mergeWithOverride, "mergeWithOverride");

// src/dev.tsx
function devOptions(yargs) {
  return yargs.positional("script", {
    describe: "The path to an entry point for your worker",
    type: "string"
  }).option("name", {
    describe: "Name of the worker",
    type: "string",
    requiresArg: true
  }).option("bundle", {
    describe: "Run wrangler's compilation step before publishing",
    type: "boolean",
    hidden: true
  }).option("no-bundle", {
    describe: "Skip internal build steps and directly deploy script",
    type: "boolean",
    default: false
  }).option("format", {
    choices: ["modules", "service-worker"],
    describe: "Choose an entry type",
    hidden: true,
    deprecated: true
  }).option("compatibility-date", {
    describe: "Date to use for compatibility checks",
    type: "string",
    requiresArg: true
  }).option("compatibility-flags", {
    describe: "Flags to use for compatibility checks",
    alias: "compatibility-flag",
    type: "string",
    requiresArg: true,
    array: true
  }).option("latest", {
    describe: "Use the latest version of the worker runtime",
    type: "boolean",
    default: true
  }).option("ip", {
    describe: "IP address to listen on",
    type: "string"
  }).option("port", {
    describe: "Port to listen on",
    type: "number"
  }).option("inspector-port", {
    describe: "Port for devtools to connect to",
    type: "number"
  }).option("routes", {
    describe: "Routes to upload",
    alias: "route",
    type: "string",
    requiresArg: true,
    array: true
  }).option("host", {
    type: "string",
    requiresArg: true,
    describe: "Host to forward requests to, defaults to the zone of project"
  }).option("local-protocol", {
    describe: "Protocol to listen to requests on, defaults to http.",
    choices: ["http", "https"]
  }).option("https-key-path", {
    describe: "Path to a custom certificate key",
    type: "string",
    requiresArg: true
  }).option("https-cert-path", {
    describe: "Path to a custom certificate",
    type: "string",
    requiresArg: true
  }).options("local-upstream", {
    type: "string",
    describe: "Host to act as origin in local mode, defaults to dev.host or route"
  }).option("experimental-public", {
    describe: "Static assets to be served",
    type: "string",
    requiresArg: true,
    deprecated: true,
    hidden: true
  }).option("assets", {
    describe: "Static assets to be served",
    type: "string",
    requiresArg: true
  }).option("public", {
    describe: "(Deprecated) Static assets to be served",
    type: "string",
    requiresArg: true,
    deprecated: true,
    hidden: true
  }).option("site", {
    describe: "Root folder of static assets for Workers Sites",
    type: "string",
    requiresArg: true
  }).option("site-include", {
    describe: "Array of .gitignore-style patterns that match file or directory names from the sites directory. Only matched items will be uploaded.",
    type: "string",
    requiresArg: true,
    array: true
  }).option("site-exclude", {
    describe: "Array of .gitignore-style patterns that match file or directory names from the sites directory. Matched items will not be uploaded.",
    type: "string",
    requiresArg: true,
    array: true
  }).option("upstream-protocol", {
    describe: "Protocol to forward requests to host on, defaults to https.",
    choices: ["http", "https"]
  }).option("var", {
    describe: "A key-value pair to be injected into the script as a variable",
    type: "string",
    requiresArg: true,
    array: true
  }).option("define", {
    describe: "A key-value pair to be substituted in the script",
    type: "string",
    requiresArg: true,
    array: true
  }).option("jsx-factory", {
    describe: "The function that is called for each JSX element",
    type: "string",
    requiresArg: true
  }).option("jsx-fragment", {
    describe: "The function that is called for each JSX fragment",
    type: "string",
    requiresArg: true
  }).option("tsconfig", {
    describe: "Path to a custom tsconfig.json file",
    type: "string",
    requiresArg: true
  }).option("remote", {
    alias: "r",
    describe: "Run on the global Cloudflare network with access to production resources",
    type: "boolean",
    default: false
  }).option("local", {
    alias: "l",
    describe: "Run on my machine",
    type: "boolean",
    deprecated: true,
    hidden: true
  }).option("experimental-local", {
    describe: "Run on my machine using the Cloudflare Workers runtime",
    type: "boolean",
    deprecated: true,
    hidden: true
  }).option("minify", {
    describe: "Minify the script",
    type: "boolean"
  }).option("node-compat", {
    describe: "Enable Node.js compatibility",
    type: "boolean"
  }).option("experimental-enable-local-persistence", {
    describe: "Enable persistence for local mode (deprecated, use --persist)",
    type: "boolean",
    deprecated: true,
    hidden: true
  }).option("persist-to", {
    describe: "Specify directory to use for local persistence (defaults to .wrangler/state)",
    type: "string",
    requiresArg: true
  }).option("live-reload", {
    describe: "Auto reload HTML pages when change is detected in local mode",
    type: "boolean"
  }).check((argv) => {
    if (argv["live-reload"] && argv.remote) {
      throw new UserError(
        "--live-reload is only supported in local mode. Please just use one of either --remote or --live-reload."
      );
    }
    return true;
  }).option("inspect", {
    describe: "Enable dev tools",
    type: "boolean",
    deprecated: true,
    hidden: true
  }).option("legacy-env", {
    type: "boolean",
    describe: "Use legacy environments",
    hidden: true
  }).option("test-scheduled", {
    describe: "Test scheduled events by visiting /__scheduled in browser",
    type: "boolean",
    default: false
  }).option("log-level", {
    choices: ["debug", "info", "log", "warn", "error", "none"],
    describe: "Specify logging level",
    // Yargs requires this to type log-level properly
    default: "log"
  }).option("show-interactive-dev-session", {
    describe: "Show interactive dev session  (defaults to true if the terminal supports interactivity)",
    type: "boolean"
  });
}
__name(devOptions, "devOptions");
async function devHandler(args) {
  if ((0, import_env2.isWebContainer)()) {
    logger.error(
      `Oh no! \u{1F61F} You tried to run \`wrangler dev\` in a StackBlitz WebContainer. \u{1F92F}
This is currently not supported \u{1F62D}, but we think that we'll get it to work soon... hang in there! \u{1F97A}`
    );
    process.exitCode = 1;
    return;
  }
  if (args.remote) {
    const isLoggedIn = await loginOrRefreshIfRequired();
    if (!isLoggedIn) {
      throw new UserError(
        "You must be logged in to use wrangler dev in remote mode. Try logging in, or run wrangler dev --local."
      );
    }
  }
  let watcher;
  try {
    const devInstance = await startDev(args);
    watcher = devInstance.watcher;
    const { waitUntilExit } = devInstance.devReactElement;
    await waitUntilExit();
  } finally {
    await watcher?.close();
  }
}
__name(devHandler, "devHandler");
async function startDev(args) {
  let watcher;
  let rerender;
  try {
    if (args.logLevel) {
      logger.loggerLevel = args.logLevel;
    }
    await printWranglerBanner(args.updateCheck);
    if (args.local) {
      logger.warn(
        "--local is no longer required and will be removed in a future version.\n`wrangler dev` now uses the local Cloudflare Workers runtime by default. \u{1F389}"
      );
    }
    if (args.experimentalLocal) {
      logger.warn(
        "--experimental-local is no longer required and will be removed in a future version.\n`wrangler dev` now uses the local Cloudflare Workers runtime by default. \u{1F389}"
      );
    }
    const configPath = args.config || args.script && findWranglerToml(import_node_path56.default.dirname(args.script));
    const projectRoot = configPath && import_node_path56.default.dirname(configPath);
    let config = readConfig(configPath, args);
    if (config.configPath) {
      watcher = (0, import_chokidar5.watch)(config.configPath, {
        persistent: true
      }).on("change", async (_event) => {
        config = readConfig(configPath, args);
        if (config.configPath) {
          logger.log(`${import_node_path56.default.basename(config.configPath)} changed...`);
          rerender(await getDevReactElement(config));
        }
      });
    }
    const {
      entry,
      legacyNodeCompat,
      nodejsCompat,
      upstreamProtocol,
      host,
      routes,
      getLocalPort,
      getInspectorPort,
      getRuntimeInspectorPort,
      cliDefines,
      localPersistencePath,
      processEntrypoint,
      additionalModules
    } = await validateDevServerSettings(args, config);
    await sendMetricsEvent(
      "run dev",
      {
        local: !args.remote,
        usesTypeScript: /\.tsx?$/.test(entry.file)
      },
      { sendMetrics: config.send_metrics, offline: !args.remote }
    );
    async function getDevReactElement(configParam) {
      const { assetPaths, bindings } = getBindingsAndAssetPaths(
        args,
        configParam
      );
      return /* @__PURE__ */ import_react20.default.createElement(
        dev_default,
        {
          name: getScriptName({ name: args.name, env: args.env }, configParam),
          noBundle: !(args.bundle ?? !configParam.no_bundle),
          findAdditionalModules: configParam.find_additional_modules,
          entry,
          env: args.env,
          host,
          routes,
          processEntrypoint,
          additionalModules,
          rules: args.rules ?? getRules(configParam),
          legacyEnv: isLegacyEnv(configParam),
          minify: args.minify ?? configParam.minify,
          legacyNodeCompat,
          nodejsCompat,
          build: configParam.build || {},
          define: { ...configParam.define, ...cliDefines },
          initialMode: args.remote ? "remote" : "local",
          jsxFactory: args.jsxFactory || configParam.jsx_factory,
          jsxFragment: args.jsxFragment || configParam.jsx_fragment,
          tsconfig: args.tsconfig ?? configParam.tsconfig,
          upstreamProtocol,
          localProtocol: args.localProtocol || configParam.dev.local_protocol,
          httpsKeyPath: args.httpsKeyPath,
          httpsCertPath: args.httpsCertPath,
          localUpstream: args.localUpstream ?? host ?? getInferredHost(routes),
          localPersistencePath,
          liveReload: args.liveReload || false,
          accountId: args.accountId ?? configParam.account_id ?? getAccountFromCache()?.id,
          assetPaths,
          assetsConfig: configParam.assets,
          initialPort: args.port ?? configParam.dev.port ?? await getLocalPort(),
          initialIp: args.ip || configParam.dev.ip,
          inspectorPort: args.inspectorPort ?? configParam.dev.inspector_port ?? await getInspectorPort(),
          runtimeInspectorPort: await getRuntimeInspectorPort(),
          isWorkersSite: Boolean(args.site || configParam.site),
          compatibilityDate: getDevCompatibilityDate(
            configParam,
            args.compatibilityDate
          ),
          compatibilityFlags: args.compatibilityFlags || configParam.compatibility_flags,
          usageModel: configParam.usage_model,
          bindings,
          crons: configParam.triggers.crons,
          queueConsumers: configParam.queues.consumers,
          onReady: args.onReady,
          inspect: args.inspect ?? true,
          showInteractiveDevSession: args.showInteractiveDevSession,
          forceLocal: args.forceLocal,
          enablePagesAssetsServiceBinding: args.enablePagesAssetsServiceBinding,
          firstPartyWorker: configParam.first_party_worker,
          sendMetrics: configParam.send_metrics,
          testScheduled: args.testScheduled,
          projectRoot
        }
      );
    }
    __name(getDevReactElement, "getDevReactElement");
    const devReactElement = (0, import_ink14.render)(await getDevReactElement(config));
    rerender = devReactElement.rerender;
    return {
      devReactElement,
      watcher,
      stop: async () => {
        devReactElement.unmount();
        await watcher?.close();
      }
    };
  } catch (e3) {
    await watcher?.close();
    throw e3;
  }
}
__name(startDev, "startDev");
async function startApiDev(args) {
  if (args.logLevel) {
    logger.loggerLevel = args.logLevel;
  }
  await printWranglerBanner(args.updateCheck);
  const configPath = args.config || args.script && findWranglerToml(import_node_path56.default.dirname(args.script));
  const projectRoot = configPath && import_node_path56.default.dirname(configPath);
  const config = readConfig(configPath, args);
  const {
    entry,
    legacyNodeCompat,
    nodejsCompat,
    upstreamProtocol,
    host,
    routes,
    getLocalPort,
    getInspectorPort,
    getRuntimeInspectorPort,
    cliDefines,
    localPersistencePath,
    processEntrypoint,
    additionalModules
  } = await validateDevServerSettings(args, config);
  await sendMetricsEvent(
    "run dev (api)",
    { local: !args.remote },
    { sendMetrics: config.send_metrics, offline: !args.remote }
  );
  async function getDevServer(configParam) {
    const { assetPaths, bindings } = getBindingsAndAssetPaths(
      args,
      configParam
    );
    const enableBundling = args.bundle ?? !configParam.no_bundle;
    return await startDevServer({
      name: getScriptName({ name: args.name, env: args.env }, configParam),
      noBundle: !enableBundling,
      findAdditionalModules: configParam.find_additional_modules,
      entry,
      env: args.env,
      host,
      routes,
      processEntrypoint,
      additionalModules,
      rules: args.rules ?? getRules(configParam),
      legacyEnv: isLegacyEnv(configParam),
      minify: args.minify ?? configParam.minify,
      legacyNodeCompat,
      nodejsCompat,
      build: configParam.build || {},
      define: { ...config.define, ...cliDefines },
      initialMode: args.remote ? "remote" : "local",
      jsxFactory: args.jsxFactory ?? configParam.jsx_factory,
      jsxFragment: args.jsxFragment ?? configParam.jsx_fragment,
      tsconfig: args.tsconfig ?? configParam.tsconfig,
      upstreamProtocol,
      localProtocol: args.localProtocol ?? configParam.dev.local_protocol,
      httpsKeyPath: args.httpsKeyPath,
      httpsCertPath: args.httpsCertPath,
      localUpstream: args.localUpstream ?? host ?? getInferredHost(routes),
      localPersistencePath,
      liveReload: args.liveReload ?? false,
      accountId: args.accountId ?? configParam.account_id ?? getAccountFromCache()?.id,
      assetPaths,
      assetsConfig: configParam.assets,
      //port can be 0, which means to use a random port
      initialPort: args.port ?? configParam.dev.port ?? await getLocalPort(),
      initialIp: args.ip ?? configParam.dev.ip,
      inspectorPort: args.inspectorPort ?? configParam.dev.inspector_port ?? await getInspectorPort(),
      runtimeInspectorPort: await getRuntimeInspectorPort(),
      isWorkersSite: Boolean(args.site || configParam.site),
      compatibilityDate: getDevCompatibilityDate(
        config,
        // Only `compatibilityDate` will be set when using `unstable_dev`
        args.compatibilityDate
      ),
      compatibilityFlags: args.compatibilityFlags ?? configParam.compatibility_flags,
      usageModel: configParam.usage_model,
      bindings,
      crons: configParam.triggers.crons,
      queueConsumers: configParam.queues.consumers,
      onReady: args.onReady,
      inspect: args.inspect ?? true,
      showInteractiveDevSession: args.showInteractiveDevSession,
      forceLocal: args.forceLocal,
      enablePagesAssetsServiceBinding: args.enablePagesAssetsServiceBinding,
      local: !args.remote,
      firstPartyWorker: configParam.first_party_worker,
      sendMetrics: configParam.send_metrics,
      testScheduled: args.testScheduled,
      disableDevRegistry: args.disableDevRegistry ?? false,
      projectRoot
    });
  }
  __name(getDevServer, "getDevServer");
  const devServer = await getDevServer(config);
  if (!devServer) {
    const error2 = new Error("Failed to start dev server.");
    logger.error(error2.message);
    throw error2;
  }
  return {
    stop: async () => {
      await devServer.stop();
    }
  };
}
__name(startApiDev, "startApiDev");
function memoizeGetPort(defaultPort, host) {
  let portValue;
  return async () => {
    portValue = portValue ?? await getPorts({ port: defaultPort, host });
    return portValue;
  };
}
__name(memoizeGetPort, "memoizeGetPort");
function maskVars(bindings, configParam) {
  const maskedVars = { ...bindings.vars };
  for (const key of Object.keys(maskedVars)) {
    if (maskedVars[key] !== configParam.vars[key]) {
      maskedVars[key] = "(hidden)";
    }
  }
  return maskedVars;
}
__name(maskVars, "maskVars");
async function getHostAndRoutes(args, config) {
  const host = args.host || config.dev.host;
  const routes = args.routes || config.route && [config.route] || config.routes;
  return { host, routes };
}
__name(getHostAndRoutes, "getHostAndRoutes");
function getInferredHost(routes) {
  if (routes) {
    const firstRoute = routes[0];
    const host = getHostFromRoute(firstRoute);
    if (host === void 0) {
      throw new UserError(
        `Cannot infer host from first route: ${JSON.stringify(
          firstRoute
        )}.
You can explicitly set the \`dev.host\` configuration in your wrangler.toml file, for example:

	\`\`\`
	[dev]
	host = "example.com"
	\`\`\`
`
      );
    }
    return host;
  }
}
__name(getInferredHost, "getInferredHost");
async function validateDevServerSettings(args, config) {
  const entry = await getEntry(
    { assets: args.assets, script: args.script, moduleRoot: args.moduleRoot },
    config,
    "dev"
  );
  const { host, routes } = await getHostAndRoutes(args, config);
  if (args.remote)
    await getZoneIdForPreview(host, routes);
  const initialIp = args.ip || config.dev.ip;
  const initialIpListenCheck = initialIp === "*" ? "0.0.0.0" : initialIp;
  const getLocalPort = memoizeGetPort(DEFAULT_LOCAL_PORT, initialIpListenCheck);
  const getInspectorPort = memoizeGetPort(DEFAULT_INSPECTOR_PORT, "127.0.0.1");
  const getRuntimeInspectorPort = memoizeGetPort(0, "127.0.0.1");
  if (config.services && config.services.length > 0) {
    logger.warn(
      `This worker is bound to live services: ${config.services.map(
        (service) => `${service.binding} (${service.service}${service.environment ? `@${service.environment}` : ""}${service.entrypoint ? `#${service.entrypoint}` : ""})`
      ).join(", ")}`
    );
  }
  if (args.inspect) {
    logger.warn(
      "Passing --inspect is unnecessary, now you can always connect to devtools."
    );
  }
  if (args.experimentalPublic) {
    throw new UserError(
      "The --experimental-public field has been renamed to --assets"
    );
  }
  if (args.public) {
    throw new UserError("The --public field has been renamed to --assets");
  }
  if ((args.assets ?? config.assets) && (args.site ?? config.site)) {
    throw new UserError(
      "Cannot use Assets and Workers Sites in the same Worker."
    );
  }
  if (args.assets) {
    logger.warn(
      "The --assets argument is experimental and may change or break at any time"
    );
  }
  const upstreamProtocol = args.upstreamProtocol ?? config.dev.upstream_protocol;
  if (upstreamProtocol === "http" && args.remote) {
    logger.warn(
      "Setting upstream-protocol to http is not currently supported for remote mode.\nIf this is required in your project, please add your use case to the following issue:\nhttps://github.com/cloudflare/workers-sdk/issues/583."
    );
  }
  const legacyNodeCompat = args.nodeCompat ?? config.node_compat;
  if (legacyNodeCompat) {
    logger.warn(
      "Enabling Node.js compatibility mode for built-ins and globals. This is experimental and has serious tradeoffs. Please see https://github.com/ionic-team/rollup-plugin-node-polyfills/ for more details."
    );
  }
  const compatibilityFlags = args.compatibilityFlags ?? config.compatibility_flags;
  const nodejsCompat = compatibilityFlags?.includes("nodejs_compat");
  if (legacyNodeCompat && nodejsCompat) {
    throw new UserError(
      "The `nodejs_compat` compatibility flag cannot be used in conjunction with the legacy `--node-compat` flag. If you want to use the Workers runtime Node.js compatibility features, please remove the `--node-compat` argument from your CLI command or `node_compat = true` from your config file."
    );
  }
  if (args.experimentalEnableLocalPersistence) {
    logger.warn(
      `--experimental-enable-local-persistence is deprecated.
Move any existing data to .wrangler/state and use --persist, or
use --persist-to=./wrangler-local-state to keep using the old path.`
    );
  }
  const localPersistencePath = getLocalPersistencePath(
    args.persistTo,
    config.configPath
  );
  const cliDefines = collectKeyValues(args.define);
  return {
    entry,
    upstreamProtocol,
    legacyNodeCompat,
    nodejsCompat,
    getLocalPort,
    getInspectorPort,
    getRuntimeInspectorPort,
    host,
    routes,
    cliDefines,
    localPersistencePath,
    processEntrypoint: !!args.processEntrypoint,
    additionalModules: args.additionalModules ?? []
  };
}
__name(validateDevServerSettings, "validateDevServerSettings");
function getBindingsAndAssetPaths(args, configParam) {
  const cliVars = collectKeyValues(args.var);
  const bindings = getBindings(configParam, args.env, !args.remote, {
    kv: args.kv,
    vars: { ...args.vars, ...cliVars },
    durableObjects: args.durableObjects,
    r2: args.r2,
    services: args.services,
    d1Databases: args.d1Databases,
    ai: args.ai,
    version_metadata: args.version_metadata
  });
  const maskedVars = maskVars(bindings, configParam);
  printBindings({
    ...bindings,
    vars: maskedVars
  });
  const assetPaths = args.assets || configParam.assets ? getAssetPaths(configParam, args.assets) : getSiteAssetPaths(
    configParam,
    args.site,
    args.siteInclude,
    args.siteExclude
  );
  return { assetPaths, bindings };
}
__name(getBindingsAndAssetPaths, "getBindingsAndAssetPaths");
function getBindings(configParam, env5, local, args) {
  const kvConfig = (configParam.kv_namespaces || []).map(
    ({ binding, preview_id, id }) => {
      if (!preview_id && !local) {
        throw new UserError(
          `In development, you should use a separate kv namespace than the one you'd use in production. Please create a new kv namespace with "wrangler kv:namespace create <name> --preview" and add its id as preview_id to the kv_namespace "${binding}" in your wrangler.toml`
        );
      }
      return {
        binding,
        id: preview_id ?? id
      };
    }
  );
  const kvArgs = args.kv || [];
  const mergedKVBindings = mergeWithOverride(kvConfig, kvArgs, "binding");
  const doConfig = (configParam.durable_objects || { bindings: [] }).bindings;
  const doArgs = args.durableObjects || [];
  const mergedDOBindings = mergeWithOverride(doConfig, doArgs, "name");
  const d1Config = (configParam.d1_databases ?? []).map((d1Db) => {
    const database_id = d1Db.preview_database_id ? d1Db.preview_database_id : d1Db.database_id;
    if (local) {
      return { ...d1Db, database_id };
    }
    if (!d1Db.preview_database_id && !process.env.NO_D1_WARNING) {
      logger.log(
        `--------------------
\u{1F4A1} Recommendation: for development, use a preview D1 database rather than the one you'd use in production.
\u{1F4A1} Create a new D1 database with "wrangler d1 create <name>" and add its id as preview_database_id to the d1_database "${d1Db.binding}" in your wrangler.toml
--------------------
`
      );
    }
    return { ...d1Db, database_id };
  });
  const d1Args = args.d1Databases || [];
  const mergedD1Bindings = mergeWithOverride(d1Config, d1Args, "binding");
  const r2Config = configParam.r2_buckets?.map(
    ({ binding, preview_bucket_name, bucket_name, jurisdiction }) => {
      if (!preview_bucket_name && !local) {
        throw new UserError(
          `In development, you should use a separate r2 bucket than the one you'd use in production. Please create a new r2 bucket with "wrangler r2 bucket create <name>" and add its name as preview_bucket_name to the r2_buckets "${binding}" in your wrangler.toml`
        );
      }
      return {
        binding,
        bucket_name: preview_bucket_name ?? bucket_name,
        jurisdiction
      };
    }
  ) || [];
  const r2Args = args.r2 || [];
  const mergedR2Bindings = mergeWithOverride(r2Config, r2Args, "binding");
  const servicesConfig = configParam.services || [];
  const servicesArgs = args.services || [];
  const mergedServiceBindings = mergeWithOverride(
    servicesConfig,
    servicesArgs,
    "binding"
  );
  const hyperdriveBindings = configParam.hyperdrive.map((hyperdrive2) => {
    const connectionStringFromEnv = process.env[`WRANGLER_HYPERDRIVE_LOCAL_CONNECTION_STRING_${hyperdrive2.binding}`];
    if (!connectionStringFromEnv && !hyperdrive2.localConnectionString) {
      throw new UserError(
        `When developing locally, you should use a local Postgres connection string to emulate Hyperdrive functionality. Please setup Postgres locally and set the value of the 'WRANGLER_HYPERDRIVE_LOCAL_CONNECTION_STRING_${hyperdrive2.binding}' variable or "${hyperdrive2.binding}"'s "localConnectionString" to the Postgres connection string.`
      );
    }
    if (connectionStringFromEnv) {
      logger.log(
        `Found a non-empty WRANGLER_HYPERDRIVE_LOCAL_CONNECTION_STRING variable for binding. Hyperdrive will connect to this database during local development.`
      );
      hyperdrive2.localConnectionString = connectionStringFromEnv;
    }
    return hyperdrive2;
  });
  const queuesBindings = [
    ...(configParam.queues.producers || []).map((queue) => {
      return {
        binding: queue.binding,
        queue_name: queue.queue,
        delivery_delay: queue.delivery_delay
      };
    })
  ];
  const bindings = {
    // top-level fields
    wasm_modules: configParam.wasm_modules,
    text_blobs: configParam.text_blobs,
    data_blobs: configParam.data_blobs,
    // inheritable fields
    dispatch_namespaces: configParam.dispatch_namespaces,
    logfwdr: configParam.logfwdr,
    // non-inheritable fields
    vars: {
      // Use a copy of combinedVars since we're modifying it later
      ...getVarsForDev(configParam, env5),
      ...args.vars
    },
    durable_objects: {
      bindings: mergedDOBindings
    },
    kv_namespaces: mergedKVBindings,
    queues: queuesBindings,
    r2_buckets: mergedR2Bindings,
    d1_databases: mergedD1Bindings,
    vectorize: configParam.vectorize,
    constellation: configParam.constellation,
    hyperdrive: hyperdriveBindings,
    services: mergedServiceBindings,
    analytics_engine_datasets: configParam.analytics_engine_datasets,
    browser: configParam.browser,
    ai: args.ai || configParam.ai,
    version_metadata: args.version_metadata || configParam.version_metadata,
    unsafe: {
      bindings: configParam.unsafe.bindings,
      metadata: configParam.unsafe.metadata,
      capnp: configParam.unsafe.capnp
    },
    mtls_certificates: configParam.mtls_certificates,
    send_email: configParam.send_email
  };
  if (bindings.constellation && bindings.constellation.length > 0) {
    logger.warn(
      "`constellation` is deprecated and will be removed in the next major version.\nPlease migrate to Workers AI, learn more here https://developers.cloudflare.com/workers-ai/."
    );
  }
  return bindings;
}
__name(getBindings, "getBindings");

// src/api/dev.ts
async function unstable_dev(script, options29, apiOptions) {
  const experimentalOptions = {
    // Defaults for "experimental" options
    disableDevRegistry: false,
    disableExperimentalWarning: false,
    showInteractiveDevSession: false,
    testMode: true,
    // Override all options, including overwriting with "undefined"
    ...options29?.experimental
  };
  const {
    // there are two types of "experimental" options:
    // 1. options to unstable_dev that we're still testing or are unsure of
    processEntrypoint = false,
    additionalModules,
    disableDevRegistry,
    disableExperimentalWarning,
    forceLocal,
    liveReload,
    showInteractiveDevSession,
    testMode,
    testScheduled,
    // 2. options for alpha/beta products/libs
    d1Databases,
    enablePagesAssetsServiceBinding
  } = experimentalOptions;
  if (apiOptions) {
    logger.error(
      "unstable_dev's third argument (apiOptions) has been deprecated in favor of an `experimental` property within the second argument (options).\nPlease update your code from:\n`await unstable_dev('...', {...}, {...});`\nto:\n`await unstable_dev('...', {..., experimental: {...}});`"
    );
  }
  if (!disableExperimentalWarning) {
    logger.warn(
      `unstable_dev() is experimental
unstable_dev()'s behaviour will likely change in future releases`
    );
  }
  let readyResolve;
  const readyPromise = new Promise((resolve19) => {
    readyResolve = resolve19;
  });
  const defaultLogLevel = testMode ? "warn" : "log";
  const local = options29?.local ?? true;
  const devOptions2 = {
    script,
    inspect: false,
    _: [],
    $0: "",
    remote: !local,
    local: void 0,
    experimentalLocal: void 0,
    d1Databases,
    disableDevRegistry,
    testScheduled: testScheduled ?? false,
    enablePagesAssetsServiceBinding,
    forceLocal,
    liveReload,
    showInteractiveDevSession,
    onReady: (address, port2, proxyData) => {
      readyResolve({ address, port: port2, proxyData });
    },
    config: options29?.config,
    env: options29?.env,
    processEntrypoint,
    additionalModules,
    bundle: options29?.bundle,
    compatibilityDate: options29?.compatibilityDate,
    compatibilityFlags: options29?.compatibilityFlags,
    ip: options29?.ip,
    inspectorPort: options29?.inspectorPort ?? 0,
    v: void 0,
    localProtocol: options29?.localProtocol,
    httpsKeyPath: options29?.httpsKeyPath,
    httpsCertPath: options29?.httpsCertPath,
    assets: options29?.assets,
    site: options29?.site,
    // Root folder of static assets for Workers Sites
    siteInclude: options29?.siteInclude,
    // Array of .gitignore-style patterns that match file or directory names from the sites directory. Only matched items will be uploaded.
    siteExclude: options29?.siteExclude,
    // Array of .gitignore-style patterns that match file or directory names from the sites directory. Matched items will not be uploaded.
    nodeCompat: options29?.nodeCompat,
    // Enable Node.js compatibility
    persist: options29?.persist,
    // Enable persistence for local mode, using default path: .wrangler/state
    persistTo: options29?.persistTo,
    // Specify directory to use for local persistence (implies --persist)
    experimentalJsonConfig: void 0,
    name: void 0,
    noBundle: false,
    format: void 0,
    latest: false,
    routes: void 0,
    host: void 0,
    localUpstream: void 0,
    experimentalPublic: void 0,
    upstreamProtocol: void 0,
    var: void 0,
    define: void 0,
    jsxFactory: void 0,
    jsxFragment: void 0,
    tsconfig: void 0,
    minify: void 0,
    experimentalEnableLocalPersistence: void 0,
    legacyEnv: void 0,
    public: void 0,
    ...options29,
    logLevel: options29?.logLevel ?? defaultLogLevel,
    port: options29?.port ?? 0,
    updateCheck: options29?.updateCheck ?? false,
    experimentalVersions: void 0
  };
  if (testMode) {
    const devServer = await startApiDev(devOptions2);
    const { port: port2, address, proxyData } = await readyPromise;
    return {
      port: port2,
      address,
      proxyData,
      stop: devServer.stop,
      fetch: async (input, init3) => {
        return await (0, import_undici25.fetch)(
          ...parseRequestInput(
            address,
            port2,
            input,
            init3,
            options29?.localProtocol
          )
        );
      },
      //no-op, does nothing in tests
      waitUntilExit: async () => {
        return;
      }
    };
  } else {
    const devServer = await startDev(devOptions2);
    const { port: port2, address, proxyData } = await readyPromise;
    return {
      port: port2,
      address,
      proxyData,
      stop: devServer.stop,
      fetch: async (input, init3) => {
        return await (0, import_undici25.fetch)(
          ...parseRequestInput(
            address,
            port2,
            input,
            init3,
            options29?.localProtocol
          )
        );
      },
      waitUntilExit: devServer.devReactElement.waitUntilExit
    };
  }
}
__name(unstable_dev, "unstable_dev");
function parseRequestInput(readyAddress, readyPort, input = "/", init3, protocol = "http") {
  if (typeof input === "string")
    input = new URL(input, "http://placeholder");
  const forward = new import_undici25.Request(input, init3);
  const url4 = new URL(forward.url);
  forward.headers.set("MF-Original-URL", url4.toString());
  forward.headers.set("MF-Disable-Pretty-Error", "true");
  url4.protocol = protocol;
  url4.hostname = readyAddress;
  url4.port = readyPort.toString();
  if (forward.body !== null && forward.headers.get("Content-Length") === "0") {
    forward.headers.delete("Content-Length");
  }
  return [url4, forward];
}
__name(parseRequestInput, "parseRequestInput");

// src/api/pages/index.ts
init_import_meta_url();
var unstable_pages = {
  deploy: deploy2
};

// src/api/startDevWorker/index.ts
init_import_meta_url();

// src/api/startDevWorker/DevEnv.ts
init_import_meta_url();
var import_node_assert21 = __toESM(require("node:assert"));
var import_node_events5 = require("node:events");

// src/api/startDevWorker/BundlerController.ts
init_import_meta_url();

// src/api/startDevWorker/BaseController.ts
init_import_meta_url();
var import_node_events2 = require("node:events");
var Controller = class extends import_node_events2.EventEmitter {
};
__name(Controller, "Controller");
var RuntimeController = class extends Controller {
  // @ts-expect-error Missing initialisation (only need the signature types, base implementation is fine)
  once;
};
__name(RuntimeController, "RuntimeController");

// src/api/startDevWorker/NotImplementedError.ts
init_import_meta_url();
var NotImplementedError = class extends Error {
  constructor(func, namespace) {
    if (namespace)
      func = `${namespace}#${func}`;
    super(`Not Implemented Error: ${func}`);
  }
};
__name(NotImplementedError, "NotImplementedError");
function notImplemented(func, namespace) {
  if (namespace)
    func = `${namespace}#${func}`;
  logger.debug(`Not Implemented Error: ${func}`);
  return new NotImplementedError(func, namespace);
}
__name(notImplemented, "notImplemented");

// src/api/startDevWorker/BundlerController.ts
var BundlerController = class extends Controller {
  // ******************
  //   Event Handlers
  // ******************
  onConfigUpdate(_3) {
    notImplemented(this.onConfigUpdate.name, this.constructor.name);
  }
  async teardown() {
    notImplemented(this.teardown.name, this.constructor.name);
  }
  // *********************
  //   Event Dispatchers
  // *********************
  emitBundleStartEvent(data) {
    this.emit("bundleStart", data);
  }
  emitBundleCompletetEvent(data) {
    this.emit("bundleComplete", data);
  }
  // @ts-expect-error Missing initialisation (only need the signature types, base implementation is fine)
  once;
};
__name(BundlerController, "BundlerController");

// src/api/startDevWorker/ConfigController.ts
init_import_meta_url();
var import_node_events3 = require("node:events");
var ConfigController = class extends import_node_events3.EventEmitter {
  config;
  setOptions(_3) {
    notImplemented(this.setOptions.name, this.constructor.name);
  }
  updateOptions(_3) {
    notImplemented(this.updateOptions.name, this.constructor.name);
  }
  // ******************
  //   Event Handlers
  // ******************
  async teardown() {
    notImplemented(this.teardown.name, this.constructor.name);
  }
  // *********************
  //   Event Dispatchers
  // *********************
  emitConfigUpdateEvent(data) {
    this.emit("configUpdate", data);
  }
  // @ts-expect-error Missing initialisation (only need the signature types, base implementation is fine)
  once;
};
__name(ConfigController, "ConfigController");

// src/api/startDevWorker/LocalRuntimeController.ts
init_import_meta_url();
var LocalRuntimeController = class extends RuntimeController {
  // ******************
  //   Event Handlers
  // ******************
  onBundleStart(_3) {
    notImplemented(this.onBundleStart.name, this.constructor.name);
  }
  onBundleComplete(_3) {
    notImplemented(this.onBundleComplete.name, this.constructor.name);
  }
  onPreviewTokenExpired(_3) {
  }
  async teardown() {
    notImplemented(this.teardown.name, this.constructor.name);
  }
  // *********************
  //   Event Dispatchers
  // *********************
  emitReloadStartEvent(data) {
    this.emit("reloadComplete", data);
  }
  emitReloadCompletetEvent(data) {
    this.emit("reloadComplete", data);
  }
};
__name(LocalRuntimeController, "LocalRuntimeController");

// src/api/startDevWorker/ProxyController.ts
init_import_meta_url();
var import_node_assert20 = __toESM(require("node:assert"));
var import_node_crypto8 = require("node:crypto");
var import_node_events4 = require("node:events");
var import_node_path59 = __toESM(require("node:path"));
var import_miniflare15 = require("miniflare");

// embed-worker:/home/runner/work/workers-sdk/workers-sdk/packages/wrangler/templates/startDevWorker/InspectorProxyWorker.ts
init_import_meta_url();
var import_node_path57 = __toESM(require("node:path"));
var scriptPath = import_node_path57.default.resolve(__dirname, "..", "wrangler-dist/InspectorProxyWorker.js");
var InspectorProxyWorker_default = scriptPath;

// embed-worker:/home/runner/work/workers-sdk/workers-sdk/packages/wrangler/templates/startDevWorker/ProxyWorker.ts
init_import_meta_url();
var import_node_path58 = __toESM(require("node:path"));
var scriptPath2 = import_node_path58.default.resolve(__dirname, "..", "wrangler-dist/ProxyWorker.js");
var ProxyWorker_default = scriptPath2;

// src/api/startDevWorker/events.ts
init_import_meta_url();

// src/api/startDevWorker/devtools.ts
init_import_meta_url();

// src/api/startDevWorker/events.ts
function castErrorCause(cause) {
  if (cause instanceof Error)
    return cause;
  const error2 = new Error();
  error2.cause = cause;
  return error2;
}
__name(castErrorCause, "castErrorCause");

// src/api/startDevWorker/utils.ts
init_import_meta_url();
var import_node_assert19 = __toESM(require("node:assert"));
function createDeferred(previousDeferred) {
  let resolve19, reject;
  const newPromise = new Promise((_resolve2, _reject) => {
    resolve19 = _resolve2;
    reject = _reject;
  });
  (0, import_node_assert19.default)(resolve19);
  (0, import_node_assert19.default)(reject);
  previousDeferred?.resolve(newPromise);
  return {
    promise: newPromise,
    resolve: resolve19,
    reject
  };
}
__name(createDeferred, "createDeferred");
function assertNever(_value) {
}
__name(assertNever, "assertNever");

// src/api/startDevWorker/ProxyController.ts
var ProxyController = class extends import_node_events4.EventEmitter {
  ready = createDeferred();
  proxyWorker;
  proxyWorkerOptions;
  inspectorProxyWorkerWebSocket;
  latestConfig;
  latestBundle;
  secret = (0, import_node_crypto8.randomUUID)();
  createProxyWorker() {
    if (this._torndown)
      return;
    (0, import_node_assert20.default)(this.latestConfig !== void 0);
    const cert = this.latestConfig.dev?.server?.secure || this.latestConfig.dev?.inspector?.secure ? getHttpsOptions(
      this.latestConfig.dev.server?.httpsKeyPath,
      this.latestConfig.dev.server?.httpsCertPath
    ) : void 0;
    const proxyWorkerOptions = {
      host: this.latestConfig.dev?.server?.hostname,
      port: this.latestConfig.dev?.server?.port,
      https: this.latestConfig.dev?.server?.secure,
      httpsCert: cert?.cert,
      httpsKey: cert?.key,
      workers: [
        {
          name: "ProxyWorker",
          compatibilityDate: "2023-12-18",
          compatibilityFlags: ["nodejs_compat"],
          modulesRoot: import_node_path59.default.dirname(ProxyWorker_default),
          modules: [{ type: "ESModule", path: ProxyWorker_default }],
          durableObjects: {
            DURABLE_OBJECT: {
              className: "ProxyWorker",
              unsafePreventEviction: true
            }
          },
          serviceBindings: {
            PROXY_CONTROLLER: async (req) => {
              const message = await req.json();
              this.onProxyWorkerMessage(message);
              return new import_miniflare15.Response(null, { status: 204 });
            }
          },
          bindings: {
            PROXY_CONTROLLER_AUTH_SECRET: this.secret
          },
          // no need to use file-system, so don't
          cache: false,
          unsafeEphemeralDurableObjects: true
        },
        {
          name: "InspectorProxyWorker",
          compatibilityDate: "2023-12-18",
          compatibilityFlags: ["nodejs_compat"],
          modulesRoot: import_node_path59.default.dirname(InspectorProxyWorker_default),
          modules: [{ type: "ESModule", path: InspectorProxyWorker_default }],
          durableObjects: {
            DURABLE_OBJECT: {
              className: "InspectorProxyWorker",
              unsafePreventEviction: true
            }
          },
          serviceBindings: {
            PROXY_CONTROLLER: async (req) => {
              const body = await req.json();
              return this.onInspectorProxyWorkerRequest(body);
            }
          },
          bindings: {
            PROXY_CONTROLLER_AUTH_SECRET: this.secret
          },
          unsafeDirectSockets: [
            {
              host: this.latestConfig.dev?.inspector?.hostname,
              port: this.latestConfig.dev?.inspector?.port ?? 0
            }
          ],
          // no need to use file-system, so don't
          cache: false,
          unsafeEphemeralDurableObjects: true
        }
      ],
      verbose: logger.loggerLevel === "debug",
      // log requests into the ProxyWorker (for local + remote mode)
      log: new ProxyControllerLogger(castLogLevel(logger.loggerLevel), {
        prefix: (
          // if debugging, log requests with specic ProxyWorker prefix
          logger.loggerLevel === "debug" ? "wrangler-ProxyWorker" : "wrangler"
        )
      }),
      handleRuntimeStdio
    };
    const proxyWorkerOptionsChanged = didMiniflareOptionsChange(
      this.proxyWorkerOptions,
      proxyWorkerOptions
    );
    const willInstantiateMiniflareInstance = !this.proxyWorker || proxyWorkerOptionsChanged;
    this.proxyWorker ??= new import_miniflare15.Miniflare(proxyWorkerOptions);
    this.proxyWorkerOptions = proxyWorkerOptions;
    if (proxyWorkerOptionsChanged) {
      logger.debug("ProxyWorker miniflare options changed, reinstantiating...");
      void this.proxyWorker.setOptions(proxyWorkerOptions);
      this.ready = createDeferred(this.ready);
    }
    const { proxyWorker } = this;
    if (willInstantiateMiniflareInstance) {
      void Promise.all([
        proxyWorker.ready,
        this.reconnectInspectorProxyWorker()
      ]).then(() => {
        this.emitReadyEvent(proxyWorker);
      }).catch((error2) => {
        this.emitErrorEvent(
          "Failed to start ProxyWorker or InspectorProxyWorker",
          error2
        );
      });
    }
  }
  async reconnectInspectorProxyWorker() {
    if (this._torndown)
      return;
    const existingWebSocket = await this.inspectorProxyWorkerWebSocket?.promise;
    if (existingWebSocket?.readyState === import_miniflare15.WebSocket.READY_STATE_OPEN) {
      return existingWebSocket;
    }
    this.inspectorProxyWorkerWebSocket = createDeferred();
    let webSocket = null;
    try {
      (0, import_node_assert20.default)(this.proxyWorker);
      const inspectorProxyWorker = await this.proxyWorker.getWorker(
        "InspectorProxyWorker"
      );
      ({ webSocket } = await inspectorProxyWorker.fetch(
        "http://dummy/cdn-cgi/InspectorProxyWorker/websocket",
        {
          headers: { Authorization: this.secret, Upgrade: "websocket" }
        }
      ));
    } catch (cause) {
      if (this._torndown)
        return;
      const error2 = castErrorCause(cause);
      this.inspectorProxyWorkerWebSocket?.reject(error2);
      this.emitErrorEvent("Could not connect to InspectorProxyWorker", error2);
      return;
    }
    (0, import_node_assert20.default)(
      webSocket,
      "Expected webSocket on response from inspectorProxyWorker"
    );
    webSocket.addEventListener("message", (event) => {
      (0, import_node_assert20.default)(typeof event.data === "string");
      this.onInspectorProxyWorkerMessage(JSON.parse(event.data));
    });
    webSocket.addEventListener("close", () => {
    });
    webSocket.addEventListener("error", () => {
      if (this._torndown)
        return;
      void this.reconnectInspectorProxyWorker();
    });
    webSocket.accept();
    this.inspectorProxyWorkerWebSocket?.resolve(webSocket);
    return webSocket;
  }
  runtimeMessageMutex = new import_miniflare15.Mutex();
  async sendMessageToProxyWorker(message, retries = 3) {
    if (this._torndown)
      return;
    try {
      await this.runtimeMessageMutex.runWith(async () => {
        (0, import_node_assert20.default)(this.proxyWorker, "proxyWorker should already be instantiated");
        const ready = await this.proxyWorker.ready.catch(() => void 0);
        if (!ready)
          return;
        return this.proxyWorker.dispatchFetch(
          `http://dummy/cdn-cgi/ProxyWorker/${message.type}`,
          {
            headers: { Authorization: this.secret },
            cf: { hostMetadata: message }
          }
        );
      });
    } catch (cause) {
      if (this._torndown)
        return;
      const error2 = castErrorCause(cause);
      if (retries > 0) {
        return this.sendMessageToProxyWorker(message, retries - 1);
      }
      this.emitErrorEvent(
        `Failed to send message to ProxyWorker: ${JSON.stringify(message)}`,
        error2
      );
      throw error2;
    }
  }
  async sendMessageToInspectorProxyWorker(message, retries = 3) {
    if (this._torndown)
      return;
    try {
      const websocket = await this.reconnectInspectorProxyWorker();
      (0, import_node_assert20.default)(websocket);
      websocket.send(JSON.stringify(message));
    } catch (cause) {
      if (this._torndown)
        return;
      const error2 = castErrorCause(cause);
      if (retries > 0) {
        return this.sendMessageToInspectorProxyWorker(message, retries - 1);
      }
      this.emitErrorEvent(
        `Failed to send message to InspectorProxyWorker: ${JSON.stringify(
          message
        )}`,
        error2
      );
      throw error2;
    }
  }
  // ******************
  //   Event Handlers
  // ******************
  onConfigUpdate(data) {
    this.latestConfig = data.config;
    this.createProxyWorker();
    void this.sendMessageToProxyWorker({ type: "pause" });
  }
  onBundleStart(data) {
    this.latestConfig = data.config;
    void this.sendMessageToProxyWorker({ type: "pause" });
  }
  onReloadStart(data) {
    this.latestConfig = data.config;
    void this.sendMessageToProxyWorker({ type: "pause" });
    void this.sendMessageToInspectorProxyWorker({ type: "reloadStart" });
  }
  onReloadComplete(data) {
    this.latestConfig = data.config;
    this.latestBundle = data.bundle;
    void this.sendMessageToProxyWorker({
      type: "play",
      proxyData: data.proxyData
    });
    void this.sendMessageToInspectorProxyWorker({
      type: "reloadComplete",
      proxyData: data.proxyData
    });
  }
  onProxyWorkerMessage(message) {
    switch (message.type) {
      case "previewTokenExpired":
        this.emitPreviewTokenExpiredEvent(message.proxyData);
        break;
      case "error":
        this.emitErrorEvent("Error inside ProxyWorker", message.error);
        break;
      case "debug-log":
        logger.debug("[ProxyWorker]", ...message.args);
        break;
      default:
        assertNever(message);
    }
  }
  onInspectorProxyWorkerMessage(message) {
    switch (message.method) {
      case "Runtime.consoleAPICalled": {
        if (this._torndown)
          return;
        logConsoleMessage(message.params);
        break;
      }
      case "Runtime.exceptionThrown": {
        if (this._torndown)
          return;
        const stack = getSourceMappedStack(message.params.exceptionDetails);
        logger.error(message.params.exceptionDetails.text, stack);
        break;
      }
      default: {
        assertNever(message);
      }
    }
  }
  async onInspectorProxyWorkerRequest(message) {
    switch (message.type) {
      case "runtime-websocket-error":
        logger.debug(
          "[InspectorProxyWorker] 'runtime websocket' error",
          message.error
        );
        break;
      case "error":
        this.emitErrorEvent("Error inside InspectorProxyWorker", message.error);
        break;
      case "debug-log":
        if (this._torndown)
          break;
        logger.debug("[InspectorProxyWorker]", ...message.args);
        break;
      case "load-network-resource": {
        (0, import_node_assert20.default)(this.latestConfig !== void 0);
        (0, import_node_assert20.default)(this.latestBundle !== void 0);
        let maybeContents;
        if (message.url.startsWith("wrangler-file:")) {
          maybeContents = maybeHandleNetworkLoadResource(
            message.url.replace("wrangler-file:", "file:"),
            this.latestBundle,
            this.latestBundle.sourceMapMetadata?.tmpDir
          );
        }
        if (maybeContents === void 0) {
          return new import_miniflare15.Response(null, { status: 404 });
        }
        return new import_miniflare15.Response(maybeContents);
      }
      default:
        assertNever(message);
        return new import_miniflare15.Response(null, { status: 404 });
    }
    return new import_miniflare15.Response(null, { status: 204 });
  }
  _torndown = false;
  async teardown() {
    logger.debug("ProxyController teardown");
    this._torndown = true;
    const { proxyWorker } = this;
    this.proxyWorker = void 0;
    await Promise.all([
      proxyWorker?.dispose(),
      this.inspectorProxyWorkerWebSocket?.promise.then((ws) => ws.close()).catch(() => {
      })
    ]);
  }
  // *********************
  //   Event Dispatchers
  // *********************
  emitReadyEvent(proxyWorker) {
    const data = {
      type: "ready",
      proxyWorker
    };
    this.emit("ready", data);
    this.ready.resolve(data);
  }
  emitPreviewTokenExpiredEvent(proxyData) {
    this.emit("previewTokenExpired", {
      type: "previewTokenExpired",
      proxyData
    });
  }
  emitErrorEvent(reason, cause) {
    const event = {
      type: "error",
      source: "ProxyController",
      cause,
      reason,
      data: {
        config: this.latestConfig,
        bundle: this.latestBundle
      }
    };
    this.emit("error", event);
  }
  // @ts-expect-error Missing initialisation (only need the signature types, base implementation is fine)
  once;
};
__name(ProxyController, "ProxyController");
var ProxyControllerLogger = class extends WranglerLog {
  log(message) {
    if (message.includes("/cdn-cgi/") && this.level < import_miniflare15.LogLevel.DEBUG)
      return;
    super.log(message);
  }
};
__name(ProxyControllerLogger, "ProxyControllerLogger");
function deepEquality(a, b2) {
  return JSON.stringify(a) === JSON.stringify(b2);
}
__name(deepEquality, "deepEquality");
function didMiniflareOptionsChange(prev, next) {
  if (prev === void 0)
    return false;
  return !deepEquality(prev, next);
}
__name(didMiniflareOptionsChange, "didMiniflareOptionsChange");

// src/api/startDevWorker/RemoteRuntimeController.ts
init_import_meta_url();
var RemoteRuntimeController = class extends RuntimeController {
  // ******************
  //   Event Handlers
  // ******************
  onBundleStart(_3) {
    notImplemented(this.onBundleStart.name, this.constructor.name);
  }
  onBundleComplete(_3) {
    notImplemented(this.onBundleComplete.name, this.constructor.name);
  }
  onPreviewTokenExpired(_3) {
    notImplemented(this.onPreviewTokenExpired.name, this.constructor.name);
  }
  async teardown() {
    notImplemented(this.teardown.name, this.constructor.name);
  }
  // *********************
  //   Event Dispatchers
  // *********************
  emitReloadStartEvent(data) {
    this.emit("reloadComplete", data);
  }
  emitReloadCompletetEvent(data) {
    this.emit("reloadComplete", data);
  }
};
__name(RemoteRuntimeController, "RemoteRuntimeController");

// src/api/startDevWorker/DevEnv.ts
var DevEnv = class extends import_node_events5.EventEmitter {
  config;
  bundler;
  runtimes;
  proxy;
  startWorker(options29) {
    const worker = createWorkerObject(this);
    this.config.setOptions(options29);
    return worker;
  }
  constructor({
    config = new ConfigController(),
    bundler = new BundlerController(),
    runtimes = [
      new LocalRuntimeController(),
      new RemoteRuntimeController()
    ],
    proxy: proxy2 = new ProxyController()
  } = {}) {
    super();
    this.config = config;
    this.bundler = bundler;
    this.runtimes = runtimes;
    this.proxy = proxy2;
    [config, bundler, ...runtimes, proxy2].forEach(
      (controller) => controller.on("error", (event) => this.emitErrorEvent(event))
    );
    this.on("error", (event) => {
      logger.error(`Error in ${event.source}: ${event.reason}
`, event.cause);
      logger.debug("=> Error contextual data:", event.data);
    });
    config.on("configUpdate", (event) => {
      bundler.onConfigUpdate(event);
      proxy2.onConfigUpdate(event);
    });
    bundler.on("bundleStart", (event) => {
      proxy2.onBundleStart(event);
      runtimes.forEach((runtime) => {
        runtime.onBundleStart(event);
      });
    });
    bundler.on("bundleComplete", (event) => {
      runtimes.forEach((runtime) => {
        runtime.onBundleComplete(event);
      });
    });
    runtimes.forEach((runtime) => {
      runtime.on("reloadStart", (event) => {
        proxy2.onReloadStart(event);
      });
      runtime.on("reloadComplete", (event) => {
        proxy2.onReloadComplete(event);
      });
    });
    proxy2.on("previewTokenExpired", (event) => {
      runtimes.forEach((runtime) => {
        runtime.onPreviewTokenExpired(event);
      });
    });
  }
  // *********************
  //   Event Dispatchers
  // *********************
  async teardown() {
    this.emit("teardown");
    await Promise.all([
      this.config.teardown(),
      this.bundler.teardown(),
      this.runtimes.forEach((runtime) => runtime.teardown()),
      this.proxy.teardown()
    ]);
  }
  emitErrorEvent(ev) {
    if (ev.source === "ProxyController" && ev.reason === "Failed to start ProxyWorker or InspectorProxyWorker") {
      (0, import_node_assert21.default)(ev.data.config);
      const { config } = ev.data;
      const port2 = config.dev?.server?.port;
      const inspectorPort = config.dev?.inspector?.port;
      const randomPorts = [0, void 0];
      if (!randomPorts.includes(port2) || !randomPorts.includes(inspectorPort)) {
        this.config.emitConfigUpdateEvent({
          type: "configUpdate",
          config: {
            ...config,
            dev: {
              ...config.dev,
              server: { ...config.dev?.server, port: 0 },
              // override port
              inspector: { ...config.dev?.inspector, port: 0 }
              // override port
            }
          }
        });
      }
    } else if (ev.source === "ProxyController" && (ev.reason.startsWith("Failed to send message to") || ev.reason.startsWith("Could not connect to InspectorProxyWorker"))) {
      logger.debug(`Error in ${ev.source}: ${ev.reason}
`, ev.cause);
      logger.debug("=> Error contextual data:", ev.data);
    } else {
      this.emit("error", ev);
    }
  }
};
__name(DevEnv, "DevEnv");
function createWorkerObject(devEnv) {
  return {
    get ready() {
      return devEnv.proxy.ready.promise.then(() => void 0);
    },
    get config() {
      return devEnv.config.config;
    },
    setOptions(options29) {
      return devEnv.config.setOptions(options29);
    },
    updateOptions(options29) {
      return devEnv.config.updateOptions(options29);
    },
    async fetch(...args) {
      const { proxyWorker } = await devEnv.proxy.ready.promise;
      await devEnv.proxy.runtimeMessageMutex.drained();
      return proxyWorker.dispatchFetch(...args);
    },
    async queue(..._args) {
    },
    async scheduled(..._args) {
    },
    async dispose() {
      await devEnv.teardown();
    }
  };
}
__name(createWorkerObject, "createWorkerObject");

// src/api/startDevWorker/types.ts
init_import_meta_url();

// src/api/integrations/index.ts
init_import_meta_url();

// src/api/integrations/platform/index.ts
init_import_meta_url();
var import_miniflare18 = require("miniflare");

// src/api/integrations/platform/caches.ts
init_import_meta_url();
var CacheStorage = class {
  constructor() {
    const unsupportedMethods = ["has", "delete", "keys", "match"];
    unsupportedMethods.forEach((method) => {
      Object.defineProperty(this, method, {
        enumerable: false,
        value: () => {
          throw new Error(
            `Failed to execute '${method}' on 'CacheStorage': the method is not implemented.`
          );
        }
      });
    });
    Object.defineProperty(this, "default", {
      enumerable: true,
      value: this.default
    });
  }
  async open(cacheName) {
    return new Cache2();
  }
  get default() {
    return new Cache2();
  }
};
__name(CacheStorage, "CacheStorage");
var Cache2 = class {
  async delete(request3, options29) {
    return false;
  }
  async match(request3, options29) {
    return void 0;
  }
  async put(request3, response) {
  }
};
__name(Cache2, "Cache");

// src/api/integrations/platform/executionContext.ts
init_import_meta_url();
var ExecutionContext = class {
  // eslint-disable-next-line @typescript-eslint/no-explicit-any, unused-imports/no-unused-vars
  waitUntil(promise) {
  }
  passThroughOnException() {
  }
};
__name(ExecutionContext, "ExecutionContext");

// src/api/integrations/platform/services.ts
init_import_meta_url();
var import_miniflare17 = require("miniflare");
var import_undici26 = __toESM(require_undici());
async function getServiceBindings(services = []) {
  if (services.length === 0) {
    return;
  }
  const registeredWorkers = await maybeGetRegisteredWorkers();
  if (!registeredWorkers) {
    return;
  }
  const foundServices = [];
  for (const { binding: bindingName, service: serviceName } of services) {
    const worker = registeredWorkers[serviceName];
    if (worker) {
      foundServices.push({
        bindingName,
        serviceName,
        workerDefinition: worker
      });
    }
  }
  const serviceBindings = {};
  for (const bindingInfo of foundServices) {
    serviceBindings[bindingInfo.bindingName] = getServiceBindingProxyFetch(bindingInfo);
  }
  return serviceBindings;
}
__name(getServiceBindings, "getServiceBindings");
function getServiceBindingProxyFetch({
  workerDefinition,
  bindingName,
  serviceName
}) {
  const { protocol, host, port: port2 } = workerDefinition;
  const getExternalUrl = /* @__PURE__ */ __name((request3) => {
    const newUrl = new URL(request3.url);
    if (protocol)
      newUrl.protocol = protocol;
    if (host)
      newUrl.host = host;
    if (port2)
      newUrl.port = `${port2}`;
    return newUrl;
  }, "getExternalUrl");
  return async (request3) => {
    const newUrl = getExternalUrl(request3);
    try {
      const resp = await (0, import_undici26.fetch)(newUrl, request3);
      const respBody = await resp.arrayBuffer();
      return new import_miniflare17.Response(respBody, resp);
    } catch {
      return new import_miniflare17.Response(
        `Error: Unable to fetch from external service (${serviceName} bound with ${bindingName} binding), please make sure that the service is still running with \`wrangler dev\``,
        { status: 500 }
      );
    }
  };
}
__name(getServiceBindingProxyFetch, "getServiceBindingProxyFetch");
async function maybeGetRegisteredWorkers() {
  try {
    return await getRegisteredWorkers();
  } catch {
    return void 0;
  }
}
__name(maybeGetRegisteredWorkers, "maybeGetRegisteredWorkers");

// src/api/integrations/platform/index.ts
async function getPlatformProxy(options29 = {}) {
  const env5 = options29.environment;
  const rawConfig = readConfig(options29.configPath, {
    experimentalJsonConfig: options29.experimentalJsonConfig,
    env: env5
  });
  const miniflareOptions = await getMiniflareOptionsFromConfig(
    rawConfig,
    env5,
    options29
  );
  const mf = new import_miniflare18.Miniflare({
    script: "",
    modules: true,
    ...miniflareOptions
  });
  const bindings = await mf.getBindings();
  const vars = getVarsForDev(rawConfig, env5);
  const cf = await mf.getCf();
  deepFreeze(cf);
  return {
    env: {
      ...vars,
      ...bindings
    },
    cf,
    ctx: new ExecutionContext(),
    caches: new CacheStorage(),
    dispose: () => mf.dispose()
  };
}
__name(getPlatformProxy, "getPlatformProxy");
async function getMiniflareOptionsFromConfig(rawConfig, env5, options29) {
  const bindings = getBindings(rawConfig, env5, true, {});
  const workerDefinitions = await getBoundRegisteredWorkers({
    name: rawConfig.name,
    services: bindings.services,
    durableObjects: rawConfig["durable_objects"]
  });
  const { bindingOptions, externalWorkers } = buildMiniflareBindingOptions({
    name: void 0,
    bindings,
    workerDefinitions,
    queueConsumers: void 0,
    services: rawConfig.services,
    serviceBindings: {}
  });
  const persistOptions = getMiniflarePersistOptions(options29.persist);
  const serviceBindings = await getServiceBindings(bindings.services);
  const miniflareOptions = {
    workers: [
      {
        script: "",
        modules: true,
        ...bindingOptions,
        serviceBindings: {
          ...serviceBindings,
          ...bindingOptions.serviceBindings
        }
      },
      ...externalWorkers
    ],
    ...persistOptions
  };
  return miniflareOptions;
}
__name(getMiniflareOptionsFromConfig, "getMiniflareOptionsFromConfig");
function getMiniflarePersistOptions(persist) {
  if (persist === false) {
    return {
      kvPersist: false,
      durableObjectsPersist: false,
      r2Persist: false,
      d1Persist: false
    };
  }
  const defaultPersistPath = ".wrangler/state/v3";
  const persistPath = typeof persist === "object" ? persist.path : defaultPersistPath;
  return {
    kvPersist: `${persistPath}/kv`,
    durableObjectsPersist: `${persistPath}/do`,
    r2Persist: `${persistPath}/r2`,
    d1Persist: `${persistPath}/d1`
  };
}
__name(getMiniflarePersistOptions, "getMiniflarePersistOptions");
function deepFreeze(obj) {
  Object.freeze(obj);
  Object.entries(obj).forEach(([, prop]) => {
    if (prop !== null && typeof prop === "object" && !Object.isFrozen(prop)) {
      deepFreeze(prop);
    }
  });
}
__name(deepFreeze, "deepFreeze");
function unstable_getMiniflareWorkerOptions(configPath, environment) {
  const config = readConfig(configPath, {
    experimentalJsonConfig: true,
    env: environment
  });
  const modulesRules = config.rules.concat(DEFAULT_MODULE_RULES).map((rule) => ({
    type: rule.type,
    include: rule.globs,
    fallthrough: rule.fallthrough
  }));
  const env5 = void 0;
  const bindings = getBindings(config, env5, true, {});
  const { bindingOptions } = buildMiniflareBindingOptions({
    name: void 0,
    bindings,
    workerDefinitions: void 0,
    queueConsumers: config.queues.consumers,
    services: [],
    serviceBindings: {}
  });
  if (bindings.services !== void 0) {
    bindingOptions.serviceBindings = Object.fromEntries(
      bindings.services.map((binding) => {
        return [binding.binding, binding.service];
      })
    );
  }
  if (bindings.durable_objects !== void 0) {
    bindingOptions.durableObjects = Object.fromEntries(
      bindings.durable_objects.bindings.map((binding) => [
        binding.name,
        { className: binding.class_name, scriptName: binding.script_name }
      ])
    );
  }
  const assetPaths = config.assets ? getAssetPaths(config, void 0) : getSiteAssetPaths(config);
  const sitesOptions = buildSitesOptions({ assetPaths });
  const workerOptions = {
    compatibilityDate: config.compatibility_date,
    compatibilityFlags: config.compatibility_flags,
    modulesRules,
    ...bindingOptions,
    ...sitesOptions
  };
  return { workerOptions, define: config.define, main: config.main };
}
__name(unstable_getMiniflareWorkerOptions, "unstable_getMiniflareWorkerOptions");

// src/api/integrations/deprecated/index.ts
init_import_meta_url();

// src/api/integrations/deprecated/getBindingsProxy.ts
init_import_meta_url();
async function getBindingsProxy(options29 = {}) {
  const { env: env5, ...restOfPlatformProxy } = await getPlatformProxy(options29);
  return {
    bindings: env5,
    ...restOfPlatformProxy
  };
}
__name(getBindingsProxy, "getBindingsProxy");

// src/cli.ts
if (typeof jest === "undefined" && require.main === module) {
  main(hideBin(import_process6.default.argv)).catch((e3) => {
    const exitCode = e3 instanceof FatalError && e3.code || 1;
    import_process6.default.exit(exitCode);
  });
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  getBindingsProxy,
  getPlatformProxy,
  unstable_DevEnv,
  unstable_dev,
  unstable_getMiniflareWorkerOptions,
  unstable_pages,
  unstable_splitSqlQuery,
  unstable_startWorkerRegistryServer
});
/*!
 * Copyright (c) 2011 Felix Geisendörfer (felix@debuggable.com)
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
 *  in the Software without restriction, including without limitation the rights
 *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 *  copies of the Software, and to permit persons to whom the Software is
 *  furnished to do so, subject to the following conditions:
 *
 *  The above copyright notice and this permission notice shall be included in
 *  all copies or substantial portions of the Software.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 *  THE SOFTWARE.
 */
/*! Bundled license information:

undici/lib/fetch/body.js:
  (*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> *)

undici/lib/websocket/frame.js:
  (*! ws. MIT License. Einar Otto Stangvik <einaros@gmail.com> *)

@webcontainer/env/dist/index.js:
  (**
   * @license Copyright 2022 Stackblitz, Inc. All Rights Reserved.
   * Portions of this software are patent pending in USA and EU jurisdictions.
   * More info available at https://stackblitz.com/terms-of-service.
   *)

object-assign/index.js:
  (*
  object-assign
  (c) Sindre Sorhus
  @license MIT
  *)

react/cjs/react.production.min.js:
  (** @license React v17.0.2
   * react.production.min.js
   *
   * Copyright (c) Facebook, Inc. and its affiliates.
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE file in the root directory of this source tree.
   *)

lodash/lodash.js:
  (**
   * @license
   * Lodash <https://lodash.com/>
   * 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
   *)

scheduler/cjs/scheduler.production.min.js:
  (** @license React v0.20.2
   * scheduler.production.min.js
   *
   * Copyright (c) Facebook, Inc. and its affiliates.
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE file in the root directory of this source tree.
   *)

react-reconciler/cjs/react-reconciler.production.min.js:
  (** @license React v0.26.2
   * react-reconciler.production.min.js
   *
   * Copyright (c) Facebook, Inc. and its affiliates.
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE file in the root directory of this source tree.
   *)

react-devtools-core/dist/backend.js:
  (*
  object-assign
  (c) Sindre Sorhus
  @license MIT
  *)
  (*! promise-polyfill 2.0.1 *)
  (**
   * @license React
   * react-is.production.min.js
   *
   * Copyright (c) Facebook, Inc. and its affiliates.
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE file in the root directory of this source tree.
   *)
  (**
   * @license React
   * react-debug-tools.production.min.js
   *
   * Copyright (c) Facebook, Inc. and its affiliates.
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE file in the root directory of this source tree.
   *)
  (**
   * @license React
   * react.production.min.js
   *
   * Copyright (c) Facebook, Inc. and its affiliates.
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE file in the root directory of this source tree.
   *)

arch/index.js:
  (*! arch. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)

depd/index.js:
  (*!
   * depd
   * Copyright(c) 2014-2018 Douglas Christopher Wilson
   * MIT Licensed
   *)

bytes/index.js:
  (*!
   * bytes
   * Copyright(c) 2012-2014 TJ Holowaychuk
   * Copyright(c) 2015 Jed Watson
   * MIT Licensed
   *)

content-type/index.js:
  (*!
   * content-type
   * Copyright(c) 2015 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
   *)

destroy/index.js:
  (*!
   * destroy
   * Copyright(c) 2014 Jonathan Ong
   * Copyright(c) 2015-2022 Douglas Christopher Wilson
   * 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
   * Copyright(c) 2013 Jonathan Ong
   * Copyright(c) 2014 Douglas Christopher Wilson
   * MIT Licensed
   *)

body-parser/lib/read.js:
  (*!
   * body-parser
   * Copyright(c) 2014-2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

media-typer/index.js:
  (*!
   * media-typer
   * Copyright(c) 2014 Douglas Christopher Wilson
   * MIT Licensed
   *)

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
   * Copyright(c) 2014 Jonathan Ong
   * Copyright(c) 2015 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/types/json.js:
  (*!
   * body-parser
   * Copyright(c) 2014 Jonathan Ong
   * Copyright(c) 2014-2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

body-parser/lib/types/raw.js:
  (*!
   * body-parser
   * Copyright(c) 2014-2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

body-parser/lib/types/text.js:
  (*!
   * body-parser
   * Copyright(c) 2014-2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

body-parser/lib/types/urlencoded.js:
  (*!
   * body-parser
   * Copyright(c) 2014 Jonathan Ong
   * Copyright(c) 2014-2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

body-parser/index.js:
  (*!
   * body-parser
   * Copyright(c) 2014-2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

merge-descriptors/index.js:
  (*!
   * merge-descriptors
   * Copyright(c) 2014 Jonathan Ong
   * Copyright(c) 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/router/layer.js:
  (*!
   * express
   * Copyright(c) 2009-2013 TJ Holowaychuk
   * Copyright(c) 2013 Roman Shtylman
   * Copyright(c) 2014-2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

methods/index.js:
  (*!
   * methods
   * Copyright(c) 2013-2014 TJ Holowaychuk
   * Copyright(c) 2015-2016 Douglas Christopher Wilson
   * MIT Licensed
   *)

express/lib/router/route.js:
  (*!
   * express
   * Copyright(c) 2009-2013 TJ Holowaychuk
   * Copyright(c) 2013 Roman Shtylman
   * Copyright(c) 2014-2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

express/lib/router/index.js:
  (*!
   * express
   * Copyright(c) 2009-2013 TJ Holowaychuk
   * Copyright(c) 2013 Roman Shtylman
   * Copyright(c) 2014-2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

express/lib/middleware/init.js:
  (*!
   * express
   * Copyright(c) 2009-2013 TJ Holowaychuk
   * Copyright(c) 2013 Roman Shtylman
   * Copyright(c) 2014-2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

express/lib/middleware/query.js:
  (*!
   * express
   * Copyright(c) 2009-2013 TJ Holowaychuk
   * Copyright(c) 2013 Roman Shtylman
   * Copyright(c) 2014-2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

express/lib/view.js:
  (*!
   * express
   * Copyright(c) 2009-2013 TJ Holowaychuk
   * Copyright(c) 2013 Roman Shtylman
   * Copyright(c) 2014-2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

safe-buffer/index.js:
  (*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)

content-disposition/index.js:
  (*!
   * content-disposition
   * Copyright(c) 2014-2017 Douglas Christopher Wilson
   * MIT Licensed
   *)

etag/index.js:
  (*!
   * etag
   * Copyright(c) 2014-2016 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
   *)

send/index.js:
  (*!
   * send
   * Copyright(c) 2012 TJ Holowaychuk
   * Copyright(c) 2014-2022 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
   * Copyright(c) 2009-2013 TJ Holowaychuk
   * Copyright(c) 2014-2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

express/lib/application.js:
  (*!
   * express
   * Copyright(c) 2009-2013 TJ Holowaychuk
   * Copyright(c) 2013 Roman Shtylman
   * Copyright(c) 2014-2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

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
   * Copyright(c) 2014 Jonathan Ong
   * Copyright(c) 2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

express/lib/request.js:
  (*!
   * express
   * Copyright(c) 2009-2013 TJ Holowaychuk
   * Copyright(c) 2013 Roman Shtylman
   * Copyright(c) 2014-2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

cookie/index.js:
  (*!
   * cookie
   * Copyright(c) 2012-2014 Roman Shtylman
   * Copyright(c) 2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

vary/index.js:
  (*!
   * vary
   * Copyright(c) 2014-2017 Douglas Christopher Wilson
   * MIT Licensed
   *)

express/lib/response.js:
  (*!
   * express
   * Copyright(c) 2009-2013 TJ Holowaychuk
   * Copyright(c) 2014-2015 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
   *)

express/lib/express.js:
  (*!
   * express
   * Copyright(c) 2009-2013 TJ Holowaychuk
   * Copyright(c) 2013 Roman Shtylman
   * Copyright(c) 2014-2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

express/index.js:
  (*!
   * express
   * Copyright(c) 2009-2013 TJ Holowaychuk
   * Copyright(c) 2013 Roman Shtylman
   * Copyright(c) 2014-2015 Douglas Christopher Wilson
   * MIT Licensed
   *)

uri-js/dist/es5/uri.all.js:
  (** @license URI.js v4.4.1 (c) 2011 Gary Court. License: http://github.com/garycourt/uri-js *)

deep-extend/lib/deep-extend.js:
  (*!
   * @description Recursive object extending
   * @author Viacheslav Lotsmanov <lotsmanov89@gmail.com>
   * @license MIT
   *
   * The MIT License (MIT)
   *
   * Copyright (c) 2013-2018 Viacheslav Lotsmanov
   *
   * Permission is hereby granted, free of charge, to any person obtaining a copy of
   * this software and associated documentation files (the "Software"), to deal in
   * the Software without restriction, including without limitation the rights to
   * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
   * the Software, and to permit persons to whom the Software is furnished to do so,
   * subject to the following conditions:
   *
   * The above copyright notice and this permission notice shall be included in all
   * copies or substantial portions of the Software.
   *
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
   * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
   * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
   * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
   * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   *)

@miniflare/shared/dist/src/index.js:
  (*! Path sanitisation regexps adapted from node-sanitize-filename:
   * https://github.com/parshap/node-sanitize-filename/blob/209c39b914c8eb48ee27bcbde64b2c7822fdf3de/index.js#L4-L37
   *
   * Licensed under the ISC license:
   *
   * Copyright Parsha Pourkhomami <parshap@gmail.com>
   *
   * Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the
   * above copyright notice and this permission notice appear in all copies.
   *
   * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY
   * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
   * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   *)

undici/lib/fetch/body.js:
  (*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> *)

undici/lib/websocket/frame.js:
  (*! ws. MIT License. Einar Otto Stangvik <einaros@gmail.com> *)

yargs-parser/build/lib/string-utils.js:
  (**
   * @license
   * Copyright (c) 2016, Contributors
   * SPDX-License-Identifier: ISC
   *)

yargs-parser/build/lib/tokenize-arg-string.js:
  (**
   * @license
   * Copyright (c) 2016, Contributors
   * SPDX-License-Identifier: ISC
   *)

yargs-parser/build/lib/yargs-parser-types.js:
  (**
   * @license
   * Copyright (c) 2016, Contributors
   * SPDX-License-Identifier: ISC
   *)

yargs-parser/build/lib/yargs-parser.js:
  (**
   * @license
   * Copyright (c) 2016, Contributors
   * SPDX-License-Identifier: ISC
   *)

yargs-parser/build/lib/index.js:
  (**
   * @fileoverview Main entrypoint for libraries using yargs-parser in Node.js
   * CJS and ESM environments.
   *
   * @license
   * Copyright (c) 2016, Contributors
   * SPDX-License-Identifier: ISC
   *)
*/