@apps-in-toss/web-framework 0.0.6 → 0.0.8

package/dist/cli.cjs

@@ -0,0 +1,4598 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, 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);
+
+// ../../.yarn/__virtual__/tsup-virtual-7254073ea3/0/cache/tsup-npm-8.3.5-ed25596739-7794953cbc.zip/node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "../../.yarn/__virtual__/tsup-virtual-7254073ea3/0/cache/tsup-npm-8.3.5-ed25596739-7794953cbc.zip/node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+// ../../.yarn/cache/typanion-npm-3.14.0-0a46072207-8b03b19844.zip/node_modules/typanion/lib/index.js
+var require_lib = __commonJS({
+  "../../.yarn/cache/typanion-npm-3.14.0-0a46072207-8b03b19844.zip/node_modules/typanion/lib/index.js"(exports2) {
+    "use strict";
+    init_cjs_shims();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var simpleKeyRegExp = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+    function getPrintable(value) {
+      if (value === null)
+        return `null`;
+      if (value === void 0)
+        return `undefined`;
+      if (value === ``)
+        return `an empty string`;
+      if (typeof value === "symbol")
+        return `<${value.toString()}>`;
+      if (Array.isArray(value))
+        return `an array`;
+      return JSON.stringify(value);
+    }
+    function getPrintableArray(value, conjunction) {
+      if (value.length === 0)
+        return `nothing`;
+      if (value.length === 1)
+        return getPrintable(value[0]);
+      const rest = value.slice(0, -1);
+      const trailing = value[value.length - 1];
+      const separator = value.length > 2 ? `, ${conjunction} ` : ` ${conjunction} `;
+      return `${rest.map((value2) => getPrintable(value2)).join(`, `)}${separator}${getPrintable(trailing)}`;
+    }
+    function computeKey(state, key) {
+      var _a, _b, _c;
+      if (typeof key === `number`) {
+        return `${(_a = state === null || state === void 0 ? void 0 : state.p) !== null && _a !== void 0 ? _a : `.`}[${key}]`;
+      } else if (simpleKeyRegExp.test(key)) {
+        return `${(_b = state === null || state === void 0 ? void 0 : state.p) !== null && _b !== void 0 ? _b : ``}.${key}`;
+      } else {
+        return `${(_c = state === null || state === void 0 ? void 0 : state.p) !== null && _c !== void 0 ? _c : `.`}[${JSON.stringify(key)}]`;
+      }
+    }
+    function plural(n, singular, plural2) {
+      return n === 1 ? singular : plural2;
+    }
+    var colorStringRegExp = /^#[0-9a-f]{6}$/i;
+    var colorStringAlphaRegExp = /^#[0-9a-f]{6}([0-9a-f]{2})?$/i;
+    var base64RegExp = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+    var uuid4RegExp = /^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89aAbB][a-f0-9]{3}-[a-f0-9]{12}$/i;
+    var iso8601RegExp = /^(?:[1-9]\d{3}(-?)(?:(?:0[1-9]|1[0-2])\1(?:0[1-9]|1\d|2[0-8])|(?:0[13-9]|1[0-2])\1(?:29|30)|(?:0[13578]|1[02])(?:\1)31|00[1-9]|0[1-9]\d|[12]\d{2}|3(?:[0-5]\d|6[0-5]))|(?:[1-9]\d(?:0[48]|[2468][048]|[13579][26])|(?:[2468][048]|[13579][26])00)(?:(-?)02(?:\2)29|-?366))T(?:[01]\d|2[0-3])(:?)[0-5]\d(?:\3[0-5]\d)?(?:Z|[+-][01]\d(?:\3[0-5]\d)?)$/;
+    function pushError({ errors, p } = {}, message) {
+      errors === null || errors === void 0 ? void 0 : errors.push(`${p !== null && p !== void 0 ? p : `.`}: ${message}`);
+      return false;
+    }
+    function makeSetter(target, key) {
+      return (v) => {
+        target[key] = v;
+      };
+    }
+    function makeCoercionFn(target, key) {
+      return (v) => {
+        const previous = target[key];
+        target[key] = v;
+        return makeCoercionFn(target, key).bind(null, previous);
+      };
+    }
+    function makeLazyCoercionFn(fn2, orig, generator) {
+      const commit = () => {
+        fn2(generator());
+        return revert;
+      };
+      const revert = () => {
+        fn2(orig);
+        return commit;
+      };
+      return commit;
+    }
+    function isUnknown() {
+      return makeValidator({
+        test: (value, state) => {
+          return true;
+        }
+      });
+    }
+    function isLiteral(expected) {
+      return makeValidator({
+        test: (value, state) => {
+          if (value !== expected)
+            return pushError(state, `Expected ${getPrintable(expected)} (got ${getPrintable(value)})`);
+          return true;
+        }
+      });
+    }
+    function isString() {
+      return makeValidator({
+        test: (value, state) => {
+          if (typeof value !== `string`)
+            return pushError(state, `Expected a string (got ${getPrintable(value)})`);
+          return true;
+        }
+      });
+    }
+    function isEnum(enumSpec) {
+      const valuesArray = Array.isArray(enumSpec) ? enumSpec : Object.values(enumSpec);
+      const isAlphaNum = valuesArray.every((item) => typeof item === "string" || typeof item === "number");
+      const values = new Set(valuesArray);
+      if (values.size === 1)
+        return isLiteral([...values][0]);
+      return makeValidator({
+        test: (value, state) => {
+          if (!values.has(value)) {
+            if (isAlphaNum) {
+              return pushError(state, `Expected one of ${getPrintableArray(valuesArray, `or`)} (got ${getPrintable(value)})`);
+            } else {
+              return pushError(state, `Expected a valid enumeration value (got ${getPrintable(value)})`);
+            }
+          }
+          return true;
+        }
+      });
+    }
+    var BOOLEAN_COERCIONS = /* @__PURE__ */ new Map([
+      [`true`, true],
+      [`True`, true],
+      [`1`, true],
+      [1, true],
+      [`false`, false],
+      [`False`, false],
+      [`0`, false],
+      [0, false]
+    ]);
+    function isBoolean() {
+      return makeValidator({
+        test: (value, state) => {
+          var _a;
+          if (typeof value !== `boolean`) {
+            if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
+              if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`)
+                return pushError(state, `Unbound coercion result`);
+              const coercion = BOOLEAN_COERCIONS.get(value);
+              if (typeof coercion !== `undefined`) {
+                state.coercions.push([(_a = state.p) !== null && _a !== void 0 ? _a : `.`, state.coercion.bind(null, coercion)]);
+                return true;
+              }
+            }
+            return pushError(state, `Expected a boolean (got ${getPrintable(value)})`);
+          }
+          return true;
+        }
+      });
+    }
+    function isNumber() {
+      return makeValidator({
+        test: (value, state) => {
+          var _a;
+          if (typeof value !== `number`) {
+            if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
+              if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`)
+                return pushError(state, `Unbound coercion result`);
+              let coercion;
+              if (typeof value === `string`) {
+                let val;
+                try {
+                  val = JSON.parse(value);
+                } catch (_b) {
+                }
+                if (typeof val === `number`) {
+                  if (JSON.stringify(val) === value) {
+                    coercion = val;
+                  } else {
+                    return pushError(state, `Received a number that can't be safely represented by the runtime (${value})`);
+                  }
+                }
+              }
+              if (typeof coercion !== `undefined`) {
+                state.coercions.push([(_a = state.p) !== null && _a !== void 0 ? _a : `.`, state.coercion.bind(null, coercion)]);
+                return true;
+              }
+            }
+            return pushError(state, `Expected a number (got ${getPrintable(value)})`);
+          }
+          return true;
+        }
+      });
+    }
+    function isPayload(spec) {
+      return makeValidator({
+        test: (value, state) => {
+          var _a;
+          if (typeof (state === null || state === void 0 ? void 0 : state.coercions) === `undefined`)
+            return pushError(state, `The isPayload predicate can only be used with coercion enabled`);
+          if (typeof state.coercion === `undefined`)
+            return pushError(state, `Unbound coercion result`);
+          if (typeof value !== `string`)
+            return pushError(state, `Expected a string (got ${getPrintable(value)})`);
+          let inner;
+          try {
+            inner = JSON.parse(value);
+          } catch (_b) {
+            return pushError(state, `Expected a JSON string (got ${getPrintable(value)})`);
+          }
+          const wrapper = { value: inner };
+          if (!spec(inner, Object.assign(Object.assign({}, state), { coercion: makeCoercionFn(wrapper, `value`) })))
+            return false;
+          state.coercions.push([(_a = state.p) !== null && _a !== void 0 ? _a : `.`, state.coercion.bind(null, wrapper.value)]);
+          return true;
+        }
+      });
+    }
+    function isDate() {
+      return makeValidator({
+        test: (value, state) => {
+          var _a;
+          if (!(value instanceof Date)) {
+            if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
+              if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`)
+                return pushError(state, `Unbound coercion result`);
+              let coercion;
+              if (typeof value === `string` && iso8601RegExp.test(value)) {
+                coercion = new Date(value);
+              } else {
+                let timestamp;
+                if (typeof value === `string`) {
+                  let val;
+                  try {
+                    val = JSON.parse(value);
+                  } catch (_b) {
+                  }
+                  if (typeof val === `number`) {
+                    timestamp = val;
+                  }
+                } else if (typeof value === `number`) {
+                  timestamp = value;
+                }
+                if (typeof timestamp !== `undefined`) {
+                  if (Number.isSafeInteger(timestamp) || !Number.isSafeInteger(timestamp * 1e3)) {
+                    coercion = new Date(timestamp * 1e3);
+                  } else {
+                    return pushError(state, `Received a timestamp that can't be safely represented by the runtime (${value})`);
+                  }
+                }
+              }
+              if (typeof coercion !== `undefined`) {
+                state.coercions.push([(_a = state.p) !== null && _a !== void 0 ? _a : `.`, state.coercion.bind(null, coercion)]);
+                return true;
+              }
+            }
+            return pushError(state, `Expected a date (got ${getPrintable(value)})`);
+          }
+          return true;
+        }
+      });
+    }
+    function isArray(spec, { delimiter } = {}) {
+      return makeValidator({
+        test: (value, state) => {
+          var _a;
+          const originalValue = value;
+          if (typeof value === `string` && typeof delimiter !== `undefined`) {
+            if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
+              if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`)
+                return pushError(state, `Unbound coercion result`);
+              value = value.split(delimiter);
+            }
+          }
+          if (!Array.isArray(value))
+            return pushError(state, `Expected an array (got ${getPrintable(value)})`);
+          let valid = true;
+          for (let t = 0, T = value.length; t < T; ++t) {
+            valid = spec(value[t], Object.assign(Object.assign({}, state), { p: computeKey(state, t), coercion: makeCoercionFn(value, t) })) && valid;
+            if (!valid && (state === null || state === void 0 ? void 0 : state.errors) == null) {
+              break;
+            }
+          }
+          if (value !== originalValue)
+            state.coercions.push([(_a = state.p) !== null && _a !== void 0 ? _a : `.`, state.coercion.bind(null, value)]);
+          return valid;
+        }
+      });
+    }
+    function isSet(spec, { delimiter } = {}) {
+      const isArrayValidator = isArray(spec, { delimiter });
+      return makeValidator({
+        test: (value, state) => {
+          var _a, _b;
+          if (Object.getPrototypeOf(value).toString() === `[object Set]`) {
+            if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
+              if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`)
+                return pushError(state, `Unbound coercion result`);
+              const originalValues = [...value];
+              const coercedValues = [...value];
+              if (!isArrayValidator(coercedValues, Object.assign(Object.assign({}, state), { coercion: void 0 })))
+                return false;
+              const updateValue = () => coercedValues.some((val, t) => val !== originalValues[t]) ? new Set(coercedValues) : value;
+              state.coercions.push([(_a = state.p) !== null && _a !== void 0 ? _a : `.`, makeLazyCoercionFn(state.coercion, value, updateValue)]);
+              return true;
+            } else {
+              let valid = true;
+              for (const subValue of value) {
+                valid = spec(subValue, Object.assign({}, state)) && valid;
+                if (!valid && (state === null || state === void 0 ? void 0 : state.errors) == null) {
+                  break;
+                }
+              }
+              return valid;
+            }
+          }
+          if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
+            if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`)
+              return pushError(state, `Unbound coercion result`);
+            const store = { value };
+            if (!isArrayValidator(value, Object.assign(Object.assign({}, state), { coercion: makeCoercionFn(store, `value`) })))
+              return false;
+            state.coercions.push([(_b = state.p) !== null && _b !== void 0 ? _b : `.`, makeLazyCoercionFn(state.coercion, value, () => new Set(store.value))]);
+            return true;
+          }
+          return pushError(state, `Expected a set (got ${getPrintable(value)})`);
+        }
+      });
+    }
+    function isMap(keySpec, valueSpec) {
+      const isArrayValidator = isArray(isTuple([keySpec, valueSpec]));
+      const isRecordValidator = isRecord(valueSpec, { keys: keySpec });
+      return makeValidator({
+        test: (value, state) => {
+          var _a, _b, _c;
+          if (Object.getPrototypeOf(value).toString() === `[object Map]`) {
+            if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
+              if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`)
+                return pushError(state, `Unbound coercion result`);
+              const originalValues = [...value];
+              const coercedValues = [...value];
+              if (!isArrayValidator(coercedValues, Object.assign(Object.assign({}, state), { coercion: void 0 })))
+                return false;
+              const updateValue = () => coercedValues.some((val, t) => val[0] !== originalValues[t][0] || val[1] !== originalValues[t][1]) ? new Map(coercedValues) : value;
+              state.coercions.push([(_a = state.p) !== null && _a !== void 0 ? _a : `.`, makeLazyCoercionFn(state.coercion, value, updateValue)]);
+              return true;
+            } else {
+              let valid = true;
+              for (const [key, subValue] of value) {
+                valid = keySpec(key, Object.assign({}, state)) && valid;
+                if (!valid && (state === null || state === void 0 ? void 0 : state.errors) == null) {
+                  break;
+                }
+                valid = valueSpec(subValue, Object.assign(Object.assign({}, state), { p: computeKey(state, key) })) && valid;
+                if (!valid && (state === null || state === void 0 ? void 0 : state.errors) == null) {
+                  break;
+                }
+              }
+              return valid;
+            }
+          }
+          if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
+            if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`)
+              return pushError(state, `Unbound coercion result`);
+            const store = { value };
+            if (Array.isArray(value)) {
+              if (!isArrayValidator(value, Object.assign(Object.assign({}, state), { coercion: void 0 })))
+                return false;
+              state.coercions.push([(_b = state.p) !== null && _b !== void 0 ? _b : `.`, makeLazyCoercionFn(state.coercion, value, () => new Map(store.value))]);
+              return true;
+            } else {
+              if (!isRecordValidator(value, Object.assign(Object.assign({}, state), { coercion: makeCoercionFn(store, `value`) })))
+                return false;
+              state.coercions.push([(_c = state.p) !== null && _c !== void 0 ? _c : `.`, makeLazyCoercionFn(state.coercion, value, () => new Map(Object.entries(store.value)))]);
+              return true;
+            }
+          }
+          return pushError(state, `Expected a map (got ${getPrintable(value)})`);
+        }
+      });
+    }
+    function isTuple(spec, { delimiter } = {}) {
+      const lengthValidator = hasExactLength(spec.length);
+      return makeValidator({
+        test: (value, state) => {
+          var _a;
+          if (typeof value === `string` && typeof delimiter !== `undefined`) {
+            if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
+              if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`)
+                return pushError(state, `Unbound coercion result`);
+              value = value.split(delimiter);
+              state.coercions.push([(_a = state.p) !== null && _a !== void 0 ? _a : `.`, state.coercion.bind(null, value)]);
+            }
+          }
+          if (!Array.isArray(value))
+            return pushError(state, `Expected a tuple (got ${getPrintable(value)})`);
+          let valid = lengthValidator(value, Object.assign({}, state));
+          for (let t = 0, T = value.length; t < T && t < spec.length; ++t) {
+            valid = spec[t](value[t], Object.assign(Object.assign({}, state), { p: computeKey(state, t), coercion: makeCoercionFn(value, t) })) && valid;
+            if (!valid && (state === null || state === void 0 ? void 0 : state.errors) == null) {
+              break;
+            }
+          }
+          return valid;
+        }
+      });
+    }
+    function isRecord(spec, { keys: keySpec = null } = {}) {
+      const isArrayValidator = isArray(isTuple([keySpec !== null && keySpec !== void 0 ? keySpec : isString(), spec]));
+      return makeValidator({
+        test: (value, state) => {
+          var _a;
+          if (Array.isArray(value)) {
+            if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
+              if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`)
+                return pushError(state, `Unbound coercion result`);
+              if (!isArrayValidator(value, Object.assign(Object.assign({}, state), { coercion: void 0 })))
+                return false;
+              value = Object.fromEntries(value);
+              state.coercions.push([(_a = state.p) !== null && _a !== void 0 ? _a : `.`, state.coercion.bind(null, value)]);
+              return true;
+            }
+          }
+          if (typeof value !== `object` || value === null)
+            return pushError(state, `Expected an object (got ${getPrintable(value)})`);
+          const keys = Object.keys(value);
+          let valid = true;
+          for (let t = 0, T = keys.length; t < T && (valid || (state === null || state === void 0 ? void 0 : state.errors) != null); ++t) {
+            const key = keys[t];
+            const sub = value[key];
+            if (key === `__proto__` || key === `constructor`) {
+              valid = pushError(Object.assign(Object.assign({}, state), { p: computeKey(state, key) }), `Unsafe property name`);
+              continue;
+            }
+            if (keySpec !== null && !keySpec(key, state)) {
+              valid = false;
+              continue;
+            }
+            if (!spec(sub, Object.assign(Object.assign({}, state), { p: computeKey(state, key), coercion: makeCoercionFn(value, key) }))) {
+              valid = false;
+              continue;
+            }
+          }
+          return valid;
+        }
+      });
+    }
+    function isDict(spec, opts = {}) {
+      return isRecord(spec, opts);
+    }
+    function isObject(props, { extra: extraSpec = null } = {}) {
+      const specKeys = Object.keys(props);
+      const validator = makeValidator({
+        test: (value, state) => {
+          if (typeof value !== `object` || value === null)
+            return pushError(state, `Expected an object (got ${getPrintable(value)})`);
+          const keys = /* @__PURE__ */ new Set([...specKeys, ...Object.keys(value)]);
+          const extra = {};
+          let valid = true;
+          for (const key of keys) {
+            if (key === `constructor` || key === `__proto__`) {
+              valid = pushError(Object.assign(Object.assign({}, state), { p: computeKey(state, key) }), `Unsafe property name`);
+            } else {
+              const spec = Object.prototype.hasOwnProperty.call(props, key) ? props[key] : void 0;
+              const sub = Object.prototype.hasOwnProperty.call(value, key) ? value[key] : void 0;
+              if (typeof spec !== `undefined`) {
+                valid = spec(sub, Object.assign(Object.assign({}, state), { p: computeKey(state, key), coercion: makeCoercionFn(value, key) })) && valid;
+              } else if (extraSpec === null) {
+                valid = pushError(Object.assign(Object.assign({}, state), { p: computeKey(state, key) }), `Extraneous property (got ${getPrintable(sub)})`);
+              } else {
+                Object.defineProperty(extra, key, {
+                  enumerable: true,
+                  get: () => sub,
+                  set: makeSetter(value, key)
+                });
+              }
+            }
+            if (!valid && (state === null || state === void 0 ? void 0 : state.errors) == null) {
+              break;
+            }
+          }
+          if (extraSpec !== null && (valid || (state === null || state === void 0 ? void 0 : state.errors) != null))
+            valid = extraSpec(extra, state) && valid;
+          return valid;
+        }
+      });
+      return Object.assign(validator, {
+        properties: props
+      });
+    }
+    function isPartial(props) {
+      return isObject(props, { extra: isRecord(isUnknown()) });
+    }
+    var isInstanceOf = (constructor) => makeValidator({
+      test: (value, state) => {
+        if (!(value instanceof constructor))
+          return pushError(state, `Expected an instance of ${constructor.name} (got ${getPrintable(value)})`);
+        return true;
+      }
+    });
+    var isOneOf = (specs, { exclusive = false } = {}) => makeValidator({
+      test: (value, state) => {
+        var _a, _b, _c;
+        const matches = [];
+        const errorBuffer = typeof (state === null || state === void 0 ? void 0 : state.errors) !== `undefined` ? [] : void 0;
+        for (let t = 0, T = specs.length; t < T; ++t) {
+          const subErrors = typeof (state === null || state === void 0 ? void 0 : state.errors) !== `undefined` ? [] : void 0;
+          const subCoercions = typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined` ? [] : void 0;
+          if (specs[t](value, Object.assign(Object.assign({}, state), { errors: subErrors, coercions: subCoercions, p: `${(_a = state === null || state === void 0 ? void 0 : state.p) !== null && _a !== void 0 ? _a : `.`}#${t + 1}` }))) {
+            matches.push([`#${t + 1}`, subCoercions]);
+            if (!exclusive) {
+              break;
+            }
+          } else {
+            errorBuffer === null || errorBuffer === void 0 ? void 0 : errorBuffer.push(subErrors[0]);
+          }
+        }
+        if (matches.length === 1) {
+          const [, subCoercions] = matches[0];
+          if (typeof subCoercions !== `undefined`)
+            (_b = state === null || state === void 0 ? void 0 : state.coercions) === null || _b === void 0 ? void 0 : _b.push(...subCoercions);
+          return true;
+        }
+        if (matches.length > 1)
+          pushError(state, `Expected to match exactly a single predicate (matched ${matches.join(`, `)})`);
+        else
+          (_c = state === null || state === void 0 ? void 0 : state.errors) === null || _c === void 0 ? void 0 : _c.push(...errorBuffer);
+        return false;
+      }
+    });
+    function makeTrait(value) {
+      return () => {
+        return value;
+      };
+    }
+    function makeValidator({ test }) {
+      return makeTrait(test)();
+    }
+    var TypeAssertionError = class extends Error {
+      constructor({ errors } = {}) {
+        let errorMessage = `Type mismatch`;
+        if (errors && errors.length > 0) {
+          errorMessage += `
+`;
+          for (const error of errors) {
+            errorMessage += `
+- ${error}`;
+          }
+        }
+        super(errorMessage);
+      }
+    };
+    function assert(val, validator) {
+      if (!validator(val)) {
+        throw new TypeAssertionError();
+      }
+    }
+    function assertWithErrors(val, validator) {
+      const errors = [];
+      if (!validator(val, { errors })) {
+        throw new TypeAssertionError({ errors });
+      }
+    }
+    function softAssert(val, validator) {
+    }
+    function as(value, validator, { coerce = false, errors: storeErrors, throw: throws } = {}) {
+      const errors = storeErrors ? [] : void 0;
+      if (!coerce) {
+        if (validator(value, { errors })) {
+          return throws ? value : { value, errors: void 0 };
+        } else if (!throws) {
+          return { value: void 0, errors: errors !== null && errors !== void 0 ? errors : true };
+        } else {
+          throw new TypeAssertionError({ errors });
+        }
+      }
+      const state = { value };
+      const coercion = makeCoercionFn(state, `value`);
+      const coercions = [];
+      if (!validator(value, { errors, coercion, coercions })) {
+        if (!throws) {
+          return { value: void 0, errors: errors !== null && errors !== void 0 ? errors : true };
+        } else {
+          throw new TypeAssertionError({ errors });
+        }
+      }
+      for (const [, apply] of coercions)
+        apply();
+      if (throws) {
+        return state.value;
+      } else {
+        return { value: state.value, errors: void 0 };
+      }
+    }
+    function fn(validators, fn2) {
+      const isValidArgList = isTuple(validators);
+      return (...args) => {
+        const check = isValidArgList(args);
+        if (!check)
+          throw new TypeAssertionError();
+        return fn2(...args);
+      };
+    }
+    function hasMinLength(length) {
+      return makeValidator({
+        test: (value, state) => {
+          if (!(value.length >= length))
+            return pushError(state, `Expected to have a length of at least ${length} elements (got ${value.length})`);
+          return true;
+        }
+      });
+    }
+    function hasMaxLength(length) {
+      return makeValidator({
+        test: (value, state) => {
+          if (!(value.length <= length))
+            return pushError(state, `Expected to have a length of at most ${length} elements (got ${value.length})`);
+          return true;
+        }
+      });
+    }
+    function hasExactLength(length) {
+      return makeValidator({
+        test: (value, state) => {
+          if (!(value.length === length))
+            return pushError(state, `Expected to have a length of exactly ${length} elements (got ${value.length})`);
+          return true;
+        }
+      });
+    }
+    function hasUniqueItems({ map } = {}) {
+      return makeValidator({
+        test: (value, state) => {
+          const set = /* @__PURE__ */ new Set();
+          const dup = /* @__PURE__ */ new Set();
+          for (let t = 0, T = value.length; t < T; ++t) {
+            const sub = value[t];
+            const key = typeof map !== `undefined` ? map(sub) : sub;
+            if (set.has(key)) {
+              if (dup.has(key))
+                continue;
+              pushError(state, `Expected to contain unique elements; got a duplicate with ${getPrintable(value)}`);
+              dup.add(key);
+            } else {
+              set.add(key);
+            }
+          }
+          return dup.size === 0;
+        }
+      });
+    }
+    function isNegative() {
+      return makeValidator({
+        test: (value, state) => {
+          if (!(value <= 0))
+            return pushError(state, `Expected to be negative (got ${value})`);
+          return true;
+        }
+      });
+    }
+    function isPositive() {
+      return makeValidator({
+        test: (value, state) => {
+          if (!(value >= 0))
+            return pushError(state, `Expected to be positive (got ${value})`);
+          return true;
+        }
+      });
+    }
+    function isAtLeast(n) {
+      return makeValidator({
+        test: (value, state) => {
+          if (!(value >= n))
+            return pushError(state, `Expected to be at least ${n} (got ${value})`);
+          return true;
+        }
+      });
+    }
+    function isAtMost(n) {
+      return makeValidator({
+        test: (value, state) => {
+          if (!(value <= n))
+            return pushError(state, `Expected to be at most ${n} (got ${value})`);
+          return true;
+        }
+      });
+    }
+    function isInInclusiveRange(a, b) {
+      return makeValidator({
+        test: (value, state) => {
+          if (!(value >= a && value <= b))
+            return pushError(state, `Expected to be in the [${a}; ${b}] range (got ${value})`);
+          return true;
+        }
+      });
+    }
+    function isInExclusiveRange(a, b) {
+      return makeValidator({
+        test: (value, state) => {
+          if (!(value >= a && value < b))
+            return pushError(state, `Expected to be in the [${a}; ${b}[ range (got ${value})`);
+          return true;
+        }
+      });
+    }
+    function isInteger({ unsafe = false } = {}) {
+      return makeValidator({
+        test: (value, state) => {
+          if (value !== Math.round(value))
+            return pushError(state, `Expected to be an integer (got ${value})`);
+          if (!unsafe && !Number.isSafeInteger(value))
+            return pushError(state, `Expected to be a safe integer (got ${value})`);
+          return true;
+        }
+      });
+    }
+    function matchesRegExp(regExp) {
+      return makeValidator({
+        test: (value, state) => {
+          if (!regExp.test(value))
+            return pushError(state, `Expected to match the pattern ${regExp.toString()} (got ${getPrintable(value)})`);
+          return true;
+        }
+      });
+    }
+    function isLowerCase() {
+      return makeValidator({
+        test: (value, state) => {
+          if (value !== value.toLowerCase())
+            return pushError(state, `Expected to be all-lowercase (got ${value})`);
+          return true;
+        }
+      });
+    }
+    function isUpperCase() {
+      return makeValidator({
+        test: (value, state) => {
+          if (value !== value.toUpperCase())
+            return pushError(state, `Expected to be all-uppercase (got ${value})`);
+          return true;
+        }
+      });
+    }
+    function isUUID4() {
+      return makeValidator({
+        test: (value, state) => {
+          if (!uuid4RegExp.test(value))
+            return pushError(state, `Expected to be a valid UUID v4 (got ${getPrintable(value)})`);
+          return true;
+        }
+      });
+    }
+    function isISO8601() {
+      return makeValidator({
+        test: (value, state) => {
+          if (!iso8601RegExp.test(value))
+            return pushError(state, `Expected to be a valid ISO 8601 date string (got ${getPrintable(value)})`);
+          return true;
+        }
+      });
+    }
+    function isHexColor({ alpha = false }) {
+      return makeValidator({
+        test: (value, state) => {
+          const res = alpha ? colorStringRegExp.test(value) : colorStringAlphaRegExp.test(value);
+          if (!res)
+            return pushError(state, `Expected to be a valid hexadecimal color string (got ${getPrintable(value)})`);
+          return true;
+        }
+      });
+    }
+    function isBase64() {
+      return makeValidator({
+        test: (value, state) => {
+          if (!base64RegExp.test(value))
+            return pushError(state, `Expected to be a valid base 64 string (got ${getPrintable(value)})`);
+          return true;
+        }
+      });
+    }
+    function isJSON(spec = isUnknown()) {
+      return makeValidator({
+        test: (value, state) => {
+          let data;
+          try {
+            data = JSON.parse(value);
+          } catch (_a) {
+            return pushError(state, `Expected to be a valid JSON string (got ${getPrintable(value)})`);
+          }
+          return spec(data, state);
+        }
+      });
+    }
+    function cascade(spec, ...followups) {
+      const resolvedFollowups = Array.isArray(followups[0]) ? followups[0] : followups;
+      return makeValidator({
+        test: (value, state) => {
+          var _a, _b;
+          const context = { value };
+          const subCoercion = typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined` ? makeCoercionFn(context, `value`) : void 0;
+          const subCoercions = typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined` ? [] : void 0;
+          if (!spec(value, Object.assign(Object.assign({}, state), { coercion: subCoercion, coercions: subCoercions })))
+            return false;
+          const reverts = [];
+          if (typeof subCoercions !== `undefined`)
+            for (const [, coercion] of subCoercions)
+              reverts.push(coercion());
+          try {
+            if (typeof (state === null || state === void 0 ? void 0 : state.coercions) !== `undefined`) {
+              if (context.value !== value) {
+                if (typeof (state === null || state === void 0 ? void 0 : state.coercion) === `undefined`)
+                  return pushError(state, `Unbound coercion result`);
+                state.coercions.push([(_a = state.p) !== null && _a !== void 0 ? _a : `.`, state.coercion.bind(null, context.value)]);
+              }
+              (_b = state === null || state === void 0 ? void 0 : state.coercions) === null || _b === void 0 ? void 0 : _b.push(...subCoercions);
+            }
+            return resolvedFollowups.every((spec2) => {
+              return spec2(context.value, state);
+            });
+          } finally {
+            for (const revert of reverts) {
+              revert();
+            }
+          }
+        }
+      });
+    }
+    function applyCascade(spec, ...followups) {
+      const resolvedFollowups = Array.isArray(followups[0]) ? followups[0] : followups;
+      return cascade(spec, resolvedFollowups);
+    }
+    function isOptional(spec) {
+      return makeValidator({
+        test: (value, state) => {
+          if (typeof value === `undefined`)
+            return true;
+          return spec(value, state);
+        }
+      });
+    }
+    function isNullable(spec) {
+      return makeValidator({
+        test: (value, state) => {
+          if (value === null)
+            return true;
+          return spec(value, state);
+        }
+      });
+    }
+    var checks = {
+      missing: (keys, key) => keys.has(key),
+      undefined: (keys, key, value) => keys.has(key) && typeof value[key] !== `undefined`,
+      nil: (keys, key, value) => keys.has(key) && value[key] != null,
+      falsy: (keys, key, value) => keys.has(key) && !!value[key]
+    };
+    function hasRequiredKeys(requiredKeys, options) {
+      var _a;
+      const requiredSet = new Set(requiredKeys);
+      const check = checks[(_a = options === null || options === void 0 ? void 0 : options.missingIf) !== null && _a !== void 0 ? _a : "missing"];
+      return makeValidator({
+        test: (value, state) => {
+          const keys = new Set(Object.keys(value));
+          const problems = [];
+          for (const key of requiredSet)
+            if (!check(keys, key, value))
+              problems.push(key);
+          if (problems.length > 0)
+            return pushError(state, `Missing required ${plural(problems.length, `property`, `properties`)} ${getPrintableArray(problems, `and`)}`);
+          return true;
+        }
+      });
+    }
+    function hasAtLeastOneKey(requiredKeys, options) {
+      var _a;
+      const requiredSet = new Set(requiredKeys);
+      const check = checks[(_a = options === null || options === void 0 ? void 0 : options.missingIf) !== null && _a !== void 0 ? _a : "missing"];
+      return makeValidator({
+        test: (value, state) => {
+          const keys = Object.keys(value);
+          const valid = keys.some((key) => check(requiredSet, key, value));
+          if (!valid)
+            return pushError(state, `Missing at least one property from ${getPrintableArray(Array.from(requiredSet), `or`)}`);
+          return true;
+        }
+      });
+    }
+    function hasForbiddenKeys(forbiddenKeys, options) {
+      var _a;
+      const forbiddenSet = new Set(forbiddenKeys);
+      const check = checks[(_a = options === null || options === void 0 ? void 0 : options.missingIf) !== null && _a !== void 0 ? _a : "missing"];
+      return makeValidator({
+        test: (value, state) => {
+          const keys = new Set(Object.keys(value));
+          const problems = [];
+          for (const key of forbiddenSet)
+            if (check(keys, key, value))
+              problems.push(key);
+          if (problems.length > 0)
+            return pushError(state, `Forbidden ${plural(problems.length, `property`, `properties`)} ${getPrintableArray(problems, `and`)}`);
+          return true;
+        }
+      });
+    }
+    function hasMutuallyExclusiveKeys(exclusiveKeys, options) {
+      var _a;
+      const exclusiveSet = new Set(exclusiveKeys);
+      const check = checks[(_a = options === null || options === void 0 ? void 0 : options.missingIf) !== null && _a !== void 0 ? _a : "missing"];
+      return makeValidator({
+        test: (value, state) => {
+          const keys = new Set(Object.keys(value));
+          const used = [];
+          for (const key of exclusiveSet)
+            if (check(keys, key, value))
+              used.push(key);
+          if (used.length > 1)
+            return pushError(state, `Mutually exclusive properties ${getPrintableArray(used, `and`)}`);
+          return true;
+        }
+      });
+    }
+    (function(KeyRelationship) {
+      KeyRelationship["Forbids"] = "Forbids";
+      KeyRelationship["Requires"] = "Requires";
+    })(exports2.KeyRelationship || (exports2.KeyRelationship = {}));
+    var keyRelationships = {
+      [exports2.KeyRelationship.Forbids]: {
+        expect: false,
+        message: `forbids using`
+      },
+      [exports2.KeyRelationship.Requires]: {
+        expect: true,
+        message: `requires using`
+      }
+    };
+    function hasKeyRelationship(subject, relationship, others, options) {
+      var _a, _b;
+      const skipped = new Set((_a = options === null || options === void 0 ? void 0 : options.ignore) !== null && _a !== void 0 ? _a : []);
+      const check = checks[(_b = options === null || options === void 0 ? void 0 : options.missingIf) !== null && _b !== void 0 ? _b : "missing"];
+      const otherSet = new Set(others);
+      const spec = keyRelationships[relationship];
+      const conjunction = relationship === exports2.KeyRelationship.Forbids ? `or` : `and`;
+      return makeValidator({
+        test: (value, state) => {
+          const keys = new Set(Object.keys(value));
+          if (!check(keys, subject, value) || skipped.has(value[subject]))
+            return true;
+          const problems = [];
+          for (const key of otherSet)
+            if ((check(keys, key, value) && !skipped.has(value[key])) !== spec.expect)
+              problems.push(key);
+          if (problems.length >= 1)
+            return pushError(state, `Property "${subject}" ${spec.message} ${plural(problems.length, `property`, `properties`)} ${getPrintableArray(problems, conjunction)}`);
+          return true;
+        }
+      });
+    }
+    exports2.TypeAssertionError = TypeAssertionError;
+    exports2.applyCascade = applyCascade;
+    exports2.as = as;
+    exports2.assert = assert;
+    exports2.assertWithErrors = assertWithErrors;
+    exports2.cascade = cascade;
+    exports2.fn = fn;
+    exports2.hasAtLeastOneKey = hasAtLeastOneKey;
+    exports2.hasExactLength = hasExactLength;
+    exports2.hasForbiddenKeys = hasForbiddenKeys;
+    exports2.hasKeyRelationship = hasKeyRelationship;
+    exports2.hasMaxLength = hasMaxLength;
+    exports2.hasMinLength = hasMinLength;
+    exports2.hasMutuallyExclusiveKeys = hasMutuallyExclusiveKeys;
+    exports2.hasRequiredKeys = hasRequiredKeys;
+    exports2.hasUniqueItems = hasUniqueItems;
+    exports2.isArray = isArray;
+    exports2.isAtLeast = isAtLeast;
+    exports2.isAtMost = isAtMost;
+    exports2.isBase64 = isBase64;
+    exports2.isBoolean = isBoolean;
+    exports2.isDate = isDate;
+    exports2.isDict = isDict;
+    exports2.isEnum = isEnum;
+    exports2.isHexColor = isHexColor;
+    exports2.isISO8601 = isISO8601;
+    exports2.isInExclusiveRange = isInExclusiveRange;
+    exports2.isInInclusiveRange = isInInclusiveRange;
+    exports2.isInstanceOf = isInstanceOf;
+    exports2.isInteger = isInteger;
+    exports2.isJSON = isJSON;
+    exports2.isLiteral = isLiteral;
+    exports2.isLowerCase = isLowerCase;
+    exports2.isMap = isMap;
+    exports2.isNegative = isNegative;
+    exports2.isNullable = isNullable;
+    exports2.isNumber = isNumber;
+    exports2.isObject = isObject;
+    exports2.isOneOf = isOneOf;
+    exports2.isOptional = isOptional;
+    exports2.isPartial = isPartial;
+    exports2.isPayload = isPayload;
+    exports2.isPositive = isPositive;
+    exports2.isRecord = isRecord;
+    exports2.isSet = isSet;
+    exports2.isString = isString;
+    exports2.isTuple = isTuple;
+    exports2.isUUID4 = isUUID4;
+    exports2.isUnknown = isUnknown;
+    exports2.isUpperCase = isUpperCase;
+    exports2.makeTrait = makeTrait;
+    exports2.makeValidator = makeValidator;
+    exports2.matchesRegExp = matchesRegExp;
+    exports2.softAssert = softAssert;
+  }
+});
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  initialize: () => initialize
+});
+module.exports = __toCommonJS(cli_exports);
+init_cjs_shims();
+
+// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/advanced/index.mjs
+init_cjs_shims();
+
+// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/advanced/Command.mjs
+init_cjs_shims();
+
+// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/advanced/options/utils.mjs
+init_cjs_shims();
+
+// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/errors.mjs
+init_cjs_shims();
+
+// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/constants.mjs
+init_cjs_shims();
+var SpecialToken;
+(function(SpecialToken2) {
+  SpecialToken2["StartOfInput"] = "\0";
+  SpecialToken2["EndOfInput"] = "
";
+  SpecialToken2["EndOfPartialInput"] = "";
+})(SpecialToken || (SpecialToken = {}));
+var NodeType;
+(function(NodeType2) {
+  NodeType2[NodeType2["InitialNode"] = 0] = "InitialNode";
+  NodeType2[NodeType2["SuccessNode"] = 1] = "SuccessNode";
+  NodeType2[NodeType2["ErrorNode"] = 2] = "ErrorNode";
+  NodeType2[NodeType2["CustomNode"] = 3] = "CustomNode";
+})(NodeType || (NodeType = {}));
+var HELP_COMMAND_INDEX = -1;
+var HELP_REGEX = /^(-h|--help)(?:=([0-9]+))?$/;
+var OPTION_REGEX = /^(--[a-z]+(?:-[a-z]+)*|-[a-zA-Z]+)$/;
+var BATCH_REGEX = /^-[a-zA-Z]{2,}$/;
+var BINDING_REGEX = /^([^=]+)=([\s\S]*)$/;
+var IS_DEBUG = process.env.DEBUG_CLI === `1`;
+
+// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/errors.mjs
+var UsageError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.clipanion = { type: `usage` };
+    this.name = `UsageError`;
+  }
+};
+var UnknownSyntaxError = class extends Error {
+  constructor(input, candidates) {
+    super();
+    this.input = input;
+    this.candidates = candidates;
+    this.clipanion = { type: `none` };
+    this.name = `UnknownSyntaxError`;
+    if (this.candidates.length === 0) {
+      this.message = `Command not found, but we're not sure what's the alternative.`;
+    } else if (this.candidates.every((candidate) => candidate.reason !== null && candidate.reason === candidates[0].reason)) {
+      const [{ reason }] = this.candidates;
+      this.message = `${reason}
+
+${this.candidates.map(({ usage }) => `$ ${usage}`).join(`
+`)}`;
+    } else if (this.candidates.length === 1) {
+      const [{ usage }] = this.candidates;
+      this.message = `Command not found; did you mean:
+
+$ ${usage}
+${whileRunning(input)}`;
+    } else {
+      this.message = `Command not found; did you mean one of:
+
+${this.candidates.map(({ usage }, index) => {
+        return `${`${index}.`.padStart(4)} ${usage}`;
+      }).join(`
+`)}
+
+${whileRunning(input)}`;
+    }
+  }
+};
+var AmbiguousSyntaxError = class extends Error {
+  constructor(input, usages) {
+    super();
+    this.input = input;
+    this.usages = usages;
+    this.clipanion = { type: `none` };
+    this.name = `AmbiguousSyntaxError`;
+    this.message = `Cannot find which to pick amongst the following alternatives:
+
+${this.usages.map((usage, index) => {
+      return `${`${index}.`.padStart(4)} ${usage}`;
+    }).join(`
+`)}
+
+${whileRunning(input)}`;
+  }
+};
+var whileRunning = (input) => `While running ${input.filter((token) => {
+  return token !== SpecialToken.EndOfInput && token !== SpecialToken.EndOfPartialInput;
+}).map((token) => {
+  const json = JSON.stringify(token);
+  if (token.match(/\s/) || token.length === 0 || json !== `"${token}"`) {
+    return json;
+  } else {
+    return token;
+  }
+}).join(` `)}`;
+
+// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/advanced/options/utils.mjs
+var isOptionSymbol = Symbol(`clipanion/isOption`);
+function cleanValidationError(message, { mergeName = false } = {}) {
+  const match = message.match(/^([^:]+): (.*)$/m);
+  if (!match)
+    return `validation failed`;
+  let [, path2, line] = match;
+  if (mergeName)
+    line = line[0].toLowerCase() + line.slice(1);
+  line = path2 !== `.` || !mergeName ? `${path2.replace(/^\.(\[|$)/, `$1`)}: ${line}` : `: ${line}`;
+  return line;
+}
+function formatError(message, errors) {
+  if (errors.length === 1) {
+    return new UsageError(`${message}${cleanValidationError(errors[0], { mergeName: true })}`);
+  } else {
+    return new UsageError(`${message}:
+${errors.map((error) => `
+- ${cleanValidationError(error)}`).join(``)}`);
+  }
+}
+
+// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/advanced/Command.mjs
+var Command = class {
+  constructor() {
+    this.help = false;
+  }
+  /**
+   * Defines the usage information for the given command.
+   */
+  static Usage(usage) {
+    return usage;
+  }
+  /**
+   * Standard error handler which will simply rethrow the error. Can be used
+   * to add custom logic to handle errors from the command or simply return
+   * the parent class error handling.
+   */
+  async catch(error) {
+    throw error;
+  }
+  async validateAndExecute() {
+    const commandClass = this.constructor;
+    const cascade = commandClass.schema;
+    if (Array.isArray(cascade)) {
+      const { isDict, isUnknown, applyCascade } = await Promise.resolve().then(() => __toESM(require_lib(), 1));
+      const schema = applyCascade(isDict(isUnknown()), cascade);
+      const errors = [];
+      const coercions = [];
+      const check = schema(this, { errors, coercions });
+      if (!check)
+        throw formatError(`Invalid option schema`, errors);
+      for (const [, op] of coercions) {
+        op();
+      }
+    } else if (cascade != null) {
+      throw new Error(`Invalid command schema`);
+    }
+    const exitCode = await this.execute();
+    if (typeof exitCode !== `undefined`) {
+      return exitCode;
+    } else {
+      return 0;
+    }
+  }
+};
+Command.isOption = isOptionSymbol;
+Command.Default = [];
+
+// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/advanced/Cli.mjs
+init_cjs_shims();
+
+// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/platform/node.mjs
+init_cjs_shims();
+var import_tty = __toESM(require("tty"), 1);
+function getDefaultColorDepth() {
+  if (import_tty.default && `getColorDepth` in import_tty.default.WriteStream.prototype)
+    return import_tty.default.WriteStream.prototype.getColorDepth();
+  if (process.env.FORCE_COLOR === `0`)
+    return 1;
+  if (process.env.FORCE_COLOR === `1`)
+    return 8;
+  if (typeof process.stdout !== `undefined` && process.stdout.isTTY)
+    return 8;
+  return 1;
+}
+var gContextStorage;
+function getCaptureActivator(context) {
+  let contextStorage = gContextStorage;
+  if (typeof contextStorage === `undefined`) {
+    if (context.stdout === process.stdout && context.stderr === process.stderr)
+      return null;
+    const { AsyncLocalStorage: LazyAsyncLocalStorage } = require("async_hooks");
+    contextStorage = gContextStorage = new LazyAsyncLocalStorage();
+    const origStdoutWrite = process.stdout._write;
+    process.stdout._write = function(chunk, encoding, cb) {
+      const context2 = contextStorage.getStore();
+      if (typeof context2 === `undefined`)
+        return origStdoutWrite.call(this, chunk, encoding, cb);
+      return context2.stdout.write(chunk, encoding, cb);
+    };
+    const origStderrWrite = process.stderr._write;
+    process.stderr._write = function(chunk, encoding, cb) {
+      const context2 = contextStorage.getStore();
+      if (typeof context2 === `undefined`)
+        return origStderrWrite.call(this, chunk, encoding, cb);
+      return context2.stderr.write(chunk, encoding, cb);
+    };
+  }
+  return (fn) => {
+    return contextStorage.run(context, fn);
+  };
+}
+
+// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/core.mjs
+init_cjs_shims();
+function debug(str) {
+  if (IS_DEBUG) {
+    console.log(str);
+  }
+}
+var basicHelpState = {
+  candidateUsage: null,
+  requiredOptions: [],
+  errorMessage: null,
+  ignoreOptions: false,
+  path: [],
+  positionals: [],
+  options: [],
+  remainder: null,
+  selectedIndex: HELP_COMMAND_INDEX,
+  tokens: []
+};
+function makeStateMachine() {
+  const stateMachine = {
+    nodes: []
+  };
+  for (let t = 0; t < NodeType.CustomNode; ++t)
+    stateMachine.nodes.push(makeNode());
+  return stateMachine;
+}
+function makeAnyOfMachine(inputs) {
+  const output = makeStateMachine();
+  const heads = [];
+  let offset = output.nodes.length;
+  for (const input of inputs) {
+    heads.push(offset);
+    for (let t = 0; t < input.nodes.length; ++t)
+      if (!isTerminalNode(t))
+        output.nodes.push(cloneNode(input.nodes[t], offset));
+    offset += input.nodes.length - NodeType.CustomNode + 1;
+  }
+  for (const head of heads)
+    registerShortcut(output, NodeType.InitialNode, head);
+  return output;
+}
+function injectNode(machine, node) {
+  machine.nodes.push(node);
+  return machine.nodes.length - 1;
+}
+function simplifyMachine(input) {
+  const visited = /* @__PURE__ */ new Set();
+  const process2 = (node) => {
+    if (visited.has(node))
+      return;
+    visited.add(node);
+    const nodeDef = input.nodes[node];
+    for (const transitions of Object.values(nodeDef.statics))
+      for (const { to } of transitions)
+        process2(to);
+    for (const [, { to }] of nodeDef.dynamics)
+      process2(to);
+    for (const { to } of nodeDef.shortcuts)
+      process2(to);
+    const shortcuts = new Set(nodeDef.shortcuts.map(({ to }) => to));
+    while (nodeDef.shortcuts.length > 0) {
+      const { to } = nodeDef.shortcuts.shift();
+      const toDef = input.nodes[to];
+      for (const [segment, transitions] of Object.entries(toDef.statics)) {
+        const store = !Object.prototype.hasOwnProperty.call(nodeDef.statics, segment) ? nodeDef.statics[segment] = [] : nodeDef.statics[segment];
+        for (const transition of transitions) {
+          if (!store.some(({ to: to2 }) => transition.to === to2)) {
+            store.push(transition);
+          }
+        }
+      }
+      for (const [test, transition] of toDef.dynamics)
+        if (!nodeDef.dynamics.some(([otherTest, { to: to2 }]) => test === otherTest && transition.to === to2))
+          nodeDef.dynamics.push([test, transition]);
+      for (const transition of toDef.shortcuts) {
+        if (!shortcuts.has(transition.to)) {
+          nodeDef.shortcuts.push(transition);
+          shortcuts.add(transition.to);
+        }
+      }
+    }
+  };
+  process2(NodeType.InitialNode);
+}
+function debugMachine(machine, { prefix = `` } = {}) {
+  if (IS_DEBUG) {
+    debug(`${prefix}Nodes are:`);
+    for (let t = 0; t < machine.nodes.length; ++t) {
+      debug(`${prefix}  ${t}: ${JSON.stringify(machine.nodes[t])}`);
+    }
+  }
+}
+function runMachineInternal(machine, input, partial = false) {
+  debug(`Running a vm on ${JSON.stringify(input)}`);
+  let branches = [{
+    node: NodeType.InitialNode,
+    state: {
+      candidateUsage: null,
+      requiredOptions: [],
+      errorMessage: null,
+      ignoreOptions: false,
+      options: [],
+      path: [],
+      positionals: [],
+      remainder: null,
+      selectedIndex: null,
+      tokens: []
+    }
+  }];
+  debugMachine(machine, { prefix: `  ` });
+  const tokens = [SpecialToken.StartOfInput, ...input];
+  for (let t = 0; t < tokens.length; ++t) {
+    const segment = tokens[t];
+    const isEOI = segment === SpecialToken.EndOfInput || segment === SpecialToken.EndOfPartialInput;
+    const segmentIndex = t - 1;
+    debug(`  Processing ${JSON.stringify(segment)}`);
+    const nextBranches = [];
+    for (const { node, state } of branches) {
+      debug(`    Current node is ${node}`);
+      const nodeDef = machine.nodes[node];
+      if (node === NodeType.ErrorNode) {
+        nextBranches.push({ node, state });
+        continue;
+      }
+      console.assert(nodeDef.shortcuts.length === 0, `Shortcuts should have been eliminated by now`);
+      const hasExactMatch = Object.prototype.hasOwnProperty.call(nodeDef.statics, segment);
+      if (!partial || t < tokens.length - 1 || hasExactMatch) {
+        if (hasExactMatch) {
+          const transitions = nodeDef.statics[segment];
+          for (const { to, reducer } of transitions) {
+            nextBranches.push({ node: to, state: typeof reducer !== `undefined` ? execute(reducers, reducer, state, segment, segmentIndex) : state });
+            debug(`      Static transition to ${to} found`);
+          }
+        } else {
+          debug(`      No static transition found`);
+        }
+      } else {
+        let hasMatches = false;
+        for (const candidate of Object.keys(nodeDef.statics)) {
+          if (!candidate.startsWith(segment))
+            continue;
+          if (segment === candidate) {
+            for (const { to, reducer } of nodeDef.statics[candidate]) {
+              nextBranches.push({ node: to, state: typeof reducer !== `undefined` ? execute(reducers, reducer, state, segment, segmentIndex) : state });
+              debug(`      Static transition to ${to} found`);
+            }
+          } else {
+            for (const { to } of nodeDef.statics[candidate]) {
+              nextBranches.push({ node: to, state: { ...state, remainder: candidate.slice(segment.length) } });
+              debug(`      Static transition to ${to} found (partial match)`);
+            }
+          }
+          hasMatches = true;
+        }
+        if (!hasMatches) {
+          debug(`      No partial static transition found`);
+        }
+      }
+      if (!isEOI) {
+        for (const [test, { to, reducer }] of nodeDef.dynamics) {
+          if (execute(tests, test, state, segment, segmentIndex)) {
+            nextBranches.push({ node: to, state: typeof reducer !== `undefined` ? execute(reducers, reducer, state, segment, segmentIndex) : state });
+            debug(`      Dynamic transition to ${to} found (via ${test})`);
+          }
+        }
+      }
+    }
+    if (nextBranches.length === 0 && isEOI && input.length === 1) {
+      return [{
+        node: NodeType.InitialNode,
+        state: basicHelpState
+      }];
+    }
+    if (nextBranches.length === 0) {
+      throw new UnknownSyntaxError(input, branches.filter(({ node }) => {
+        return node !== NodeType.ErrorNode;
+      }).map(({ state }) => {
+        return { usage: state.candidateUsage, reason: null };
+      }));
+    }
+    if (nextBranches.every(({ node }) => node === NodeType.ErrorNode)) {
+      throw new UnknownSyntaxError(input, nextBranches.map(({ state }) => {
+        return { usage: state.candidateUsage, reason: state.errorMessage };
+      }));
+    }
+    branches = trimSmallerBranches(nextBranches);
+  }
+  if (branches.length > 0) {
+    debug(`  Results:`);
+    for (const branch of branches) {
+      debug(`    - ${branch.node} -> ${JSON.stringify(branch.state)}`);
+    }
+  } else {
+    debug(`  No results`);
+  }
+  return branches;
+}
+function runMachine(machine, input, { endToken = SpecialToken.EndOfInput } = {}) {
+  const branches = runMachineInternal(machine, [...input, endToken]);
+  return selectBestState(input, branches.map(({ state }) => {
+    return state;
+  }));
+}
+function trimSmallerBranches(branches) {
+  let maxPathSize = 0;
+  for (const { state } of branches)
+    if (state.path.length > maxPathSize)
+      maxPathSize = state.path.length;
+  return branches.filter(({ state }) => {
+    return state.path.length === maxPathSize;
+  });
+}
+function selectBestState(input, states) {
+  const terminalStates = states.filter((state) => {
+    return state.selectedIndex !== null;
+  });
+  if (terminalStates.length === 0)
+    throw new Error();
+  const requiredOptionsSetStates = terminalStates.filter((state) => state.selectedIndex === HELP_COMMAND_INDEX || state.requiredOptions.every((names) => names.some((name) => state.options.find((opt) => opt.name === name))));
+  if (requiredOptionsSetStates.length === 0) {
+    throw new UnknownSyntaxError(input, terminalStates.map((state) => ({
+      usage: state.candidateUsage,
+      reason: null
+    })));
+  }
+  let maxPathSize = 0;
+  for (const state of requiredOptionsSetStates)
+    if (state.path.length > maxPathSize)
+      maxPathSize = state.path.length;
+  const bestPathBranches = requiredOptionsSetStates.filter((state) => {
+    return state.path.length === maxPathSize;
+  });
+  const getPositionalCount = (state) => state.positionals.filter(({ extra }) => {
+    return !extra;
+  }).length + state.options.length;
+  const statesWithPositionalCount = bestPathBranches.map((state) => {
+    return { state, positionalCount: getPositionalCount(state) };
+  });
+  let maxPositionalCount = 0;
+  for (const { positionalCount } of statesWithPositionalCount)
+    if (positionalCount > maxPositionalCount)
+      maxPositionalCount = positionalCount;
+  const bestPositionalStates = statesWithPositionalCount.filter(({ positionalCount }) => {
+    return positionalCount === maxPositionalCount;
+  }).map(({ state }) => {
+    return state;
+  });
+  const fixedStates = aggregateHelpStates(bestPositionalStates);
+  if (fixedStates.length > 1)
+    throw new AmbiguousSyntaxError(input, fixedStates.map((state) => state.candidateUsage));
+  return fixedStates[0];
+}
+function aggregateHelpStates(states) {
+  const notHelps = [];
+  const helps = [];
+  for (const state of states) {
+    if (state.selectedIndex === HELP_COMMAND_INDEX) {
+      helps.push(state);
+    } else {
+      notHelps.push(state);
+    }
+  }
+  if (helps.length > 0) {
+    notHelps.push({
+      ...basicHelpState,
+      path: findCommonPrefix(...helps.map((state) => state.path)),
+      options: helps.reduce((options, state) => options.concat(state.options), [])
+    });
+  }
+  return notHelps;
+}
+function findCommonPrefix(firstPath, secondPath, ...rest) {
+  if (secondPath === void 0)
+    return Array.from(firstPath);
+  return findCommonPrefix(firstPath.filter((segment, i) => segment === secondPath[i]), ...rest);
+}
+function makeNode() {
+  return {
+    dynamics: [],
+    shortcuts: [],
+    statics: {}
+  };
+}
+function isTerminalNode(node) {
+  return node === NodeType.SuccessNode || node === NodeType.ErrorNode;
+}
+function cloneTransition(input, offset = 0) {
+  const to = !isTerminalNode(input.to) ? input.to >= NodeType.CustomNode ? input.to + offset - NodeType.CustomNode + 1 : input.to + offset : input.to;
+  return {
+    to,
+    reducer: input.reducer
+  };
+}
+function cloneNode(input, offset = 0) {
+  const output = makeNode();
+  for (const [test, transition] of input.dynamics)
+    output.dynamics.push([test, cloneTransition(transition, offset)]);
+  for (const transition of input.shortcuts)
+    output.shortcuts.push(cloneTransition(transition, offset));
+  for (const [segment, transitions] of Object.entries(input.statics))
+    output.statics[segment] = transitions.map((transition) => cloneTransition(transition, offset));
+  return output;
+}
+function registerDynamic(machine, from, test, to, reducer) {
+  machine.nodes[from].dynamics.push([
+    test,
+    { to, reducer }
+  ]);
+}
+function registerShortcut(machine, from, to, reducer) {
+  machine.nodes[from].shortcuts.push({ to, reducer });
+}
+function registerStatic(machine, from, test, to, reducer) {
+  const store = !Object.prototype.hasOwnProperty.call(machine.nodes[from].statics, test) ? machine.nodes[from].statics[test] = [] : machine.nodes[from].statics[test];
+  store.push({ to, reducer });
+}
+function execute(store, callback, state, segment, segmentIndex) {
+  if (Array.isArray(callback)) {
+    const [name, ...args] = callback;
+    return store[name](state, segment, segmentIndex, ...args);
+  } else {
+    return store[callback](state, segment, segmentIndex);
+  }
+}
+var tests = {
+  always: () => {
+    return true;
+  },
+  isOptionLike: (state, segment) => {
+    return !state.ignoreOptions && (segment !== `-` && segment.startsWith(`-`));
+  },
+  isNotOptionLike: (state, segment) => {
+    return state.ignoreOptions || segment === `-` || !segment.startsWith(`-`);
+  },
+  isOption: (state, segment, segmentIndex, name) => {
+    return !state.ignoreOptions && segment === name;
+  },
+  isBatchOption: (state, segment, segmentIndex, names) => {
+    return !state.ignoreOptions && BATCH_REGEX.test(segment) && [...segment.slice(1)].every((name) => names.has(`-${name}`));
+  },
+  isBoundOption: (state, segment, segmentIndex, names, options) => {
+    const optionParsing = segment.match(BINDING_REGEX);
+    return !state.ignoreOptions && !!optionParsing && OPTION_REGEX.test(optionParsing[1]) && names.has(optionParsing[1]) && options.filter((opt) => opt.nameSet.includes(optionParsing[1])).every((opt) => opt.allowBinding);
+  },
+  isNegatedOption: (state, segment, segmentIndex, name) => {
+    return !state.ignoreOptions && segment === `--no-${name.slice(2)}`;
+  },
+  isHelp: (state, segment) => {
+    return !state.ignoreOptions && HELP_REGEX.test(segment);
+  },
+  isUnsupportedOption: (state, segment, segmentIndex, names) => {
+    return !state.ignoreOptions && segment.startsWith(`-`) && OPTION_REGEX.test(segment) && !names.has(segment);
+  },
+  isInvalidOption: (state, segment) => {
+    return !state.ignoreOptions && segment.startsWith(`-`) && !OPTION_REGEX.test(segment);
+  }
+};
+var reducers = {
+  setCandidateState: (state, segment, segmentIndex, candidateState) => {
+    return { ...state, ...candidateState };
+  },
+  setSelectedIndex: (state, segment, segmentIndex, index) => {
+    return { ...state, selectedIndex: index };
+  },
+  pushBatch: (state, segment, segmentIndex, names) => {
+    const options = state.options.slice();
+    const tokens = state.tokens.slice();
+    for (let t = 1; t < segment.length; ++t) {
+      const name = names.get(`-${segment[t]}`);
+      const slice = t === 1 ? [0, 2] : [t, t + 1];
+      options.push({ name, value: true });
+      tokens.push({ segmentIndex, type: `option`, option: name, slice });
+    }
+    return { ...state, options, tokens };
+  },
+  pushBound: (state, segment, segmentIndex) => {
+    const [, name, value] = segment.match(BINDING_REGEX);
+    const options = state.options.concat({ name, value });
+    const tokens = state.tokens.concat([
+      { segmentIndex, type: `option`, slice: [0, name.length], option: name },
+      { segmentIndex, type: `assign`, slice: [name.length, name.length + 1] },
+      { segmentIndex, type: `value`, slice: [name.length + 1, name.length + value.length + 1] }
+    ]);
+    return { ...state, options, tokens };
+  },
+  pushPath: (state, segment, segmentIndex) => {
+    const path2 = state.path.concat(segment);
+    const tokens = state.tokens.concat({ segmentIndex, type: `path` });
+    return { ...state, path: path2, tokens };
+  },
+  pushPositional: (state, segment, segmentIndex) => {
+    const positionals = state.positionals.concat({ value: segment, extra: false });
+    const tokens = state.tokens.concat({ segmentIndex, type: `positional` });
+    return { ...state, positionals, tokens };
+  },
+  pushExtra: (state, segment, segmentIndex) => {
+    const positionals = state.positionals.concat({ value: segment, extra: true });
+    const tokens = state.tokens.concat({ segmentIndex, type: `positional` });
+    return { ...state, positionals, tokens };
+  },
+  pushExtraNoLimits: (state, segment, segmentIndex) => {
+    const positionals = state.positionals.concat({ value: segment, extra: NoLimits });
+    const tokens = state.tokens.concat({ segmentIndex, type: `positional` });
+    return { ...state, positionals, tokens };
+  },
+  pushTrue: (state, segment, segmentIndex, name) => {
+    const options = state.options.concat({ name, value: true });
+    const tokens = state.tokens.concat({ segmentIndex, type: `option`, option: name });
+    return { ...state, options, tokens };
+  },
+  pushFalse: (state, segment, segmentIndex, name) => {
+    const options = state.options.concat({ name, value: false });
+    const tokens = state.tokens.concat({ segmentIndex, type: `option`, option: name });
+    return { ...state, options, tokens };
+  },
+  pushUndefined: (state, segment, segmentIndex, name) => {
+    const options = state.options.concat({ name: segment, value: void 0 });
+    const tokens = state.tokens.concat({ segmentIndex, type: `option`, option: segment });
+    return { ...state, options, tokens };
+  },
+  pushStringValue: (state, segment, segmentIndex) => {
+    var _a;
+    const lastOption = state.options[state.options.length - 1];
+    const options = state.options.slice();
+    const tokens = state.tokens.concat({ segmentIndex, type: `value` });
+    lastOption.value = ((_a = lastOption.value) !== null && _a !== void 0 ? _a : []).concat([segment]);
+    return { ...state, options, tokens };
+  },
+  setStringValue: (state, segment, segmentIndex) => {
+    const lastOption = state.options[state.options.length - 1];
+    const options = state.options.slice();
+    const tokens = state.tokens.concat({ segmentIndex, type: `value` });
+    lastOption.value = segment;
+    return { ...state, options, tokens };
+  },
+  inhibateOptions: (state) => {
+    return { ...state, ignoreOptions: true };
+  },
+  useHelp: (state, segment, segmentIndex, command) => {
+    const [
+      ,
+      /* name */
+      ,
+      index
+    ] = segment.match(HELP_REGEX);
+    if (typeof index !== `undefined`) {
+      return { ...state, options: [{ name: `-c`, value: String(command) }, { name: `-i`, value: index }] };
+    } else {
+      return { ...state, options: [{ name: `-c`, value: String(command) }] };
+    }
+  },
+  setError: (state, segment, segmentIndex, errorMessage) => {
+    if (segment === SpecialToken.EndOfInput || segment === SpecialToken.EndOfPartialInput) {
+      return { ...state, errorMessage: `${errorMessage}.` };
+    } else {
+      return { ...state, errorMessage: `${errorMessage} ("${segment}").` };
+    }
+  },
+  setOptionArityError: (state, segment) => {
+    const lastOption = state.options[state.options.length - 1];
+    return { ...state, errorMessage: `Not enough arguments to option ${lastOption.name}.` };
+  }
+};
+var NoLimits = Symbol();
+var CommandBuilder = class {
+  constructor(cliIndex, cliOpts) {
+    this.allOptionNames = /* @__PURE__ */ new Map();
+    this.arity = { leading: [], trailing: [], extra: [], proxy: false };
+    this.options = [];
+    this.paths = [];
+    this.cliIndex = cliIndex;
+    this.cliOpts = cliOpts;
+  }
+  addPath(path2) {
+    this.paths.push(path2);
+  }
+  setArity({ leading = this.arity.leading, trailing = this.arity.trailing, extra = this.arity.extra, proxy = this.arity.proxy }) {
+    Object.assign(this.arity, { leading, trailing, extra, proxy });
+  }
+  addPositional({ name = `arg`, required = true } = {}) {
+    if (!required && this.arity.extra === NoLimits)
+      throw new Error(`Optional parameters cannot be declared when using .rest() or .proxy()`);
+    if (!required && this.arity.trailing.length > 0)
+      throw new Error(`Optional parameters cannot be declared after the required trailing positional arguments`);
+    if (!required && this.arity.extra !== NoLimits) {
+      this.arity.extra.push(name);
+    } else if (this.arity.extra !== NoLimits && this.arity.extra.length === 0) {
+      this.arity.leading.push(name);
+    } else {
+      this.arity.trailing.push(name);
+    }
+  }
+  addRest({ name = `arg`, required = 0 } = {}) {
+    if (this.arity.extra === NoLimits)
+      throw new Error(`Infinite lists cannot be declared multiple times in the same command`);
+    if (this.arity.trailing.length > 0)
+      throw new Error(`Infinite lists cannot be declared after the required trailing positional arguments`);
+    for (let t = 0; t < required; ++t)
+      this.addPositional({ name });
+    this.arity.extra = NoLimits;
+  }
+  addProxy({ required = 0 } = {}) {
+    this.addRest({ required });
+    this.arity.proxy = true;
+  }
+  addOption({ names: nameSet, description, arity = 0, hidden = false, required = false, allowBinding = true }) {
+    if (!allowBinding && arity > 1)
+      throw new Error(`The arity cannot be higher than 1 when the option only supports the --arg=value syntax`);
+    if (!Number.isInteger(arity))
+      throw new Error(`The arity must be an integer, got ${arity}`);
+    if (arity < 0)
+      throw new Error(`The arity must be positive, got ${arity}`);
+    const preferredName = nameSet.reduce((longestName, name) => {
+      return name.length > longestName.length ? name : longestName;
+    }, ``);
+    for (const name of nameSet)
+      this.allOptionNames.set(name, preferredName);
+    this.options.push({ preferredName, nameSet, description, arity, hidden, required, allowBinding });
+  }
+  setContext(context) {
+    this.context = context;
+  }
+  usage({ detailed = true, inlineOptions = true } = {}) {
+    const segments = [this.cliOpts.binaryName];
+    const detailedOptionList = [];
+    if (this.paths.length > 0)
+      segments.push(...this.paths[0]);
+    if (detailed) {
+      for (const { preferredName, nameSet, arity, hidden, description, required } of this.options) {
+        if (hidden)
+          continue;
+        const args = [];
+        for (let t = 0; t < arity; ++t)
+          args.push(` #${t}`);
+        const definition = `${nameSet.join(`,`)}${args.join(``)}`;
+        if (!inlineOptions && description) {
+          detailedOptionList.push({ preferredName, nameSet, definition, description, required });
+        } else {
+          segments.push(required ? `<${definition}>` : `[${definition}]`);
+        }
+      }
+      segments.push(...this.arity.leading.map((name) => `<${name}>`));
+      if (this.arity.extra === NoLimits)
+        segments.push(`...`);
+      else
+        segments.push(...this.arity.extra.map((name) => `[${name}]`));
+      segments.push(...this.arity.trailing.map((name) => `<${name}>`));
+    }
+    const usage = segments.join(` `);
+    return { usage, options: detailedOptionList };
+  }
+  compile() {
+    if (typeof this.context === `undefined`)
+      throw new Error(`Assertion failed: No context attached`);
+    const machine = makeStateMachine();
+    let firstNode = NodeType.InitialNode;
+    const candidateUsage = this.usage().usage;
+    const requiredOptions = this.options.filter((opt) => opt.required).map((opt) => opt.nameSet);
+    firstNode = injectNode(machine, makeNode());
+    registerStatic(machine, NodeType.InitialNode, SpecialToken.StartOfInput, firstNode, [`setCandidateState`, { candidateUsage, requiredOptions }]);
+    const positionalArgument = this.arity.proxy ? `always` : `isNotOptionLike`;
+    const paths = this.paths.length > 0 ? this.paths : [[]];
+    for (const path2 of paths) {
+      let lastPathNode = firstNode;
+      if (path2.length > 0) {
+        const optionPathNode = injectNode(machine, makeNode());
+        registerShortcut(machine, lastPathNode, optionPathNode);
+        this.registerOptions(machine, optionPathNode);
+        lastPathNode = optionPathNode;
+      }
+      for (let t = 0; t < path2.length; ++t) {
+        const nextPathNode = injectNode(machine, makeNode());
+        registerStatic(machine, lastPathNode, path2[t], nextPathNode, `pushPath`);
+        lastPathNode = nextPathNode;
+        if (t + 1 < path2.length) {
+          const helpNode = injectNode(machine, makeNode());
+          registerDynamic(machine, lastPathNode, `isHelp`, helpNode, [`useHelp`, this.cliIndex]);
+          registerStatic(machine, helpNode, SpecialToken.EndOfInput, NodeType.SuccessNode, [`setSelectedIndex`, HELP_COMMAND_INDEX]);
+        }
+      }
+      if (this.arity.leading.length > 0 || !this.arity.proxy) {
+        const helpNode = injectNode(machine, makeNode());
+        registerDynamic(machine, lastPathNode, `isHelp`, helpNode, [`useHelp`, this.cliIndex]);
+        registerDynamic(machine, helpNode, `always`, helpNode, `pushExtra`);
+        registerStatic(machine, helpNode, SpecialToken.EndOfInput, NodeType.SuccessNode, [`setSelectedIndex`, HELP_COMMAND_INDEX]);
+        this.registerOptions(machine, lastPathNode);
+      }
+      if (this.arity.leading.length > 0) {
+        registerStatic(machine, lastPathNode, SpecialToken.EndOfInput, NodeType.ErrorNode, [`setError`, `Not enough positional arguments`]);
+        registerStatic(machine, lastPathNode, SpecialToken.EndOfPartialInput, NodeType.SuccessNode, [`setSelectedIndex`, this.cliIndex]);
+      }
+      let lastLeadingNode = lastPathNode;
+      for (let t = 0; t < this.arity.leading.length; ++t) {
+        const nextLeadingNode = injectNode(machine, makeNode());
+        if (!this.arity.proxy || t + 1 !== this.arity.leading.length)
+          this.registerOptions(machine, nextLeadingNode);
+        if (this.arity.trailing.length > 0 || t + 1 !== this.arity.leading.length) {
+          registerStatic(machine, nextLeadingNode, SpecialToken.EndOfInput, NodeType.ErrorNode, [`setError`, `Not enough positional arguments`]);
+          registerStatic(machine, nextLeadingNode, SpecialToken.EndOfPartialInput, NodeType.SuccessNode, [`setSelectedIndex`, this.cliIndex]);
+        }
+        registerDynamic(machine, lastLeadingNode, `isNotOptionLike`, nextLeadingNode, `pushPositional`);
+        lastLeadingNode = nextLeadingNode;
+      }
+      let lastExtraNode = lastLeadingNode;
+      if (this.arity.extra === NoLimits || this.arity.extra.length > 0) {
+        const extraShortcutNode = injectNode(machine, makeNode());
+        registerShortcut(machine, lastLeadingNode, extraShortcutNode);
+        if (this.arity.extra === NoLimits) {
+          const extraNode = injectNode(machine, makeNode());
+          if (!this.arity.proxy)
+            this.registerOptions(machine, extraNode);
+          registerDynamic(machine, lastLeadingNode, positionalArgument, extraNode, `pushExtraNoLimits`);
+          registerDynamic(machine, extraNode, positionalArgument, extraNode, `pushExtraNoLimits`);
+          registerShortcut(machine, extraNode, extraShortcutNode);
+        } else {
+          for (let t = 0; t < this.arity.extra.length; ++t) {
+            const nextExtraNode = injectNode(machine, makeNode());
+            if (!this.arity.proxy || t > 0)
+              this.registerOptions(machine, nextExtraNode);
+            registerDynamic(machine, lastExtraNode, positionalArgument, nextExtraNode, `pushExtra`);
+            registerShortcut(machine, nextExtraNode, extraShortcutNode);
+            lastExtraNode = nextExtraNode;
+          }
+        }
+        lastExtraNode = extraShortcutNode;
+      }
+      if (this.arity.trailing.length > 0) {
+        registerStatic(machine, lastExtraNode, SpecialToken.EndOfInput, NodeType.ErrorNode, [`setError`, `Not enough positional arguments`]);
+        registerStatic(machine, lastExtraNode, SpecialToken.EndOfPartialInput, NodeType.SuccessNode, [`setSelectedIndex`, this.cliIndex]);
+      }
+      let lastTrailingNode = lastExtraNode;
+      for (let t = 0; t < this.arity.trailing.length; ++t) {
+        const nextTrailingNode = injectNode(machine, makeNode());
+        if (!this.arity.proxy)
+          this.registerOptions(machine, nextTrailingNode);
+        if (t + 1 < this.arity.trailing.length) {
+          registerStatic(machine, nextTrailingNode, SpecialToken.EndOfInput, NodeType.ErrorNode, [`setError`, `Not enough positional arguments`]);
+          registerStatic(machine, nextTrailingNode, SpecialToken.EndOfPartialInput, NodeType.SuccessNode, [`setSelectedIndex`, this.cliIndex]);
+        }
+        registerDynamic(machine, lastTrailingNode, `isNotOptionLike`, nextTrailingNode, `pushPositional`);
+        lastTrailingNode = nextTrailingNode;
+      }
+      registerDynamic(machine, lastTrailingNode, positionalArgument, NodeType.ErrorNode, [`setError`, `Extraneous positional argument`]);
+      registerStatic(machine, lastTrailingNode, SpecialToken.EndOfInput, NodeType.SuccessNode, [`setSelectedIndex`, this.cliIndex]);
+      registerStatic(machine, lastTrailingNode, SpecialToken.EndOfPartialInput, NodeType.SuccessNode, [`setSelectedIndex`, this.cliIndex]);
+    }
+    return {
+      machine,
+      context: this.context
+    };
+  }
+  registerOptions(machine, node) {
+    registerDynamic(machine, node, [`isOption`, `--`], node, `inhibateOptions`);
+    registerDynamic(machine, node, [`isBatchOption`, this.allOptionNames], node, [`pushBatch`, this.allOptionNames]);
+    registerDynamic(machine, node, [`isBoundOption`, this.allOptionNames, this.options], node, `pushBound`);
+    registerDynamic(machine, node, [`isUnsupportedOption`, this.allOptionNames], NodeType.ErrorNode, [`setError`, `Unsupported option name`]);
+    registerDynamic(machine, node, [`isInvalidOption`], NodeType.ErrorNode, [`setError`, `Invalid option name`]);
+    for (const option of this.options) {
+      if (option.arity === 0) {
+        for (const name of option.nameSet) {
+          registerDynamic(machine, node, [`isOption`, name], node, [`pushTrue`, option.preferredName]);
+          if (name.startsWith(`--`) && !name.startsWith(`--no-`)) {
+            registerDynamic(machine, node, [`isNegatedOption`, name], node, [`pushFalse`, option.preferredName]);
+          }
+        }
+      } else {
+        let lastNode = injectNode(machine, makeNode());
+        for (const name of option.nameSet)
+          registerDynamic(machine, node, [`isOption`, name], lastNode, [`pushUndefined`, option.preferredName]);
+        for (let t = 0; t < option.arity; ++t) {
+          const nextNode = injectNode(machine, makeNode());
+          registerStatic(machine, lastNode, SpecialToken.EndOfInput, NodeType.ErrorNode, `setOptionArityError`);
+          registerStatic(machine, lastNode, SpecialToken.EndOfPartialInput, NodeType.ErrorNode, `setOptionArityError`);
+          registerDynamic(machine, lastNode, `isOptionLike`, NodeType.ErrorNode, `setOptionArityError`);
+          const action = option.arity === 1 ? `setStringValue` : `pushStringValue`;
+          registerDynamic(machine, lastNode, `isNotOptionLike`, nextNode, action);
+          lastNode = nextNode;
+        }
+        registerShortcut(machine, lastNode, node);
+      }
+    }
+  }
+};
+var CliBuilder = class _CliBuilder {
+  static build(cbs, opts = {}) {
+    return new _CliBuilder(opts).commands(cbs).compile();
+  }
+  constructor({ binaryName = `...` } = {}) {
+    this.builders = [];
+    this.opts = { binaryName };
+  }
+  getBuilderByIndex(n) {
+    if (!(n >= 0 && n < this.builders.length))
+      throw new Error(`Assertion failed: Out-of-bound command index (${n})`);
+    return this.builders[n];
+  }
+  commands(cbs) {
+    for (const cb of cbs)
+      cb(this.command());
+    return this;
+  }
+  command() {
+    const builder = new CommandBuilder(this.builders.length, this.opts);
+    this.builders.push(builder);
+    return builder;
+  }
+  compile() {
+    const machines = [];
+    const contexts = [];
+    for (const builder of this.builders) {
+      const { machine: machine2, context } = builder.compile();
+      machines.push(machine2);
+      contexts.push(context);
+    }
+    const machine = makeAnyOfMachine(machines);
+    simplifyMachine(machine);
+    return {
+      machine,
+      contexts,
+      process: (input, { partial } = {}) => {
+        const endToken = partial ? SpecialToken.EndOfPartialInput : SpecialToken.EndOfInput;
+        return runMachine(machine, input, { endToken });
+      }
+    };
+  }
+};
+
+// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/format.mjs
+init_cjs_shims();
+var MAX_LINE_LENGTH = 80;
+var richLine = Array(MAX_LINE_LENGTH).fill(`\u2501`);
+for (let t = 0; t <= 24; ++t)
+  richLine[richLine.length - t] = `\x1B[38;5;${232 + t}m\u2501`;
+var richFormat = {
+  header: (str) => `\x1B[1m\u2501\u2501\u2501 ${str}${str.length < MAX_LINE_LENGTH - 5 ? ` ${richLine.slice(str.length + 5).join(``)}` : `:`}\x1B[0m`,
+  bold: (str) => `\x1B[1m${str}\x1B[22m`,
+  error: (str) => `\x1B[31m\x1B[1m${str}\x1B[22m\x1B[39m`,
+  code: (str) => `\x1B[36m${str}\x1B[39m`
+};
+var textFormat = {
+  header: (str) => str,
+  bold: (str) => str,
+  error: (str) => str,
+  code: (str) => str
+};
+function dedent(text) {
+  const lines = text.split(`
+`);
+  const nonEmptyLines = lines.filter((line) => line.match(/\S/));
+  const indent = nonEmptyLines.length > 0 ? nonEmptyLines.reduce((minLength, line) => Math.min(minLength, line.length - line.trimStart().length), Number.MAX_VALUE) : 0;
+  return lines.map((line) => line.slice(indent).trimRight()).join(`
+`);
+}
+function formatMarkdownish(text, { format, paragraphs }) {
+  text = text.replace(/\r\n?/g, `
+`);
+  text = dedent(text);
+  text = text.replace(/^\n+|\n+$/g, ``);
+  text = text.replace(/^(\s*)-([^\n]*?)\n+/gm, `$1-$2
+
+`);
+  text = text.replace(/\n(\n)?\n*/g, ($0, $1) => $1 ? $1 : ` `);
+  if (paragraphs) {
+    text = text.split(/\n/).map((paragraph) => {
+      const bulletMatch = paragraph.match(/^\s*[*-][\t ]+(.*)/);
+      if (!bulletMatch)
+        return paragraph.match(/(.{1,80})(?: |$)/g).join(`
+`);
+      const indent = paragraph.length - paragraph.trimStart().length;
+      return bulletMatch[1].match(new RegExp(`(.{1,${78 - indent}})(?: |$)`, `g`)).map((line, index) => {
+        return ` `.repeat(indent) + (index === 0 ? `- ` : `  `) + line;
+      }).join(`
+`);
+    }).join(`
+
+`);
+  }
+  text = text.replace(/(`+)((?:.|[\n])*?)\1/g, ($0, $1, $2) => {
+    return format.code($1 + $2 + $1);
+  });
+  text = text.replace(/(\*\*)((?:.|[\n])*?)\1/g, ($0, $1, $2) => {
+    return format.bold($1 + $2 + $1);
+  });
+  return text ? `${text}
+` : ``;
+}
+
+// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/advanced/HelpCommand.mjs
+init_cjs_shims();
+var HelpCommand = class _HelpCommand extends Command {
+  static from(state, contexts) {
+    const command = new _HelpCommand(contexts);
+    command.path = state.path;
+    for (const opt of state.options) {
+      switch (opt.name) {
+        case `-c`:
+          {
+            command.commands.push(Number(opt.value));
+          }
+          break;
+        case `-i`:
+          {
+            command.index = Number(opt.value);
+          }
+          break;
+      }
+    }
+    return command;
+  }
+  constructor(contexts) {
+    super();
+    this.contexts = contexts;
+    this.commands = [];
+  }
+  async execute() {
+    let commands = this.commands;
+    if (typeof this.index !== `undefined` && this.index >= 0 && this.index < commands.length)
+      commands = [commands[this.index]];
+    if (commands.length === 0) {
+      this.context.stdout.write(this.cli.usage());
+    } else if (commands.length === 1) {
+      this.context.stdout.write(this.cli.usage(this.contexts[commands[0]].commandClass, { detailed: true }));
+    } else if (commands.length > 1) {
+      this.context.stdout.write(`Multiple commands match your selection:
+`);
+      this.context.stdout.write(`
+`);
+      let index = 0;
+      for (const command of this.commands)
+        this.context.stdout.write(this.cli.usage(this.contexts[command].commandClass, { prefix: `${index++}. `.padStart(5) }));
+      this.context.stdout.write(`
+`);
+      this.context.stdout.write(`Run again with -h=<index> to see the longer details of any of those commands.
+`);
+    }
+  }
+};
+
+// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/advanced/Cli.mjs
+var errorCommandSymbol = Symbol(`clipanion/errorCommand`);
+var Cli = class _Cli {
+  /**
+   * Creates a new Cli and registers all commands passed as parameters.
+   *
+   * @param commandClasses The Commands to register
+   * @returns The created `Cli` instance
+   */
+  static from(commandClasses, options = {}) {
+    const cli2 = new _Cli(options);
+    const resolvedCommandClasses = Array.isArray(commandClasses) ? commandClasses : [commandClasses];
+    for (const commandClass of resolvedCommandClasses)
+      cli2.register(commandClass);
+    return cli2;
+  }
+  constructor({ binaryLabel, binaryName: binaryNameOpt = `...`, binaryVersion, enableCapture = false, enableColors } = {}) {
+    this.registrations = /* @__PURE__ */ new Map();
+    this.builder = new CliBuilder({ binaryName: binaryNameOpt });
+    this.binaryLabel = binaryLabel;
+    this.binaryName = binaryNameOpt;
+    this.binaryVersion = binaryVersion;
+    this.enableCapture = enableCapture;
+    this.enableColors = enableColors;
+  }
+  /**
+   * Registers a command inside the CLI.
+   */
+  register(commandClass) {
+    var _a;
+    if (this.registrations.has(commandClass))
+      throw new RangeError(`${commandClass.name} has already been registered`);
+    const specs = /* @__PURE__ */ new Map();
+    const command = new commandClass();
+    for (const key in command) {
+      const value = command[key];
+      if (typeof value === `object` && value !== null && value[Command.isOption]) {
+        specs.set(key, value);
+      }
+    }
+    const builder = this.builder.command();
+    const index = builder.cliIndex;
+    const paths = (_a = commandClass.paths) !== null && _a !== void 0 ? _a : command.paths;
+    if (typeof paths !== `undefined`)
+      for (const path2 of paths)
+        builder.addPath(path2);
+    this.registrations.set(commandClass, { specs, builder, index });
+    for (const [key, { definition }] of specs.entries())
+      definition(builder, key);
+    builder.setContext({
+      commandClass
+    });
+  }
+  process(opts, contextArg) {
+    const { input, context: userContext, partial } = typeof opts === `object` && Array.isArray(opts) ? { input: opts, context: contextArg } : opts;
+    const { contexts, process: process2 } = this.builder.compile();
+    const state = process2(input, { partial });
+    const context = {
+      ..._Cli.defaultContext,
+      ...userContext
+    };
+    switch (state.selectedIndex) {
+      case HELP_COMMAND_INDEX: {
+        const command = HelpCommand.from(state, contexts);
+        command.context = context;
+        command.tokens = state.tokens;
+        return command;
+      }
+      default:
+        {
+          const { commandClass } = contexts[state.selectedIndex];
+          const record = this.registrations.get(commandClass);
+          if (typeof record === `undefined`)
+            throw new Error(`Assertion failed: Expected the command class to have been registered.`);
+          const command = new commandClass();
+          command.context = context;
+          command.tokens = state.tokens;
+          command.path = state.path;
+          try {
+            for (const [key, { transformer }] of record.specs.entries())
+              command[key] = transformer(record.builder, key, state, context);
+            return command;
+          } catch (error) {
+            error[errorCommandSymbol] = command;
+            throw error;
+          }
+        }
+        break;
+    }
+  }
+  async run(input, userContext) {
+    var _a, _b;
+    let command;
+    const context = {
+      ..._Cli.defaultContext,
+      ...userContext
+    };
+    const colored = (_a = this.enableColors) !== null && _a !== void 0 ? _a : context.colorDepth > 1;
+    if (!Array.isArray(input)) {
+      command = input;
+    } else {
+      try {
+        command = this.process(input, context);
+      } catch (error) {
+        context.stdout.write(this.error(error, { colored }));
+        return 1;
+      }
+    }
+    if (command.help) {
+      context.stdout.write(this.usage(command, { colored, detailed: true }));
+      return 0;
+    }
+    command.context = context;
+    command.cli = {
+      binaryLabel: this.binaryLabel,
+      binaryName: this.binaryName,
+      binaryVersion: this.binaryVersion,
+      enableCapture: this.enableCapture,
+      enableColors: this.enableColors,
+      definitions: () => this.definitions(),
+      definition: (command2) => this.definition(command2),
+      error: (error, opts) => this.error(error, opts),
+      format: (colored2) => this.format(colored2),
+      process: (input2, subContext) => this.process(input2, { ...context, ...subContext }),
+      run: (input2, subContext) => this.run(input2, { ...context, ...subContext }),
+      usage: (command2, opts) => this.usage(command2, opts)
+    };
+    const activate = this.enableCapture ? (_b = getCaptureActivator(context)) !== null && _b !== void 0 ? _b : noopCaptureActivator : noopCaptureActivator;
+    let exitCode;
+    try {
+      exitCode = await activate(() => command.validateAndExecute().catch((error) => command.catch(error).then(() => 0)));
+    } catch (error) {
+      context.stdout.write(this.error(error, { colored, command }));
+      return 1;
+    }
+    return exitCode;
+  }
+  async runExit(input, context) {
+    process.exitCode = await this.run(input, context);
+  }
+  definition(commandClass, { colored = false } = {}) {
+    if (!commandClass.usage)
+      return null;
+    const { usage: path2 } = this.getUsageByRegistration(commandClass, { detailed: false });
+    const { usage, options } = this.getUsageByRegistration(commandClass, { detailed: true, inlineOptions: false });
+    const category = typeof commandClass.usage.category !== `undefined` ? formatMarkdownish(commandClass.usage.category, { format: this.format(colored), paragraphs: false }) : void 0;
+    const description = typeof commandClass.usage.description !== `undefined` ? formatMarkdownish(commandClass.usage.description, { format: this.format(colored), paragraphs: false }) : void 0;
+    const details = typeof commandClass.usage.details !== `undefined` ? formatMarkdownish(commandClass.usage.details, { format: this.format(colored), paragraphs: true }) : void 0;
+    const examples = typeof commandClass.usage.examples !== `undefined` ? commandClass.usage.examples.map(([label, cli2]) => [formatMarkdownish(label, { format: this.format(colored), paragraphs: false }), cli2.replace(/\$0/g, this.binaryName)]) : void 0;
+    return { path: path2, usage, category, description, details, examples, options };
+  }
+  definitions({ colored = false } = {}) {
+    const data = [];
+    for (const commandClass of this.registrations.keys()) {
+      const usage = this.definition(commandClass, { colored });
+      if (!usage)
+        continue;
+      data.push(usage);
+    }
+    return data;
+  }
+  usage(command = null, { colored, detailed = false, prefix = `$ ` } = {}) {
+    var _a;
+    if (command === null) {
+      for (const commandClass2 of this.registrations.keys()) {
+        const paths = commandClass2.paths;
+        const isDocumented = typeof commandClass2.usage !== `undefined`;
+        const isExclusivelyDefault = !paths || paths.length === 0 || paths.length === 1 && paths[0].length === 0;
+        const isDefault = isExclusivelyDefault || ((_a = paths === null || paths === void 0 ? void 0 : paths.some((path2) => path2.length === 0)) !== null && _a !== void 0 ? _a : false);
+        if (isDefault) {
+          if (command) {
+            command = null;
+            break;
+          } else {
+            command = commandClass2;
+          }
+        } else {
+          if (isDocumented) {
+            command = null;
+            continue;
+          }
+        }
+      }
+      if (command) {
+        detailed = true;
+      }
+    }
+    const commandClass = command !== null && command instanceof Command ? command.constructor : command;
+    let result = ``;
+    if (!commandClass) {
+      const commandsByCategories = /* @__PURE__ */ new Map();
+      for (const [commandClass2, { index }] of this.registrations.entries()) {
+        if (typeof commandClass2.usage === `undefined`)
+          continue;
+        const category = typeof commandClass2.usage.category !== `undefined` ? formatMarkdownish(commandClass2.usage.category, { format: this.format(colored), paragraphs: false }) : null;
+        let categoryCommands = commandsByCategories.get(category);
+        if (typeof categoryCommands === `undefined`)
+          commandsByCategories.set(category, categoryCommands = []);
+        const { usage } = this.getUsageByIndex(index);
+        categoryCommands.push({ commandClass: commandClass2, usage });
+      }
+      const categoryNames = Array.from(commandsByCategories.keys()).sort((a, b) => {
+        if (a === null)
+          return -1;
+        if (b === null)
+          return 1;
+        return a.localeCompare(b, `en`, { usage: `sort`, caseFirst: `upper` });
+      });
+      const hasLabel = typeof this.binaryLabel !== `undefined`;
+      const hasVersion = typeof this.binaryVersion !== `undefined`;
+      if (hasLabel || hasVersion) {
+        if (hasLabel && hasVersion)
+          result += `${this.format(colored).header(`${this.binaryLabel} - ${this.binaryVersion}`)}
+
+`;
+        else if (hasLabel)
+          result += `${this.format(colored).header(`${this.binaryLabel}`)}
+`;
+        else
+          result += `${this.format(colored).header(`${this.binaryVersion}`)}
+`;
+        result += `  ${this.format(colored).bold(prefix)}${this.binaryName} <command>
+`;
+      } else {
+        result += `${this.format(colored).bold(prefix)}${this.binaryName} <command>
+`;
+      }
+      for (const categoryName of categoryNames) {
+        const commands = commandsByCategories.get(categoryName).slice().sort((a, b) => {
+          return a.usage.localeCompare(b.usage, `en`, { usage: `sort`, caseFirst: `upper` });
+        });
+        const header = categoryName !== null ? categoryName.trim() : `General commands`;
+        result += `
+`;
+        result += `${this.format(colored).header(`${header}`)}
+`;
+        for (const { commandClass: commandClass2, usage } of commands) {
+          const doc = commandClass2.usage.description || `undocumented`;
+          result += `
+`;
+          result += `  ${this.format(colored).bold(usage)}
+`;
+          result += `    ${formatMarkdownish(doc, { format: this.format(colored), paragraphs: false })}`;
+        }
+      }
+      result += `
+`;
+      result += formatMarkdownish(`You can also print more details about any of these commands by calling them with the \`-h,--help\` flag right after the command name.`, { format: this.format(colored), paragraphs: true });
+    } else {
+      if (!detailed) {
+        const { usage } = this.getUsageByRegistration(commandClass);
+        result += `${this.format(colored).bold(prefix)}${usage}
+`;
+      } else {
+        const { description = ``, details = ``, examples = [] } = commandClass.usage || {};
+        if (description !== ``) {
+          result += formatMarkdownish(description, { format: this.format(colored), paragraphs: false }).replace(/^./, ($0) => $0.toUpperCase());
+          result += `
+`;
+        }
+        if (details !== `` || examples.length > 0) {
+          result += `${this.format(colored).header(`Usage`)}
+`;
+          result += `
+`;
+        }
+        const { usage, options } = this.getUsageByRegistration(commandClass, { inlineOptions: false });
+        result += `${this.format(colored).bold(prefix)}${usage}
+`;
+        if (options.length > 0) {
+          result += `
+`;
+          result += `${this.format(colored).header(`Options`)}
+`;
+          const maxDefinitionLength = options.reduce((length, option) => {
+            return Math.max(length, option.definition.length);
+          }, 0);
+          result += `
+`;
+          for (const { definition, description: description2 } of options) {
+            result += `  ${this.format(colored).bold(definition.padEnd(maxDefinitionLength))}    ${formatMarkdownish(description2, { format: this.format(colored), paragraphs: false })}`;
+          }
+        }
+        if (details !== ``) {
+          result += `
+`;
+          result += `${this.format(colored).header(`Details`)}
+`;
+          result += `
+`;
+          result += formatMarkdownish(details, { format: this.format(colored), paragraphs: true });
+        }
+        if (examples.length > 0) {
+          result += `
+`;
+          result += `${this.format(colored).header(`Examples`)}
+`;
+          for (const [description2, example] of examples) {
+            result += `
+`;
+            result += formatMarkdownish(description2, { format: this.format(colored), paragraphs: false });
+            result += `${example.replace(/^/m, `  ${this.format(colored).bold(prefix)}`).replace(/\$0/g, this.binaryName)}
+`;
+          }
+        }
+      }
+    }
+    return result;
+  }
+  error(error, _a) {
+    var _b;
+    var { colored, command = (_b = error[errorCommandSymbol]) !== null && _b !== void 0 ? _b : null } = _a === void 0 ? {} : _a;
+    if (!error || typeof error !== `object` || !(`stack` in error))
+      error = new Error(`Execution failed with a non-error rejection (rejected value: ${JSON.stringify(error)})`);
+    let result = ``;
+    let name = error.name.replace(/([a-z])([A-Z])/g, `$1 $2`);
+    if (name === `Error`)
+      name = `Internal Error`;
+    result += `${this.format(colored).error(name)}: ${error.message}
+`;
+    const meta = error.clipanion;
+    if (typeof meta !== `undefined`) {
+      if (meta.type === `usage`) {
+        result += `
+`;
+        result += this.usage(command);
+      }
+    } else {
+      if (error.stack) {
+        result += `${error.stack.replace(/^.*\n/, ``)}
+`;
+      }
+    }
+    return result;
+  }
+  format(colored) {
+    var _a;
+    return ((_a = colored !== null && colored !== void 0 ? colored : this.enableColors) !== null && _a !== void 0 ? _a : _Cli.defaultContext.colorDepth > 1) ? richFormat : textFormat;
+  }
+  getUsageByRegistration(klass, opts) {
+    const record = this.registrations.get(klass);
+    if (typeof record === `undefined`)
+      throw new Error(`Assertion failed: Unregistered command`);
+    return this.getUsageByIndex(record.index, opts);
+  }
+  getUsageByIndex(n, opts) {
+    return this.builder.getBuilderByIndex(n).usage(opts);
+  }
+};
+Cli.defaultContext = {
+  env: process.env,
+  stdin: process.stdin,
+  stdout: process.stdout,
+  stderr: process.stderr,
+  colorDepth: getDefaultColorDepth()
+};
+function noopCaptureActivator(fn) {
+  return fn();
+}
+
+// src/commands/DevCommand.ts
+init_cjs_shims();
+
+// ../../.yarn/__virtual__/@hono-node-server-virtual-cf2888014c/0/cache/@hono-node-server-npm-1.13.8-e78cfff928-5880892fdd.zip/node_modules/@hono/node-server/dist/index.mjs
+init_cjs_shims();
+var import_http = require("http");
+var import_http2 = require("http2");
+var import_stream = require("stream");
+var import_crypto = __toESM(require("crypto"), 1);
+var RequestError = class extends Error {
+  static name = "RequestError";
+  constructor(message, options) {
+    super(message, options);
+  }
+};
+var toRequestError = (e) => {
+  if (e instanceof RequestError) {
+    return e;
+  }
+  return new RequestError(e.message, { cause: e });
+};
+var GlobalRequest = global.Request;
+var Request2 = class extends GlobalRequest {
+  constructor(input, options) {
+    if (typeof input === "object" && getRequestCache in input) {
+      input = input[getRequestCache]();
+    }
+    if (typeof options?.body?.getReader !== "undefined") {
+      ;
+      options.duplex ??= "half";
+    }
+    super(input, options);
+  }
+};
+var newRequestFromIncoming = (method, url, incoming, abortController) => {
+  const headerRecord = [];
+  const rawHeaders = incoming.rawHeaders;
+  for (let i = 0; i < rawHeaders.length; i += 2) {
+    const { [i]: key, [i + 1]: value } = rawHeaders;
+    if (key.charCodeAt(0) !== /*:*/
+    58) {
+      headerRecord.push([key, value]);
+    }
+  }
+  const init = {
+    method,
+    headers: headerRecord,
+    signal: abortController.signal
+  };
+  if (method === "TRACE") {
+    init.method = "GET";
+    const req = new Request2(url, init);
+    Object.defineProperty(req, "method", {
+      get() {
+        return "TRACE";
+      }
+    });
+    return req;
+  }
+  if (!(method === "GET" || method === "HEAD")) {
+    if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) {
+      init.body = new ReadableStream({
+        start(controller) {
+          controller.enqueue(incoming.rawBody);
+          controller.close();
+        }
+      });
+    } else {
+      init.body = import_stream.Readable.toWeb(incoming);
+    }
+  }
+  return new Request2(url, init);
+};
+var getRequestCache = Symbol("getRequestCache");
+var requestCache = Symbol("requestCache");
+var incomingKey = Symbol("incomingKey");
+var urlKey = Symbol("urlKey");
+var abortControllerKey = Symbol("abortControllerKey");
+var getAbortController = Symbol("getAbortController");
+var requestPrototype = {
+  get method() {
+    return this[incomingKey].method || "GET";
+  },
+  get url() {
+    return this[urlKey];
+  },
+  [getAbortController]() {
+    this[getRequestCache]();
+    return this[abortControllerKey];
+  },
+  [getRequestCache]() {
+    this[abortControllerKey] ||= new AbortController();
+    return this[requestCache] ||= newRequestFromIncoming(
+      this.method,
+      this[urlKey],
+      this[incomingKey],
+      this[abortControllerKey]
+    );
+  }
+};
+[
+  "body",
+  "bodyUsed",
+  "cache",
+  "credentials",
+  "destination",
+  "headers",
+  "integrity",
+  "mode",
+  "redirect",
+  "referrer",
+  "referrerPolicy",
+  "signal",
+  "keepalive"
+].forEach((k) => {
+  Object.defineProperty(requestPrototype, k, {
+    get() {
+      return this[getRequestCache]()[k];
+    }
+  });
+});
+["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+  Object.defineProperty(requestPrototype, k, {
+    value: function() {
+      return this[getRequestCache]()[k]();
+    }
+  });
+});
+Object.setPrototypeOf(requestPrototype, Request2.prototype);
+var newRequest = (incoming, defaultHostname) => {
+  const req = Object.create(requestPrototype);
+  req[incomingKey] = incoming;
+  const host = (incoming instanceof import_http2.Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
+  if (!host) {
+    throw new RequestError("Missing host header");
+  }
+  const url = new URL(
+    `${incoming instanceof import_http2.Http2ServerRequest || incoming.socket && incoming.socket.encrypted ? "https" : "http"}://${host}${incoming.url}`
+  );
+  if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
+    throw new RequestError("Invalid host header");
+  }
+  req[urlKey] = url.href;
+  return req;
+};
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  } else if (writable.destroyed) {
+    stream.cancel();
+    return;
+  }
+  const reader = stream.getReader();
+  writable.on("close", cancel);
+  writable.on("error", cancel);
+  reader.read().then(flow, cancel);
+  return reader.closed.finally(() => {
+    writable.off("close", cancel);
+    writable.off("error", cancel);
+  });
+  function cancel(error) {
+    reader.cancel(error).catch(() => {
+    });
+    if (error) {
+      writable.destroy(error);
+    }
+  }
+  function onDrain() {
+    reader.read().then(flow, cancel);
+  }
+  function flow({ done, value }) {
+    try {
+      if (done) {
+        writable.end();
+      } else if (!writable.write(value)) {
+        writable.once("drain", onDrain);
+      } else {
+        return reader.read().then(flow, cancel);
+      }
+    } catch (e) {
+      cancel(e);
+    }
+  }
+}
+var buildOutgoingHttpHeaders = (headers) => {
+  const res = {};
+  if (!(headers instanceof Headers)) {
+    headers = new Headers(headers ?? void 0);
+  }
+  const cookies = [];
+  for (const [k, v] of headers) {
+    if (k === "set-cookie") {
+      cookies.push(v);
+    } else {
+      res[k] = v;
+    }
+  }
+  if (cookies.length > 0) {
+    res["set-cookie"] = cookies;
+  }
+  res["content-type"] ??= "text/plain; charset=UTF-8";
+  return res;
+};
+var responseCache = Symbol("responseCache");
+var getResponseCache = Symbol("getResponseCache");
+var cacheKey = Symbol("cache");
+var GlobalResponse = global.Response;
+var Response2 = class _Response {
+  #body;
+  #init;
+  [getResponseCache]() {
+    delete this[cacheKey];
+    return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
+  }
+  constructor(body, init) {
+    this.#body = body;
+    if (init instanceof _Response) {
+      const cachedGlobalResponse = init[responseCache];
+      if (cachedGlobalResponse) {
+        this.#init = cachedGlobalResponse;
+        this[getResponseCache]();
+        return;
+      } else {
+        this.#init = init.#init;
+      }
+    } else {
+      this.#init = init;
+    }
+    if (typeof body === "string" || typeof body?.getReader !== "undefined") {
+      let headers = init?.headers || { "content-type": "text/plain; charset=UTF-8" };
+      if (headers instanceof Headers) {
+        headers = buildOutgoingHttpHeaders(headers);
+      }
+      ;
+      this[cacheKey] = [init?.status || 200, body, headers];
+    }
+  }
+};
+[
+  "body",
+  "bodyUsed",
+  "headers",
+  "ok",
+  "redirected",
+  "status",
+  "statusText",
+  "trailers",
+  "type",
+  "url"
+].forEach((k) => {
+  Object.defineProperty(Response2.prototype, k, {
+    get() {
+      return this[getResponseCache]()[k];
+    }
+  });
+});
+["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+  Object.defineProperty(Response2.prototype, k, {
+    value: function() {
+      return this[getResponseCache]()[k]();
+    }
+  });
+});
+Object.setPrototypeOf(Response2, GlobalResponse);
+Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
+var stateKey = Reflect.ownKeys(new GlobalResponse()).find(
+  (k) => typeof k === "symbol" && k.toString() === "Symbol(state)"
+);
+if (!stateKey) {
+  console.warn("Failed to find Response internal state key");
+}
+function getInternalBody(response) {
+  if (!stateKey) {
+    return;
+  }
+  if (response instanceof Response2) {
+    response = response[getResponseCache]();
+  }
+  const state = response[stateKey];
+  return state && state.body || void 0;
+}
+var X_ALREADY_SENT = "x-hono-already-sent";
+var webFetch = global.fetch;
+if (typeof global.crypto === "undefined") {
+  global.crypto = import_crypto.default;
+}
+global.fetch = (info, init) => {
+  init = {
+    // Disable compression handling so people can return the result of a fetch
+    // directly in the loader without messing with the Content-Encoding header.
+    compress: false,
+    ...init
+  };
+  return webFetch(info, init);
+};
+var regBuffer = /^no$/i;
+var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
+var handleRequestError = () => new Response(null, {
+  status: 400
+});
+var handleFetchError = (e) => new Response(null, {
+  status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500
+});
+var handleResponseError = (e, outgoing) => {
+  const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
+  if (err.code === "ERR_STREAM_PREMATURE_CLOSE") {
+    console.info("The user aborted a request.");
+  } else {
+    console.error(e);
+    if (!outgoing.headersSent) {
+      outgoing.writeHead(500, { "Content-Type": "text/plain" });
+    }
+    outgoing.end(`Error: ${err.message}`);
+    outgoing.destroy(err);
+  }
+};
+var responseViaCache = (res, outgoing) => {
+  const [status, body, header] = res[cacheKey];
+  if (typeof body === "string") {
+    header["Content-Length"] = Buffer.byteLength(body);
+    outgoing.writeHead(status, header);
+    outgoing.end(body);
+  } else {
+    outgoing.writeHead(status, header);
+    return writeFromReadableStream(body, outgoing)?.catch(
+      (e) => handleResponseError(e, outgoing)
+    );
+  }
+};
+var responseViaResponseObject = async (res, outgoing, options = {}) => {
+  if (res instanceof Promise) {
+    if (options.errorHandler) {
+      try {
+        res = await res;
+      } catch (err) {
+        const errRes = await options.errorHandler(err);
+        if (!errRes) {
+          return;
+        }
+        res = errRes;
+      }
+    } else {
+      res = await res.catch(handleFetchError);
+    }
+  }
+  if (cacheKey in res) {
+    return responseViaCache(res, outgoing);
+  }
+  const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
+  const internalBody = getInternalBody(res);
+  if (internalBody) {
+    const { length, source, stream } = internalBody;
+    if (source instanceof Uint8Array && source.byteLength !== length) {
+    } else {
+      if (length) {
+        resHeaderRecord["content-length"] = length;
+      }
+      outgoing.writeHead(res.status, resHeaderRecord);
+      if (typeof source === "string" || source instanceof Uint8Array) {
+        outgoing.end(source);
+      } else if (source instanceof Blob) {
+        outgoing.end(new Uint8Array(await source.arrayBuffer()));
+      } else {
+        await writeFromReadableStream(stream, outgoing);
+      }
+      return;
+    }
+  }
+  if (res.body) {
+    const {
+      "transfer-encoding": transferEncoding,
+      "content-encoding": contentEncoding,
+      "content-length": contentLength,
+      "x-accel-buffering": accelBuffering,
+      "content-type": contentType
+    } = resHeaderRecord;
+    if (transferEncoding || contentEncoding || contentLength || // nginx buffering variant
+    accelBuffering && regBuffer.test(accelBuffering) || !regContentType.test(contentType)) {
+      outgoing.writeHead(res.status, resHeaderRecord);
+      await writeFromReadableStream(res.body, outgoing);
+    } else {
+      const buffer = await res.arrayBuffer();
+      resHeaderRecord["content-length"] = buffer.byteLength;
+      outgoing.writeHead(res.status, resHeaderRecord);
+      outgoing.end(new Uint8Array(buffer));
+    }
+  } else if (resHeaderRecord[X_ALREADY_SENT]) {
+  } else {
+    outgoing.writeHead(res.status, resHeaderRecord);
+    outgoing.end();
+  }
+};
+var getRequestListener = (fetchCallback, options = {}) => {
+  if (options.overrideGlobalObjects !== false && global.Request !== Request2) {
+    Object.defineProperty(global, "Request", {
+      value: Request2
+    });
+    Object.defineProperty(global, "Response", {
+      value: Response2
+    });
+  }
+  return async (incoming, outgoing) => {
+    let res, req;
+    try {
+      req = newRequest(incoming, options.hostname);
+      outgoing.on("close", () => {
+        const abortController = req[abortControllerKey];
+        if (!abortController) {
+          return;
+        }
+        if (incoming.errored) {
+          req[abortControllerKey].abort(incoming.errored.toString());
+        } else if (!outgoing.writableFinished) {
+          req[abortControllerKey].abort("Client connection prematurely closed.");
+        }
+      });
+      res = fetchCallback(req, { incoming, outgoing });
+      if (cacheKey in res) {
+        return responseViaCache(res, outgoing);
+      }
+    } catch (e) {
+      if (!res) {
+        if (options.errorHandler) {
+          res = await options.errorHandler(req ? e : toRequestError(e));
+          if (!res) {
+            return;
+          }
+        } else if (!req) {
+          res = handleRequestError();
+        } else {
+          res = handleFetchError(e);
+        }
+      } else {
+        return handleResponseError(e, outgoing);
+      }
+    }
+    try {
+      return responseViaResponseObject(res, outgoing, options);
+    } catch (e) {
+      return handleResponseError(e, outgoing);
+    }
+  };
+};
+var createAdaptorServer = (options) => {
+  const fetchCallback = options.fetch;
+  const requestListener = getRequestListener(fetchCallback, {
+    hostname: options.hostname,
+    overrideGlobalObjects: options.overrideGlobalObjects
+  });
+  const createServer = options.createServer || import_http.createServer;
+  const server = createServer(options.serverOptions || {}, requestListener);
+  return server;
+};
+var serve = (options, listeningListener) => {
+  const server = createAdaptorServer(options);
+  server.listen(options?.port ?? 3e3, options.hostname, () => {
+    const serverInfo = server.address();
+    listeningListener && listeningListener(serverInfo);
+  });
+  return server;
+};
+
+// src/server.ts
+init_cjs_shims();
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_core2 = require("@babel/core");
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/index.js
+init_cjs_shims();
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/hono.js
+init_cjs_shims();
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/hono-base.js
+init_cjs_shims();
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/compose.js
+init_cjs_shims();
+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 handler;
+      if (middleware[i]) {
+        handler = middleware[i][0][0];
+        context.req.routeIndex = i;
+      } else {
+        handler = i === middleware.length && next || void 0;
+      }
+      if (handler) {
+        try {
+          res = await handler(context, () => dispatch(i + 1));
+        } catch (err) {
+          if (err instanceof Error && onError) {
+            context.error = err;
+            res = await onError(err, context);
+            isError = true;
+          } else {
+            throw err;
+          }
+        }
+      } else {
+        if (context.finalized === false && onNotFound) {
+          res = await onNotFound(context);
+        }
+      }
+      if (res && (context.finalized === false || isError)) {
+        context.res = res;
+      }
+      return context;
+    }
+  };
+};
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/context.js
+init_cjs_shims();
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/request.js
+init_cjs_shims();
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/utils/body.js
+init_cjs_shims();
+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];
+    }
+  });
+};
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/utils/url.js
+init_cjs_shims();
+var splitPath = (path2) => {
+  const paths = path2.split("/");
+  if (paths[0] === "") {
+    paths.shift();
+  }
+  return paths;
+};
+var splitRoutingPath = (routePath) => {
+  const { groups, path: path2 } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path2);
+  return replaceGroupMarks(paths, groups);
+};
+var extractGroupsFromPath = (path2) => {
+  const groups = [];
+  path2 = path2.replace(/\{[^}]+\}/g, (match, index) => {
+    const mark = `@${index}`;
+    groups.push([mark, match]);
+    return mark;
+  });
+  return { groups, path: path2 };
+};
+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, next) => {
+  if (label === "*") {
+    return "*";
+  }
+  const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+  if (match) {
+    const cacheKey2 = `${label}#${next}`;
+    if (!patternCache[cacheKey2]) {
+      if (match[2]) {
+        patternCache[cacheKey2] = next && next[0] !== ":" && next[0] !== "*" ? [cacheKey2, match[1], new RegExp(`^${match[2]}(?=/${next})`)] : [label, match[1], new RegExp(`^${match[2]}$`)];
+      } else {
+        patternCache[cacheKey2] = [label, match[1], true];
+      }
+    }
+    return patternCache[cacheKey2];
+  }
+  return null;
+};
+var tryDecode = (str, decoder) => {
+  try {
+    return decoder(str);
+  } catch {
+    return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
+      try {
+        return decoder(match);
+      } catch {
+        return match;
+      }
+    });
+  }
+};
+var tryDecodeURI = (str) => tryDecode(str, decodeURI);
+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 path2 = url.slice(start, queryIndex === -1 ? void 0 : queryIndex);
+      return tryDecodeURI(path2.includes("%25") ? path2.replace(/%25/g, "%2525") : path2);
+    } else if (charCode === 63) {
+      break;
+    }
+  }
+  return url.slice(start, i);
+};
+var getPathNoStrict = (request) => {
+  const result = getPath(request);
+  return result.length > 1 && result.at(-1) === "/" ? result.slice(0, -1) : result;
+};
+var mergePath = (base, sub, ...rest) => {
+  if (rest.length) {
+    sub = mergePath(sub, ...rest);
+  }
+  return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
+};
+var checkOptionalParameter = (path2) => {
+  if (path2.charCodeAt(path2.length - 1) !== 63 || !path2.includes(":")) {
+    return null;
+  }
+  const segments = path2.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 value.indexOf("%") !== -1 ? 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;
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/request.js
+var tryDecodeURIComponent = (str) => tryDecode(str, decodeURIComponent_);
+var HonoRequest = class {
+  raw;
+  #validatedData;
+  #matchResult;
+  routeIndex = 0;
+  path;
+  bodyCache = {};
+  constructor(request, path2 = "/", matchResult = [[]]) {
+    this.raw = request;
+    this.path = path2;
+    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) ? tryDecodeURIComponent(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) ? tryDecodeURIComponent(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) ?? 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;
+  }
+};
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/utils/html.js
+init_cjs_shims();
+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;
+  }
+};
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/context.js
+var TEXT_PLAIN = "text/plain; charset=UTF-8";
+var setHeaders = (headers, map = {}) => {
+  for (const key of Object.keys(map)) {
+    headers.set(key, map[key]);
+  }
+  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
+    });
+  }
+  newResponse = (...args) => this.#newResponse(...args);
+  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;
+    if (typeof arg === "number") {
+      return this.#newResponse(text, arg, headers);
+    }
+    return this.#newResponse(text, arg);
+  };
+  json = (object, arg, headers) => {
+    const body = JSON.stringify(object);
+    this.#preparedHeaders ??= {};
+    this.#preparedHeaders["content-type"] = "application/json";
+    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", String(location));
+    return this.newResponse(null, status ?? 302);
+  };
+  notFound = () => {
+    this.#notFoundHandler ??= () => new Response();
+    return this.#notFoundHandler(this);
+  };
+};
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router.js
+init_cjs_shims();
+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 {
+};
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/utils/constants.js
+init_cjs_shims();
+var COMPOSED_HANDLER = "__COMPOSED_HANDLER";
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/hono-base.js
+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((handler) => {
+          this.#addRoute(method, this.#path, handler);
+        });
+        return this;
+      };
+    });
+    this.on = (method, path2, ...handlers) => {
+      for (const p of [path2].flat()) {
+        this.#path = p;
+        for (const m of [method].flat()) {
+          handlers.map((handler) => {
+            this.#addRoute(m.toUpperCase(), this.#path, handler);
+          });
+        }
+      }
+      return this;
+    };
+    this.use = (arg1, ...handlers) => {
+      if (typeof arg1 === "string") {
+        this.#path = arg1;
+      } else {
+        this.#path = "*";
+        handlers.unshift(arg1);
+      }
+      handlers.forEach((handler) => {
+        this.#addRoute(METHOD_NAME_ALL, this.#path, handler);
+      });
+      return this;
+    };
+    const { strict, ...optionsWithoutStrict } = options;
+    Object.assign(this, optionsWithoutStrict);
+    this.getPath = strict ?? true ? 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(path2, app2) {
+    const subApp = this.basePath(path2);
+    app2.routes.map((r) => {
+      let handler;
+      if (app2.errorHandler === errorHandler) {
+        handler = r.handler;
+      } else {
+        handler = async (c, next) => (await compose([], app2.errorHandler)(c, () => r.handler(c, next))).res;
+        handler[COMPOSED_HANDLER] = r.handler;
+      }
+      subApp.#addRoute(r.method, r.path, handler);
+    });
+    return this;
+  }
+  basePath(path2) {
+    const subApp = this.#clone();
+    subApp._basePath = mergePath(this._basePath, path2);
+    return subApp;
+  }
+  onError = (handler) => {
+    this.errorHandler = handler;
+    return this;
+  };
+  notFound = (handler) => {
+    this.#notFoundHandler = handler;
+    return this;
+  };
+  mount(path2, 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, path2);
+      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 handler = 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(path2, "*"), handler);
+    return this;
+  }
+  #addRoute(method, path2, handler) {
+    method = method.toUpperCase();
+    path2 = mergePath(this._basePath, path2);
+    const r = { path: path2, method, handler };
+    this.router.add(method, path2, [handler, r]);
+    this.routes.push(r);
+  }
+  #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 path2 = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path2);
+    const c = new Context(request, {
+      path: path2,
+      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) {
+      return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx);
+    }
+    input = input.toString();
+    return this.fetch(
+      new Request(
+        /^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`,
+        requestInit
+      ),
+      Env,
+      executionCtx
+    );
+  };
+  fire = () => {
+    addEventListener("fetch", (event) => {
+      event.respondWith(this.#dispatch(event.request, event, void 0, event.request.method));
+    });
+  };
+};
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router/reg-exp-router/index.js
+init_cjs_shims();
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router/reg-exp-router/router.js
+init_cjs_shims();
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router/reg-exp-router/node.js
+init_cjs_shims();
+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("|") + ")";
+  }
+};
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router/reg-exp-router/trie.js
+init_cjs_shims();
+var Trie = class {
+  #context = { varIndex: 0 };
+  #root = new Node();
+  insert(path2, index, pathErrorCheckOnly) {
+    const paramAssoc = [];
+    const groups = [];
+    for (let i = 0; ; ) {
+      let replaced = false;
+      path2 = path2.replace(/\{[^}]+\}/g, (m) => {
+        const mark = `@\\${i}`;
+        groups[i] = [mark, m];
+        i++;
+        replaced = true;
+        return mark;
+      });
+      if (!replaced) {
+        break;
+      }
+    }
+    const tokens = path2.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 (handlerIndex !== void 0) {
+        indexReplacementMap[++captureIndex] = Number(handlerIndex);
+        return "$()";
+      }
+      if (paramIndex !== void 0) {
+        paramReplacementMap[Number(paramIndex)] = ++captureIndex;
+        return "";
+      }
+      return "";
+    });
+    return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
+  }
+};
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/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(path2) {
+  return wildcardRegExpCache[path2] ??= new RegExp(
+    path2 === "*" ? "" : `^${path2.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, path2, handlers] = routesWithStaticPathFlag[i];
+    if (pathErrorCheckOnly) {
+      staticMap[path2] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+    } else {
+      j++;
+    }
+    let paramAssoc;
+    try {
+      paramAssoc = trie.insert(path2, j, pathErrorCheckOnly);
+    } catch (e) {
+      throw e === PATH_ERROR ? new UnsupportedPathError(path2) : 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, path2) {
+  if (!middleware) {
+    return void 0;
+  }
+  for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
+    if (buildWildcardRegExp(k).test(path2)) {
+      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, path2, handler) {
+    const middleware = this.#middleware;
+    const routes = this.#routes;
+    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 (path2 === "/*") {
+      path2 = "*";
+    }
+    const paramCount = (path2.match(/\/:/g) || []).length;
+    if (/\*$/.test(path2)) {
+      const re = buildWildcardRegExp(path2);
+      if (method === METHOD_NAME_ALL) {
+        Object.keys(middleware).forEach((m) => {
+          middleware[m][path2] ||= findMiddleware(middleware[m], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || [];
+        });
+      } else {
+        middleware[method][path2] ||= findMiddleware(middleware[method], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || [];
+      }
+      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([handler, 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([handler, paramCount])
+          );
+        }
+      });
+      return;
+    }
+    const paths = checkOptionalParameter(path2) || [path2];
+    for (let i = 0, len = paths.length; i < len; i++) {
+      const path22 = paths[i];
+      Object.keys(routes).forEach((m) => {
+        if (method === METHOD_NAME_ALL || method === m) {
+          routes[m][path22] ||= [
+            ...findMiddleware(middleware[m], path22) || findMiddleware(middleware[METHOD_NAME_ALL], path22) || []
+          ];
+          routes[m][path22].push([handler, paramCount - len + i + 1]);
+        }
+      });
+    }
+  }
+  match(method, path2) {
+    clearWildcardRegExpCache();
+    const matchers = this.#buildAllMatchers();
+    this.match = (method2, path22) => {
+      const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
+      const staticMatch = matcher[2][path22];
+      if (staticMatch) {
+        return staticMatch;
+      }
+      const match = path22.match(matcher[0]);
+      if (!match) {
+        return [[], emptyParam];
+      }
+      const index = match.indexOf("", 1);
+      return [matcher[1][index], match];
+    };
+    return this.match(method, path2);
+  }
+  #buildAllMatchers() {
+    const matchers = /* @__PURE__ */ Object.create(null);
+    Object.keys(this.#routes).concat(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((path2) => [path2, r[method][path2]]) : [];
+      if (ownRoute.length !== 0) {
+        hasOwnRoute ||= true;
+        routes.push(...ownRoute);
+      } else if (method !== METHOD_NAME_ALL) {
+        routes.push(
+          ...Object.keys(r[METHOD_NAME_ALL]).map((path2) => [path2, r[METHOD_NAME_ALL][path2]])
+        );
+      }
+    });
+    if (!hasOwnRoute) {
+      return null;
+    } else {
+      return buildMatcherFromPreprocessedRoutes(routes);
+    }
+  }
+};
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router/smart-router/index.js
+init_cjs_shims();
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router/smart-router/router.js
+init_cjs_shims();
+var SmartRouter = class {
+  name = "SmartRouter";
+  #routers = [];
+  #routes = [];
+  constructor(init) {
+    this.#routers = init.routers;
+  }
+  add(method, path2, handler) {
+    if (!this.#routes) {
+      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+    }
+    this.#routes.push([method, path2, handler]);
+  }
+  match(method, path2) {
+    if (!this.#routes) {
+      throw new Error("Fatal error");
+    }
+    const routers = this.#routers;
+    const routes = this.#routes;
+    const len = routers.length;
+    let i = 0;
+    let res;
+    for (; i < len; i++) {
+      const router = routers[i];
+      try {
+        for (let i2 = 0, len2 = routes.length; i2 < len2; i2++) {
+          router.add(...routes[i2]);
+        }
+        res = router.match(method, path2);
+      } 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];
+  }
+};
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router/trie-router/index.js
+init_cjs_shims();
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router/trie-router/router.js
+init_cjs_shims();
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router/trie-router/node.js
+init_cjs_shims();
+var emptyParams = /* @__PURE__ */ Object.create(null);
+var Node2 = class {
+  #methods;
+  #children;
+  #patterns;
+  #order = 0;
+  #params = emptyParams;
+  constructor(method, handler, children) {
+    this.#children = children || /* @__PURE__ */ Object.create(null);
+    this.#methods = [];
+    if (method && handler) {
+      const m = /* @__PURE__ */ Object.create(null);
+      m[method] = { handler, possibleKeys: [], score: 0 };
+      this.#methods = [m];
+    }
+    this.#patterns = [];
+  }
+  insert(method, path2, handler) {
+    this.#order = ++this.#order;
+    let curNode = this;
+    const parts = splitRoutingPath(path2);
+    const possibleKeys = [];
+    for (let i = 0, len = parts.length; i < len; i++) {
+      const p = parts[i];
+      const nextP = parts[i + 1];
+      const pattern = getPattern(p, nextP);
+      const key = Array.isArray(pattern) ? pattern[0] : p;
+      if (Object.keys(curNode.#children).includes(key)) {
+        curNode = curNode.#children[key];
+        const pattern2 = getPattern(p, nextP);
+        if (pattern2) {
+          possibleKeys.push(pattern2[1]);
+        }
+        continue;
+      }
+      curNode.#children[key] = new Node2();
+      if (pattern) {
+        curNode.#patterns.push(pattern);
+        possibleKeys.push(pattern[1]);
+      }
+      curNode = curNode.#children[key];
+    }
+    const m = /* @__PURE__ */ Object.create(null);
+    const handlerSet = {
+      handler,
+      possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
+      score: this.#order
+    };
+    m[method] = handlerSet;
+    curNode.#methods.push(m);
+    return curNode;
+  }
+  #getHandlerSets(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 = {};
+      if (handlerSet !== void 0) {
+        handlerSet.params = /* @__PURE__ */ Object.create(null);
+        handlerSets.push(handlerSet);
+        if (nodeParams !== emptyParams || params && params !== emptyParams) {
+          for (let i2 = 0, len2 = handlerSet.possibleKeys.length; i2 < len2; i2++) {
+            const key = handlerSet.possibleKeys[i2];
+            const processed = processedSet[handlerSet.score];
+            handlerSet.params[key] = params?.[key] && !processed ? params[key] : nodeParams[key] ?? params?.[key];
+            processedSet[handlerSet.score] = true;
+          }
+        }
+      }
+    }
+    return handlerSets;
+  }
+  search(method, path2) {
+    const handlerSets = [];
+    this.#params = emptyParams;
+    const curNode = this;
+    let curNodes = [curNode];
+    const parts = splitPath(path2);
+    const curNodesQueue = [];
+    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) {
+            if (nextNode.#children["*"]) {
+              handlerSets.push(
+                ...this.#getHandlerSets(nextNode.#children["*"], method, node.#params)
+              );
+            }
+            handlerSets.push(...this.#getHandlerSets(nextNode, method, node.#params));
+          } else {
+            tempNodes.push(nextNode);
+          }
+        }
+        for (let k = 0, len3 = node.#patterns.length; k < len3; k++) {
+          const pattern = node.#patterns[k];
+          const params = node.#params === emptyParams ? {} : { ...node.#params };
+          if (pattern === "*") {
+            const astNode = node.#children["*"];
+            if (astNode) {
+              handlerSets.push(...this.#getHandlerSets(astNode, method, node.#params));
+              astNode.#params = params;
+              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) {
+            const m = matcher.exec(restPathString);
+            if (m) {
+              params[name] = m[0];
+              handlerSets.push(...this.#getHandlerSets(child, method, node.#params, params));
+              if (Object.keys(child.#children).length) {
+                child.#params = params;
+                const componentCount = m[0].match(/\//)?.length ?? 0;
+                const targetCurNodes = curNodesQueue[componentCount] ||= [];
+                targetCurNodes.push(child);
+              }
+              continue;
+            }
+          }
+          if (matcher === true || matcher.test(part)) {
+            params[name] = part;
+            if (isLast) {
+              handlerSets.push(...this.#getHandlerSets(child, method, params, node.#params));
+              if (child.#children["*"]) {
+                handlerSets.push(
+                  ...this.#getHandlerSets(child.#children["*"], method, params, node.#params)
+                );
+              }
+            } else {
+              child.#params = params;
+              tempNodes.push(child);
+            }
+          }
+        }
+      }
+      curNodes = tempNodes.concat(curNodesQueue.shift() ?? []);
+    }
+    if (handlerSets.length > 1) {
+      handlerSets.sort((a, b) => {
+        return a.score - b.score;
+      });
+    }
+    return [handlerSets.map(({ handler, params }) => [handler, params])];
+  }
+};
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router/trie-router/router.js
+var TrieRouter = class {
+  name = "TrieRouter";
+  #node;
+  constructor() {
+    this.#node = new Node2();
+  }
+  add(method, path2, handler) {
+    const results = checkOptionalParameter(path2);
+    if (results) {
+      for (let i = 0, len = results.length; i < len; i++) {
+        this.#node.insert(method, results[i], handler);
+      }
+      return;
+    }
+    this.#node.insert(method, path2, handler);
+  }
+  match(method, path2) {
+    return this.#node.search(method, path2);
+  }
+};
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/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()]
+    });
+  }
+};
+
+// src/server.ts
+var app = new Hono2();
+app.get("/status", (c) => {
+  c.header("X-React-Native-Project-Root", import_path.default.resolve(__dirname, "..", "react-native"));
+  return c.text("packager-status:running");
+});
+app.get("/permissions", (c) => {
+  return c.text("contacts:rw");
+});
+app.get("/oauth/scope", (c) => {
+  return c.text("user_email;user_name");
+});
+app.get("/index.bundle", async (c) => {
+  const platform = c.req.query("platform");
+  const bundle = import_fs.default.readFileSync(import_path.default.resolve(__dirname, "..", "dist", `app-name.${platform}.js`), "utf-8");
+  c.header("Surrogate-Control", "no-store");
+  c.header("Cache-Control", "no-store, no-cache, must-revalidate, proxy-revalidate");
+  c.header("Pragma", "no-cache");
+  c.header("Expires", "0");
+  c.header("Content-Type", "application/javascript");
+  const result = await (0, import_core2.transform)(bundle, {
+    plugins: [
+      [
+        "@apps-in-toss/babel-plugin-json",
+        {
+          json: {
+            appName: "web-framework",
+            webPort: 5173
+          },
+          identifierName: "Ait"
+        }
+      ]
+    ]
+  });
+  if (!result?.code) {
+    return c.text("Error", 500);
+  }
+  return c.body(result.code);
+});
+
+// src/commands/DevCommand.ts
+var DevCommand = class extends Command {
+  static paths = [[`dev`]];
+  static usage = Command.Usage({
+    category: "Development",
+    description: "Bedrock \uAC1C\uBC1C \uC11C\uBC84\uB97C \uC2E4\uD589\uD569\uB2C8\uB2E4",
+    examples: [["\uAC1C\uBC1C \uC11C\uBC84 \uC2E4\uD589\uD558\uAE30", "bedrock dev"]]
+  });
+  async execute() {
+    serve(
+      {
+        hostname: "0.0.0.0",
+        fetch: app.fetch,
+        port: 8081
+      },
+      (info) => {
+        console.log(`Listening on http://localhost:${info.port}`);
+      }
+    );
+  }
+};
+
+// src/cli.ts
+var cli = new Cli({
+  binaryLabel: "bedrock",
+  binaryName: "bedrock",
+  enableCapture: true
+});
+async function initialize() {
+  cli.register(DevCommand);
+  cli.runExit(process.argv.slice(2));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  initialize
+});