@hot-updater/aws 0.11.0 → 0.12.1-0

package/dist/lambda/index.cjs

@@ -0,0 +1,4734 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[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 __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);
+
+// lambda/index.ts
+var index_exports = {};
+__export(index_exports, {
+  handler: () => handler
+});
+module.exports = __toCommonJS(index_exports);
+var import_client_s32 = require("@aws-sdk/client-s3");
+
+// ../../node_modules/.pnpm/@smithy+util-uri-escape@4.0.0/node_modules/@smithy/util-uri-escape/dist-es/escape-uri.js
+var escapeUri = (uri) => encodeURIComponent(uri).replace(/[!'()*]/g, hexEncode);
+var hexEncode = (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`;
+
+// ../../node_modules/.pnpm/@smithy+querystring-builder@4.0.1/node_modules/@smithy/querystring-builder/dist-es/index.js
+function buildQueryString(query) {
+  const parts = [];
+  for (let key of Object.keys(query).sort()) {
+    const value = query[key];
+    key = escapeUri(key);
+    if (Array.isArray(value)) {
+      for (let i = 0, iLen = value.length; i < iLen; i++) {
+        parts.push(`${key}=${escapeUri(value[i])}`);
+      }
+    } else {
+      let qsEntry = key;
+      if (value || typeof value === "string") {
+        qsEntry += `=${escapeUri(value)}`;
+      }
+      parts.push(qsEntry);
+    }
+  }
+  return parts.join("&");
+}
+
+// ../../node_modules/.pnpm/@aws-sdk+util-format-url@3.734.0/node_modules/@aws-sdk/util-format-url/dist-es/index.js
+function formatUrl(request) {
+  const { port, query } = request;
+  let { protocol, path, hostname } = request;
+  if (protocol && protocol.slice(-1) !== ":") {
+    protocol += ":";
+  }
+  if (port) {
+    hostname += `:${port}`;
+  }
+  if (path && path.charAt(0) !== "/") {
+    path = `/${path}`;
+  }
+  let queryString = query ? buildQueryString(query) : "";
+  if (queryString && queryString[0] !== "?") {
+    queryString = `?${queryString}`;
+  }
+  let auth = "";
+  if (request.username != null || request.password != null) {
+    const username = request.username ?? "";
+    const password = request.password ?? "";
+    auth = `${username}:${password}@`;
+  }
+  let fragment = "";
+  if (request.fragment) {
+    fragment = `#${request.fragment}`;
+  }
+  return `${protocol}//${auth}${hostname}${path}${queryString}${fragment}`;
+}
+
+// ../../node_modules/.pnpm/@smithy+middleware-endpoint@4.0.5/node_modules/@smithy/middleware-endpoint/dist-es/service-customizations/s3.js
+var resolveParamsForS3 = async (endpointParams) => {
+  const bucket = endpointParams?.Bucket || "";
+  if (typeof endpointParams.Bucket === "string") {
+    endpointParams.Bucket = bucket.replace(/#/g, encodeURIComponent("#")).replace(/\?/g, encodeURIComponent("?"));
+  }
+  if (isArnBucketName(bucket)) {
+    if (endpointParams.ForcePathStyle === true) {
+      throw new Error("Path-style addressing cannot be used with ARN buckets");
+    }
+  } else if (!isDnsCompatibleBucketName(bucket) || bucket.indexOf(".") !== -1 && !String(endpointParams.Endpoint).startsWith("http:") || bucket.toLowerCase() !== bucket || bucket.length < 3) {
+    endpointParams.ForcePathStyle = true;
+  }
+  if (endpointParams.DisableMultiRegionAccessPoints) {
+    endpointParams.disableMultiRegionAccessPoints = true;
+    endpointParams.DisableMRAP = true;
+  }
+  return endpointParams;
+};
+var DOMAIN_PATTERN = /^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$/;
+var IP_ADDRESS_PATTERN = /(\d+\.){3}\d+/;
+var DOTS_PATTERN = /\.\./;
+var isDnsCompatibleBucketName = (bucketName) => DOMAIN_PATTERN.test(bucketName) && !IP_ADDRESS_PATTERN.test(bucketName) && !DOTS_PATTERN.test(bucketName);
+var isArnBucketName = (bucketName) => {
+  const [arn, partition, service, , , bucket] = bucketName.split(":");
+  const isArn = arn === "arn" && bucketName.split(":").length >= 6;
+  const isValidArn = Boolean(isArn && partition && service && bucket);
+  if (isArn && !isValidArn) {
+    throw new Error(`Invalid ARN: ${bucketName} was an invalid ARN.`);
+  }
+  return isValidArn;
+};
+
+// ../../node_modules/.pnpm/@smithy+middleware-endpoint@4.0.5/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/createConfigValueProvider.js
+var createConfigValueProvider = (configKey, canonicalEndpointParamKey, config) => {
+  const configProvider = async () => {
+    const configValue = config[configKey] ?? config[canonicalEndpointParamKey];
+    if (typeof configValue === "function") {
+      return configValue();
+    }
+    return configValue;
+  };
+  if (configKey === "credentialScope" || canonicalEndpointParamKey === "CredentialScope") {
+    return async () => {
+      const credentials = typeof config.credentials === "function" ? await config.credentials() : config.credentials;
+      const configValue = credentials?.credentialScope ?? credentials?.CredentialScope;
+      return configValue;
+    };
+  }
+  if (configKey === "accountId" || canonicalEndpointParamKey === "AccountId") {
+    return async () => {
+      const credentials = typeof config.credentials === "function" ? await config.credentials() : config.credentials;
+      const configValue = credentials?.accountId ?? credentials?.AccountId;
+      return configValue;
+    };
+  }
+  if (configKey === "endpoint" || canonicalEndpointParamKey === "endpoint") {
+    return async () => {
+      const endpoint = await configProvider();
+      if (endpoint && typeof endpoint === "object") {
+        if ("url" in endpoint) {
+          return endpoint.url.href;
+        }
+        if ("hostname" in endpoint) {
+          const { protocol, hostname, port, path } = endpoint;
+          return `${protocol}//${hostname}${port ? ":" + port : ""}${path}`;
+        }
+      }
+      return endpoint;
+    };
+  }
+  return configProvider;
+};
+
+// ../../node_modules/.pnpm/@smithy+property-provider@4.0.1/node_modules/@smithy/property-provider/dist-es/ProviderError.js
+var ProviderError = class _ProviderError extends Error {
+  constructor(message, options = true) {
+    let logger;
+    let tryNextLink = true;
+    if (typeof options === "boolean") {
+      logger = void 0;
+      tryNextLink = options;
+    } else if (options != null && typeof options === "object") {
+      logger = options.logger;
+      tryNextLink = options.tryNextLink ?? true;
+    }
+    super(message);
+    this.name = "ProviderError";
+    this.tryNextLink = tryNextLink;
+    Object.setPrototypeOf(this, _ProviderError.prototype);
+    logger?.debug?.(`@smithy/property-provider ${tryNextLink ? "->" : "(!)"} ${message}`);
+  }
+  static from(error, options = true) {
+    return Object.assign(new this(error.message, options), error);
+  }
+};
+
+// ../../node_modules/.pnpm/@smithy+property-provider@4.0.1/node_modules/@smithy/property-provider/dist-es/CredentialsProviderError.js
+var CredentialsProviderError = class _CredentialsProviderError extends ProviderError {
+  constructor(message, options = true) {
+    super(message, options);
+    this.name = "CredentialsProviderError";
+    Object.setPrototypeOf(this, _CredentialsProviderError.prototype);
+  }
+};
+
+// ../../node_modules/.pnpm/@smithy+property-provider@4.0.1/node_modules/@smithy/property-provider/dist-es/chain.js
+var chain = (...providers) => async () => {
+  if (providers.length === 0) {
+    throw new ProviderError("No providers in chain");
+  }
+  let lastProviderError;
+  for (const provider of providers) {
+    try {
+      const credentials = await provider();
+      return credentials;
+    } catch (err) {
+      lastProviderError = err;
+      if (err?.tryNextLink) {
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw lastProviderError;
+};
+
+// ../../node_modules/.pnpm/@smithy+property-provider@4.0.1/node_modules/@smithy/property-provider/dist-es/fromStatic.js
+var fromStatic = (staticValue) => () => Promise.resolve(staticValue);
+
+// ../../node_modules/.pnpm/@smithy+property-provider@4.0.1/node_modules/@smithy/property-provider/dist-es/memoize.js
+var memoize = (provider, isExpired, requiresRefresh) => {
+  let resolved;
+  let pending;
+  let hasResult;
+  let isConstant = false;
+  const coalesceProvider = async () => {
+    if (!pending) {
+      pending = provider();
+    }
+    try {
+      resolved = await pending;
+      hasResult = true;
+      isConstant = false;
+    } finally {
+      pending = void 0;
+    }
+    return resolved;
+  };
+  if (isExpired === void 0) {
+    return async (options) => {
+      if (!hasResult || options?.forceRefresh) {
+        resolved = await coalesceProvider();
+      }
+      return resolved;
+    };
+  }
+  return async (options) => {
+    if (!hasResult || options?.forceRefresh) {
+      resolved = await coalesceProvider();
+    }
+    if (isConstant) {
+      return resolved;
+    }
+    if (requiresRefresh && !requiresRefresh(resolved)) {
+      isConstant = true;
+      return resolved;
+    }
+    if (isExpired(resolved)) {
+      await coalesceProvider();
+      return resolved;
+    }
+    return resolved;
+  };
+};
+
+// ../../node_modules/.pnpm/@smithy+node-config-provider@4.0.1/node_modules/@smithy/node-config-provider/dist-es/getSelectorName.js
+function getSelectorName(functionString) {
+  try {
+    const constants = new Set(Array.from(functionString.match(/([A-Z_]){3,}/g) ?? []));
+    constants.delete("CONFIG");
+    constants.delete("CONFIG_PREFIX_SEPARATOR");
+    constants.delete("ENV");
+    return [...constants].join(", ");
+  } catch (e) {
+    return functionString;
+  }
+}
+
+// ../../node_modules/.pnpm/@smithy+node-config-provider@4.0.1/node_modules/@smithy/node-config-provider/dist-es/fromEnv.js
+var fromEnv = (envVarSelector, logger) => async () => {
+  try {
+    const config = envVarSelector(process.env);
+    if (config === void 0) {
+      throw new Error();
+    }
+    return config;
+  } catch (e) {
+    throw new CredentialsProviderError(e.message || `Not found in ENV: ${getSelectorName(envVarSelector.toString())}`, { logger });
+  }
+};
+
+// ../../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.1/node_modules/@smithy/shared-ini-file-loader/dist-es/getHomeDir.js
+var import_os = require("os");
+var import_path = require("path");
+var homeDirCache = {};
+var getHomeDirCacheKey = () => {
+  if (process && process.geteuid) {
+    return `${process.geteuid()}`;
+  }
+  return "DEFAULT";
+};
+var getHomeDir = () => {
+  const { HOME, USERPROFILE, HOMEPATH, HOMEDRIVE = `C:${import_path.sep}` } = process.env;
+  if (HOME)
+    return HOME;
+  if (USERPROFILE)
+    return USERPROFILE;
+  if (HOMEPATH)
+    return `${HOMEDRIVE}${HOMEPATH}`;
+  const homeDirCacheKey = getHomeDirCacheKey();
+  if (!homeDirCache[homeDirCacheKey])
+    homeDirCache[homeDirCacheKey] = (0, import_os.homedir)();
+  return homeDirCache[homeDirCacheKey];
+};
+
+// ../../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.1/node_modules/@smithy/shared-ini-file-loader/dist-es/getProfileName.js
+var ENV_PROFILE = "AWS_PROFILE";
+var DEFAULT_PROFILE = "default";
+var getProfileName = (init) => init.profile || process.env[ENV_PROFILE] || DEFAULT_PROFILE;
+
+// ../../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.1/node_modules/@smithy/shared-ini-file-loader/dist-es/getSSOTokenFromFile.js
+var import_fs = require("fs");
+var { readFile } = import_fs.promises;
+
+// ../../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.1/node_modules/@smithy/shared-ini-file-loader/dist-es/loadSharedConfigFiles.js
+var import_path4 = require("path");
+
+// ../../node_modules/.pnpm/@smithy+types@4.1.0/node_modules/@smithy/types/dist-es/auth/auth.js
+var HttpAuthLocation;
+(function(HttpAuthLocation2) {
+  HttpAuthLocation2["HEADER"] = "header";
+  HttpAuthLocation2["QUERY"] = "query";
+})(HttpAuthLocation || (HttpAuthLocation = {}));
+
+// ../../node_modules/.pnpm/@smithy+types@4.1.0/node_modules/@smithy/types/dist-es/auth/HttpApiKeyAuth.js
+var HttpApiKeyAuthLocation;
+(function(HttpApiKeyAuthLocation2) {
+  HttpApiKeyAuthLocation2["HEADER"] = "header";
+  HttpApiKeyAuthLocation2["QUERY"] = "query";
+})(HttpApiKeyAuthLocation || (HttpApiKeyAuthLocation = {}));
+
+// ../../node_modules/.pnpm/@smithy+types@4.1.0/node_modules/@smithy/types/dist-es/endpoint.js
+var EndpointURLScheme;
+(function(EndpointURLScheme2) {
+  EndpointURLScheme2["HTTP"] = "http";
+  EndpointURLScheme2["HTTPS"] = "https";
+})(EndpointURLScheme || (EndpointURLScheme = {}));
+
+// ../../node_modules/.pnpm/@smithy+types@4.1.0/node_modules/@smithy/types/dist-es/extensions/checksum.js
+var AlgorithmId;
+(function(AlgorithmId2) {
+  AlgorithmId2["MD5"] = "md5";
+  AlgorithmId2["CRC32"] = "crc32";
+  AlgorithmId2["CRC32C"] = "crc32c";
+  AlgorithmId2["SHA1"] = "sha1";
+  AlgorithmId2["SHA256"] = "sha256";
+})(AlgorithmId || (AlgorithmId = {}));
+
+// ../../node_modules/.pnpm/@smithy+types@4.1.0/node_modules/@smithy/types/dist-es/http.js
+var FieldPosition;
+(function(FieldPosition2) {
+  FieldPosition2[FieldPosition2["HEADER"] = 0] = "HEADER";
+  FieldPosition2[FieldPosition2["TRAILER"] = 1] = "TRAILER";
+})(FieldPosition || (FieldPosition = {}));
+
+// ../../node_modules/.pnpm/@smithy+types@4.1.0/node_modules/@smithy/types/dist-es/profile.js
+var IniSectionType;
+(function(IniSectionType2) {
+  IniSectionType2["PROFILE"] = "profile";
+  IniSectionType2["SSO_SESSION"] = "sso-session";
+  IniSectionType2["SERVICES"] = "services";
+})(IniSectionType || (IniSectionType = {}));
+
+// ../../node_modules/.pnpm/@smithy+types@4.1.0/node_modules/@smithy/types/dist-es/transfer.js
+var RequestHandlerProtocol;
+(function(RequestHandlerProtocol2) {
+  RequestHandlerProtocol2["HTTP_0_9"] = "http/0.9";
+  RequestHandlerProtocol2["HTTP_1_0"] = "http/1.0";
+  RequestHandlerProtocol2["TDS_8_0"] = "tds/8.0";
+})(RequestHandlerProtocol || (RequestHandlerProtocol = {}));
+
+// ../../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.1/node_modules/@smithy/shared-ini-file-loader/dist-es/getConfigData.js
+var getConfigData = (data) => Object.entries(data).filter(([key]) => {
+  const indexOfSeparator = key.indexOf(CONFIG_PREFIX_SEPARATOR);
+  if (indexOfSeparator === -1) {
+    return false;
+  }
+  return Object.values(IniSectionType).includes(key.substring(0, indexOfSeparator));
+}).reduce((acc, [key, value]) => {
+  const indexOfSeparator = key.indexOf(CONFIG_PREFIX_SEPARATOR);
+  const updatedKey = key.substring(0, indexOfSeparator) === IniSectionType.PROFILE ? key.substring(indexOfSeparator + 1) : key;
+  acc[updatedKey] = value;
+  return acc;
+}, {
+  ...data.default && { default: data.default }
+});
+
+// ../../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.1/node_modules/@smithy/shared-ini-file-loader/dist-es/getConfigFilepath.js
+var import_path2 = require("path");
+var ENV_CONFIG_PATH = "AWS_CONFIG_FILE";
+var getConfigFilepath = () => process.env[ENV_CONFIG_PATH] || (0, import_path2.join)(getHomeDir(), ".aws", "config");
+
+// ../../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.1/node_modules/@smithy/shared-ini-file-loader/dist-es/getCredentialsFilepath.js
+var import_path3 = require("path");
+var ENV_CREDENTIALS_PATH = "AWS_SHARED_CREDENTIALS_FILE";
+var getCredentialsFilepath = () => process.env[ENV_CREDENTIALS_PATH] || (0, import_path3.join)(getHomeDir(), ".aws", "credentials");
+
+// ../../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.1/node_modules/@smithy/shared-ini-file-loader/dist-es/parseIni.js
+var prefixKeyRegex = /^([\w-]+)\s(["'])?([\w-@\+\.%:/]+)\2$/;
+var profileNameBlockList = ["__proto__", "profile __proto__"];
+var parseIni = (iniData) => {
+  const map = {};
+  let currentSection;
+  let currentSubSection;
+  for (const iniLine of iniData.split(/\r?\n/)) {
+    const trimmedLine = iniLine.split(/(^|\s)[;#]/)[0].trim();
+    const isSection = trimmedLine[0] === "[" && trimmedLine[trimmedLine.length - 1] === "]";
+    if (isSection) {
+      currentSection = void 0;
+      currentSubSection = void 0;
+      const sectionName = trimmedLine.substring(1, trimmedLine.length - 1);
+      const matches = prefixKeyRegex.exec(sectionName);
+      if (matches) {
+        const [, prefix, , name] = matches;
+        if (Object.values(IniSectionType).includes(prefix)) {
+          currentSection = [prefix, name].join(CONFIG_PREFIX_SEPARATOR);
+        }
+      } else {
+        currentSection = sectionName;
+      }
+      if (profileNameBlockList.includes(sectionName)) {
+        throw new Error(`Found invalid profile name "${sectionName}"`);
+      }
+    } else if (currentSection) {
+      const indexOfEqualsSign = trimmedLine.indexOf("=");
+      if (![0, -1].includes(indexOfEqualsSign)) {
+        const [name, value] = [
+          trimmedLine.substring(0, indexOfEqualsSign).trim(),
+          trimmedLine.substring(indexOfEqualsSign + 1).trim()
+        ];
+        if (value === "") {
+          currentSubSection = name;
+        } else {
+          if (currentSubSection && iniLine.trimStart() === iniLine) {
+            currentSubSection = void 0;
+          }
+          map[currentSection] = map[currentSection] || {};
+          const key = currentSubSection ? [currentSubSection, name].join(CONFIG_PREFIX_SEPARATOR) : name;
+          map[currentSection][key] = value;
+        }
+      }
+    }
+  }
+  return map;
+};
+
+// ../../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.1/node_modules/@smithy/shared-ini-file-loader/dist-es/slurpFile.js
+var import_fs2 = require("fs");
+var { readFile: readFile2 } = import_fs2.promises;
+var filePromisesHash = {};
+var slurpFile = (path, options) => {
+  if (!filePromisesHash[path] || options?.ignoreCache) {
+    filePromisesHash[path] = readFile2(path, "utf8");
+  }
+  return filePromisesHash[path];
+};
+
+// ../../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.1/node_modules/@smithy/shared-ini-file-loader/dist-es/loadSharedConfigFiles.js
+var swallowError = () => ({});
+var CONFIG_PREFIX_SEPARATOR = ".";
+var loadSharedConfigFiles = async (init = {}) => {
+  const { filepath = getCredentialsFilepath(), configFilepath = getConfigFilepath() } = init;
+  const homeDir = getHomeDir();
+  const relativeHomeDirPrefix = "~/";
+  let resolvedFilepath = filepath;
+  if (filepath.startsWith(relativeHomeDirPrefix)) {
+    resolvedFilepath = (0, import_path4.join)(homeDir, filepath.slice(2));
+  }
+  let resolvedConfigFilepath = configFilepath;
+  if (configFilepath.startsWith(relativeHomeDirPrefix)) {
+    resolvedConfigFilepath = (0, import_path4.join)(homeDir, configFilepath.slice(2));
+  }
+  const parsedFiles = await Promise.all([
+    slurpFile(resolvedConfigFilepath, {
+      ignoreCache: init.ignoreCache
+    }).then(parseIni).then(getConfigData).catch(swallowError),
+    slurpFile(resolvedFilepath, {
+      ignoreCache: init.ignoreCache
+    }).then(parseIni).catch(swallowError)
+  ]);
+  return {
+    configFile: parsedFiles[0],
+    credentialsFile: parsedFiles[1]
+  };
+};
+
+// ../../node_modules/.pnpm/@smithy+node-config-provider@4.0.1/node_modules/@smithy/node-config-provider/dist-es/fromSharedConfigFiles.js
+var fromSharedConfigFiles = (configSelector, { preferredFile = "config", ...init } = {}) => async () => {
+  const profile = getProfileName(init);
+  const { configFile, credentialsFile } = await loadSharedConfigFiles(init);
+  const profileFromCredentials = credentialsFile[profile] || {};
+  const profileFromConfig = configFile[profile] || {};
+  const mergedProfile = preferredFile === "config" ? { ...profileFromCredentials, ...profileFromConfig } : { ...profileFromConfig, ...profileFromCredentials };
+  try {
+    const cfgFile = preferredFile === "config" ? configFile : credentialsFile;
+    const configValue = configSelector(mergedProfile, cfgFile);
+    if (configValue === void 0) {
+      throw new Error();
+    }
+    return configValue;
+  } catch (e) {
+    throw new CredentialsProviderError(e.message || `Not found in config files w/ profile [${profile}]: ${getSelectorName(configSelector.toString())}`, { logger: init.logger });
+  }
+};
+
+// ../../node_modules/.pnpm/@smithy+node-config-provider@4.0.1/node_modules/@smithy/node-config-provider/dist-es/fromStatic.js
+var isFunction = (func) => typeof func === "function";
+var fromStatic2 = (defaultValue) => isFunction(defaultValue) ? async () => await defaultValue() : fromStatic(defaultValue);
+
+// ../../node_modules/.pnpm/@smithy+node-config-provider@4.0.1/node_modules/@smithy/node-config-provider/dist-es/configLoader.js
+var loadConfig = ({ environmentVariableSelector, configFileSelector, default: defaultValue }, configuration = {}) => memoize(chain(fromEnv(environmentVariableSelector), fromSharedConfigFiles(configFileSelector, configuration), fromStatic2(defaultValue)));
+
+// ../../node_modules/.pnpm/@smithy+middleware-endpoint@4.0.5/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/getEndpointUrlConfig.js
+var ENV_ENDPOINT_URL = "AWS_ENDPOINT_URL";
+var CONFIG_ENDPOINT_URL = "endpoint_url";
+var getEndpointUrlConfig = (serviceId) => ({
+  environmentVariableSelector: (env) => {
+    const serviceSuffixParts = serviceId.split(" ").map((w) => w.toUpperCase());
+    const serviceEndpointUrl = env[[ENV_ENDPOINT_URL, ...serviceSuffixParts].join("_")];
+    if (serviceEndpointUrl)
+      return serviceEndpointUrl;
+    const endpointUrl = env[ENV_ENDPOINT_URL];
+    if (endpointUrl)
+      return endpointUrl;
+    return void 0;
+  },
+  configFileSelector: (profile, config) => {
+    if (config && profile.services) {
+      const servicesSection = config[["services", profile.services].join(CONFIG_PREFIX_SEPARATOR)];
+      if (servicesSection) {
+        const servicePrefixParts = serviceId.split(" ").map((w) => w.toLowerCase());
+        const endpointUrl2 = servicesSection[[servicePrefixParts.join("_"), CONFIG_ENDPOINT_URL].join(CONFIG_PREFIX_SEPARATOR)];
+        if (endpointUrl2)
+          return endpointUrl2;
+      }
+    }
+    const endpointUrl = profile[CONFIG_ENDPOINT_URL];
+    if (endpointUrl)
+      return endpointUrl;
+    return void 0;
+  },
+  default: void 0
+});
+
+// ../../node_modules/.pnpm/@smithy+middleware-endpoint@4.0.5/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/getEndpointFromConfig.js
+var getEndpointFromConfig = async (serviceId) => loadConfig(getEndpointUrlConfig(serviceId ?? ""))();
+
+// ../../node_modules/.pnpm/@smithy+querystring-parser@4.0.1/node_modules/@smithy/querystring-parser/dist-es/index.js
+function parseQueryString(querystring) {
+  const query = {};
+  querystring = querystring.replace(/^\?/, "");
+  if (querystring) {
+    for (const pair of querystring.split("&")) {
+      let [key, value = null] = pair.split("=");
+      key = decodeURIComponent(key);
+      if (value) {
+        value = decodeURIComponent(value);
+      }
+      if (!(key in query)) {
+        query[key] = value;
+      } else if (Array.isArray(query[key])) {
+        query[key].push(value);
+      } else {
+        query[key] = [query[key], value];
+      }
+    }
+  }
+  return query;
+}
+
+// ../../node_modules/.pnpm/@smithy+url-parser@4.0.1/node_modules/@smithy/url-parser/dist-es/index.js
+var parseUrl = (url) => {
+  if (typeof url === "string") {
+    return parseUrl(new URL(url));
+  }
+  const { hostname, pathname, port, protocol, search } = url;
+  let query;
+  if (search) {
+    query = parseQueryString(search);
+  }
+  return {
+    hostname,
+    port: port ? parseInt(port) : void 0,
+    protocol,
+    path: pathname,
+    query
+  };
+};
+
+// ../../node_modules/.pnpm/@smithy+middleware-endpoint@4.0.5/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/toEndpointV1.js
+var toEndpointV1 = (endpoint) => {
+  if (typeof endpoint === "object") {
+    if ("url" in endpoint) {
+      return parseUrl(endpoint.url);
+    }
+    return endpoint;
+  }
+  return parseUrl(endpoint);
+};
+
+// ../../node_modules/.pnpm/@smithy+middleware-endpoint@4.0.5/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/getEndpointFromInstructions.js
+var getEndpointFromInstructions = async (commandInput, instructionsSupplier, clientConfig, context) => {
+  if (!clientConfig.endpoint) {
+    let endpointFromConfig;
+    if (clientConfig.serviceConfiguredEndpoint) {
+      endpointFromConfig = await clientConfig.serviceConfiguredEndpoint();
+    } else {
+      endpointFromConfig = await getEndpointFromConfig(clientConfig.serviceId);
+    }
+    if (endpointFromConfig) {
+      clientConfig.endpoint = () => Promise.resolve(toEndpointV1(endpointFromConfig));
+    }
+  }
+  const endpointParams = await resolveParams(commandInput, instructionsSupplier, clientConfig);
+  if (typeof clientConfig.endpointProvider !== "function") {
+    throw new Error("config.endpointProvider is not set.");
+  }
+  const endpoint = clientConfig.endpointProvider(endpointParams, context);
+  return endpoint;
+};
+var resolveParams = async (commandInput, instructionsSupplier, clientConfig) => {
+  const endpointParams = {};
+  const instructions = instructionsSupplier?.getEndpointParameterInstructions?.() || {};
+  for (const [name, instruction] of Object.entries(instructions)) {
+    switch (instruction.type) {
+      case "staticContextParams":
+        endpointParams[name] = instruction.value;
+        break;
+      case "contextParams":
+        endpointParams[name] = commandInput[instruction.name];
+        break;
+      case "clientContextParams":
+      case "builtInParams":
+        endpointParams[name] = await createConfigValueProvider(instruction.name, name, clientConfig)();
+        break;
+      case "operationContextParams":
+        endpointParams[name] = instruction.get(commandInput);
+        break;
+      default:
+        throw new Error("Unrecognized endpoint parameter instruction: " + JSON.stringify(instruction));
+    }
+  }
+  if (Object.keys(instructions).length === 0) {
+    Object.assign(endpointParams, clientConfig);
+  }
+  if (String(clientConfig.serviceId).toLowerCase() === "s3") {
+    await resolveParamsForS3(endpointParams);
+  }
+  return endpointParams;
+};
+
+// ../../node_modules/.pnpm/@smithy+util-middleware@4.0.1/node_modules/@smithy/util-middleware/dist-es/normalizeProvider.js
+var normalizeProvider = (input) => {
+  if (typeof input === "function")
+    return input;
+  const promisified = Promise.resolve(input);
+  return () => promisified;
+};
+
+// ../../node_modules/.pnpm/@smithy+middleware-serde@4.0.2/node_modules/@smithy/middleware-serde/dist-es/serdePlugin.js
+var serializerMiddlewareOption = {
+  name: "serializerMiddleware",
+  step: "serialize",
+  tags: ["SERIALIZER"],
+  override: true
+};
+
+// ../../node_modules/.pnpm/@smithy+core@3.1.4/node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/getHttpAuthSchemePlugin.js
+var httpAuthSchemeMiddlewareOptions = {
+  step: "serialize",
+  tags: ["HTTP_AUTH_SCHEME"],
+  name: "httpAuthSchemeMiddleware",
+  override: true,
+  relation: "before",
+  toMiddleware: serializerMiddlewareOption.name
+};
+
+// ../../node_modules/.pnpm/@smithy+protocol-http@5.0.1/node_modules/@smithy/protocol-http/dist-es/httpRequest.js
+var HttpRequest = class _HttpRequest {
+  constructor(options) {
+    this.method = options.method || "GET";
+    this.hostname = options.hostname || "localhost";
+    this.port = options.port;
+    this.query = options.query || {};
+    this.headers = options.headers || {};
+    this.body = options.body;
+    this.protocol = options.protocol ? options.protocol.slice(-1) !== ":" ? `${options.protocol}:` : options.protocol : "https:";
+    this.path = options.path ? options.path.charAt(0) !== "/" ? `/${options.path}` : options.path : "/";
+    this.username = options.username;
+    this.password = options.password;
+    this.fragment = options.fragment;
+  }
+  static clone(request) {
+    const cloned = new _HttpRequest({
+      ...request,
+      headers: { ...request.headers }
+    });
+    if (cloned.query) {
+      cloned.query = cloneQuery(cloned.query);
+    }
+    return cloned;
+  }
+  static isInstance(request) {
+    if (!request) {
+      return false;
+    }
+    const req = request;
+    return "method" in req && "protocol" in req && "hostname" in req && "path" in req && typeof req["query"] === "object" && typeof req["headers"] === "object";
+  }
+  clone() {
+    return _HttpRequest.clone(this);
+  }
+};
+function cloneQuery(query) {
+  return Object.keys(query).reduce((carry, paramName) => {
+    const param = query[paramName];
+    return {
+      ...carry,
+      [paramName]: Array.isArray(param) ? [...param] : param
+    };
+  }, {});
+}
+
+// ../../node_modules/.pnpm/@smithy+is-array-buffer@4.0.0/node_modules/@smithy/is-array-buffer/dist-es/index.js
+var isArrayBuffer = (arg) => typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer || Object.prototype.toString.call(arg) === "[object ArrayBuffer]";
+
+// ../../node_modules/.pnpm/@smithy+util-buffer-from@4.0.0/node_modules/@smithy/util-buffer-from/dist-es/index.js
+var import_buffer = require("buffer");
+var fromString = (input, encoding) => {
+  if (typeof input !== "string") {
+    throw new TypeError(`The "input" argument must be of type string. Received type ${typeof input} (${input})`);
+  }
+  return encoding ? import_buffer.Buffer.from(input, encoding) : import_buffer.Buffer.from(input);
+};
+
+// ../../node_modules/.pnpm/@smithy+util-utf8@4.0.0/node_modules/@smithy/util-utf8/dist-es/fromUtf8.js
+var fromUtf8 = (input) => {
+  const buf = fromString(input, "utf8");
+  return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+};
+
+// ../../node_modules/.pnpm/@smithy+util-utf8@4.0.0/node_modules/@smithy/util-utf8/dist-es/toUint8Array.js
+var toUint8Array = (data) => {
+  if (typeof data === "string") {
+    return fromUtf8(data);
+  }
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+  }
+  return new Uint8Array(data);
+};
+
+// ../../node_modules/.pnpm/@smithy+util-stream@4.1.1/node_modules/@smithy/util-stream/dist-es/createBufferedReadable.js
+var import_node_stream = require("stream");
+
+// ../../node_modules/.pnpm/@smithy+util-hex-encoding@4.0.0/node_modules/@smithy/util-hex-encoding/dist-es/index.js
+var SHORT_TO_HEX = {};
+var HEX_TO_SHORT = {};
+for (let i = 0; i < 256; i++) {
+  let encodedByte = i.toString(16).toLowerCase();
+  if (encodedByte.length === 1) {
+    encodedByte = `0${encodedByte}`;
+  }
+  SHORT_TO_HEX[i] = encodedByte;
+  HEX_TO_SHORT[encodedByte] = i;
+}
+function fromHex(encoded) {
+  if (encoded.length % 2 !== 0) {
+    throw new Error("Hex encoded strings must have an even number length");
+  }
+  const out = new Uint8Array(encoded.length / 2);
+  for (let i = 0; i < encoded.length; i += 2) {
+    const encodedByte = encoded.slice(i, i + 2).toLowerCase();
+    if (encodedByte in HEX_TO_SHORT) {
+      out[i / 2] = HEX_TO_SHORT[encodedByte];
+    } else {
+      throw new Error(`Cannot decode unrecognized sequence ${encodedByte} as hexadecimal`);
+    }
+  }
+  return out;
+}
+function toHex(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.byteLength; i++) {
+    out += SHORT_TO_HEX[bytes[i]];
+  }
+  return out;
+}
+
+// ../../node_modules/.pnpm/@smithy+core@3.1.4/node_modules/@smithy/core/dist-es/util-identity-and-auth/memoizeIdentityProvider.js
+var createIsIdentityExpiredFunction = (expirationMs) => (identity) => doesIdentityRequireRefresh(identity) && identity.expiration.getTime() - Date.now() < expirationMs;
+var EXPIRATION_MS = 3e5;
+var isIdentityExpired = createIsIdentityExpiredFunction(EXPIRATION_MS);
+var doesIdentityRequireRefresh = (identity) => identity.expiration !== void 0;
+
+// ../../node_modules/.pnpm/@smithy+middleware-endpoint@4.0.5/node_modules/@smithy/middleware-endpoint/dist-es/getEndpointPlugin.js
+var endpointMiddlewareOptions = {
+  step: "serialize",
+  tags: ["ENDPOINT_PARAMETERS", "ENDPOINT_V2", "ENDPOINT"],
+  name: "endpointV2Middleware",
+  override: true,
+  relation: "before",
+  toMiddleware: serializerMiddlewareOption.name
+};
+
+// ../../node_modules/.pnpm/@smithy+smithy-client@4.1.5/node_modules/@smithy/smithy-client/dist-es/parse-utils.js
+var MAX_FLOAT = Math.ceil(2 ** 127 * (2 - 2 ** -23));
+
+// ../../node_modules/.pnpm/@smithy+smithy-client@4.1.5/node_modules/@smithy/smithy-client/dist-es/date-utils.js
+var RFC3339 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?[zZ]$/);
+var RFC3339_WITH_OFFSET = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(([-+]\d{2}\:\d{2})|[zZ])$/);
+var IMF_FIXDATE = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d{2}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/);
+var RFC_850_DATE = new RegExp(/^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d{2})-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/);
+var ASC_TIME = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( [1-9]|\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? (\d{4})$/);
+var FIFTY_YEARS_IN_MILLIS = 50 * 365 * 24 * 60 * 60 * 1e3;
+
+// ../../node_modules/.pnpm/@smithy+smithy-client@4.1.5/node_modules/@smithy/smithy-client/dist-es/lazy-json.js
+var LazyJsonString = function LazyJsonString2(val) {
+  const str = Object.assign(new String(val), {
+    deserializeJSON() {
+      return JSON.parse(String(val));
+    },
+    toString() {
+      return String(val);
+    },
+    toJSON() {
+      return String(val);
+    }
+  });
+  return str;
+};
+LazyJsonString.from = (object) => {
+  if (object && typeof object === "object" && (object instanceof LazyJsonString || "deserializeJSON" in object)) {
+    return object;
+  } else if (typeof object === "string" || Object.getPrototypeOf(object) === String.prototype) {
+    return LazyJsonString(String(object));
+  }
+  return LazyJsonString(JSON.stringify(object));
+};
+LazyJsonString.fromObject = LazyJsonString.from;
+
+// ../../node_modules/.pnpm/@smithy+signature-v4@5.0.1/node_modules/@smithy/signature-v4/dist-es/constants.js
+var ALGORITHM_QUERY_PARAM = "X-Amz-Algorithm";
+var CREDENTIAL_QUERY_PARAM = "X-Amz-Credential";
+var AMZ_DATE_QUERY_PARAM = "X-Amz-Date";
+var SIGNED_HEADERS_QUERY_PARAM = "X-Amz-SignedHeaders";
+var EXPIRES_QUERY_PARAM = "X-Amz-Expires";
+var SIGNATURE_QUERY_PARAM = "X-Amz-Signature";
+var TOKEN_QUERY_PARAM = "X-Amz-Security-Token";
+var AUTH_HEADER = "authorization";
+var AMZ_DATE_HEADER = AMZ_DATE_QUERY_PARAM.toLowerCase();
+var DATE_HEADER = "date";
+var GENERATED_HEADERS = [AUTH_HEADER, AMZ_DATE_HEADER, DATE_HEADER];
+var SIGNATURE_HEADER = SIGNATURE_QUERY_PARAM.toLowerCase();
+var SHA256_HEADER = "x-amz-content-sha256";
+var TOKEN_HEADER = TOKEN_QUERY_PARAM.toLowerCase();
+var ALWAYS_UNSIGNABLE_HEADERS = {
+  authorization: true,
+  "cache-control": true,
+  connection: true,
+  expect: true,
+  from: true,
+  "keep-alive": true,
+  "max-forwards": true,
+  pragma: true,
+  referer: true,
+  te: true,
+  trailer: true,
+  "transfer-encoding": true,
+  upgrade: true,
+  "user-agent": true,
+  "x-amzn-trace-id": true
+};
+var PROXY_HEADER_PATTERN = /^proxy-/;
+var SEC_HEADER_PATTERN = /^sec-/;
+var ALGORITHM_IDENTIFIER = "AWS4-HMAC-SHA256";
+var EVENT_ALGORITHM_IDENTIFIER = "AWS4-HMAC-SHA256-PAYLOAD";
+var UNSIGNED_PAYLOAD = "UNSIGNED-PAYLOAD";
+var MAX_CACHE_SIZE = 50;
+var KEY_TYPE_IDENTIFIER = "aws4_request";
+var MAX_PRESIGNED_TTL = 60 * 60 * 24 * 7;
+
+// ../../node_modules/.pnpm/@smithy+signature-v4@5.0.1/node_modules/@smithy/signature-v4/dist-es/credentialDerivation.js
+var signingKeyCache = {};
+var cacheQueue = [];
+var createScope = (shortDate, region, service) => `${shortDate}/${region}/${service}/${KEY_TYPE_IDENTIFIER}`;
+var getSigningKey = async (sha256Constructor, credentials, shortDate, region, service) => {
+  const credsHash = await hmac(sha256Constructor, credentials.secretAccessKey, credentials.accessKeyId);
+  const cacheKey = `${shortDate}:${region}:${service}:${toHex(credsHash)}:${credentials.sessionToken}`;
+  if (cacheKey in signingKeyCache) {
+    return signingKeyCache[cacheKey];
+  }
+  cacheQueue.push(cacheKey);
+  while (cacheQueue.length > MAX_CACHE_SIZE) {
+    delete signingKeyCache[cacheQueue.shift()];
+  }
+  let key = `AWS4${credentials.secretAccessKey}`;
+  for (const signable of [shortDate, region, service, KEY_TYPE_IDENTIFIER]) {
+    key = await hmac(sha256Constructor, key, signable);
+  }
+  return signingKeyCache[cacheKey] = key;
+};
+var hmac = (ctor, secret, data) => {
+  const hash = new ctor(secret);
+  hash.update(toUint8Array(data));
+  return hash.digest();
+};
+
+// ../../node_modules/.pnpm/@smithy+signature-v4@5.0.1/node_modules/@smithy/signature-v4/dist-es/getCanonicalHeaders.js
+var getCanonicalHeaders = ({ headers }, unsignableHeaders, signableHeaders) => {
+  const canonical = {};
+  for (const headerName of Object.keys(headers).sort()) {
+    if (headers[headerName] == void 0) {
+      continue;
+    }
+    const canonicalHeaderName = headerName.toLowerCase();
+    if (canonicalHeaderName in ALWAYS_UNSIGNABLE_HEADERS || unsignableHeaders?.has(canonicalHeaderName) || PROXY_HEADER_PATTERN.test(canonicalHeaderName) || SEC_HEADER_PATTERN.test(canonicalHeaderName)) {
+      if (!signableHeaders || signableHeaders && !signableHeaders.has(canonicalHeaderName)) {
+        continue;
+      }
+    }
+    canonical[canonicalHeaderName] = headers[headerName].trim().replace(/\s+/g, " ");
+  }
+  return canonical;
+};
+
+// ../../node_modules/.pnpm/@smithy+signature-v4@5.0.1/node_modules/@smithy/signature-v4/dist-es/getCanonicalQuery.js
+var getCanonicalQuery = ({ query = {} }) => {
+  const keys = [];
+  const serialized = {};
+  for (const key of Object.keys(query)) {
+    if (key.toLowerCase() === SIGNATURE_HEADER) {
+      continue;
+    }
+    const encodedKey = escapeUri(key);
+    keys.push(encodedKey);
+    const value = query[key];
+    if (typeof value === "string") {
+      serialized[encodedKey] = `${encodedKey}=${escapeUri(value)}`;
+    } else if (Array.isArray(value)) {
+      serialized[encodedKey] = value.slice(0).reduce((encoded, value2) => encoded.concat([`${encodedKey}=${escapeUri(value2)}`]), []).sort().join("&");
+    }
+  }
+  return keys.sort().map((key) => serialized[key]).filter((serialized2) => serialized2).join("&");
+};
+
+// ../../node_modules/.pnpm/@smithy+signature-v4@5.0.1/node_modules/@smithy/signature-v4/dist-es/getPayloadHash.js
+var getPayloadHash = async ({ headers, body }, hashConstructor) => {
+  for (const headerName of Object.keys(headers)) {
+    if (headerName.toLowerCase() === SHA256_HEADER) {
+      return headers[headerName];
+    }
+  }
+  if (body == void 0) {
+    return "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
+  } else if (typeof body === "string" || ArrayBuffer.isView(body) || isArrayBuffer(body)) {
+    const hashCtor = new hashConstructor();
+    hashCtor.update(toUint8Array(body));
+    return toHex(await hashCtor.digest());
+  }
+  return UNSIGNED_PAYLOAD;
+};
+
+// ../../node_modules/.pnpm/@smithy+signature-v4@5.0.1/node_modules/@smithy/signature-v4/dist-es/HeaderFormatter.js
+var HeaderFormatter = class {
+  format(headers) {
+    const chunks = [];
+    for (const headerName of Object.keys(headers)) {
+      const bytes = fromUtf8(headerName);
+      chunks.push(Uint8Array.from([bytes.byteLength]), bytes, this.formatHeaderValue(headers[headerName]));
+    }
+    const out = new Uint8Array(chunks.reduce((carry, bytes) => carry + bytes.byteLength, 0));
+    let position = 0;
+    for (const chunk of chunks) {
+      out.set(chunk, position);
+      position += chunk.byteLength;
+    }
+    return out;
+  }
+  formatHeaderValue(header) {
+    switch (header.type) {
+      case "boolean":
+        return Uint8Array.from([header.value ? 0 : 1]);
+      case "byte":
+        return Uint8Array.from([2, header.value]);
+      case "short":
+        const shortView = new DataView(new ArrayBuffer(3));
+        shortView.setUint8(0, 3);
+        shortView.setInt16(1, header.value, false);
+        return new Uint8Array(shortView.buffer);
+      case "integer":
+        const intView = new DataView(new ArrayBuffer(5));
+        intView.setUint8(0, 4);
+        intView.setInt32(1, header.value, false);
+        return new Uint8Array(intView.buffer);
+      case "long":
+        const longBytes = new Uint8Array(9);
+        longBytes[0] = 5;
+        longBytes.set(header.value.bytes, 1);
+        return longBytes;
+      case "binary":
+        const binView = new DataView(new ArrayBuffer(3 + header.value.byteLength));
+        binView.setUint8(0, 6);
+        binView.setUint16(1, header.value.byteLength, false);
+        const binBytes = new Uint8Array(binView.buffer);
+        binBytes.set(header.value, 3);
+        return binBytes;
+      case "string":
+        const utf8Bytes = fromUtf8(header.value);
+        const strView = new DataView(new ArrayBuffer(3 + utf8Bytes.byteLength));
+        strView.setUint8(0, 7);
+        strView.setUint16(1, utf8Bytes.byteLength, false);
+        const strBytes = new Uint8Array(strView.buffer);
+        strBytes.set(utf8Bytes, 3);
+        return strBytes;
+      case "timestamp":
+        const tsBytes = new Uint8Array(9);
+        tsBytes[0] = 8;
+        tsBytes.set(Int64.fromNumber(header.value.valueOf()).bytes, 1);
+        return tsBytes;
+      case "uuid":
+        if (!UUID_PATTERN.test(header.value)) {
+          throw new Error(`Invalid UUID received: ${header.value}`);
+        }
+        const uuidBytes = new Uint8Array(17);
+        uuidBytes[0] = 9;
+        uuidBytes.set(fromHex(header.value.replace(/\-/g, "")), 1);
+        return uuidBytes;
+    }
+  }
+};
+var HEADER_VALUE_TYPE;
+(function(HEADER_VALUE_TYPE2) {
+  HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["boolTrue"] = 0] = "boolTrue";
+  HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["boolFalse"] = 1] = "boolFalse";
+  HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["byte"] = 2] = "byte";
+  HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["short"] = 3] = "short";
+  HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["integer"] = 4] = "integer";
+  HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["long"] = 5] = "long";
+  HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["byteArray"] = 6] = "byteArray";
+  HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["string"] = 7] = "string";
+  HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["timestamp"] = 8] = "timestamp";
+  HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["uuid"] = 9] = "uuid";
+})(HEADER_VALUE_TYPE || (HEADER_VALUE_TYPE = {}));
+var UUID_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
+var Int64 = class _Int64 {
+  constructor(bytes) {
+    this.bytes = bytes;
+    if (bytes.byteLength !== 8) {
+      throw new Error("Int64 buffers must be exactly 8 bytes");
+    }
+  }
+  static fromNumber(number) {
+    if (number > 9223372036854776e3 || number < -9223372036854776e3) {
+      throw new Error(`${number} is too large (or, if negative, too small) to represent as an Int64`);
+    }
+    const bytes = new Uint8Array(8);
+    for (let i = 7, remaining = Math.abs(Math.round(number)); i > -1 && remaining > 0; i--, remaining /= 256) {
+      bytes[i] = remaining;
+    }
+    if (number < 0) {
+      negate(bytes);
+    }
+    return new _Int64(bytes);
+  }
+  valueOf() {
+    const bytes = this.bytes.slice(0);
+    const negative = bytes[0] & 128;
+    if (negative) {
+      negate(bytes);
+    }
+    return parseInt(toHex(bytes), 16) * (negative ? -1 : 1);
+  }
+  toString() {
+    return String(this.valueOf());
+  }
+};
+function negate(bytes) {
+  for (let i = 0; i < 8; i++) {
+    bytes[i] ^= 255;
+  }
+  for (let i = 7; i > -1; i--) {
+    bytes[i]++;
+    if (bytes[i] !== 0)
+      break;
+  }
+}
+
+// ../../node_modules/.pnpm/@smithy+signature-v4@5.0.1/node_modules/@smithy/signature-v4/dist-es/headerUtil.js
+var hasHeader = (soughtHeader, headers) => {
+  soughtHeader = soughtHeader.toLowerCase();
+  for (const headerName of Object.keys(headers)) {
+    if (soughtHeader === headerName.toLowerCase()) {
+      return true;
+    }
+  }
+  return false;
+};
+
+// ../../node_modules/.pnpm/@smithy+signature-v4@5.0.1/node_modules/@smithy/signature-v4/dist-es/moveHeadersToQuery.js
+var moveHeadersToQuery = (request, options = {}) => {
+  const { headers, query = {} } = HttpRequest.clone(request);
+  for (const name of Object.keys(headers)) {
+    const lname = name.toLowerCase();
+    if (lname.slice(0, 6) === "x-amz-" && !options.unhoistableHeaders?.has(lname) || options.hoistableHeaders?.has(lname)) {
+      query[name] = headers[name];
+      delete headers[name];
+    }
+  }
+  return {
+    ...request,
+    headers,
+    query
+  };
+};
+
+// ../../node_modules/.pnpm/@smithy+signature-v4@5.0.1/node_modules/@smithy/signature-v4/dist-es/prepareRequest.js
+var prepareRequest = (request) => {
+  request = HttpRequest.clone(request);
+  for (const headerName of Object.keys(request.headers)) {
+    if (GENERATED_HEADERS.indexOf(headerName.toLowerCase()) > -1) {
+      delete request.headers[headerName];
+    }
+  }
+  return request;
+};
+
+// ../../node_modules/.pnpm/@smithy+signature-v4@5.0.1/node_modules/@smithy/signature-v4/dist-es/utilDate.js
+var iso8601 = (time) => toDate(time).toISOString().replace(/\.\d{3}Z$/, "Z");
+var toDate = (time) => {
+  if (typeof time === "number") {
+    return new Date(time * 1e3);
+  }
+  if (typeof time === "string") {
+    if (Number(time)) {
+      return new Date(Number(time) * 1e3);
+    }
+    return new Date(time);
+  }
+  return time;
+};
+
+// ../../node_modules/.pnpm/@smithy+signature-v4@5.0.1/node_modules/@smithy/signature-v4/dist-es/SignatureV4.js
+var SignatureV4 = class {
+  constructor({ applyChecksum, credentials, region, service, sha256, uriEscapePath = true }) {
+    this.headerFormatter = new HeaderFormatter();
+    this.service = service;
+    this.sha256 = sha256;
+    this.uriEscapePath = uriEscapePath;
+    this.applyChecksum = typeof applyChecksum === "boolean" ? applyChecksum : true;
+    this.regionProvider = normalizeProvider(region);
+    this.credentialProvider = normalizeProvider(credentials);
+  }
+  async presign(originalRequest, options = {}) {
+    const { signingDate = /* @__PURE__ */ new Date(), expiresIn = 3600, unsignableHeaders, unhoistableHeaders, signableHeaders, hoistableHeaders, signingRegion, signingService } = options;
+    const credentials = await this.credentialProvider();
+    this.validateResolvedCredentials(credentials);
+    const region = signingRegion ?? await this.regionProvider();
+    const { longDate, shortDate } = formatDate(signingDate);
+    if (expiresIn > MAX_PRESIGNED_TTL) {
+      return Promise.reject("Signature version 4 presigned URLs must have an expiration date less than one week in the future");
+    }
+    const scope = createScope(shortDate, region, signingService ?? this.service);
+    const request = moveHeadersToQuery(prepareRequest(originalRequest), { unhoistableHeaders, hoistableHeaders });
+    if (credentials.sessionToken) {
+      request.query[TOKEN_QUERY_PARAM] = credentials.sessionToken;
+    }
+    request.query[ALGORITHM_QUERY_PARAM] = ALGORITHM_IDENTIFIER;
+    request.query[CREDENTIAL_QUERY_PARAM] = `${credentials.accessKeyId}/${scope}`;
+    request.query[AMZ_DATE_QUERY_PARAM] = longDate;
+    request.query[EXPIRES_QUERY_PARAM] = expiresIn.toString(10);
+    const canonicalHeaders = getCanonicalHeaders(request, unsignableHeaders, signableHeaders);
+    request.query[SIGNED_HEADERS_QUERY_PARAM] = getCanonicalHeaderList(canonicalHeaders);
+    request.query[SIGNATURE_QUERY_PARAM] = await this.getSignature(longDate, scope, this.getSigningKey(credentials, region, shortDate, signingService), this.createCanonicalRequest(request, canonicalHeaders, await getPayloadHash(originalRequest, this.sha256)));
+    return request;
+  }
+  async sign(toSign, options) {
+    if (typeof toSign === "string") {
+      return this.signString(toSign, options);
+    } else if (toSign.headers && toSign.payload) {
+      return this.signEvent(toSign, options);
+    } else if (toSign.message) {
+      return this.signMessage(toSign, options);
+    } else {
+      return this.signRequest(toSign, options);
+    }
+  }
+  async signEvent({ headers, payload }, { signingDate = /* @__PURE__ */ new Date(), priorSignature, signingRegion, signingService }) {
+    const region = signingRegion ?? await this.regionProvider();
+    const { shortDate, longDate } = formatDate(signingDate);
+    const scope = createScope(shortDate, region, signingService ?? this.service);
+    const hashedPayload = await getPayloadHash({ headers: {}, body: payload }, this.sha256);
+    const hash = new this.sha256();
+    hash.update(headers);
+    const hashedHeaders = toHex(await hash.digest());
+    const stringToSign = [
+      EVENT_ALGORITHM_IDENTIFIER,
+      longDate,
+      scope,
+      priorSignature,
+      hashedHeaders,
+      hashedPayload
+    ].join("\n");
+    return this.signString(stringToSign, { signingDate, signingRegion: region, signingService });
+  }
+  async signMessage(signableMessage, { signingDate = /* @__PURE__ */ new Date(), signingRegion, signingService }) {
+    const promise = this.signEvent({
+      headers: this.headerFormatter.format(signableMessage.message.headers),
+      payload: signableMessage.message.body
+    }, {
+      signingDate,
+      signingRegion,
+      signingService,
+      priorSignature: signableMessage.priorSignature
+    });
+    return promise.then((signature) => {
+      return { message: signableMessage.message, signature };
+    });
+  }
+  async signString(stringToSign, { signingDate = /* @__PURE__ */ new Date(), signingRegion, signingService } = {}) {
+    const credentials = await this.credentialProvider();
+    this.validateResolvedCredentials(credentials);
+    const region = signingRegion ?? await this.regionProvider();
+    const { shortDate } = formatDate(signingDate);
+    const hash = new this.sha256(await this.getSigningKey(credentials, region, shortDate, signingService));
+    hash.update(toUint8Array(stringToSign));
+    return toHex(await hash.digest());
+  }
+  async signRequest(requestToSign, { signingDate = /* @__PURE__ */ new Date(), signableHeaders, unsignableHeaders, signingRegion, signingService } = {}) {
+    const credentials = await this.credentialProvider();
+    this.validateResolvedCredentials(credentials);
+    const region = signingRegion ?? await this.regionProvider();
+    const request = prepareRequest(requestToSign);
+    const { longDate, shortDate } = formatDate(signingDate);
+    const scope = createScope(shortDate, region, signingService ?? this.service);
+    request.headers[AMZ_DATE_HEADER] = longDate;
+    if (credentials.sessionToken) {
+      request.headers[TOKEN_HEADER] = credentials.sessionToken;
+    }
+    const payloadHash = await getPayloadHash(request, this.sha256);
+    if (!hasHeader(SHA256_HEADER, request.headers) && this.applyChecksum) {
+      request.headers[SHA256_HEADER] = payloadHash;
+    }
+    const canonicalHeaders = getCanonicalHeaders(request, unsignableHeaders, signableHeaders);
+    const signature = await this.getSignature(longDate, scope, this.getSigningKey(credentials, region, shortDate, signingService), this.createCanonicalRequest(request, canonicalHeaders, payloadHash));
+    request.headers[AUTH_HEADER] = `${ALGORITHM_IDENTIFIER} Credential=${credentials.accessKeyId}/${scope}, SignedHeaders=${getCanonicalHeaderList(canonicalHeaders)}, Signature=${signature}`;
+    return request;
+  }
+  createCanonicalRequest(request, canonicalHeaders, payloadHash) {
+    const sortedHeaders = Object.keys(canonicalHeaders).sort();
+    return `${request.method}
+${this.getCanonicalPath(request)}
+${getCanonicalQuery(request)}
+${sortedHeaders.map((name) => `${name}:${canonicalHeaders[name]}`).join("\n")}
+
+${sortedHeaders.join(";")}
+${payloadHash}`;
+  }
+  async createStringToSign(longDate, credentialScope, canonicalRequest) {
+    const hash = new this.sha256();
+    hash.update(toUint8Array(canonicalRequest));
+    const hashedRequest = await hash.digest();
+    return `${ALGORITHM_IDENTIFIER}
+${longDate}
+${credentialScope}
+${toHex(hashedRequest)}`;
+  }
+  getCanonicalPath({ path }) {
+    if (this.uriEscapePath) {
+      const normalizedPathSegments = [];
+      for (const pathSegment of path.split("/")) {
+        if (pathSegment?.length === 0)
+          continue;
+        if (pathSegment === ".")
+          continue;
+        if (pathSegment === "..") {
+          normalizedPathSegments.pop();
+        } else {
+          normalizedPathSegments.push(pathSegment);
+        }
+      }
+      const normalizedPath = `${path?.startsWith("/") ? "/" : ""}${normalizedPathSegments.join("/")}${normalizedPathSegments.length > 0 && path?.endsWith("/") ? "/" : ""}`;
+      const doubleEncoded = escapeUri(normalizedPath);
+      return doubleEncoded.replace(/%2F/g, "/");
+    }
+    return path;
+  }
+  async getSignature(longDate, credentialScope, keyPromise, canonicalRequest) {
+    const stringToSign = await this.createStringToSign(longDate, credentialScope, canonicalRequest);
+    const hash = new this.sha256(await keyPromise);
+    hash.update(toUint8Array(stringToSign));
+    return toHex(await hash.digest());
+  }
+  getSigningKey(credentials, region, shortDate, service) {
+    return getSigningKey(this.sha256, credentials, shortDate, region, service || this.service);
+  }
+  validateResolvedCredentials(credentials) {
+    if (typeof credentials !== "object" || typeof credentials.accessKeyId !== "string" || typeof credentials.secretAccessKey !== "string") {
+      throw new Error("Resolved credential object is not valid");
+    }
+  }
+};
+var formatDate = (now) => {
+  const longDate = iso8601(now).replace(/[\-:]/g, "");
+  return {
+    longDate,
+    shortDate: longDate.slice(0, 8)
+  };
+};
+var getCanonicalHeaderList = (headers) => Object.keys(headers).sort().join(";");
+
+// ../../node_modules/.pnpm/@smithy+util-config-provider@4.0.0/node_modules/@smithy/util-config-provider/dist-es/types.js
+var SelectorType;
+(function(SelectorType2) {
+  SelectorType2["ENV"] = "env";
+  SelectorType2["CONFIG"] = "shared config entry";
+})(SelectorType || (SelectorType = {}));
+
+// ../../node_modules/.pnpm/@aws-sdk+middleware-sdk-s3@3.750.0/node_modules/@aws-sdk/middleware-sdk-s3/dist-es/s3-express/constants.js
+var SESSION_TOKEN_QUERY_PARAM = "X-Amz-S3session-Token";
+var SESSION_TOKEN_HEADER = SESSION_TOKEN_QUERY_PARAM.toLowerCase();
+
+// ../../node_modules/.pnpm/@aws-sdk+middleware-sdk-s3@3.750.0/node_modules/@aws-sdk/middleware-sdk-s3/dist-es/s3-express/classes/SignatureV4S3Express.js
+var SignatureV4S3Express = class extends SignatureV4 {
+  async signWithCredentials(requestToSign, credentials, options) {
+    const credentialsWithoutSessionToken = getCredentialsWithoutSessionToken(credentials);
+    requestToSign.headers[SESSION_TOKEN_HEADER] = credentials.sessionToken;
+    const privateAccess = this;
+    setSingleOverride(privateAccess, credentialsWithoutSessionToken);
+    return privateAccess.signRequest(requestToSign, options ?? {});
+  }
+  async presignWithCredentials(requestToSign, credentials, options) {
+    const credentialsWithoutSessionToken = getCredentialsWithoutSessionToken(credentials);
+    delete requestToSign.headers[SESSION_TOKEN_HEADER];
+    requestToSign.headers[SESSION_TOKEN_QUERY_PARAM] = credentials.sessionToken;
+    requestToSign.query = requestToSign.query ?? {};
+    requestToSign.query[SESSION_TOKEN_QUERY_PARAM] = credentials.sessionToken;
+    const privateAccess = this;
+    setSingleOverride(privateAccess, credentialsWithoutSessionToken);
+    return this.presign(requestToSign, options);
+  }
+};
+function getCredentialsWithoutSessionToken(credentials) {
+  const credentialsWithoutSessionToken = {
+    accessKeyId: credentials.accessKeyId,
+    secretAccessKey: credentials.secretAccessKey,
+    expiration: credentials.expiration
+  };
+  return credentialsWithoutSessionToken;
+}
+function setSingleOverride(privateAccess, credentialsWithoutSessionToken) {
+  const id = setTimeout(() => {
+    throw new Error("SignatureV4S3Express credential override was created but not called.");
+  }, 10);
+  const currentCredentialProvider = privateAccess.credentialProvider;
+  const overrideCredentialsProviderOnce = () => {
+    clearTimeout(id);
+    privateAccess.credentialProvider = currentCredentialProvider;
+    return Promise.resolve(credentialsWithoutSessionToken);
+  };
+  privateAccess.credentialProvider = overrideCredentialsProviderOnce;
+}
+
+// ../../node_modules/.pnpm/@aws-sdk+signature-v4-multi-region@3.750.0/node_modules/@aws-sdk/signature-v4-multi-region/dist-es/signature-v4-crt-container.js
+var signatureV4CrtContainer = {
+  CrtSignerV4: null
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+signature-v4-multi-region@3.750.0/node_modules/@aws-sdk/signature-v4-multi-region/dist-es/SignatureV4MultiRegion.js
+var SignatureV4MultiRegion = class {
+  sigv4aSigner;
+  sigv4Signer;
+  signerOptions;
+  constructor(options) {
+    this.sigv4Signer = new SignatureV4S3Express(options);
+    this.signerOptions = options;
+  }
+  async sign(requestToSign, options = {}) {
+    if (options.signingRegion === "*") {
+      if (this.signerOptions.runtime !== "node")
+        throw new Error("This request requires signing with SigV4Asymmetric algorithm. It's only available in Node.js");
+      return this.getSigv4aSigner().sign(requestToSign, options);
+    }
+    return this.sigv4Signer.sign(requestToSign, options);
+  }
+  async signWithCredentials(requestToSign, credentials, options = {}) {
+    if (options.signingRegion === "*") {
+      if (this.signerOptions.runtime !== "node")
+        throw new Error("This request requires signing with SigV4Asymmetric algorithm. It's only available in Node.js");
+      return this.getSigv4aSigner().signWithCredentials(requestToSign, credentials, options);
+    }
+    return this.sigv4Signer.signWithCredentials(requestToSign, credentials, options);
+  }
+  async presign(originalRequest, options = {}) {
+    if (options.signingRegion === "*") {
+      if (this.signerOptions.runtime !== "node")
+        throw new Error("This request requires signing with SigV4Asymmetric algorithm. It's only available in Node.js");
+      return this.getSigv4aSigner().presign(originalRequest, options);
+    }
+    return this.sigv4Signer.presign(originalRequest, options);
+  }
+  async presignWithCredentials(originalRequest, credentials, options = {}) {
+    if (options.signingRegion === "*") {
+      throw new Error("Method presignWithCredentials is not supported for [signingRegion=*].");
+    }
+    return this.sigv4Signer.presignWithCredentials(originalRequest, credentials, options);
+  }
+  getSigv4aSigner() {
+    if (!this.sigv4aSigner) {
+      let CrtSignerV4 = null;
+      try {
+        CrtSignerV4 = signatureV4CrtContainer.CrtSignerV4;
+        if (typeof CrtSignerV4 !== "function")
+          throw new Error();
+      } catch (e) {
+        e.message = `${e.message}
+Please check whether you have installed the "@aws-sdk/signature-v4-crt" package explicitly. 
+You must also register the package by calling [require("@aws-sdk/signature-v4-crt");] or an ESM equivalent such as [import "@aws-sdk/signature-v4-crt";]. 
+For more information please go to https://github.com/aws/aws-sdk-js-v3#functionality-requiring-aws-common-runtime-crt`;
+        throw e;
+      }
+      this.sigv4aSigner = new CrtSignerV4({
+        ...this.signerOptions,
+        signingAlgorithm: 1
+      });
+    }
+    return this.sigv4aSigner;
+  }
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+s3-request-presigner@3.750.0/node_modules/@aws-sdk/s3-request-presigner/dist-es/constants.js
+var UNSIGNED_PAYLOAD2 = "UNSIGNED-PAYLOAD";
+var SHA256_HEADER2 = "X-Amz-Content-Sha256";
+
+// ../../node_modules/.pnpm/@aws-sdk+s3-request-presigner@3.750.0/node_modules/@aws-sdk/s3-request-presigner/dist-es/presigner.js
+var S3RequestPresigner = class {
+  signer;
+  constructor(options) {
+    const resolvedOptions = {
+      service: options.signingName || options.service || "s3",
+      uriEscapePath: options.uriEscapePath || false,
+      applyChecksum: options.applyChecksum || false,
+      ...options
+    };
+    this.signer = new SignatureV4MultiRegion(resolvedOptions);
+  }
+  presign(requestToSign, { unsignableHeaders = /* @__PURE__ */ new Set(), hoistableHeaders = /* @__PURE__ */ new Set(), unhoistableHeaders = /* @__PURE__ */ new Set(), ...options } = {}) {
+    this.prepareRequest(requestToSign, {
+      unsignableHeaders,
+      unhoistableHeaders,
+      hoistableHeaders
+    });
+    return this.signer.presign(requestToSign, {
+      expiresIn: 900,
+      unsignableHeaders,
+      unhoistableHeaders,
+      ...options
+    });
+  }
+  presignWithCredentials(requestToSign, credentials, { unsignableHeaders = /* @__PURE__ */ new Set(), hoistableHeaders = /* @__PURE__ */ new Set(), unhoistableHeaders = /* @__PURE__ */ new Set(), ...options } = {}) {
+    this.prepareRequest(requestToSign, {
+      unsignableHeaders,
+      unhoistableHeaders,
+      hoistableHeaders
+    });
+    return this.signer.presignWithCredentials(requestToSign, credentials, {
+      expiresIn: 900,
+      unsignableHeaders,
+      unhoistableHeaders,
+      ...options
+    });
+  }
+  prepareRequest(requestToSign, { unsignableHeaders = /* @__PURE__ */ new Set(), unhoistableHeaders = /* @__PURE__ */ new Set(), hoistableHeaders = /* @__PURE__ */ new Set() } = {}) {
+    unsignableHeaders.add("content-type");
+    Object.keys(requestToSign.headers).map((header) => header.toLowerCase()).filter((header) => header.startsWith("x-amz-server-side-encryption")).forEach((header) => {
+      if (!hoistableHeaders.has(header)) {
+        unhoistableHeaders.add(header);
+      }
+    });
+    requestToSign.headers[SHA256_HEADER2] = UNSIGNED_PAYLOAD2;
+    const currentHostHeader = requestToSign.headers.host;
+    const port = requestToSign.port;
+    const expectedHostHeader = `${requestToSign.hostname}${requestToSign.port != null ? ":" + port : ""}`;
+    if (!currentHostHeader || currentHostHeader === requestToSign.hostname && requestToSign.port != null) {
+      requestToSign.headers.host = expectedHostHeader;
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/@aws-sdk+s3-request-presigner@3.750.0/node_modules/@aws-sdk/s3-request-presigner/dist-es/getSignedUrl.js
+var getSignedUrl = async (client, command, options = {}) => {
+  let s3Presigner;
+  let region;
+  if (typeof client.config.endpointProvider === "function") {
+    const endpointV2 = await getEndpointFromInstructions(command.input, command.constructor, client.config);
+    const authScheme = endpointV2.properties?.authSchemes?.[0];
+    if (authScheme?.name === "sigv4a") {
+      region = authScheme?.signingRegionSet?.join(",");
+    } else {
+      region = authScheme?.signingRegion;
+    }
+    s3Presigner = new S3RequestPresigner({
+      ...client.config,
+      signingName: authScheme?.signingName,
+      region: async () => region
+    });
+  } else {
+    s3Presigner = new S3RequestPresigner(client.config);
+  }
+  const presignInterceptMiddleware = (next, context) => async (args) => {
+    const { request } = args;
+    if (!HttpRequest.isInstance(request)) {
+      throw new Error("Request to be presigned is not an valid HTTP request.");
+    }
+    delete request.headers["amz-sdk-invocation-id"];
+    delete request.headers["amz-sdk-request"];
+    delete request.headers["x-amz-user-agent"];
+    let presigned2;
+    const presignerOptions = {
+      ...options,
+      signingRegion: options.signingRegion ?? context["signing_region"] ?? region,
+      signingService: options.signingService ?? context["signing_service"]
+    };
+    if (context.s3ExpressIdentity) {
+      presigned2 = await s3Presigner.presignWithCredentials(request, context.s3ExpressIdentity, presignerOptions);
+    } else {
+      presigned2 = await s3Presigner.presign(request, presignerOptions);
+    }
+    return {
+      response: {},
+      output: {
+        $metadata: { httpStatusCode: 200 },
+        presigned: presigned2
+      }
+    };
+  };
+  const middlewareName = "presignInterceptMiddleware";
+  const clientStack = client.middlewareStack.clone();
+  clientStack.addRelativeTo(presignInterceptMiddleware, {
+    name: middlewareName,
+    relation: "before",
+    toMiddleware: "awsAuthMiddleware",
+    override: true
+  });
+  const handler2 = command.resolveMiddleware(clientStack, client.config, {});
+  const { output } = await handler2({ input: command.input });
+  const { presigned } = output;
+  return formatUrl(presigned);
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/body.js
+var parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
+  const { all = false, dot = false } = options;
+  const headers = request instanceof HonoRequest ? request.raw.headers : request.headers;
+  const contentType = headers.get("Content-Type");
+  if (contentType?.startsWith("multipart/form-data") || contentType?.startsWith("application/x-www-form-urlencoded")) {
+    return parseFormData(request, { all, dot });
+  }
+  return {};
+};
+async function parseFormData(request, options) {
+  const formData = await request.formData();
+  if (formData) {
+    return convertFormDataToBodyData(formData, options);
+  }
+  return {};
+}
+function convertFormDataToBodyData(formData, options) {
+  const form = /* @__PURE__ */ Object.create(null);
+  formData.forEach((value, key) => {
+    const shouldParseAllValues = options.all || key.endsWith("[]");
+    if (!shouldParseAllValues) {
+      form[key] = value;
+    } else {
+      handleParsingAllValues(form, key, value);
+    }
+  });
+  if (options.dot) {
+    Object.entries(form).forEach(([key, value]) => {
+      const shouldParseDotValues = key.includes(".");
+      if (shouldParseDotValues) {
+        handleParsingNestedValues(form, key, value);
+        delete form[key];
+      }
+    });
+  }
+  return form;
+}
+var handleParsingAllValues = (form, key, value) => {
+  if (form[key] !== void 0) {
+    if (Array.isArray(form[key])) {
+      ;
+      form[key].push(value);
+    } else {
+      form[key] = [form[key], value];
+    }
+  } else {
+    form[key] = value;
+  }
+};
+var handleParsingNestedValues = (form, key, value) => {
+  let nestedForm = form;
+  const keys = key.split(".");
+  keys.forEach((key2, index) => {
+    if (index === keys.length - 1) {
+      nestedForm[key2] = value;
+    } else {
+      if (!nestedForm[key2] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) {
+        nestedForm[key2] = /* @__PURE__ */ Object.create(null);
+      }
+      nestedForm = nestedForm[key2];
+    }
+  });
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/url.js
+var splitPath = (path) => {
+  const paths = path.split("/");
+  if (paths[0] === "") {
+    paths.shift();
+  }
+  return paths;
+};
+var splitRoutingPath = (routePath) => {
+  const { groups, path } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path);
+  return replaceGroupMarks(paths, groups);
+};
+var extractGroupsFromPath = (path) => {
+  const groups = [];
+  path = path.replace(/\{[^}]+\}/g, (match, index) => {
+    const mark = `@${index}`;
+    groups.push([mark, match]);
+    return mark;
+  });
+  return { groups, path };
+};
+var replaceGroupMarks = (paths, groups) => {
+  for (let i = groups.length - 1; i >= 0; i--) {
+    const [mark] = groups[i];
+    for (let j = paths.length - 1; j >= 0; j--) {
+      if (paths[j].includes(mark)) {
+        paths[j] = paths[j].replace(mark, groups[i][1]);
+        break;
+      }
+    }
+  }
+  return paths;
+};
+var patternCache = {};
+var getPattern = (label) => {
+  if (label === "*") {
+    return "*";
+  }
+  const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+  if (match) {
+    if (!patternCache[label]) {
+      if (match[2]) {
+        patternCache[label] = [label, match[1], new RegExp("^" + match[2] + "$")];
+      } else {
+        patternCache[label] = [label, match[1], true];
+      }
+    }
+    return patternCache[label];
+  }
+  return null;
+};
+var tryDecodeURI = (str) => {
+  try {
+    return decodeURI(str);
+  } catch {
+    return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
+      try {
+        return decodeURI(match);
+      } catch {
+        return match;
+      }
+    });
+  }
+};
+var getPath = (request) => {
+  const url = request.url;
+  const start = url.indexOf("/", 8);
+  let i = start;
+  for (; i < url.length; i++) {
+    const charCode = url.charCodeAt(i);
+    if (charCode === 37) {
+      const queryIndex = url.indexOf("?", i);
+      const path = url.slice(start, queryIndex === -1 ? void 0 : queryIndex);
+      return tryDecodeURI(path.includes("%25") ? path.replace(/%25/g, "%2525") : path);
+    } else if (charCode === 63) {
+      break;
+    }
+  }
+  return url.slice(start, i);
+};
+var getPathNoStrict = (request) => {
+  const result = getPath(request);
+  return result.length > 1 && result[result.length - 1] === "/" ? result.slice(0, -1) : result;
+};
+var mergePath = (...paths) => {
+  let p = "";
+  let endsWithSlash = false;
+  for (let path of paths) {
+    if (p[p.length - 1] === "/") {
+      p = p.slice(0, -1);
+      endsWithSlash = true;
+    }
+    if (path[0] !== "/") {
+      path = `/${path}`;
+    }
+    if (path === "/" && endsWithSlash) {
+      p = `${p}/`;
+    } else if (path !== "/") {
+      p = `${p}${path}`;
+    }
+    if (path === "/" && p === "") {
+      p = "/";
+    }
+  }
+  return p;
+};
+var checkOptionalParameter = (path) => {
+  if (!path.match(/\:.+\?$/)) {
+    return null;
+  }
+  const segments = path.split("/");
+  const results = [];
+  let basePath = "";
+  segments.forEach((segment) => {
+    if (segment !== "" && !/\:/.test(segment)) {
+      basePath += "/" + segment;
+    } else if (/\:/.test(segment)) {
+      if (/\?/.test(segment)) {
+        if (results.length === 0 && basePath === "") {
+          results.push("/");
+        } else {
+          results.push(basePath);
+        }
+        const optionalSegment = segment.replace("?", "");
+        basePath += "/" + optionalSegment;
+        results.push(basePath);
+      } else {
+        basePath += "/" + segment;
+      }
+    }
+  });
+  return results.filter((v, i, a) => a.indexOf(v) === i);
+};
+var _decodeURI = (value) => {
+  if (!/[%+]/.test(value)) {
+    return value;
+  }
+  if (value.indexOf("+") !== -1) {
+    value = value.replace(/\+/g, " ");
+  }
+  return /%/.test(value) ? decodeURIComponent_(value) : value;
+};
+var _getQueryParam = (url, key, multiple) => {
+  let encoded;
+  if (!multiple && key && !/[%+]/.test(key)) {
+    let keyIndex2 = url.indexOf(`?${key}`, 8);
+    if (keyIndex2 === -1) {
+      keyIndex2 = url.indexOf(`&${key}`, 8);
+    }
+    while (keyIndex2 !== -1) {
+      const trailingKeyCode = url.charCodeAt(keyIndex2 + key.length + 1);
+      if (trailingKeyCode === 61) {
+        const valueIndex = keyIndex2 + key.length + 2;
+        const endIndex = url.indexOf("&", valueIndex);
+        return _decodeURI(url.slice(valueIndex, endIndex === -1 ? void 0 : endIndex));
+      } else if (trailingKeyCode == 38 || isNaN(trailingKeyCode)) {
+        return "";
+      }
+      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
+    }
+    encoded = /[%+]/.test(url);
+    if (!encoded) {
+      return void 0;
+    }
+  }
+  const results = {};
+  encoded ??= /[%+]/.test(url);
+  let keyIndex = url.indexOf("?", 8);
+  while (keyIndex !== -1) {
+    const nextKeyIndex = url.indexOf("&", keyIndex + 1);
+    let valueIndex = url.indexOf("=", keyIndex);
+    if (valueIndex > nextKeyIndex && nextKeyIndex !== -1) {
+      valueIndex = -1;
+    }
+    let name = url.slice(
+      keyIndex + 1,
+      valueIndex === -1 ? nextKeyIndex === -1 ? void 0 : nextKeyIndex : valueIndex
+    );
+    if (encoded) {
+      name = _decodeURI(name);
+    }
+    keyIndex = nextKeyIndex;
+    if (name === "") {
+      continue;
+    }
+    let value;
+    if (valueIndex === -1) {
+      value = "";
+    } else {
+      value = url.slice(valueIndex + 1, nextKeyIndex === -1 ? void 0 : nextKeyIndex);
+      if (encoded) {
+        value = _decodeURI(value);
+      }
+    }
+    if (multiple) {
+      if (!(results[name] && Array.isArray(results[name]))) {
+        results[name] = [];
+      }
+      ;
+      results[name].push(value);
+    } else {
+      results[name] ??= value;
+    }
+  }
+  return key ? results[key] : results;
+};
+var getQueryParam = _getQueryParam;
+var getQueryParams = (url, key) => {
+  return _getQueryParam(url, key, true);
+};
+var decodeURIComponent_ = decodeURIComponent;
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/request.js
+var HonoRequest = class {
+  raw;
+  #validatedData;
+  #matchResult;
+  routeIndex = 0;
+  path;
+  bodyCache = {};
+  constructor(request, path = "/", matchResult = [[]]) {
+    this.raw = request;
+    this.path = path;
+    this.#matchResult = matchResult;
+    this.#validatedData = {};
+  }
+  param(key) {
+    return key ? this.getDecodedParam(key) : this.getAllDecodedParams();
+  }
+  getDecodedParam(key) {
+    const paramKey = this.#matchResult[0][this.routeIndex][1][key];
+    const param = this.getParamValue(paramKey);
+    return param ? /\%/.test(param) ? decodeURIComponent_(param) : param : void 0;
+  }
+  getAllDecodedParams() {
+    const decoded = {};
+    const keys = Object.keys(this.#matchResult[0][this.routeIndex][1]);
+    for (const key of keys) {
+      const value = this.getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
+      if (value && typeof value === "string") {
+        decoded[key] = /\%/.test(value) ? decodeURIComponent_(value) : value;
+      }
+    }
+    return decoded;
+  }
+  getParamValue(paramKey) {
+    return this.#matchResult[1] ? this.#matchResult[1][paramKey] : paramKey;
+  }
+  query(key) {
+    return getQueryParam(this.url, key);
+  }
+  queries(key) {
+    return getQueryParams(this.url, key);
+  }
+  header(name) {
+    if (name) {
+      return this.raw.headers.get(name.toLowerCase()) ?? void 0;
+    }
+    const headerData = {};
+    this.raw.headers.forEach((value, key) => {
+      headerData[key] = value;
+    });
+    return headerData;
+  }
+  async parseBody(options) {
+    return this.bodyCache.parsedBody ??= await parseBody(this, options);
+  }
+  cachedBody = (key) => {
+    const { bodyCache, raw: raw2 } = this;
+    const cachedBody = bodyCache[key];
+    if (cachedBody) {
+      return cachedBody;
+    }
+    const anyCachedKey = Object.keys(bodyCache)[0];
+    if (anyCachedKey) {
+      return bodyCache[anyCachedKey].then((body) => {
+        if (anyCachedKey === "json") {
+          body = JSON.stringify(body);
+        }
+        return new Response(body)[key]();
+      });
+    }
+    return bodyCache[key] = raw2[key]();
+  };
+  json() {
+    return this.cachedBody("json");
+  }
+  text() {
+    return this.cachedBody("text");
+  }
+  arrayBuffer() {
+    return this.cachedBody("arrayBuffer");
+  }
+  blob() {
+    return this.cachedBody("blob");
+  }
+  formData() {
+    return this.cachedBody("formData");
+  }
+  addValidatedData(target, data) {
+    this.#validatedData[target] = data;
+  }
+  valid(target) {
+    return this.#validatedData[target];
+  }
+  get url() {
+    return this.raw.url;
+  }
+  get method() {
+    return this.raw.method;
+  }
+  get matchedRoutes() {
+    return this.#matchResult[0].map(([[, route]]) => route);
+  }
+  get routePath() {
+    return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/html.js
+var HtmlEscapedCallbackPhase = {
+  Stringify: 1,
+  BeforeStream: 2,
+  Stream: 3
+};
+var raw = (value, callbacks) => {
+  const escapedString = new String(value);
+  escapedString.isEscaped = true;
+  escapedString.callbacks = callbacks;
+  return escapedString;
+};
+var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
+  if (typeof str === "object" && !(str instanceof String)) {
+    if (!(str instanceof Promise)) {
+      str = str.toString();
+    }
+    if (str instanceof Promise) {
+      str = await str;
+    }
+  }
+  const callbacks = str.callbacks;
+  if (!callbacks?.length) {
+    return Promise.resolve(str);
+  }
+  if (buffer) {
+    buffer[0] += str;
+  } else {
+    buffer = [str];
+  }
+  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then(
+    (res) => Promise.all(
+      res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))
+    ).then(() => buffer[0])
+  );
+  if (preserveCallbacks) {
+    return raw(await resStr, callbacks);
+  } else {
+    return resStr;
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/context.js
+var TEXT_PLAIN = "text/plain; charset=UTF-8";
+var setHeaders = (headers, map = {}) => {
+  Object.entries(map).forEach(([key, value]) => headers.set(key, value));
+  return headers;
+};
+var Context = class {
+  #rawRequest;
+  #req;
+  env = {};
+  #var;
+  finalized = false;
+  error;
+  #status = 200;
+  #executionCtx;
+  #headers;
+  #preparedHeaders;
+  #res;
+  #isFresh = true;
+  #layout;
+  #renderer;
+  #notFoundHandler;
+  #matchResult;
+  #path;
+  constructor(req, options) {
+    this.#rawRequest = req;
+    if (options) {
+      this.#executionCtx = options.executionCtx;
+      this.env = options.env;
+      this.#notFoundHandler = options.notFoundHandler;
+      this.#path = options.path;
+      this.#matchResult = options.matchResult;
+    }
+  }
+  get req() {
+    this.#req ??= new HonoRequest(this.#rawRequest, this.#path, this.#matchResult);
+    return this.#req;
+  }
+  get event() {
+    if (this.#executionCtx && "respondWith" in this.#executionCtx) {
+      return this.#executionCtx;
+    } else {
+      throw Error("This context has no FetchEvent");
+    }
+  }
+  get executionCtx() {
+    if (this.#executionCtx) {
+      return this.#executionCtx;
+    } else {
+      throw Error("This context has no ExecutionContext");
+    }
+  }
+  get res() {
+    this.#isFresh = false;
+    return this.#res ||= new Response("404 Not Found", { status: 404 });
+  }
+  set res(_res) {
+    this.#isFresh = false;
+    if (this.#res && _res) {
+      try {
+        for (const [k, v] of this.#res.headers.entries()) {
+          if (k === "content-type") {
+            continue;
+          }
+          if (k === "set-cookie") {
+            const cookies = this.#res.headers.getSetCookie();
+            _res.headers.delete("set-cookie");
+            for (const cookie of cookies) {
+              _res.headers.append("set-cookie", cookie);
+            }
+          } else {
+            _res.headers.set(k, v);
+          }
+        }
+      } catch (e) {
+        if (e instanceof TypeError && e.message.includes("immutable")) {
+          this.res = new Response(_res.body, {
+            headers: _res.headers,
+            status: _res.status
+          });
+          return;
+        } else {
+          throw e;
+        }
+      }
+    }
+    this.#res = _res;
+    this.finalized = true;
+  }
+  render = (...args) => {
+    this.#renderer ??= (content) => this.html(content);
+    return this.#renderer(...args);
+  };
+  setLayout = (layout) => this.#layout = layout;
+  getLayout = () => this.#layout;
+  setRenderer = (renderer) => {
+    this.#renderer = renderer;
+  };
+  header = (name, value, options) => {
+    if (value === void 0) {
+      if (this.#headers) {
+        this.#headers.delete(name);
+      } else if (this.#preparedHeaders) {
+        delete this.#preparedHeaders[name.toLocaleLowerCase()];
+      }
+      if (this.finalized) {
+        this.res.headers.delete(name);
+      }
+      return;
+    }
+    if (options?.append) {
+      if (!this.#headers) {
+        this.#isFresh = false;
+        this.#headers = new Headers(this.#preparedHeaders);
+        this.#preparedHeaders = {};
+      }
+      this.#headers.append(name, value);
+    } else {
+      if (this.#headers) {
+        this.#headers.set(name, value);
+      } else {
+        this.#preparedHeaders ??= {};
+        this.#preparedHeaders[name.toLowerCase()] = value;
+      }
+    }
+    if (this.finalized) {
+      if (options?.append) {
+        this.res.headers.append(name, value);
+      } else {
+        this.res.headers.set(name, value);
+      }
+    }
+  };
+  status = (status) => {
+    this.#isFresh = false;
+    this.#status = status;
+  };
+  set = (key, value) => {
+    this.#var ??= /* @__PURE__ */ new Map();
+    this.#var.set(key, value);
+  };
+  get = (key) => {
+    return this.#var ? this.#var.get(key) : void 0;
+  };
+  get var() {
+    if (!this.#var) {
+      return {};
+    }
+    return Object.fromEntries(this.#var);
+  }
+  newResponse = (data, arg, headers) => {
+    if (this.#isFresh && !headers && !arg && this.#status === 200) {
+      return new Response(data, {
+        headers: this.#preparedHeaders
+      });
+    }
+    if (arg && typeof arg !== "number") {
+      const header = new Headers(arg.headers);
+      if (this.#headers) {
+        this.#headers.forEach((v, k) => {
+          if (k === "set-cookie") {
+            header.append(k, v);
+          } else {
+            header.set(k, v);
+          }
+        });
+      }
+      const headers2 = setHeaders(header, this.#preparedHeaders);
+      return new Response(data, {
+        headers: headers2,
+        status: arg.status ?? this.#status
+      });
+    }
+    const status = typeof arg === "number" ? arg : this.#status;
+    this.#preparedHeaders ??= {};
+    this.#headers ??= new Headers();
+    setHeaders(this.#headers, this.#preparedHeaders);
+    if (this.#res) {
+      this.#res.headers.forEach((v, k) => {
+        if (k === "set-cookie") {
+          this.#headers?.append(k, v);
+        } else {
+          this.#headers?.set(k, v);
+        }
+      });
+      setHeaders(this.#headers, this.#preparedHeaders);
+    }
+    headers ??= {};
+    for (const [k, v] of Object.entries(headers)) {
+      if (typeof v === "string") {
+        this.#headers.set(k, v);
+      } else {
+        this.#headers.delete(k);
+        for (const v2 of v) {
+          this.#headers.append(k, v2);
+        }
+      }
+    }
+    return new Response(data, {
+      status,
+      headers: this.#headers
+    });
+  };
+  body = (data, arg, headers) => {
+    return typeof arg === "number" ? this.newResponse(data, arg, headers) : this.newResponse(data, arg);
+  };
+  text = (text, arg, headers) => {
+    if (!this.#preparedHeaders) {
+      if (this.#isFresh && !headers && !arg) {
+        return new Response(text);
+      }
+      this.#preparedHeaders = {};
+    }
+    this.#preparedHeaders["content-type"] = TEXT_PLAIN;
+    return typeof arg === "number" ? this.newResponse(text, arg, headers) : this.newResponse(text, arg);
+  };
+  json = (object, arg, headers) => {
+    const body = JSON.stringify(object);
+    this.#preparedHeaders ??= {};
+    this.#preparedHeaders["content-type"] = "application/json; charset=UTF-8";
+    return typeof arg === "number" ? this.newResponse(body, arg, headers) : this.newResponse(body, arg);
+  };
+  html = (html, arg, headers) => {
+    this.#preparedHeaders ??= {};
+    this.#preparedHeaders["content-type"] = "text/html; charset=UTF-8";
+    if (typeof html === "object") {
+      return resolveCallback(html, HtmlEscapedCallbackPhase.Stringify, false, {}).then((html2) => {
+        return typeof arg === "number" ? this.newResponse(html2, arg, headers) : this.newResponse(html2, arg);
+      });
+    }
+    return typeof arg === "number" ? this.newResponse(html, arg, headers) : this.newResponse(html, arg);
+  };
+  redirect = (location, status) => {
+    this.#headers ??= new Headers();
+    this.#headers.set("Location", location);
+    return this.newResponse(null, status ?? 302);
+  };
+  notFound = () => {
+    this.#notFoundHandler ??= () => new Response();
+    return this.#notFoundHandler(this);
+  };
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/compose.js
+var compose = (middleware, onError, onNotFound) => {
+  return (context, next) => {
+    let index = -1;
+    return dispatch(0);
+    async function dispatch(i) {
+      if (i <= index) {
+        throw new Error("next() called multiple times");
+      }
+      index = i;
+      let res;
+      let isError = false;
+      let handler2;
+      if (middleware[i]) {
+        handler2 = middleware[i][0][0];
+        if (context instanceof Context) {
+          context.req.routeIndex = i;
+        }
+      } else {
+        handler2 = i === middleware.length && next || void 0;
+      }
+      if (!handler2) {
+        if (context instanceof Context && context.finalized === false && onNotFound) {
+          res = await onNotFound(context);
+        }
+      } else {
+        try {
+          res = await handler2(context, () => {
+            return dispatch(i + 1);
+          });
+        } catch (err) {
+          if (err instanceof Error && context instanceof Context && onError) {
+            context.error = err;
+            res = await onError(err, context);
+            isError = true;
+          } else {
+            throw err;
+          }
+        }
+      }
+      if (res && (context.finalized === false || isError)) {
+        context.res = res;
+      }
+      return context;
+    }
+  };
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router.js
+var METHOD_NAME_ALL = "ALL";
+var METHOD_NAME_ALL_LOWERCASE = "all";
+var METHODS = ["get", "post", "put", "delete", "options", "patch"];
+var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
+var UnsupportedPathError = class extends Error {
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/hono-base.js
+var COMPOSED_HANDLER = Symbol("composedHandler");
+var notFoundHandler = (c) => {
+  return c.text("404 Not Found", 404);
+};
+var errorHandler = (err, c) => {
+  if ("getResponse" in err) {
+    return err.getResponse();
+  }
+  console.error(err);
+  return c.text("Internal Server Error", 500);
+};
+var Hono = class {
+  get;
+  post;
+  put;
+  delete;
+  options;
+  patch;
+  all;
+  on;
+  use;
+  router;
+  getPath;
+  _basePath = "/";
+  #path = "/";
+  routes = [];
+  constructor(options = {}) {
+    const allMethods = [...METHODS, METHOD_NAME_ALL_LOWERCASE];
+    allMethods.forEach((method) => {
+      this[method] = (args1, ...args) => {
+        if (typeof args1 === "string") {
+          this.#path = args1;
+        } else {
+          this.addRoute(method, this.#path, args1);
+        }
+        args.forEach((handler2) => {
+          if (typeof handler2 !== "string") {
+            this.addRoute(method, this.#path, handler2);
+          }
+        });
+        return this;
+      };
+    });
+    this.on = (method, path, ...handlers) => {
+      for (const p of [path].flat()) {
+        this.#path = p;
+        for (const m of [method].flat()) {
+          handlers.map((handler2) => {
+            this.addRoute(m.toUpperCase(), this.#path, handler2);
+          });
+        }
+      }
+      return this;
+    };
+    this.use = (arg1, ...handlers) => {
+      if (typeof arg1 === "string") {
+        this.#path = arg1;
+      } else {
+        this.#path = "*";
+        handlers.unshift(arg1);
+      }
+      handlers.forEach((handler2) => {
+        this.addRoute(METHOD_NAME_ALL, this.#path, handler2);
+      });
+      return this;
+    };
+    const strict = options.strict ?? true;
+    delete options.strict;
+    Object.assign(this, options);
+    this.getPath = strict ? options.getPath ?? getPath : getPathNoStrict;
+  }
+  clone() {
+    const clone = new Hono({
+      router: this.router,
+      getPath: this.getPath
+    });
+    clone.routes = this.routes;
+    return clone;
+  }
+  notFoundHandler = notFoundHandler;
+  errorHandler = errorHandler;
+  route(path, app2) {
+    const subApp = this.basePath(path);
+    app2.routes.map((r) => {
+      let handler2;
+      if (app2.errorHandler === errorHandler) {
+        handler2 = r.handler;
+      } else {
+        handler2 = async (c, next) => (await compose([], app2.errorHandler)(c, () => r.handler(c, next))).res;
+        handler2[COMPOSED_HANDLER] = r.handler;
+      }
+      subApp.addRoute(r.method, r.path, handler2);
+    });
+    return this;
+  }
+  basePath(path) {
+    const subApp = this.clone();
+    subApp._basePath = mergePath(this._basePath, path);
+    return subApp;
+  }
+  onError = (handler2) => {
+    this.errorHandler = handler2;
+    return this;
+  };
+  notFound = (handler2) => {
+    this.notFoundHandler = handler2;
+    return this;
+  };
+  mount(path, applicationHandler, options) {
+    let replaceRequest;
+    let optionHandler;
+    if (options) {
+      if (typeof options === "function") {
+        optionHandler = options;
+      } else {
+        optionHandler = options.optionHandler;
+        replaceRequest = options.replaceRequest;
+      }
+    }
+    const getOptions = optionHandler ? (c) => {
+      const options2 = optionHandler(c);
+      return Array.isArray(options2) ? options2 : [options2];
+    } : (c) => {
+      let executionContext = void 0;
+      try {
+        executionContext = c.executionCtx;
+      } catch {
+      }
+      return [c.env, executionContext];
+    };
+    replaceRequest ||= (() => {
+      const mergedPath = mergePath(this._basePath, path);
+      const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
+      return (request) => {
+        const url = new URL(request.url);
+        url.pathname = url.pathname.slice(pathPrefixLength) || "/";
+        return new Request(url, request);
+      };
+    })();
+    const handler2 = async (c, next) => {
+      const res = await applicationHandler(replaceRequest(c.req.raw), ...getOptions(c));
+      if (res) {
+        return res;
+      }
+      await next();
+    };
+    this.addRoute(METHOD_NAME_ALL, mergePath(path, "*"), handler2);
+    return this;
+  }
+  addRoute(method, path, handler2) {
+    method = method.toUpperCase();
+    path = mergePath(this._basePath, path);
+    const r = { path, method, handler: handler2 };
+    this.router.add(method, path, [handler2, r]);
+    this.routes.push(r);
+  }
+  matchRoute(method, path) {
+    return this.router.match(method, path);
+  }
+  handleError(err, c) {
+    if (err instanceof Error) {
+      return this.errorHandler(err, c);
+    }
+    throw err;
+  }
+  dispatch(request, executionCtx, env, method) {
+    if (method === "HEAD") {
+      return (async () => new Response(null, await this.dispatch(request, executionCtx, env, "GET")))();
+    }
+    const path = this.getPath(request, { env });
+    const matchResult = this.matchRoute(method, path);
+    const c = new Context(request, {
+      path,
+      matchResult,
+      env,
+      executionCtx,
+      notFoundHandler: this.notFoundHandler
+    });
+    if (matchResult[0].length === 1) {
+      let res;
+      try {
+        res = matchResult[0][0][0][0](c, async () => {
+          c.res = await this.notFoundHandler(c);
+        });
+      } catch (err) {
+        return this.handleError(err, c);
+      }
+      return res instanceof Promise ? res.then(
+        (resolved) => resolved || (c.finalized ? c.res : this.notFoundHandler(c))
+      ).catch((err) => this.handleError(err, c)) : res ?? this.notFoundHandler(c);
+    }
+    const composed = compose(matchResult[0], this.errorHandler, this.notFoundHandler);
+    return (async () => {
+      try {
+        const context = await composed(c);
+        if (!context.finalized) {
+          throw new Error(
+            "Context is not finalized. Did you forget to return a Response object or `await next()`?"
+          );
+        }
+        return context.res;
+      } catch (err) {
+        return this.handleError(err, c);
+      }
+    })();
+  }
+  fetch = (request, ...rest) => {
+    return this.dispatch(request, rest[1], rest[0], request.method);
+  };
+  request = (input, requestInit, Env, executionCtx) => {
+    if (input instanceof Request) {
+      if (requestInit !== void 0) {
+        input = new Request(input, requestInit);
+      }
+      return this.fetch(input, Env, executionCtx);
+    }
+    input = input.toString();
+    const path = /^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`;
+    const req = new Request(path, requestInit);
+    return this.fetch(req, Env, executionCtx);
+  };
+  fire = () => {
+    addEventListener("fetch", (event) => {
+      event.respondWith(this.dispatch(event.request, event, void 0, event.request.method));
+    });
+  };
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router/reg-exp-router/node.js
+var LABEL_REG_EXP_STR = "[^/]+";
+var ONLY_WILDCARD_REG_EXP_STR = ".*";
+var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
+var PATH_ERROR = Symbol();
+var regExpMetaChars = new Set(".\\+*[^]$()");
+function compareKey(a, b) {
+  if (a.length === 1) {
+    return b.length === 1 ? a < b ? -1 : 1 : -1;
+  }
+  if (b.length === 1) {
+    return 1;
+  }
+  if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) {
+    return 1;
+  } else if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) {
+    return -1;
+  }
+  if (a === LABEL_REG_EXP_STR) {
+    return 1;
+  } else if (b === LABEL_REG_EXP_STR) {
+    return -1;
+  }
+  return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
+}
+var Node = class {
+  index;
+  varIndex;
+  children = /* @__PURE__ */ Object.create(null);
+  insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
+    if (tokens.length === 0) {
+      if (this.index !== void 0) {
+        throw PATH_ERROR;
+      }
+      if (pathErrorCheckOnly) {
+        return;
+      }
+      this.index = index;
+      return;
+    }
+    const [token, ...restTokens] = tokens;
+    const pattern = token === "*" ? restTokens.length === 0 ? ["", "", ONLY_WILDCARD_REG_EXP_STR] : ["", "", LABEL_REG_EXP_STR] : token === "/*" ? ["", "", TAIL_WILDCARD_REG_EXP_STR] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+    let node;
+    if (pattern) {
+      const name = pattern[1];
+      let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
+      if (name && pattern[2]) {
+        regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
+        if (/\((?!\?:)/.test(regexpStr)) {
+          throw PATH_ERROR;
+        }
+      }
+      node = this.children[regexpStr];
+      if (!node) {
+        if (Object.keys(this.children).some(
+          (k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
+        )) {
+          throw PATH_ERROR;
+        }
+        if (pathErrorCheckOnly) {
+          return;
+        }
+        node = this.children[regexpStr] = new Node();
+        if (name !== "") {
+          node.varIndex = context.varIndex++;
+        }
+      }
+      if (!pathErrorCheckOnly && name !== "") {
+        paramMap.push([name, node.varIndex]);
+      }
+    } else {
+      node = this.children[token];
+      if (!node) {
+        if (Object.keys(this.children).some(
+          (k) => k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
+        )) {
+          throw PATH_ERROR;
+        }
+        if (pathErrorCheckOnly) {
+          return;
+        }
+        node = this.children[token] = new Node();
+      }
+    }
+    node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
+  }
+  buildRegExpStr() {
+    const childKeys = Object.keys(this.children).sort(compareKey);
+    const strList = childKeys.map((k) => {
+      const c = this.children[k];
+      return (typeof c.varIndex === "number" ? `(${k})@${c.varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
+    });
+    if (typeof this.index === "number") {
+      strList.unshift(`#${this.index}`);
+    }
+    if (strList.length === 0) {
+      return "";
+    }
+    if (strList.length === 1) {
+      return strList[0];
+    }
+    return "(?:" + strList.join("|") + ")";
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router/reg-exp-router/trie.js
+var Trie = class {
+  context = { varIndex: 0 };
+  root = new Node();
+  insert(path, index, pathErrorCheckOnly) {
+    const paramAssoc = [];
+    const groups = [];
+    for (let i = 0; ; ) {
+      let replaced = false;
+      path = path.replace(/\{[^}]+\}/g, (m) => {
+        const mark = `@\\${i}`;
+        groups[i] = [mark, m];
+        i++;
+        replaced = true;
+        return mark;
+      });
+      if (!replaced) {
+        break;
+      }
+    }
+    const tokens = path.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+    for (let i = groups.length - 1; i >= 0; i--) {
+      const [mark] = groups[i];
+      for (let j = tokens.length - 1; j >= 0; j--) {
+        if (tokens[j].indexOf(mark) !== -1) {
+          tokens[j] = tokens[j].replace(mark, groups[i][1]);
+          break;
+        }
+      }
+    }
+    this.root.insert(tokens, index, paramAssoc, this.context, pathErrorCheckOnly);
+    return paramAssoc;
+  }
+  buildRegExp() {
+    let regexp = this.root.buildRegExpStr();
+    if (regexp === "") {
+      return [/^$/, [], []];
+    }
+    let captureIndex = 0;
+    const indexReplacementMap = [];
+    const paramReplacementMap = [];
+    regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
+      if (typeof handlerIndex !== "undefined") {
+        indexReplacementMap[++captureIndex] = Number(handlerIndex);
+        return "$()";
+      }
+      if (typeof paramIndex !== "undefined") {
+        paramReplacementMap[Number(paramIndex)] = ++captureIndex;
+        return "";
+      }
+      return "";
+    });
+    return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router/reg-exp-router/router.js
+var emptyParam = [];
+var nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
+var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
+function buildWildcardRegExp(path) {
+  return wildcardRegExpCache[path] ??= new RegExp(
+    path === "*" ? "" : `^${path.replace(
+      /\/\*$|([.\\+*[^\]$()])/g,
+      (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)"
+    )}$`
+  );
+}
+function clearWildcardRegExpCache() {
+  wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
+}
+function buildMatcherFromPreprocessedRoutes(routes) {
+  const trie = new Trie();
+  const handlerData = [];
+  if (routes.length === 0) {
+    return nullMatcher;
+  }
+  const routesWithStaticPathFlag = routes.map(
+    (route) => [!/\*|\/:/.test(route[0]), ...route]
+  ).sort(
+    ([isStaticA, pathA], [isStaticB, pathB]) => isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length
+  );
+  const staticMap = /* @__PURE__ */ Object.create(null);
+  for (let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++) {
+    const [pathErrorCheckOnly, path, handlers] = routesWithStaticPathFlag[i];
+    if (pathErrorCheckOnly) {
+      staticMap[path] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+    } else {
+      j++;
+    }
+    let paramAssoc;
+    try {
+      paramAssoc = trie.insert(path, j, pathErrorCheckOnly);
+    } catch (e) {
+      throw e === PATH_ERROR ? new UnsupportedPathError(path) : e;
+    }
+    if (pathErrorCheckOnly) {
+      continue;
+    }
+    handlerData[j] = handlers.map(([h, paramCount]) => {
+      const paramIndexMap = /* @__PURE__ */ Object.create(null);
+      paramCount -= 1;
+      for (; paramCount >= 0; paramCount--) {
+        const [key, value] = paramAssoc[paramCount];
+        paramIndexMap[key] = value;
+      }
+      return [h, paramIndexMap];
+    });
+  }
+  const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
+  for (let i = 0, len = handlerData.length; i < len; i++) {
+    for (let j = 0, len2 = handlerData[i].length; j < len2; j++) {
+      const map = handlerData[i][j]?.[1];
+      if (!map) {
+        continue;
+      }
+      const keys = Object.keys(map);
+      for (let k = 0, len3 = keys.length; k < len3; k++) {
+        map[keys[k]] = paramReplacementMap[map[keys[k]]];
+      }
+    }
+  }
+  const handlerMap = [];
+  for (const i in indexReplacementMap) {
+    handlerMap[i] = handlerData[indexReplacementMap[i]];
+  }
+  return [regexp, handlerMap, staticMap];
+}
+function findMiddleware(middleware, path) {
+  if (!middleware) {
+    return void 0;
+  }
+  for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
+    if (buildWildcardRegExp(k).test(path)) {
+      return [...middleware[k]];
+    }
+  }
+  return void 0;
+}
+var RegExpRouter = class {
+  name = "RegExpRouter";
+  middleware;
+  routes;
+  constructor() {
+    this.middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+    this.routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+  }
+  add(method, path, handler2) {
+    const { middleware, routes } = this;
+    if (!middleware || !routes) {
+      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+    }
+    if (!middleware[method]) {
+      ;
+      [middleware, routes].forEach((handlerMap) => {
+        handlerMap[method] = /* @__PURE__ */ Object.create(null);
+        Object.keys(handlerMap[METHOD_NAME_ALL]).forEach((p) => {
+          handlerMap[method][p] = [...handlerMap[METHOD_NAME_ALL][p]];
+        });
+      });
+    }
+    if (path === "/*") {
+      path = "*";
+    }
+    const paramCount = (path.match(/\/:/g) || []).length;
+    if (/\*$/.test(path)) {
+      const re = buildWildcardRegExp(path);
+      if (method === METHOD_NAME_ALL) {
+        Object.keys(middleware).forEach((m) => {
+          middleware[m][path] ||= findMiddleware(middleware[m], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
+        });
+      } else {
+        middleware[method][path] ||= findMiddleware(middleware[method], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
+      }
+      Object.keys(middleware).forEach((m) => {
+        if (method === METHOD_NAME_ALL || method === m) {
+          Object.keys(middleware[m]).forEach((p) => {
+            re.test(p) && middleware[m][p].push([handler2, paramCount]);
+          });
+        }
+      });
+      Object.keys(routes).forEach((m) => {
+        if (method === METHOD_NAME_ALL || method === m) {
+          Object.keys(routes[m]).forEach(
+            (p) => re.test(p) && routes[m][p].push([handler2, paramCount])
+          );
+        }
+      });
+      return;
+    }
+    const paths = checkOptionalParameter(path) || [path];
+    for (let i = 0, len = paths.length; i < len; i++) {
+      const path2 = paths[i];
+      Object.keys(routes).forEach((m) => {
+        if (method === METHOD_NAME_ALL || method === m) {
+          routes[m][path2] ||= [
+            ...findMiddleware(middleware[m], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || []
+          ];
+          routes[m][path2].push([handler2, paramCount - len + i + 1]);
+        }
+      });
+    }
+  }
+  match(method, path) {
+    clearWildcardRegExpCache();
+    const matchers = this.buildAllMatchers();
+    this.match = (method2, path2) => {
+      const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
+      const staticMatch = matcher[2][path2];
+      if (staticMatch) {
+        return staticMatch;
+      }
+      const match = path2.match(matcher[0]);
+      if (!match) {
+        return [[], emptyParam];
+      }
+      const index = match.indexOf("", 1);
+      return [matcher[1][index], match];
+    };
+    return this.match(method, path);
+  }
+  buildAllMatchers() {
+    const matchers = /* @__PURE__ */ Object.create(null);
+    [...Object.keys(this.routes), ...Object.keys(this.middleware)].forEach((method) => {
+      matchers[method] ||= this.buildMatcher(method);
+    });
+    this.middleware = this.routes = void 0;
+    return matchers;
+  }
+  buildMatcher(method) {
+    const routes = [];
+    let hasOwnRoute = method === METHOD_NAME_ALL;
+    [this.middleware, this.routes].forEach((r) => {
+      const ownRoute = r[method] ? Object.keys(r[method]).map((path) => [path, r[method][path]]) : [];
+      if (ownRoute.length !== 0) {
+        hasOwnRoute ||= true;
+        routes.push(...ownRoute);
+      } else if (method !== METHOD_NAME_ALL) {
+        routes.push(
+          ...Object.keys(r[METHOD_NAME_ALL]).map((path) => [path, r[METHOD_NAME_ALL][path]])
+        );
+      }
+    });
+    if (!hasOwnRoute) {
+      return null;
+    } else {
+      return buildMatcherFromPreprocessedRoutes(routes);
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router/smart-router/router.js
+var SmartRouter = class {
+  name = "SmartRouter";
+  routers = [];
+  routes = [];
+  constructor(init) {
+    Object.assign(this, init);
+  }
+  add(method, path, handler2) {
+    if (!this.routes) {
+      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+    }
+    this.routes.push([method, path, handler2]);
+  }
+  match(method, path) {
+    if (!this.routes) {
+      throw new Error("Fatal error");
+    }
+    const { routers, routes } = this;
+    const len = routers.length;
+    let i = 0;
+    let res;
+    for (; i < len; i++) {
+      const router = routers[i];
+      try {
+        routes.forEach((args) => {
+          router.add(...args);
+        });
+        res = router.match(method, path);
+      } catch (e) {
+        if (e instanceof UnsupportedPathError) {
+          continue;
+        }
+        throw e;
+      }
+      this.match = router.match.bind(router);
+      this.routers = [router];
+      this.routes = void 0;
+      break;
+    }
+    if (i === len) {
+      throw new Error("Fatal error");
+    }
+    this.name = `SmartRouter + ${this.activeRouter.name}`;
+    return res;
+  }
+  get activeRouter() {
+    if (this.routes || this.routers.length !== 1) {
+      throw new Error("No active router has been determined yet.");
+    }
+    return this.routers[0];
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router/trie-router/node.js
+var Node2 = class {
+  methods;
+  children;
+  patterns;
+  order = 0;
+  name;
+  params = /* @__PURE__ */ Object.create(null);
+  constructor(method, handler2, children) {
+    this.children = children || /* @__PURE__ */ Object.create(null);
+    this.methods = [];
+    this.name = "";
+    if (method && handler2) {
+      const m = /* @__PURE__ */ Object.create(null);
+      m[method] = { handler: handler2, possibleKeys: [], score: 0, name: this.name };
+      this.methods = [m];
+    }
+    this.patterns = [];
+  }
+  insert(method, path, handler2) {
+    this.name = `${method} ${path}`;
+    this.order = ++this.order;
+    let curNode = this;
+    const parts = splitRoutingPath(path);
+    const possibleKeys = [];
+    for (let i = 0, len = parts.length; i < len; i++) {
+      const p = parts[i];
+      if (Object.keys(curNode.children).includes(p)) {
+        curNode = curNode.children[p];
+        const pattern2 = getPattern(p);
+        if (pattern2) {
+          possibleKeys.push(pattern2[1]);
+        }
+        continue;
+      }
+      curNode.children[p] = new Node2();
+      const pattern = getPattern(p);
+      if (pattern) {
+        curNode.patterns.push(pattern);
+        possibleKeys.push(pattern[1]);
+      }
+      curNode = curNode.children[p];
+    }
+    if (!curNode.methods.length) {
+      curNode.methods = [];
+    }
+    const m = /* @__PURE__ */ Object.create(null);
+    const handlerSet = {
+      handler: handler2,
+      possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
+      name: this.name,
+      score: this.order
+    };
+    m[method] = handlerSet;
+    curNode.methods.push(m);
+    return curNode;
+  }
+  gHSets(node, method, nodeParams, params) {
+    const handlerSets = [];
+    for (let i = 0, len = node.methods.length; i < len; i++) {
+      const m = node.methods[i];
+      const handlerSet = m[method] || m[METHOD_NAME_ALL];
+      const processedSet = /* @__PURE__ */ Object.create(null);
+      if (handlerSet !== void 0) {
+        handlerSet.params = /* @__PURE__ */ Object.create(null);
+        handlerSet.possibleKeys.forEach((key) => {
+          const processed = processedSet[handlerSet.name];
+          handlerSet.params[key] = params[key] && !processed ? params[key] : nodeParams[key] ?? params[key];
+          processedSet[handlerSet.name] = true;
+        });
+        handlerSets.push(handlerSet);
+      }
+    }
+    return handlerSets;
+  }
+  search(method, path) {
+    const handlerSets = [];
+    this.params = /* @__PURE__ */ Object.create(null);
+    const curNode = this;
+    let curNodes = [curNode];
+    const parts = splitPath(path);
+    for (let i = 0, len = parts.length; i < len; i++) {
+      const part = parts[i];
+      const isLast = i === len - 1;
+      const tempNodes = [];
+      for (let j = 0, len2 = curNodes.length; j < len2; j++) {
+        const node = curNodes[j];
+        const nextNode = node.children[part];
+        if (nextNode) {
+          nextNode.params = node.params;
+          if (isLast === true) {
+            if (nextNode.children["*"]) {
+              handlerSets.push(
+                ...this.gHSets(nextNode.children["*"], method, node.params, /* @__PURE__ */ Object.create(null))
+              );
+            }
+            handlerSets.push(...this.gHSets(nextNode, method, node.params, /* @__PURE__ */ Object.create(null)));
+          } else {
+            tempNodes.push(nextNode);
+          }
+        }
+        for (let k = 0, len3 = node.patterns.length; k < len3; k++) {
+          const pattern = node.patterns[k];
+          const params = { ...node.params };
+          if (pattern === "*") {
+            const astNode = node.children["*"];
+            if (astNode) {
+              handlerSets.push(...this.gHSets(astNode, method, node.params, /* @__PURE__ */ Object.create(null)));
+              tempNodes.push(astNode);
+            }
+            continue;
+          }
+          if (part === "") {
+            continue;
+          }
+          const [key, name, matcher] = pattern;
+          const child = node.children[key];
+          const restPathString = parts.slice(i).join("/");
+          if (matcher instanceof RegExp && matcher.test(restPathString)) {
+            params[name] = restPathString;
+            handlerSets.push(...this.gHSets(child, method, node.params, params));
+            continue;
+          }
+          if (matcher === true || matcher instanceof RegExp && matcher.test(part)) {
+            if (typeof key === "string") {
+              params[name] = part;
+              if (isLast === true) {
+                handlerSets.push(...this.gHSets(child, method, params, node.params));
+                if (child.children["*"]) {
+                  handlerSets.push(...this.gHSets(child.children["*"], method, params, node.params));
+                }
+              } else {
+                child.params = params;
+                tempNodes.push(child);
+              }
+            }
+          }
+        }
+      }
+      curNodes = tempNodes;
+    }
+    const results = handlerSets.sort((a, b) => {
+      return a.score - b.score;
+    });
+    return [results.map(({ handler: handler2, params }) => [handler2, params])];
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router/trie-router/router.js
+var TrieRouter = class {
+  name = "TrieRouter";
+  node;
+  constructor() {
+    this.node = new Node2();
+  }
+  add(method, path, handler2) {
+    const results = checkOptionalParameter(path);
+    if (results) {
+      for (const p of results) {
+        this.node.insert(method, p, handler2);
+      }
+      return;
+    }
+    this.node.insert(method, path, handler2);
+  }
+  match(method, path) {
+    return this.node.search(method, path);
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/hono.js
+var Hono2 = class extends Hono {
+  constructor(options = {}) {
+    super(options);
+    this.router = options.router ?? new SmartRouter({
+      routers: [new RegExpRouter(), new TrieRouter()]
+    });
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/adapter/lambda-edge/handler.js
+var import_node_crypto = __toESM(require("crypto"), 1);
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/encode.js
+var encodeBase64 = (buf) => {
+  let binary = "";
+  const bytes = new Uint8Array(buf);
+  for (let i = 0, len = bytes.length; i < len; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+};
+var decodeBase64 = (str) => {
+  const binary = atob(str);
+  const bytes = new Uint8Array(new ArrayBuffer(binary.length));
+  const half = binary.length / 2;
+  for (let i = 0, j = binary.length - 1; i <= half; i++, j--) {
+    bytes[i] = binary.charCodeAt(i);
+    bytes[j] = binary.charCodeAt(j);
+  }
+  return bytes;
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/adapter/lambda-edge/handler.js
+globalThis.crypto ??= import_node_crypto.default;
+var convertHeaders = (headers) => {
+  const cfHeaders = {};
+  headers.forEach((value, key) => {
+    cfHeaders[key.toLowerCase()] = [{ key: key.toLowerCase(), value }];
+  });
+  return cfHeaders;
+};
+var handle = (app2) => {
+  return async (event, context, callback) => {
+    const res = await app2.fetch(createRequest2(event), {
+      event,
+      context,
+      callback: (err, result) => {
+        callback?.(err, result);
+      },
+      config: event.Records[0].cf.config,
+      request: event.Records[0].cf.request,
+      response: event.Records[0].cf.response
+    });
+    return createResult(res);
+  };
+};
+var createResult = async (res) => {
+  const isBase64Encoded = isContentTypeBinary(res.headers.get("content-type") || "");
+  const body = isBase64Encoded ? encodeBase64(await res.arrayBuffer()) : await res.text();
+  return {
+    status: res.status.toString(),
+    headers: convertHeaders(res.headers),
+    body,
+    ...isBase64Encoded ? { bodyEncoding: "base64" } : {}
+  };
+};
+var createRequest2 = (event) => {
+  const queryString = event.Records[0].cf.request.querystring;
+  const urlPath = `https://${event.Records[0].cf.config.distributionDomainName}${event.Records[0].cf.request.uri}`;
+  const url = queryString ? `${urlPath}?${queryString}` : urlPath;
+  const headers = new Headers();
+  Object.entries(event.Records[0].cf.request.headers).forEach(([k, v]) => {
+    v.forEach((header) => headers.set(k, header.value));
+  });
+  const requestBody = event.Records[0].cf.request.body;
+  const method = event.Records[0].cf.request.method;
+  const body = createBody(method, requestBody);
+  return new Request(url, {
+    headers,
+    method,
+    body
+  });
+};
+var createBody = (method, requestBody) => {
+  if (!requestBody || !requestBody.data) {
+    return void 0;
+  }
+  if (method === "GET" || method === "HEAD") {
+    return void 0;
+  }
+  if (requestBody.encoding === "base64") {
+    return decodeBase64(requestBody.data);
+  }
+  return requestBody.data;
+};
+var isContentTypeBinary = (contentType) => {
+  return !/^(text\/(plain|html|css|javascript|csv).*|application\/(.*json|.*xml).*|image\/svg\+xml.*)$/.test(
+    contentType
+  );
+};
+
+// lambda/getUpdateInfo.ts
+var import_client_s3 = require("@aws-sdk/client-s3");
+
+// ../../packages/core/dist/index.js
+var NIL_UUID = "00000000-0000-0000-0000-000000000000";
+
+// ../js/dist/index.js
+var __webpack_modules__ = {
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/comparator.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const ANY = Symbol("SemVer ANY");
+    class Comparator {
+      static get ANY() {
+        return ANY;
+      }
+      constructor(comp, options) {
+        options = parseOptions(options);
+        if (comp instanceof Comparator) {
+          if (!!options.loose === comp.loose) return comp;
+          comp = comp.value;
+        }
+        comp = comp.trim().split(/\s+/).join(" ");
+        debug("comparator", comp, options);
+        this.options = options;
+        this.loose = !!options.loose;
+        this.parse(comp);
+        if (this.semver === ANY) this.value = "";
+        else this.value = this.operator + this.semver.version;
+        debug("comp", this);
+      }
+      parse(comp) {
+        const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+        const m = comp.match(r);
+        if (!m) throw new TypeError(`Invalid comparator: ${comp}`);
+        this.operator = void 0 !== m[1] ? m[1] : "";
+        if ("=" === this.operator) this.operator = "";
+        if (m[2]) this.semver = new SemVer(m[2], this.options.loose);
+        else this.semver = ANY;
+      }
+      toString() {
+        return this.value;
+      }
+      test(version) {
+        debug("Comparator.test", version, this.options.loose);
+        if (this.semver === ANY || version === ANY) return true;
+        if ("string" == typeof version) try {
+          version = new SemVer(version, this.options);
+        } catch (er) {
+          return false;
+        }
+        return cmp(version, this.operator, this.semver, this.options);
+      }
+      intersects(comp, options) {
+        if (!(comp instanceof Comparator)) throw new TypeError("a Comparator is required");
+        if ("" === this.operator) {
+          if ("" === this.value) return true;
+          return new Range(comp.value, options).test(this.value);
+        }
+        if ("" === comp.operator) {
+          if ("" === comp.value) return true;
+          return new Range(this.value, options).test(comp.semver);
+        }
+        options = parseOptions(options);
+        if (options.includePrerelease && ("<0.0.0-0" === this.value || "<0.0.0-0" === comp.value)) return false;
+        if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) return false;
+        if (this.operator.startsWith(">") && comp.operator.startsWith(">")) return true;
+        if (this.operator.startsWith("<") && comp.operator.startsWith("<")) return true;
+        if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) return true;
+        if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) return true;
+        if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) return true;
+        return false;
+      }
+    }
+    module2.exports = Comparator;
+    const parseOptions = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/internal/parse-options.js");
+    const { safeRe: re, t } = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/internal/re.js");
+    const cmp = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/cmp.js");
+    const debug = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/internal/debug.js");
+    const SemVer = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/semver.js");
+    const Range = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/range.js");
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/range.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const SPACE_CHARACTERS = /\s+/g;
+    class Range {
+      constructor(range, options) {
+        options = parseOptions(options);
+        if (range instanceof Range) {
+          if (!!options.loose === range.loose && !!options.includePrerelease === range.includePrerelease) return range;
+          return new Range(range.raw, options);
+        }
+        if (range instanceof Comparator) {
+          this.raw = range.value;
+          this.set = [
+            [
+              range
+            ]
+          ];
+          this.formatted = void 0;
+          return this;
+        }
+        this.options = options;
+        this.loose = !!options.loose;
+        this.includePrerelease = !!options.includePrerelease;
+        this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
+        this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
+        if (!this.set.length) throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+        if (this.set.length > 1) {
+          const first = this.set[0];
+          this.set = this.set.filter((c) => !isNullSet(c[0]));
+          if (0 === this.set.length) this.set = [
+            first
+          ];
+          else if (this.set.length > 1) {
+            for (const c of this.set) if (1 === c.length && isAny(c[0])) {
+              this.set = [
+                c
+              ];
+              break;
+            }
+          }
+        }
+        this.formatted = void 0;
+      }
+      get range() {
+        if (void 0 === this.formatted) {
+          this.formatted = "";
+          for (let i = 0; i < this.set.length; i++) {
+            if (i > 0) this.formatted += "||";
+            const comps = this.set[i];
+            for (let k = 0; k < comps.length; k++) {
+              if (k > 0) this.formatted += " ";
+              this.formatted += comps[k].toString().trim();
+            }
+          }
+        }
+        return this.formatted;
+      }
+      format() {
+        return this.range;
+      }
+      toString() {
+        return this.range;
+      }
+      parseRange(range) {
+        const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
+        const memoKey = memoOpts + ":" + range;
+        const cached = cache.get(memoKey);
+        if (cached) return cached;
+        const loose = this.options.loose;
+        const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
+        range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+        debug("hyphen replace", range);
+        range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+        debug("comparator trim", range);
+        range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
+        debug("tilde trim", range);
+        range = range.replace(re[t.CARETTRIM], caretTrimReplace);
+        debug("caret trim", range);
+        let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+        if (loose) rangeList = rangeList.filter((comp) => {
+          debug("loose invalid filter", comp, this.options);
+          return !!comp.match(re[t.COMPARATORLOOSE]);
+        });
+        debug("range list", rangeList);
+        const rangeMap = /* @__PURE__ */ new Map();
+        const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
+        for (const comp of comparators) {
+          if (isNullSet(comp)) return [
+            comp
+          ];
+          rangeMap.set(comp.value, comp);
+        }
+        if (rangeMap.size > 1 && rangeMap.has("")) rangeMap.delete("");
+        const result = [
+          ...rangeMap.values()
+        ];
+        cache.set(memoKey, result);
+        return result;
+      }
+      intersects(range, options) {
+        if (!(range instanceof Range)) throw new TypeError("a Range is required");
+        return this.set.some((thisComparators) => isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => rangeComparators.every((rangeComparator) => thisComparator.intersects(rangeComparator, options)))));
+      }
+      test(version) {
+        if (!version) return false;
+        if ("string" == typeof version) try {
+          version = new SemVer(version, this.options);
+        } catch (er) {
+          return false;
+        }
+        for (let i = 0; i < this.set.length; i++) if (testSet(this.set[i], version, this.options)) return true;
+        return false;
+      }
+    }
+    module2.exports = Range;
+    const LRU = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/internal/lrucache.js");
+    const cache = new LRU();
+    const parseOptions = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/internal/parse-options.js");
+    const Comparator = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/comparator.js");
+    const debug = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/internal/debug.js");
+    const SemVer = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/semver.js");
+    const { safeRe: re, t, comparatorTrimReplace, tildeTrimReplace, caretTrimReplace } = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/internal/re.js");
+    const { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/internal/constants.js");
+    const isNullSet = (c) => "<0.0.0-0" === c.value;
+    const isAny = (c) => "" === c.value;
+    const isSatisfiable = (comparators, options) => {
+      let result = true;
+      const remainingComparators = comparators.slice();
+      let testComparator = remainingComparators.pop();
+      while (result && remainingComparators.length) {
+        result = remainingComparators.every((otherComparator) => testComparator.intersects(otherComparator, options));
+        testComparator = remainingComparators.pop();
+      }
+      return result;
+    };
+    const parseComparator = (comp, options) => {
+      debug("comp", comp, options);
+      comp = replaceCarets(comp, options);
+      debug("caret", comp);
+      comp = replaceTildes(comp, options);
+      debug("tildes", comp);
+      comp = replaceXRanges(comp, options);
+      debug("xrange", comp);
+      comp = replaceStars(comp, options);
+      debug("stars", comp);
+      return comp;
+    };
+    const isX = (id) => !id || "x" === id.toLowerCase() || "*" === id;
+    const replaceTildes = (comp, options) => comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
+    const replaceTilde = (comp, options) => {
+      const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
+      return comp.replace(r, (_, M, m, p, pr) => {
+        debug("tilde", comp, _, M, m, p, pr);
+        let ret;
+        if (isX(M)) ret = "";
+        else if (isX(m)) ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
+        else if (isX(p)) ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
+        else if (pr) {
+          debug("replaceTilde pr", pr);
+          ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+        } else ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+        debug("tilde return", ret);
+        return ret;
+      });
+    };
+    const replaceCarets = (comp, options) => comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
+    const replaceCaret = (comp, options) => {
+      debug("caret", comp, options);
+      const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
+      const z = options.includePrerelease ? "-0" : "";
+      return comp.replace(r, (_, M, m, p, pr) => {
+        debug("caret", comp, _, M, m, p, pr);
+        let ret;
+        if (isX(M)) ret = "";
+        else if (isX(m)) ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+        else if (isX(p)) ret = "0" === M ? `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0` : `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
+        else if (pr) {
+          debug("replaceCaret pr", pr);
+          ret = "0" === M ? "0" === m ? `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0` : `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0` : `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
+        } else {
+          debug("no pr");
+          ret = "0" === M ? "0" === m ? `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0` : `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0` : `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
+        }
+        debug("caret return", ret);
+        return ret;
+      });
+    };
+    const replaceXRanges = (comp, options) => {
+      debug("replaceXRanges", comp, options);
+      return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
+    };
+    const replaceXRange = (comp, options) => {
+      comp = comp.trim();
+      const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
+      return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+        debug("xRange", comp, ret, gtlt, M, m, p, pr);
+        const xM = isX(M);
+        const xm = xM || isX(m);
+        const xp = xm || isX(p);
+        const anyX = xp;
+        if ("=" === gtlt && anyX) gtlt = "";
+        pr = options.includePrerelease ? "-0" : "";
+        if (xM) ret = ">" === gtlt || "<" === gtlt ? "<0.0.0-0" : "*";
+        else if (gtlt && anyX) {
+          if (xm) m = 0;
+          p = 0;
+          if (">" === gtlt) {
+            gtlt = ">=";
+            if (xm) {
+              M = +M + 1;
+              m = 0;
+              p = 0;
+            } else {
+              m = +m + 1;
+              p = 0;
+            }
+          } else if ("<=" === gtlt) {
+            gtlt = "<";
+            if (xm) M = +M + 1;
+            else m = +m + 1;
+          }
+          if ("<" === gtlt) pr = "-0";
+          ret = `${gtlt + M}.${m}.${p}${pr}`;
+        } else if (xm) ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
+        else if (xp) ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
+        debug("xRange return", ret);
+        return ret;
+      });
+    };
+    const replaceStars = (comp, options) => {
+      debug("replaceStars", comp, options);
+      return comp.trim().replace(re[t.STAR], "");
+    };
+    const replaceGTE0 = (comp, options) => {
+      debug("replaceGTE0", comp, options);
+      return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
+    };
+    const hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
+      from = isX(fM) ? "" : isX(fm) ? `>=${fM}.0.0${incPr ? "-0" : ""}` : isX(fp) ? `>=${fM}.${fm}.0${incPr ? "-0" : ""}` : fpr ? `>=${from}` : `>=${from}${incPr ? "-0" : ""}`;
+      to = isX(tM) ? "" : isX(tm) ? `<${+tM + 1}.0.0-0` : isX(tp) ? `<${tM}.${+tm + 1}.0-0` : tpr ? `<=${tM}.${tm}.${tp}-${tpr}` : incPr ? `<${tM}.${tm}.${+tp + 1}-0` : `<=${to}`;
+      return `${from} ${to}`.trim();
+    };
+    const testSet = (set, version, options) => {
+      for (let i = 0; i < set.length; i++) if (!set[i].test(version)) return false;
+      if (version.prerelease.length && !options.includePrerelease) {
+        for (let i = 0; i < set.length; i++) {
+          debug(set[i].semver);
+          if (set[i].semver !== Comparator.ANY) {
+            if (set[i].semver.prerelease.length > 0) {
+              const allowed = set[i].semver;
+              if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) return true;
+            }
+          }
+        }
+        return false;
+      }
+      return true;
+    };
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/semver.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const debug = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/internal/debug.js");
+    const { MAX_LENGTH, MAX_SAFE_INTEGER } = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/internal/constants.js");
+    const { safeRe: re, t } = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/internal/re.js");
+    const parseOptions = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/internal/parse-options.js");
+    const { compareIdentifiers } = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/internal/identifiers.js");
+    class SemVer {
+      constructor(version, options) {
+        options = parseOptions(options);
+        if (version instanceof SemVer) {
+          if (!!options.loose === version.loose && !!options.includePrerelease === version.includePrerelease) return version;
+          version = version.version;
+        } else if ("string" != typeof version) throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
+        if (version.length > MAX_LENGTH) throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
+        debug("SemVer", version, options);
+        this.options = options;
+        this.loose = !!options.loose;
+        this.includePrerelease = !!options.includePrerelease;
+        const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+        if (!m) throw new TypeError(`Invalid Version: ${version}`);
+        this.raw = version;
+        this.major = +m[1];
+        this.minor = +m[2];
+        this.patch = +m[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 (m[4]) this.prerelease = m[4].split(".").map((id) => {
+          if (/^[0-9]+$/.test(id)) {
+            const num = +id;
+            if (num >= 0 && num < MAX_SAFE_INTEGER) return num;
+          }
+          return id;
+        });
+        else this.prerelease = [];
+        this.build = m[5] ? m[5].split(".") : [];
+        this.format();
+      }
+      format() {
+        this.version = `${this.major}.${this.minor}.${this.patch}`;
+        if (this.prerelease.length) this.version += `-${this.prerelease.join(".")}`;
+        return this.version;
+      }
+      toString() {
+        return this.version;
+      }
+      compare(other) {
+        debug("SemVer.compare", this.version, this.options, other);
+        if (!(other instanceof SemVer)) {
+          if ("string" == typeof other && 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;
+        if (!this.prerelease.length && other.prerelease.length) return 1;
+        if (!this.prerelease.length && !other.prerelease.length) return 0;
+        let i = 0;
+        do {
+          const a = this.prerelease[i];
+          const b = other.prerelease[i];
+          debug("prerelease compare", i, a, b);
+          if (void 0 === a && void 0 === b) return 0;
+          if (void 0 === b) return 1;
+          if (void 0 === a) return -1;
+          else if (a === b) continue;
+          else return compareIdentifiers(a, b);
+        } while (++i);
+      }
+      compareBuild(other) {
+        if (!(other instanceof SemVer)) other = new SemVer(other, this.options);
+        let i = 0;
+        do {
+          const a = this.build[i];
+          const b = other.build[i];
+          debug("build compare", i, a, b);
+          if (void 0 === a && void 0 === b) return 0;
+          if (void 0 === b) return 1;
+          if (void 0 === a) return -1;
+          else if (a === b) continue;
+          else return compareIdentifiers(a, b);
+        } while (++i);
+      }
+      inc(release, identifier, identifierBase) {
+        switch (release) {
+          case "premajor":
+            this.prerelease.length = 0;
+            this.patch = 0;
+            this.minor = 0;
+            this.major++;
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "preminor":
+            this.prerelease.length = 0;
+            this.patch = 0;
+            this.minor++;
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "prepatch":
+            this.prerelease.length = 0;
+            this.inc("patch", identifier, identifierBase);
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "prerelease":
+            if (0 === this.prerelease.length) this.inc("patch", identifier, identifierBase);
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "major":
+            if (0 !== this.minor || 0 !== this.patch || 0 === this.prerelease.length) this.major++;
+            this.minor = 0;
+            this.patch = 0;
+            this.prerelease = [];
+            break;
+          case "minor":
+            if (0 !== this.patch || 0 === this.prerelease.length) this.minor++;
+            this.patch = 0;
+            this.prerelease = [];
+            break;
+          case "patch":
+            if (0 === this.prerelease.length) this.patch++;
+            this.prerelease = [];
+            break;
+          case "pre": {
+            const base = Number(identifierBase) ? 1 : 0;
+            if (!identifier && false === identifierBase) throw new Error("invalid increment argument: identifier is empty");
+            if (0 === this.prerelease.length) this.prerelease = [
+              base
+            ];
+            else {
+              let i = this.prerelease.length;
+              while (--i >= 0) if ("number" == typeof this.prerelease[i]) {
+                this.prerelease[i]++;
+                i = -2;
+              }
+              if (-1 === i) {
+                if (identifier === this.prerelease.join(".") && false === identifierBase) throw new Error("invalid increment argument: identifier already exists");
+                this.prerelease.push(base);
+              }
+            }
+            if (identifier) {
+              let prerelease = [
+                identifier,
+                base
+              ];
+              if (false === identifierBase) prerelease = [
+                identifier
+              ];
+              if (0 === compareIdentifiers(this.prerelease[0], identifier)) {
+                if (isNaN(this.prerelease[1])) this.prerelease = prerelease;
+              } else this.prerelease = prerelease;
+            }
+            break;
+          }
+          default:
+            throw new Error(`invalid increment argument: ${release}`);
+        }
+        this.raw = this.format();
+        if (this.build.length) this.raw += `+${this.build.join(".")}`;
+        return this;
+      }
+    }
+    module2.exports = SemVer;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/clean.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const parse = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/parse.js");
+    const clean = (version, options) => {
+      const s = parse(version.trim().replace(/^[=v]+/, ""), options);
+      return s ? s.version : null;
+    };
+    module2.exports = clean;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/cmp.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const eq = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/eq.js");
+    const neq = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/neq.js");
+    const gt = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/gt.js");
+    const gte = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/gte.js");
+    const lt = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/lt.js");
+    const lte = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/lte.js");
+    const cmp = (a, op, b, loose) => {
+      switch (op) {
+        case "===":
+          if ("object" == typeof a) a = a.version;
+          if ("object" == typeof b) b = b.version;
+          return a === b;
+        case "!==":
+          if ("object" == typeof a) a = a.version;
+          if ("object" == typeof b) b = b.version;
+          return a !== b;
+        case "":
+        case "=":
+        case "==":
+          return eq(a, b, loose);
+        case "!=":
+          return neq(a, b, loose);
+        case ">":
+          return gt(a, b, loose);
+        case ">=":
+          return gte(a, b, loose);
+        case "<":
+          return lt(a, b, loose);
+        case "<=":
+          return lte(a, b, loose);
+        default:
+          throw new TypeError(`Invalid operator: ${op}`);
+      }
+    };
+    module2.exports = cmp;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/coerce.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const SemVer = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/semver.js");
+    const parse = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/parse.js");
+    const { safeRe: re, t } = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/internal/re.js");
+    const coerce = (version, options) => {
+      if (version instanceof SemVer) return version;
+      if ("number" == typeof version) version = String(version);
+      if ("string" != typeof version) return null;
+      options = options || {};
+      let match = null;
+      if (options.rtl) {
+        const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
+        let next;
+        while ((next = coerceRtlRegex.exec(version)) && (!match || match.index + match[0].length !== version.length)) {
+          if (!match || next.index + next[0].length !== match.index + match[0].length) match = next;
+          coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
+        }
+        coerceRtlRegex.lastIndex = -1;
+      } else match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
+      if (null === match) return null;
+      const major = match[2];
+      const minor = match[3] || "0";
+      const patch = match[4] || "0";
+      const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
+      const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
+      return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options);
+    };
+    module2.exports = coerce;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/compare-build.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const SemVer = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/semver.js");
+    const compareBuild = (a, b, loose) => {
+      const versionA = new SemVer(a, loose);
+      const versionB = new SemVer(b, loose);
+      return versionA.compare(versionB) || versionA.compareBuild(versionB);
+    };
+    module2.exports = compareBuild;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/compare-loose.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const compare = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/compare.js");
+    const compareLoose = (a, b) => compare(a, b, true);
+    module2.exports = compareLoose;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/compare.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const SemVer = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/semver.js");
+    const compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+    module2.exports = compare;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/diff.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const parse = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/parse.js");
+    const diff = (version1, version2) => {
+      const v1 = parse(version1, null, true);
+      const v2 = parse(version2, null, true);
+      const comparison = v1.compare(v2);
+      if (0 === comparison) 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";
+    };
+    module2.exports = diff;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/eq.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const compare = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/compare.js");
+    const eq = (a, b, loose) => 0 === compare(a, b, loose);
+    module2.exports = eq;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/gt.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const compare = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/compare.js");
+    const gt = (a, b, loose) => compare(a, b, loose) > 0;
+    module2.exports = gt;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/gte.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const compare = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/compare.js");
+    const gte = (a, b, loose) => compare(a, b, loose) >= 0;
+    module2.exports = gte;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/inc.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const SemVer = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/semver.js");
+    const inc = (version, release, options, identifier, identifierBase) => {
+      if ("string" == typeof options) {
+        identifierBase = identifier;
+        identifier = options;
+        options = void 0;
+      }
+      try {
+        return new SemVer(version instanceof SemVer ? version.version : version, options).inc(release, identifier, identifierBase).version;
+      } catch (er) {
+        return null;
+      }
+    };
+    module2.exports = inc;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/lt.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const compare = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/compare.js");
+    const lt = (a, b, loose) => compare(a, b, loose) < 0;
+    module2.exports = lt;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/lte.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const compare = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/compare.js");
+    const lte = (a, b, loose) => compare(a, b, loose) <= 0;
+    module2.exports = lte;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/major.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const SemVer = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/semver.js");
+    const major = (a, loose) => new SemVer(a, loose).major;
+    module2.exports = major;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/minor.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const SemVer = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/semver.js");
+    const minor = (a, loose) => new SemVer(a, loose).minor;
+    module2.exports = minor;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/neq.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const compare = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/compare.js");
+    const neq = (a, b, loose) => 0 !== compare(a, b, loose);
+    module2.exports = neq;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/parse.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const SemVer = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/semver.js");
+    const parse = (version, options, throwErrors = false) => {
+      if (version instanceof SemVer) return version;
+      try {
+        return new SemVer(version, options);
+      } catch (er) {
+        if (!throwErrors) return null;
+        throw er;
+      }
+    };
+    module2.exports = parse;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/patch.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const SemVer = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/semver.js");
+    const patch = (a, loose) => new SemVer(a, loose).patch;
+    module2.exports = patch;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/prerelease.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const parse = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/parse.js");
+    const prerelease = (version, options) => {
+      const parsed = parse(version, options);
+      return parsed && parsed.prerelease.length ? parsed.prerelease : null;
+    };
+    module2.exports = prerelease;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/rcompare.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const compare = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/compare.js");
+    const rcompare = (a, b, loose) => compare(b, a, loose);
+    module2.exports = rcompare;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/rsort.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const compareBuild = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/compare-build.js");
+    const rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose));
+    module2.exports = rsort;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/satisfies.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const Range = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/range.js");
+    const satisfies = (version, range, options) => {
+      try {
+        range = new Range(range, options);
+      } catch (er) {
+        return false;
+      }
+      return range.test(version);
+    };
+    module2.exports = satisfies;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/sort.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const compareBuild = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/compare-build.js");
+    const sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose));
+    module2.exports = sort;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/valid.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const parse = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/parse.js");
+    const valid = (version, options) => {
+      const v = parse(version, options);
+      return v ? v.version : null;
+    };
+    module2.exports = valid;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/index.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const internalRe = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/internal/re.js");
+    const constants = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/internal/constants.js");
+    const SemVer = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/semver.js");
+    const identifiers = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/internal/identifiers.js");
+    const parse = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/parse.js");
+    const valid = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/valid.js");
+    const clean = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/clean.js");
+    const inc = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/inc.js");
+    const diff = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/diff.js");
+    const major = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/major.js");
+    const minor = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/minor.js");
+    const patch = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/patch.js");
+    const prerelease = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/prerelease.js");
+    const compare = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/compare.js");
+    const rcompare = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/rcompare.js");
+    const compareLoose = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/compare-loose.js");
+    const compareBuild = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/compare-build.js");
+    const sort = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/sort.js");
+    const rsort = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/rsort.js");
+    const gt = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/gt.js");
+    const lt = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/lt.js");
+    const eq = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/eq.js");
+    const neq = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/neq.js");
+    const gte = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/gte.js");
+    const lte = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/lte.js");
+    const cmp = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/cmp.js");
+    const coerce = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/coerce.js");
+    const Comparator = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/comparator.js");
+    const Range = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/range.js");
+    const satisfies = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/satisfies.js");
+    const toComparators = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/ranges/to-comparators.js");
+    const maxSatisfying = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/ranges/max-satisfying.js");
+    const minSatisfying = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/ranges/min-satisfying.js");
+    const minVersion = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/ranges/min-version.js");
+    const validRange = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/ranges/valid.js");
+    const outside = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/ranges/outside.js");
+    const gtr = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/ranges/gtr.js");
+    const ltr = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/ranges/ltr.js");
+    const intersects = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/ranges/intersects.js");
+    const simplifyRange = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/ranges/simplify.js");
+    const subset = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/ranges/subset.js");
+    module2.exports = {
+      parse,
+      valid,
+      clean,
+      inc,
+      diff,
+      major,
+      minor,
+      patch,
+      prerelease,
+      compare,
+      rcompare,
+      compareLoose,
+      compareBuild,
+      sort,
+      rsort,
+      gt,
+      lt,
+      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: constants.SEMVER_SPEC_VERSION,
+      RELEASE_TYPES: constants.RELEASE_TYPES,
+      compareIdentifiers: identifiers.compareIdentifiers,
+      rcompareIdentifiers: identifiers.rcompareIdentifiers
+    };
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/internal/constants.js": function(module2) {
+    const SEMVER_SPEC_VERSION = "2.0.0";
+    const MAX_LENGTH = 256;
+    const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
+    const MAX_SAFE_COMPONENT_LENGTH = 16;
+    const MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
+    const RELEASE_TYPES = [
+      "major",
+      "premajor",
+      "minor",
+      "preminor",
+      "patch",
+      "prepatch",
+      "prerelease"
+    ];
+    module2.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.6.3/node_modules/semver/internal/debug.js": function(module2) {
+    const debug = "object" == typeof process && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
+    };
+    module2.exports = debug;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/internal/identifiers.js": function(module2) {
+    const numeric = /^[0-9]+$/;
+    const compareIdentifiers = (a, b) => {
+      const anum = numeric.test(a);
+      const bnum = numeric.test(b);
+      if (anum && bnum) {
+        a = +a;
+        b = +b;
+      }
+      return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+    };
+    const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
+    module2.exports = {
+      compareIdentifiers,
+      rcompareIdentifiers
+    };
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/internal/lrucache.js": function(module2) {
+    class LRUCache {
+      constructor() {
+        this.max = 1e3;
+        this.map = /* @__PURE__ */ new Map();
+      }
+      get(key) {
+        const value = this.map.get(key);
+        if (void 0 === value) return;
+        this.map.delete(key);
+        this.map.set(key, value);
+        return value;
+      }
+      delete(key) {
+        return this.map.delete(key);
+      }
+      set(key, value) {
+        const deleted = this.delete(key);
+        if (!deleted && void 0 !== value) {
+          if (this.map.size >= this.max) {
+            const firstKey = this.map.keys().next().value;
+            this.delete(firstKey);
+          }
+          this.map.set(key, value);
+        }
+        return this;
+      }
+    }
+    module2.exports = LRUCache;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/internal/parse-options.js": function(module2) {
+    const looseOption = Object.freeze({
+      loose: true
+    });
+    const emptyOpts = Object.freeze({});
+    const parseOptions = (options) => {
+      if (!options) return emptyOpts;
+      if ("object" != typeof options) return looseOption;
+      return options;
+    };
+    module2.exports = parseOptions;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/internal/re.js": function(module2, exports2, __webpack_require__2) {
+    const { MAX_SAFE_COMPONENT_LENGTH, MAX_SAFE_BUILD_LENGTH, MAX_LENGTH } = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/internal/constants.js");
+    const debug = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/internal/debug.js");
+    exports2 = module2.exports = {};
+    const re = exports2.re = [];
+    const safeRe = exports2.safeRe = [];
+    const src = exports2.src = [];
+    const t = exports2.t = {};
+    let R = 0;
+    const LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+    const safeRegexReplacements = [
+      [
+        "\\s",
+        1
+      ],
+      [
+        "\\d",
+        MAX_LENGTH
+      ],
+      [
+        LETTERDASHNUMBER,
+        MAX_SAFE_BUILD_LENGTH
+      ]
+    ];
+    const makeSafeRegex = (value) => {
+      for (const [token, max] of safeRegexReplacements) value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
+      return value;
+    };
+    const createToken = (name, value, isGlobal) => {
+      const safe = makeSafeRegex(value);
+      const index = R++;
+      debug(name, index, value);
+      t[name] = index;
+      src[index] = value;
+      re[index] = new RegExp(value, isGlobal ? "g" : void 0);
+      safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
+    };
+    createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+    createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
+    createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+    createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
+    createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+    createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NUMERICIDENTIFIER]}|${src[t.NONNUMERICIDENTIFIER]})`);
+    createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NUMERICIDENTIFIERLOOSE]}|${src[t.NONNUMERICIDENTIFIER]})`);
+    createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+    createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+    createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+    createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+    createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
+    createToken("FULL", `^${src[t.FULLPLAIN]}$`);
+    createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
+    createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
+    createToken("GTLT", "((?:<|>)?=?)");
+    createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+    createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+    createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
+    createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
+    createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+    createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("COERCEPLAIN", `(^|[^\\d])(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+    createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+    createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
+    createToken("COERCERTL", src[t.COERCE], true);
+    createToken("COERCERTLFULL", src[t.COERCEFULL], true);
+    createToken("LONETILDE", "(?:~>?)");
+    createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+    exports2.tildeTrimReplace = "$1~";
+    createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+    createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("LONECARET", "(?:\\^)");
+    createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
+    exports2.caretTrimReplace = "$1^";
+    createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+    createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+    createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+    createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+    exports2.comparatorTrimReplace = "$1$2$3";
+    createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
+    createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
+    createToken("STAR", "(<|>)?=?\\s*\\*");
+    createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+    createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/ranges/gtr.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const outside = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/ranges/outside.js");
+    const gtr = (version, range, options) => outside(version, range, ">", options);
+    module2.exports = gtr;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/ranges/intersects.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const Range = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/range.js");
+    const intersects = (r1, r2, options) => {
+      r1 = new Range(r1, options);
+      r2 = new Range(r2, options);
+      return r1.intersects(r2, options);
+    };
+    module2.exports = intersects;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/ranges/ltr.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const outside = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/ranges/outside.js");
+    const ltr = (version, range, options) => outside(version, range, "<", options);
+    module2.exports = ltr;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/ranges/max-satisfying.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const SemVer = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/semver.js");
+    const Range = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/range.js");
+    const maxSatisfying = (versions, range, options) => {
+      let max = null;
+      let maxSV = null;
+      let rangeObj = null;
+      try {
+        rangeObj = new Range(range, options);
+      } catch (er) {
+        return null;
+      }
+      versions.forEach((v) => {
+        if (rangeObj.test(v)) {
+          if (!max || -1 === maxSV.compare(v)) {
+            max = v;
+            maxSV = new SemVer(max, options);
+          }
+        }
+      });
+      return max;
+    };
+    module2.exports = maxSatisfying;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/ranges/min-satisfying.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const SemVer = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/semver.js");
+    const Range = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/range.js");
+    const minSatisfying = (versions, range, options) => {
+      let min = null;
+      let minSV = null;
+      let rangeObj = null;
+      try {
+        rangeObj = new Range(range, options);
+      } catch (er) {
+        return null;
+      }
+      versions.forEach((v) => {
+        if (rangeObj.test(v)) {
+          if (!min || 1 === minSV.compare(v)) {
+            min = v;
+            minSV = new SemVer(min, options);
+          }
+        }
+      });
+      return min;
+    };
+    module2.exports = minSatisfying;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/ranges/min-version.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const SemVer = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/semver.js");
+    const Range = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/range.js");
+    const gt = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/gt.js");
+    const minVersion = (range, loose) => {
+      range = new Range(range, loose);
+      let minver = new SemVer("0.0.0");
+      if (range.test(minver)) return minver;
+      minver = new SemVer("0.0.0-0");
+      if (range.test(minver)) return minver;
+      minver = null;
+      for (let i = 0; i < range.set.length; ++i) {
+        const comparators = range.set[i];
+        let setMin = null;
+        comparators.forEach((comparator) => {
+          const compver = new SemVer(comparator.semver.version);
+          switch (comparator.operator) {
+            case ">":
+              if (0 === compver.prerelease.length) 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;
+    };
+    module2.exports = minVersion;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/ranges/outside.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const SemVer = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/semver.js");
+    const Comparator = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/comparator.js");
+    const { ANY } = Comparator;
+    const Range = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/range.js");
+    const satisfies = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/satisfies.js");
+    const gt = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/gt.js");
+    const lt = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/lt.js");
+    const lte = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/lte.js");
+    const gte = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/gte.js");
+    const outside = (version, range, hilo, options) => {
+      version = new SemVer(version, options);
+      range = new Range(range, options);
+      let gtfn, ltefn, ltfn, comp, ecomp;
+      switch (hilo) {
+        case ">":
+          gtfn = gt;
+          ltefn = lte;
+          ltfn = lt;
+          comp = ">";
+          ecomp = ">=";
+          break;
+        case "<":
+          gtfn = lt;
+          ltefn = gte;
+          ltfn = gt;
+          comp = "<";
+          ecomp = "<=";
+          break;
+        default:
+          throw new TypeError('Must provide a hilo val of "<" or ">"');
+      }
+      if (satisfies(version, range, options)) return false;
+      for (let i = 0; i < range.set.length; ++i) {
+        const comparators = range.set[i];
+        let high = null;
+        let low = null;
+        comparators.forEach((comparator) => {
+          if (comparator.semver === ANY) comparator = new Comparator(">=0.0.0");
+          high = high || comparator;
+          low = low || comparator;
+          if (gtfn(comparator.semver, high.semver, options)) high = comparator;
+          else if (ltfn(comparator.semver, low.semver, options)) low = comparator;
+        });
+        if (high.operator === comp || high.operator === ecomp) return false;
+        if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) return false;
+        if (low.operator === ecomp && ltfn(version, low.semver)) return false;
+      }
+      return true;
+    };
+    module2.exports = outside;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/ranges/simplify.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const satisfies = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/satisfies.js");
+    const compare = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/compare.js");
+    module2.exports = (versions, range, options) => {
+      const set = [];
+      let first = null;
+      let prev = null;
+      const v = versions.sort((a, b) => compare(a, b, options));
+      for (const version of v) {
+        const included = satisfies(version, range, options);
+        if (included) {
+          prev = version;
+          if (!first) first = version;
+        } 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 !== v[0]) {
+        if (max) {
+          if (min === v[0]) ranges.push(`<=${max}`);
+          else ranges.push(`${min} - ${max}`);
+        } else ranges.push(`>=${min}`);
+      } else ranges.push("*");
+      const simplified = ranges.join(" || ");
+      const original = "string" == typeof range.raw ? range.raw : String(range);
+      return simplified.length < original.length ? simplified : range;
+    };
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/ranges/subset.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const Range = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/range.js");
+    const Comparator = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/comparator.js");
+    const { ANY } = Comparator;
+    const satisfies = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/satisfies.js");
+    const compare = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/functions/compare.js");
+    const subset = (sub, dom, options = {}) => {
+      if (sub === dom) return true;
+      sub = new Range(sub, options);
+      dom = new Range(dom, options);
+      let sawNonNull = false;
+      OUTER: for (const simpleSub of sub.set) {
+        for (const simpleDom of dom.set) {
+          const isSub = simpleSubset(simpleSub, simpleDom, options);
+          sawNonNull = sawNonNull || null !== isSub;
+          if (isSub) continue OUTER;
+        }
+        if (sawNonNull) return false;
+      }
+      return true;
+    };
+    const minimumVersionWithPreRelease = [
+      new Comparator(">=0.0.0-0")
+    ];
+    const minimumVersion = [
+      new Comparator(">=0.0.0")
+    ];
+    const simpleSubset = (sub, dom, options) => {
+      if (sub === dom) return true;
+      if (1 === sub.length && sub[0].semver === ANY) {
+        if (1 === dom.length && dom[0].semver === ANY) return true;
+        sub = options.includePrerelease ? minimumVersionWithPreRelease : minimumVersion;
+      }
+      if (1 === dom.length && dom[0].semver === ANY) {
+        if (options.includePrerelease) return true;
+        dom = minimumVersion;
+      }
+      const eqSet = /* @__PURE__ */ new Set();
+      let gt, lt;
+      for (const c of sub) if (">" === c.operator || ">=" === c.operator) gt = higherGT(gt, c, options);
+      else if ("<" === c.operator || "<=" === c.operator) lt = lowerLT(lt, c, options);
+      else eqSet.add(c.semver);
+      if (eqSet.size > 1) return null;
+      let gtltComp;
+      if (gt && lt) {
+        gtltComp = compare(gt.semver, lt.semver, options);
+        if (gtltComp > 0) return null;
+        if (0 === gtltComp && (">=" !== gt.operator || "<=" !== lt.operator)) return null;
+      }
+      for (const eq of eqSet) {
+        if (gt && !satisfies(eq, String(gt), options)) return null;
+        if (lt && !satisfies(eq, String(lt), options)) return null;
+        for (const c of dom) if (!satisfies(eq, String(c), options)) return false;
+        return true;
+      }
+      let higher, lower;
+      let hasDomLT, hasDomGT;
+      let needDomLTPre = !!lt && !options.includePrerelease && !!lt.semver.prerelease.length && lt.semver;
+      let needDomGTPre = !!gt && !options.includePrerelease && !!gt.semver.prerelease.length && gt.semver;
+      if (needDomLTPre && 1 === needDomLTPre.prerelease.length && "<" === lt.operator && 0 === needDomLTPre.prerelease[0]) needDomLTPre = false;
+      for (const c of dom) {
+        hasDomGT = hasDomGT || ">" === c.operator || ">=" === c.operator;
+        hasDomLT = hasDomLT || "<" === c.operator || "<=" === c.operator;
+        if (gt) {
+          if (needDomGTPre) {
+            if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) needDomGTPre = false;
+          }
+          if (">" === c.operator || ">=" === c.operator) {
+            higher = higherGT(gt, c, options);
+            if (higher === c && higher !== gt) return false;
+          } else if (">=" === gt.operator && !satisfies(gt.semver, String(c), options)) return false;
+        }
+        if (lt) {
+          if (needDomLTPre) {
+            if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) needDomLTPre = false;
+          }
+          if ("<" === c.operator || "<=" === c.operator) {
+            lower = lowerLT(lt, c, options);
+            if (lower === c && lower !== lt) return false;
+          } else if ("<=" === lt.operator && !satisfies(lt.semver, String(c), options)) return false;
+        }
+        if (!c.operator && (lt || gt) && 0 !== gtltComp) return false;
+      }
+      if (gt && hasDomLT && !lt && 0 !== gtltComp) return false;
+      if (lt && hasDomGT && !gt && 0 !== gtltComp) return false;
+      if (needDomGTPre || needDomLTPre) return false;
+      return true;
+    };
+    const higherGT = (a, b, options) => {
+      if (!a) return b;
+      const comp = compare(a.semver, b.semver, options);
+      return comp > 0 ? a : comp < 0 ? b : ">" === b.operator && ">=" === a.operator ? b : a;
+    };
+    const lowerLT = (a, b, options) => {
+      if (!a) return b;
+      const comp = compare(a.semver, b.semver, options);
+      return comp < 0 ? a : comp > 0 ? b : "<" === b.operator && "<=" === a.operator ? b : a;
+    };
+    module2.exports = subset;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/ranges/to-comparators.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const Range = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/range.js");
+    const toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
+    module2.exports = toComparators;
+  },
+  "../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/ranges/valid.js": function(module2, __unused_webpack_exports, __webpack_require__2) {
+    const Range = __webpack_require__2("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/classes/range.js");
+    const validRange = (range, options) => {
+      try {
+        return new Range(range, options).range || "*";
+      } catch (er) {
+        return null;
+      }
+    };
+    module2.exports = validRange;
+  }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+  var cachedModule = __webpack_module_cache__[moduleId];
+  if (void 0 !== cachedModule) return cachedModule.exports;
+  var module2 = __webpack_module_cache__[moduleId] = {
+    exports: {}
+  };
+  __webpack_modules__[moduleId](module2, module2.exports, __webpack_require__);
+  return module2.exports;
+}
+(() => {
+  __webpack_require__.n = function(module2) {
+    var getter = module2 && module2.__esModule ? function() {
+      return module2["default"];
+    } : function() {
+      return module2;
+    };
+    __webpack_require__.d(getter, {
+      a: getter
+    });
+    return getter;
+  };
+})();
+(() => {
+  __webpack_require__.d = function(exports2, definition) {
+    for (var key in definition) if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports2, key)) Object.defineProperty(exports2, key, {
+      enumerable: true,
+      get: definition[key]
+    });
+  };
+})();
+(() => {
+  __webpack_require__.o = function(obj, prop) {
+    return Object.prototype.hasOwnProperty.call(obj, prop);
+  };
+})();
+var isNullable = (value) => null == value;
+var checkForRollback = (bundles, currentBundleId) => {
+  if (currentBundleId === NIL_UUID) return false;
+  if (0 === bundles.length) return true;
+  const enabled = bundles.find((item) => item.id === currentBundleId)?.enabled;
+  const availableOldVersion = bundles.find((item) => item.id.localeCompare(currentBundleId) < 0 && item.enabled)?.enabled;
+  if (isNullable(enabled)) return Boolean(availableOldVersion);
+  return !enabled;
+};
+var semver = __webpack_require__("../../node_modules/.pnpm/semver@7.6.3/node_modules/semver/index.js");
+var semver_default = /* @__PURE__ */ __webpack_require__.n(semver);
+var semverSatisfies = (targetAppVersion, currentVersion) => {
+  const currentCoerce = semver_default().coerce(currentVersion);
+  if (!currentCoerce) return false;
+  return semver_default().satisfies(currentCoerce.version, targetAppVersion);
+};
+var findLatestBundles = (bundles) => bundles?.filter((item) => item.enabled)?.sort((a, b) => b.id.localeCompare(a.id))?.[0] ?? null;
+var getUpdateInfo = async (bundles, { platform, bundleId, appVersion }) => {
+  const filteredBundles = bundles.filter((b) => b.platform === platform && semverSatisfies(b.targetAppVersion, appVersion));
+  const isRollback = checkForRollback(filteredBundles, bundleId);
+  const latestBundle = await findLatestBundles(filteredBundles);
+  if (!latestBundle) {
+    if (isRollback) return {
+      id: NIL_UUID,
+      shouldForceUpdate: true,
+      fileUrl: null,
+      fileHash: null,
+      status: "ROLLBACK"
+    };
+    return null;
+  }
+  if (latestBundle.fileUrl) {
+    if (isRollback) {
+      if (latestBundle.id === bundleId) return null;
+      if (latestBundle.id.localeCompare(bundleId) > 0) return {
+        id: latestBundle.id,
+        shouldForceUpdate: Boolean(latestBundle.shouldForceUpdate),
+        fileUrl: latestBundle.fileUrl,
+        fileHash: latestBundle.fileHash,
+        status: "UPDATE"
+      };
+      return {
+        id: latestBundle.id,
+        shouldForceUpdate: true,
+        fileUrl: latestBundle.fileUrl,
+        fileHash: latestBundle.fileHash,
+        status: "ROLLBACK"
+      };
+    }
+  }
+  if (latestBundle.id.localeCompare(bundleId) > 0) return {
+    id: latestBundle.id,
+    shouldForceUpdate: Boolean(latestBundle.shouldForceUpdate),
+    fileUrl: latestBundle.fileUrl,
+    fileHash: latestBundle.fileHash,
+    status: "UPDATE"
+  };
+  return null;
+};
+var filterCompatibleAppVersions = (targetAppVersionList, currentVersion) => {
+  const compatibleAppVersionList = targetAppVersionList.filter((version) => semverSatisfies(version, currentVersion));
+  return compatibleAppVersionList.sort((a, b) => b.localeCompare(a));
+};
+
+// lambda/getUpdateInfo.ts
+var getS3Json = async (s32, bucket, key) => {
+  try {
+    const command = new import_client_s3.GetObjectCommand({ Bucket: bucket, Key: key });
+    const { Body } = await s32.send(command);
+    if (!Body) {
+      return null;
+    }
+    const jsonString = await Body.transformToString();
+    return JSON.parse(jsonString);
+  } catch {
+    return null;
+  }
+};
+var getUpdateInfo2 = async (s32, bucketName, {
+  platform,
+  appVersion,
+  bundleId
+}) => {
+  const targetAppVersions = await getS3Json(
+    s32,
+    bucketName,
+    `${platform}/target-app-versions.json`
+  );
+  const matchingVersions = filterCompatibleAppVersions(
+    targetAppVersions ?? [],
+    appVersion
+  );
+  const results = await Promise.allSettled(
+    matchingVersions.map(
+      (targetAppVersion) => getS3Json(s32, bucketName, `${platform}/${targetAppVersion}/update.json`)
+    )
+  );
+  const bundles = results.filter(
+    (r) => r.status === "fulfilled"
+  ).flatMap((r) => r.value ?? []);
+  return getUpdateInfo(bundles, {
+    platform,
+    bundleId,
+    appVersion
+  });
+};
+
+// lambda/index.ts
+var s3 = new import_client_s32.S3Client();
+function parseS3Url(url) {
+  try {
+    const parsedUrl = new URL(url);
+    const { hostname, pathname } = parsedUrl;
+    if (!hostname.includes(".s3.")) return { isS3Url: false };
+    const [bucket] = hostname.split(".s3");
+    const key = pathname.startsWith("/") ? pathname.slice(1) : pathname;
+    return { isS3Url: true, bucket, key };
+  } catch {
+    return { isS3Url: false };
+  }
+}
+async function createPresignedUrl(url) {
+  const { isS3Url, bucket, key } = parseS3Url(url);
+  if (!isS3Url || !bucket || !key) {
+    return url;
+  }
+  return getSignedUrl(s3, new import_client_s32.GetObjectCommand({ Bucket: bucket, Key: key }), {
+    expiresIn: 60
+  });
+}
+async function signUpdateInfoFileUrl(updateInfo) {
+  if (updateInfo?.fileUrl) {
+    updateInfo.fileUrl = await createPresignedUrl(updateInfo.fileUrl);
+  }
+  return updateInfo;
+}
+var app = new Hono2();
+app.get("/api/check-update", async (c) => {
+  try {
+    const { headers, origin } = c.env.request;
+    let bucketName;
+    if (origin?.s3?.domainName) {
+      const domainName = origin.s3.domainName;
+      [bucketName] = domainName.split(".s3");
+    }
+    if (!bucketName) {
+      return c.json({ error: "Bucket name not found." }, 500);
+    }
+    const bundleId = headers["x-bundle-id"]?.[0]?.value;
+    const appPlatform = headers["x-app-platform"]?.[0]?.value;
+    const appVersion = headers["x-app-version"]?.[0]?.value;
+    if (!bundleId || !appPlatform || !appVersion) {
+      return c.json({ error: "Missing required headers." }, 400);
+    }
+    const updateInfo = await getUpdateInfo2(s3, bucketName, {
+      platform: appPlatform,
+      bundleId,
+      appVersion
+    });
+    if (!updateInfo) {
+      return c.json(null);
+    }
+    const finalInfo = await signUpdateInfoFileUrl(updateInfo);
+    return c.json(finalInfo);
+  } catch {
+    return c.json({ error: "Internal Server Error" }, 500);
+  }
+});
+app.get("*", async (c) => {
+  c.env.callback(null, c.env.request);
+});
+var handler = handle(app);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handler
+});