#!/usr/bin/env node
"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 __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
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
));

// ../node_modules/@emprespresso/pengueno/dist/leftpadesque/prepend.js
var require_prepend = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/leftpadesque/prepend.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.prependWith = void 0;
    var prependWith = (arr, prep) => Array(arr.length * 2).fill(0).map((_, i) => i % 2 === 0).map((isPrep, i) => isPrep ? prep : arr[Math.floor(i / 2)]);
    exports2.prependWith = prependWith;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/leftpadesque/debug.js
var require_debug = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/leftpadesque/debug.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.isDebug = exports2.isProd = void 0;
    var _hasEnv = true;
    var _env = _hasEnv && (process.env.ENVIRONMENT ?? "").toLowerCase().includes("prod") ? "production" : "development";
    var isProd = () => _env === "production";
    exports2.isProd = isProd;
    var _debug = !(0, exports2.isProd)() || _hasEnv && ["y", "t"].some((process.env.DEBUG ?? "").toLowerCase().startsWith);
    var isDebug = () => _debug;
    exports2.isDebug = isDebug;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/leftpadesque/memoize.js
var require_memoize = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/leftpadesque/memoize.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.memoize = void 0;
    var memoize = (fn) => {
      const cache = /* @__PURE__ */ new Map();
      return (...args) => {
        const key = JSON.stringify(args);
        if (cache.has(key)) {
          return cache.get(key);
        }
        const res = fn(...args);
        cache.set(key, res);
        return res;
      };
    };
    exports2.memoize = memoize;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/leftpadesque/index.js
var require_leftpadesque = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/leftpadesque/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_prepend(), exports2);
    __exportStar(require_debug(), exports2);
    __exportStar(require_memoize(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/types/misc.js
var require_misc = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/types/misc.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// ../node_modules/@emprespresso/pengueno/dist/types/object.js
var require_object = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/types/object.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.isObject = void 0;
    var isObject3 = (o) => typeof o === "object" && !Array.isArray(o) && !!o;
    exports2.isObject = isObject3;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/types/tagged.js
var require_tagged = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/types/tagged.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.isTagged = void 0;
    var index_1 = require_types();
    var isTagged = (o, tag) => !!((0, index_1.isObject)(o) && "_tag" in o && o._tag === tag);
    exports2.isTagged = isTagged;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/types/fn/callable.js
var require_callable = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/types/fn/callable.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// ../node_modules/@emprespresso/pengueno/dist/types/fn/optional.js
var require_optional = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/types/fn/optional.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Optional = exports2.IOptionalEmptyError = exports2.isOptional = exports2.IOptionalTag = void 0;
    var pengueno_1 = require_dist2();
    exports2.IOptionalTag = "IOptional";
    var isOptional = (o) => (0, pengueno_1.isTagged)(o, exports2.IOptionalTag);
    exports2.isOptional = isOptional;
    var IOptionalEmptyError = class extends Error {
    };
    exports2.IOptionalEmptyError = IOptionalEmptyError;
    var OSomeTag = "O.Some";
    var ONoneTag = "O.None";
    var isNone = (o) => (0, pengueno_1.isTagged)(o, ONoneTag);
    var isSome = (o) => (0, pengueno_1.isTagged)(o, OSomeTag);
    var _Tagged = class {
      _tag;
      constructor(_tag = exports2.IOptionalTag) {
        this._tag = _tag;
      }
    };
    var Optional = class _Optional extends _Tagged {
      self;
      constructor(self) {
        super();
        this.self = self;
      }
      move(t) {
        return this.map(() => t);
      }
      orSome(supplier) {
        if (isNone(this.self))
          return _Optional.from(supplier());
        return this;
      }
      get() {
        if (isNone(this.self))
          throw new IOptionalEmptyError("called get() on None optional");
        return this.self.value;
      }
      filter(mapper) {
        if (isNone(this.self) || !mapper(this.self.value))
          return _Optional.none();
        return _Optional.some(this.self.value);
      }
      map(mapper) {
        if (isNone(this.self))
          return _Optional.none();
        return _Optional.from(mapper(this.self.value));
      }
      flatMap(mapper) {
        if (isNone(this.self))
          return _Optional.none();
        return _Optional.from(mapper(this.self.value)).orSome(() => _Optional.none()).get();
      }
      present() {
        return isSome(this.self);
      }
      *[Symbol.iterator]() {
        if (isSome(this.self))
          yield this.self.value;
      }
      static some(value) {
        return new _Optional({ value, _tag: OSomeTag });
      }
      static _none = new _Optional({ _tag: ONoneTag });
      static none() {
        return this._none;
      }
      static from(value) {
        if (value === null || value === void 0)
          return _Optional.none();
        return _Optional.some(value);
      }
    };
    exports2.Optional = Optional;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/types/fn/either.js
var require_either = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/types/fn/either.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Either = exports2.isRight = exports2.isLeft = exports2.isEither = exports2.IEitherTag = void 0;
    var pengueno_1 = require_dist2();
    exports2.IEitherTag = "IEither";
    var isEither = (o) => (0, pengueno_1.isTagged)(o, exports2.IEitherTag);
    exports2.isEither = isEither;
    var ELeftTag = "E.Left";
    var isLeft = (o) => (0, pengueno_1.isTagged)(o, ELeftTag);
    exports2.isLeft = isLeft;
    var ERightTag = "E.Right";
    var isRight = (o) => (0, pengueno_1.isTagged)(o, ERightTag);
    exports2.isRight = isRight;
    var _Tagged = class {
      _tag;
      constructor(_tag = exports2.IEitherTag) {
        this._tag = _tag;
      }
    };
    var Either2 = class _Either extends _Tagged {
      self;
      constructor(self) {
        super();
        this.self = self;
      }
      moveRight(t) {
        return this.mapRight(() => t);
      }
      mapBoth(errBranch, okBranch) {
        if ((0, exports2.isLeft)(this.self))
          return _Either.left(errBranch(this.self.err));
        return _Either.right(okBranch(this.self.ok));
      }
      mapRight(mapper) {
        if ((0, exports2.isRight)(this.self))
          return _Either.right(mapper(this.self.ok));
        return _Either.left(this.self.err);
      }
      mapLeft(mapper) {
        if ((0, exports2.isLeft)(this.self))
          return _Either.left(mapper(this.self.err));
        return _Either.right(this.self.ok);
      }
      flatMap(mapper) {
        if ((0, exports2.isRight)(this.self))
          return mapper(this.self.ok);
        return _Either.left(this.self.err);
      }
      filter(mapper) {
        if ((0, exports2.isLeft)(this.self))
          return _Either.left(this.self.err);
        return _Either.fromFailable(() => this.right().filter(mapper).get());
      }
      async flatMapAsync(mapper) {
        if ((0, exports2.isLeft)(this.self))
          return Promise.resolve(_Either.left(this.self.err));
        return await mapper(this.self.ok).catch((err) => _Either.left(err));
      }
      fold(leftFolder, rightFolder) {
        if ((0, exports2.isLeft)(this.self))
          return leftFolder(this.self.err);
        return rightFolder(this.self.ok);
      }
      left() {
        if ((0, exports2.isLeft)(this.self))
          return pengueno_1.Optional.from(this.self.err);
        return pengueno_1.Optional.none();
      }
      right() {
        if ((0, exports2.isRight)(this.self))
          return pengueno_1.Optional.from(this.self.ok);
        return pengueno_1.Optional.none();
      }
      joinRight(other, mapper) {
        return this.flatMap((t) => other.mapRight((o) => mapper(o, t)));
      }
      joinRightAsync(other, mapper) {
        return this.flatMapAsync(async (t) => {
          const o = typeof other === "function" ? other() : other;
          return await o.then((other2) => other2.mapRight((o2) => mapper(o2, t)));
        });
      }
      swap() {
        if ((0, exports2.isRight)(this.self))
          return _Either.left(this.self.ok);
        return _Either.right(this.self.err);
      }
      static left(e) {
        return new _Either({ err: e, _tag: ELeftTag });
      }
      static right(t) {
        return new _Either({ ok: t, _tag: ERightTag });
      }
      static fromFailable(s) {
        try {
          return _Either.right(s());
        } catch (e) {
          return _Either.left(e);
        }
      }
      static async fromFailableAsync(s) {
        return await (typeof s === "function" ? s() : s).then((t) => _Either.right(t)).catch((e) => _Either.left(e));
      }
      static async retrying(s, attempts = 3, interval = (attempt) => _Either.attemptWait(attempt)) {
        let result = _Either.right(new Error("No attempts made"));
        for (let attempt = 0; attempt < attempts && result.right().present(); attempt++) {
          await interval(attempt);
          const currentAttempt = await s().then((s2) => s2.swap());
          result = await result.joinRightAsync(() => Promise.resolve(currentAttempt), (res, _prevError) => res);
        }
        return result.swap();
      }
      static attemptWait(attempt, backoffFactor = 500, jitter = 300, exponent = 1.3) {
        if (attempt === 0) {
          return Promise.resolve();
        }
        const wait = Math.pow(exponent, attempt) * backoffFactor + jitter * Math.random() * Math.pow(exponent, attempt);
        return new Promise((res) => setTimeout(res, wait));
      }
    };
    exports2.Either = Either2;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/types/fn/index.js
var require_fn = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/types/fn/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_callable(), exports2);
    __exportStar(require_optional(), exports2);
    __exportStar(require_either(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/types/collections/cons.js
var require_cons = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/types/collections/cons.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ListZipper = exports2.Cons = void 0;
    var pengueno_1 = require_dist2();
    var Cons = class _Cons {
      value;
      next;
      constructor(value, next = pengueno_1.Optional.none()) {
        this.value = value;
        this.next = next;
      }
      before(head) {
        return new _Cons(this.value, head);
      }
      replace(_value) {
        return new _Cons(_value, this.next);
      }
      *[Symbol.iterator]() {
        for (let cur = pengueno_1.Optional.some(this); cur.present(); cur = cur.flatMap((cur2) => cur2.next)) {
          yield cur.get().value;
        }
      }
      static addOnto(items, tail) {
        return Array.from(items).reverse().reduce((cons, value) => pengueno_1.Optional.from(new _Cons(value, cons)), tail);
      }
      static from(items) {
        return _Cons.addOnto(items, pengueno_1.Optional.none());
      }
    };
    exports2.Cons = Cons;
    var ListZipper = class _ListZipper {
      reversedPathToHead;
      currentHead;
      constructor(reversedPathToHead, currentHead) {
        this.reversedPathToHead = reversedPathToHead;
        this.currentHead = currentHead;
      }
      read() {
        return this.currentHead.map(({ value }) => value);
      }
      next() {
        return this.currentHead.map((head) => new _ListZipper(pengueno_1.Optional.some(head.before(this.reversedPathToHead)), head.next));
      }
      previous() {
        return this.reversedPathToHead.map((lastVisited) => new _ListZipper(lastVisited.next, pengueno_1.Optional.some(lastVisited.before(this.currentHead))));
      }
      prependChunk(values) {
        return new _ListZipper(Cons.addOnto(Array.from(values).reverse(), this.reversedPathToHead), this.currentHead);
      }
      prepend(value) {
        return this.prependChunk([value]);
      }
      remove() {
        const newHead = this.currentHead.flatMap((right) => right.next);
        return new _ListZipper(this.reversedPathToHead, newHead);
      }
      replace(value) {
        const newHead = this.currentHead.map((right) => right.replace(value));
        return new _ListZipper(this.reversedPathToHead, newHead);
      }
      *[Symbol.iterator]() {
        let head = this;
        for (let prev = head.previous(); prev.present(); prev = prev.flatMap((p) => p.previous())) {
          head = prev.get();
        }
        if (head.currentHead.present())
          yield* head.currentHead.get();
      }
      collection() {
        return Array.from(this);
      }
      static from(iterable) {
        return new _ListZipper(pengueno_1.Optional.none(), Cons.from(iterable));
      }
    };
    exports2.ListZipper = ListZipper;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/types/collections/jsonds.js
var require_jsonds = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/types/collections/jsonds.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.JSONHashMap = exports2.JSONSet = void 0;
    var JSONSet = class {
      items;
      constructor(items = /* @__PURE__ */ new Set()) {
        this.items = items;
      }
      add(item) {
        const itemJson = JSON.stringify(item, Object.keys(item).sort());
        this.items.add(itemJson);
      }
      has(item) {
        const itemJson = JSON.stringify(item, Object.keys(item).sort());
        return this.items.has(itemJson);
      }
      delete(item) {
        const itemJson = JSON.stringify(item, Object.keys(item).sort());
        return this.items.delete(itemJson);
      }
      clear() {
        this.items.clear();
      }
      size() {
        return this.items.size;
      }
    };
    exports2.JSONSet = JSONSet;
    var JSONHashMap = class {
      map;
      constructor(map = /* @__PURE__ */ new Map()) {
        this.map = map;
      }
      set(key, value) {
        const keyJson = JSON.stringify(key, Object.keys(key).sort());
        this.map.set(keyJson, value);
      }
      get(key) {
        const keyJson = JSON.stringify(key, Object.keys(key).sort());
        return this.map.get(keyJson);
      }
      has(key) {
        const keyJson = JSON.stringify(key, Object.keys(key).sort());
        return this.map.has(keyJson);
      }
      keys() {
        return Array.from(this.map.keys()).map((x) => JSON.parse(x));
      }
      delete(key) {
        const keyJson = JSON.stringify(key, Object.keys(key).sort());
        return this.map.delete(keyJson);
      }
      clear() {
        this.map.clear();
      }
      size() {
        return this.map.size;
      }
    };
    exports2.JSONHashMap = JSONHashMap;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/types/collections/index.js
var require_collections = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/types/collections/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_cons(), exports2);
    __exportStar(require_jsonds(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/types/index.js
var require_types = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/types/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_misc(), exports2);
    __exportStar(require_object(), exports2);
    __exportStar(require_tagged(), exports2);
    __exportStar(require_fn(), exports2);
    __exportStar(require_collections(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/itrace.js
var require_itrace = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/itrace.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.TraceableImpl = void 0;
    var TraceableImpl = class _TraceableImpl {
      item;
      trace;
      constructor(item, trace) {
        this.item = item;
        this.trace = trace;
      }
      map(mapper) {
        const result = mapper(this);
        return new _TraceableImpl(result, this.trace);
      }
      coExtend(mapper) {
        const results = mapper(this);
        return Array.from(results).map((result) => this.move(result));
      }
      flatMap(mapper) {
        return mapper(this);
      }
      flatMapAsync(mapper) {
        return new _TraceableImpl(mapper(this).then((t) => t.get()), this.trace);
      }
      traceScope(mapper) {
        return new _TraceableImpl(this.get(), this.trace.traceScope(mapper(this)));
      }
      peek(peek) {
        peek(this);
        return this;
      }
      move(t) {
        return this.map(() => t);
      }
      bimap(mapper) {
        const { item, trace: _trace } = mapper(this);
        return this.move(item).traceScope(() => _trace);
      }
      get() {
        return this.item;
      }
    };
    exports2.TraceableImpl = TraceableImpl;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/metric/emittable.js
var require_emittable = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/metric/emittable.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.EmittableMetric = void 0;
    var index_1 = require_metric2();
    var EmittableMetric = class {
      name;
      unit;
      constructor(name, unit) {
        this.name = name;
        this.unit = unit;
      }
      withValue(value) {
        return {
          name: this.name,
          unit: this.unit,
          emissionTimestamp: Date.now(),
          value,
          _tag: index_1.MetricValueTag
        };
      }
    };
    exports2.EmittableMetric = EmittableMetric;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/metric/metric.js
var require_metric = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/metric/metric.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ResultMetric = exports2.Metric = void 0;
    var index_1 = require_metric2();
    var _Tagged = class {
      _tag;
      constructor(_tag = index_1.IMetricTag) {
        this._tag = _tag;
      }
    };
    var Metric = class _Metric extends _Tagged {
      name;
      parent;
      count;
      time;
      static DELIM = ".";
      constructor(name, parent = void 0, count = new index_1.EmittableMetric(_Metric.join(name, "count"), index_1.Unit.COUNT), time = new index_1.EmittableMetric(_Metric.join(name, "time"), index_1.Unit.MILLISECONDS)) {
        super();
        this.name = name;
        this.parent = parent;
        this.count = count;
        this.time = time;
      }
      child(_name) {
        const childName = _Metric.join(this.name, _name);
        return new _Metric(childName, this);
      }
      asResult() {
        return ResultMetric.from(this);
      }
      static join(...name) {
        return name.join(_Metric.DELIM);
      }
      static fromName(name) {
        return new _Metric(name);
      }
    };
    exports2.Metric = Metric;
    var ResultMetric = class _ResultMetric extends Metric {
      name;
      parent;
      failure;
      success;
      warn;
      constructor(name, parent = void 0, failure, success, warn) {
        super(name, parent);
        this.name = name;
        this.parent = parent;
        this.failure = failure;
        this.success = success;
        this.warn = warn;
      }
      static from(metric) {
        const failure = metric.child("failure");
        const success = metric.child("success");
        const warn = metric.child("warn");
        return new _ResultMetric(metric.name, metric.parent, failure, success, warn);
      }
    };
    exports2.ResultMetric = ResultMetric;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/metric/trace.js
var require_trace = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/metric/trace.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.MetricsTrace = exports2.isMetricsTraceSupplier = void 0;
    var pengueno_1 = require_dist2();
    var isMetricsTraceSupplier = (t) => (0, pengueno_1.isMetricValue)(t) || (0, pengueno_1.isIMetric)(t) || Array.isArray(t) && t.every((_m) => (0, pengueno_1.isMetricValue)(_m) || (0, pengueno_1.isIMetric)(_m));
    exports2.isMetricsTraceSupplier = isMetricsTraceSupplier;
    var MetricsTrace = class _MetricsTrace {
      metricConsumer;
      activeTraces;
      completedTraces;
      constructor(metricConsumer, activeTraces = /* @__PURE__ */ new Map(), completedTraces = /* @__PURE__ */ new Set()) {
        this.metricConsumer = metricConsumer;
        this.activeTraces = activeTraces;
        this.completedTraces = completedTraces;
      }
      traceScope(trace) {
        const now = Date.now();
        const metricsToTrace = (Array.isArray(trace) ? trace : [trace]).filter(pengueno_1.isIMetric);
        const initialTraces = new Map(metricsToTrace.map((metric) => [metric.name, now]));
        return new _MetricsTrace(this.metricConsumer, initialTraces, this.completedTraces);
      }
      trace(metrics) {
        if (!metrics || typeof metrics === "string") {
          return this;
        }
        const now = Date.now();
        const allMetrics = Array.isArray(metrics) ? metrics : [metrics];
        const valuesToEmit = allMetrics.filter(pengueno_1.isMetricValue);
        const traceableMetrics = allMetrics.filter(pengueno_1.isIMetric);
        const metricsToStart = traceableMetrics.filter((m) => !this.activeTraces.has(m.name));
        const metricsToEnd = traceableMetrics.filter((m) => this.activeTraces.has(m.name) && !this.completedTraces.has(m.name));
        const endedMetricValues = metricsToEnd.flatMap((metric) => [
          metric.count.withValue(1),
          metric.time.withValue(now - this.activeTraces.get(metric.name))
        ]);
        const parentBasedMetrics = metricsToStart.filter((metric) => {
          const parent = metric.parent;
          return parent && this.activeTraces.has(parent.name);
        });
        const parentBasedValues = parentBasedMetrics.flatMap((metric) => {
          const parentStart = this.activeTraces.get(metric.parent.name);
          return [metric.count.withValue(1), metric.time.withValue(now - parentStart)];
        });
        const allMetricsToEmit = [...valuesToEmit, ...endedMetricValues, ...parentBasedValues];
        if (allMetricsToEmit.length > 0) {
          this.metricConsumer(allMetricsToEmit);
        }
        const nextActiveTraces = new Map([
          ...this.activeTraces,
          ...metricsToStart.map((m) => [m.name, now])
        ]);
        const nextCompletedTraces = /* @__PURE__ */ new Set([
          ...this.completedTraces,
          ...metricsToEnd.map((m) => m.name),
          ...parentBasedMetrics.map((m) => m.name)
        ]);
        return new _MetricsTrace(this.metricConsumer, nextActiveTraces, nextCompletedTraces);
      }
    };
    exports2.MetricsTrace = MetricsTrace;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/metric/index.js
var require_metric2 = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/metric/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.isIMetric = exports2.IMetricTag = exports2.isMetricValue = exports2.MetricValueTag = exports2.Unit = void 0;
    var pengueno_1 = require_dist2();
    var Unit;
    (function(Unit2) {
      Unit2["COUNT"] = "COUNT";
      Unit2["MILLISECONDS"] = "MILLISECONDS";
    })(Unit || (exports2.Unit = Unit = {}));
    exports2.MetricValueTag = "MetricValue";
    var isMetricValue = (t) => (0, pengueno_1.isTagged)(t, exports2.MetricValueTag);
    exports2.isMetricValue = isMetricValue;
    exports2.IMetricTag = "IMetric";
    var isIMetric = (t) => (0, pengueno_1.isTagged)(t, exports2.IMetricTag);
    exports2.isIMetric = isIMetric;
    __exportStar(require_emittable(), exports2);
    __exportStar(require_metric(), exports2);
    __exportStar(require_trace(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/log/ansi.js
var require_ansi = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/log/ansi.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ANSI = void 0;
    exports2.ANSI = {
      RESET: "\x1B[0m",
      BOLD: "\x1B[1m",
      DIM: "\x1B[2m",
      RED: "\x1B[31m",
      GREEN: "\x1B[32m",
      YELLOW: "\x1B[33m",
      BLUE: "\x1B[34m",
      MAGENTA: "\x1B[35m",
      CYAN: "\x1B[36m",
      WHITE: "\x1B[37m",
      BRIGHT_RED: "\x1B[91m",
      BRIGHT_YELLOW: "\x1B[93m",
      GRAY: "\x1B[90m"
    };
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/log/level.js
var require_level = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/log/level.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.isLogLevel = exports2.logLevelOrder = exports2.LogLevel = void 0;
    var LogLevel;
    (function(LogLevel2) {
      LogLevel2["UNKNOWN"] = "UNKNOWN";
      LogLevel2["INFO"] = "INFO";
      LogLevel2["WARN"] = "WARN";
      LogLevel2["DEBUG"] = "DEBUG";
      LogLevel2["ERROR"] = "ERROR";
      LogLevel2["SYS"] = "SYS";
    })(LogLevel || (exports2.LogLevel = LogLevel = {}));
    exports2.logLevelOrder = [
      LogLevel.DEBUG,
      LogLevel.INFO,
      LogLevel.WARN,
      LogLevel.ERROR,
      LogLevel.SYS
    ];
    var isLogLevel = (l) => typeof l === "string" && exports2.logLevelOrder.some((level) => level === l);
    exports2.isLogLevel = isLogLevel;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/log/logger.js
var require_logger = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/log/logger.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/log/pretty_json_console.js
var require_pretty_json_console = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/log/pretty_json_console.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.PrettyJsonConsoleLogger = void 0;
    var index_1 = require_log();
    var PrettyJsonConsoleLogger = class {
      log(level, ...trace) {
        const message = JSON.stringify({
          level,
          trace
        }, null, 4);
        const styled = `${this.getStyle(level)}${message}${index_1.ANSI.RESET}
`;
        this.getStream(level)(styled);
      }
      getStream(level) {
        if (level === index_1.LogLevel.ERROR) {
          return console.error;
        }
        return console.log;
      }
      getStyle(level) {
        switch (level) {
          case index_1.LogLevel.UNKNOWN:
          case index_1.LogLevel.INFO:
            return `${index_1.ANSI.MAGENTA}`;
          case index_1.LogLevel.DEBUG:
            return `${index_1.ANSI.CYAN}`;
          case index_1.LogLevel.WARN:
            return `${index_1.ANSI.BRIGHT_YELLOW}`;
          case index_1.LogLevel.ERROR:
            return `${index_1.ANSI.BRIGHT_RED}`;
          case index_1.LogLevel.SYS:
            return `${index_1.ANSI.DIM}${index_1.ANSI.BLUE}`;
        }
      }
    };
    exports2.PrettyJsonConsoleLogger = PrettyJsonConsoleLogger;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/log/trace.js
var require_trace2 = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/log/trace.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.LogTrace = void 0;
    var pengueno_1 = require_dist2();
    var index_1 = require_log();
    var LogTrace = class _LogTrace {
      logger;
      traces;
      defaultLevel;
      allowedLevels;
      constructor(logger = new index_1.PrettyJsonConsoleLogger(), traces = [defaultTrace], defaultLevel = index_1.LogLevel.INFO, allowedLevels = defaultAllowedLevelsSupplier) {
        this.logger = logger;
        this.traces = traces;
        this.defaultLevel = defaultLevel;
        this.allowedLevels = allowedLevels;
      }
      traceScope(trace) {
        return new _LogTrace(this.logger, this.traces.concat(trace), this.defaultLevel, this.allowedLevels);
      }
      trace(trace) {
        const { traces, level: _level } = this.foldTraces(this.traces.concat(trace));
        if (!this.allowedLevels().has(_level))
          return;
        const level = _level === index_1.LogLevel.UNKNOWN ? this.defaultLevel : _level;
        this.logger.log(level, ...traces);
      }
      foldTraces(_traces) {
        const _logTraces = _traces.map((trace) => typeof trace === "function" ? trace() : trace);
        const _level = _logTraces.filter((trace) => (0, index_1.isLogLevel)(trace)).reduce((acc, level2) => Math.max(index_1.logLevelOrder.indexOf(level2), acc), -1);
        const level = index_1.logLevelOrder[_level] ?? index_1.LogLevel.UNKNOWN;
        const traces = _logTraces.filter((trace) => !(0, index_1.isLogLevel)(trace)).map((trace) => {
          if (typeof trace === "object") {
            return `TracedException.Name = ${trace.name}, TracedException.Message = ${trace.message}, TracedException.Stack = ${trace.stack}`;
          }
          return trace;
        });
        return {
          level,
          traces
        };
      }
    };
    exports2.LogTrace = LogTrace;
    var defaultTrace = () => `TimeStamp = ${(/* @__PURE__ */ new Date()).toISOString()}`;
    var defaultAllowedLevels = (0, pengueno_1.memoize)((isDebug) => /* @__PURE__ */ new Set([
      index_1.LogLevel.UNKNOWN,
      ...isDebug ? [index_1.LogLevel.DEBUG] : [],
      index_1.LogLevel.INFO,
      index_1.LogLevel.WARN,
      index_1.LogLevel.ERROR,
      index_1.LogLevel.SYS
    ]));
    var defaultAllowedLevelsSupplier = () => defaultAllowedLevels((0, pengueno_1.isDebug)());
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/log/index.js
var require_log = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/log/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_ansi(), exports2);
    __exportStar(require_level(), exports2);
    __exportStar(require_logger(), exports2);
    __exportStar(require_pretty_json_console(), exports2);
    __exportStar(require_trace2(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/trace.js
var require_trace3 = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/trace.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.LogMetricTraceable = exports2.LogMetricTrace = exports2.EmbeddedMetricsTraceable = exports2.LogTraceable = void 0;
    var _1 = require_trace4();
    var LogTraceable = class _LogTraceable extends _1.TraceableImpl {
      static LogTrace = new _1.LogTrace();
      static of(t) {
        return new _LogTraceable(t, _LogTraceable.LogTrace);
      }
    };
    exports2.LogTraceable = LogTraceable;
    var getEmbeddedMetricConsumer = (logTrace) => (metrics) => {
      if (metrics.length === 0)
        return;
      logTrace.traceScope(_1.LogLevel.SYS).trace(`Metrics = <metrics>${JSON.stringify(metrics)}</metrics>`);
    };
    var EmbeddedMetricsTraceable = class _EmbeddedMetricsTraceable extends _1.TraceableImpl {
      static MetricsTrace = new _1.MetricsTrace(getEmbeddedMetricConsumer(LogTraceable.LogTrace));
      static of(t, metricsTrace = _EmbeddedMetricsTraceable.MetricsTrace) {
        return new _EmbeddedMetricsTraceable(t, metricsTrace);
      }
    };
    exports2.EmbeddedMetricsTraceable = EmbeddedMetricsTraceable;
    var LogMetricTrace = class _LogMetricTrace {
      logTrace;
      metricsTrace;
      constructor(logTrace, metricsTrace) {
        this.logTrace = logTrace;
        this.metricsTrace = metricsTrace;
      }
      traceScope(trace) {
        if ((0, _1.isMetricsTraceSupplier)(trace)) {
          return new _LogMetricTrace(this.logTrace, this.metricsTrace.traceScope(trace));
        }
        return new _LogMetricTrace(this.logTrace.traceScope(trace), this.metricsTrace);
      }
      trace(trace) {
        if ((0, _1.isMetricsTraceSupplier)(trace)) {
          this.metricsTrace.trace(trace);
          return this;
        }
        this.logTrace.trace(trace);
        return this;
      }
    };
    exports2.LogMetricTrace = LogMetricTrace;
    var LogMetricTraceable = class _LogMetricTraceable extends _1.TraceableImpl {
      static ofLogTraceable(t) {
        const metricsTrace = new _1.MetricsTrace(getEmbeddedMetricConsumer(t.trace));
        return new _LogMetricTraceable(t.get(), new LogMetricTrace(t.trace, metricsTrace));
      }
      static of(t) {
        const logTrace = LogTraceable.of(t);
        return _LogMetricTraceable.ofLogTraceable(logTrace);
      }
    };
    exports2.LogMetricTraceable = LogMetricTraceable;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/util.js
var require_util = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/util.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.TraceUtil = void 0;
    var pengueno_1 = require_dist2();
    var TraceUtil = class _TraceUtil {
      static promiseify(mapper) {
        return (traceablePromise) => traceablePromise.flatMapAsync(async (t) => t.move(await t.get()).map(mapper)).get();
      }
      static traceResultingEither(metric, warnOnFailure = false) {
        return (t) => {
          if (metric)
            t.trace.trace(t.get().fold((_err) => warnOnFailure ? metric.warn : metric.failure, (_ok) => metric.success));
          return t.traceScope((_t) => _t.get().fold((_err) => warnOnFailure ? pengueno_1.LogLevel.WARN : pengueno_1.LogLevel.ERROR, (_ok) => pengueno_1.LogLevel.INFO));
        };
      }
      static withTrace(trace) {
        return (t) => t.traceScope(() => trace);
      }
      static withMetricTrace(metric) {
        return _TraceUtil.withTrace(metric);
      }
      static withFunctionTrace(f) {
        return _TraceUtil.withTrace(`fn.${f.name}`);
      }
      static withClassTrace(c) {
        return _TraceUtil.withTrace(`class.${c.constructor.name}`);
      }
    };
    exports2.TraceUtil = TraceUtil;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/index.js
var require_trace4 = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_itrace(), exports2);
    __exportStar(require_metric2(), exports2);
    __exportStar(require_log(), exports2);
    __exportStar(require_trace3(), exports2);
    __exportStar(require_util(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/process/exec.js
var require_exec = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/process/exec.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.getStdoutMany = exports2.getStdout = exports2.CmdMetric = void 0;
    var pengueno_1 = require_dist2();
    var node_child_process_1 = require("node:child_process");
    exports2.CmdMetric = pengueno_1.Metric.fromName("Exec").asResult();
    var getStdout = (cmd, options = { streamTraceable: [] }) => cmd.flatMap(pengueno_1.TraceUtil.withFunctionTrace(exports2.getStdout)).flatMap((tCmd) => tCmd.traceScope(() => `Command = ${tCmd.get()}`)).map((tCmd) => {
      const cmd2 = tCmd.get();
      const _exec = typeof cmd2 === "string" ? cmd2 : cmd2.join(" ");
      const env = options.clearEnv ? options.env : { ...process.env, ...options.env };
      return pengueno_1.Either.fromFailableAsync(new Promise((res, rej) => {
        const proc = (0, node_child_process_1.exec)(_exec, { env });
        let stdout = "";
        proc.stdout?.on("data", (d) => {
          const s = d.toString();
          stdout += s;
          if (options.streamTraceable?.includes("stdout")) {
            tCmd.trace.trace(s);
          }
        });
        const stderr = "";
        proc.stderr?.on("data", (d) => {
          const s = d.toString();
          stdout += s;
          if (options.streamTraceable?.includes("stderr")) {
            tCmd.trace.trace(s);
          }
        });
        proc.on("exit", (code) => {
          const streams = { stdout, stderr };
          if (code === 0) {
            res(streams);
          } else {
            rej(new Error(`exited with non-zero code: ${code}. ${stderr}`));
          }
        });
      }));
    }).map(pengueno_1.TraceUtil.promiseify((tEitherStdStreams) => tEitherStdStreams.get().mapRight(({ stderr, stdout }) => {
      if (stderr)
        tEitherStdStreams.trace.traceScope(pengueno_1.LogLevel.DEBUG).trace(`StdErr = ${stderr}`);
      return stdout;
    }))).peek(pengueno_1.TraceUtil.promiseify(pengueno_1.TraceUtil.traceResultingEither(exports2.CmdMetric))).get();
    exports2.getStdout = getStdout;
    var getStdoutMany = (cmds, options = { streamTraceable: [] }) => cmds.coExtend((t) => t.get()).reduce(async (_result, tCmd) => {
      const result = await _result;
      return result.joinRightAsync(() => tCmd.map((cmd) => (0, exports2.getStdout)(cmd, options)).get(), (stdout, pre) => pre.concat(stdout));
    }, Promise.resolve(pengueno_1.Either.right([])));
    exports2.getStdoutMany = getStdoutMany;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/process/env.js
var require_env = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/process/env.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.getRequiredEnvVars = exports2.getRequiredEnv = exports2.getEnv = void 0;
    var pengueno_1 = require_dist2();
    var getEnv = (name) => pengueno_1.Optional.from(process.env[name]);
    exports2.getEnv = getEnv;
    var getRequiredEnv = (name) => pengueno_1.Either.fromFailable(() => (0, exports2.getEnv)(name).get()).mapLeft(() => new Error(`environment variable "${name}" is required D:`));
    exports2.getRequiredEnv = getRequiredEnv;
    var getRequiredEnvVars = (vars) => {
      const emptyEnvironment = pengueno_1.Either.right({});
      const addTo = (env, key, val) => ({
        ...env,
        [key]: val
      });
      return vars.reduce((environment, key) => environment.joinRight((0, exports2.getRequiredEnv)(key), (value, environment2) => addTo(environment2, key, value)), emptyEnvironment);
    };
    exports2.getRequiredEnvVars = getRequiredEnvVars;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/process/validate_identifier.js
var require_validate_identifier = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/process/validate_identifier.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.validateExecutionEntries = exports2.validateIdentifier = void 0;
    var pengueno_1 = require_dist2();
    var validateIdentifier = (token) => {
      return /^[a-zA-Z0-9_\-:. \/]+$/.test(token) && !token.includes("..");
    };
    exports2.validateIdentifier = validateIdentifier;
    var validateExecutionEntries = (obj) => {
      const invalidEntries = Object.entries(obj).filter((e) => !e.every((x) => typeof x === "string" && (0, exports2.validateIdentifier)(x)));
      if (invalidEntries.length > 0)
        return pengueno_1.Either.left(invalidEntries);
      return pengueno_1.Either.right(obj);
    };
    exports2.validateExecutionEntries = validateExecutionEntries;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/process/argv.js
var require_argv = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/process/argv.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.argv = exports2.getArg = exports2.isArgKey = void 0;
    var pengueno_1 = require_dist2();
    var isArgKey = (k) => k.startsWith("--");
    exports2.isArgKey = isArgKey;
    var getArg = (arg, argv2, whenValue) => {
      const argIndex = pengueno_1.Optional.from(argv2.findIndex((_argv) => (0, exports2.isArgKey)(_argv) && _argv.split("=")[0] === arg)).filter((index) => index >= 0 && index < argv2.length);
      if (!argIndex.present()) {
        return pengueno_1.Optional.from(whenValue.absent).map((v) => pengueno_1.Either.right(v)).orSome(() => pengueno_1.Either.left(new Error(`arg ${arg} is not present in arguments list and does not have an 'absent' value`))).get();
      }
      return argIndex.flatMap((idx) => pengueno_1.Optional.from(argv2.at(idx)).map((_argv) => _argv.includes("=") ? _argv.split("=")[1] : argv2.at(idx + 1))).filter((next) => !(0, exports2.isArgKey)(next)).map((next) => whenValue.present(next)).orSome(() => whenValue.unspecified).map((v) => pengueno_1.Either.right(v)).get();
    };
    exports2.getArg = getArg;
    var argv = (args, handlers, argv2 = process.argv.slice(2)) => {
      const defaultHandler = { present: (value) => value };
      const processArg = (arg) => {
        const handler = handlers?.[arg] ?? defaultHandler;
        return (0, exports2.getArg)(arg, argv2, handler).mapRight((value) => [arg, value]);
      };
      const res = args.map(processArg).reduce((acc, current) => acc.flatMap((accValue) => current.mapRight(([key, value]) => ({
        ...accValue,
        [key]: value
      }))), pengueno_1.Either.right({})).mapRight((result) => result);
      return res;
    };
    exports2.argv = argv;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/process/signals.js
var require_signals = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/process/signals.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Signals = exports2.SigTermMetric = exports2.SigIntMetric = void 0;
    var pengueno_1 = require_dist2();
    exports2.SigIntMetric = pengueno_1.Metric.fromName("SigInt").asResult();
    exports2.SigTermMetric = pengueno_1.Metric.fromName("SigTerm").asResult();
    var Signals = class {
      static async awaitClose(t) {
        const success = pengueno_1.Either.right(void 0);
        return new Promise((res) => {
          const metricizedInterruptHandler = (metric) => (err) => t.flatMap(pengueno_1.TraceUtil.withMetricTrace(metric)).peek((_t) => _t.trace.trace("closing")).move(pengueno_1.Optional.from(err).map((e) => pengueno_1.Either.left(e)).orSome(() => success).get()).flatMap(pengueno_1.TraceUtil.traceResultingEither(metric)).map((e) => res(e.get())).peek((_t) => _t.trace.trace("finished")).get();
          const sigintCloser = metricizedInterruptHandler(exports2.SigIntMetric);
          const sigtermCloser = metricizedInterruptHandler(exports2.SigTermMetric);
          process.on("SIGINT", () => t.flatMap(pengueno_1.TraceUtil.withTrace("SIGINT")).get().close(sigintCloser));
          process.on("SIGTERM", () => t.flatMap(pengueno_1.TraceUtil.withTrace("SIGTERM")).get().close(sigtermCloser));
        });
      }
    };
    exports2.Signals = Signals;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/process/index.js
var require_process = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/process/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_exec(), exports2);
    __exportStar(require_env(), exports2);
    __exportStar(require_validate_identifier(), exports2);
    __exportStar(require_argv(), exports2);
    __exportStar(require_signals(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/http/body.js
var require_body = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/http/body.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/http/status.js
var require_status = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/http/status.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.HttpStatusCodes = void 0;
    exports2.HttpStatusCodes = {
      100: "Continue",
      101: "Switching Protocols",
      102: "Processing (WebDAV)",
      200: "OK",
      201: "Created",
      202: "Accepted",
      203: "Non-Authoritative Information",
      204: "No Content",
      205: "Reset Content",
      206: "Partial Content",
      207: "Multi-Status (WebDAV)",
      208: "Already Reported (WebDAV)",
      226: "IM Used",
      300: "Multiple Choices",
      301: "Moved Permanently",
      302: "Found",
      303: "See Other",
      304: "Not Modified",
      305: "Use Proxy",
      306: "(Unused)",
      307: "Temporary Redirect",
      308: "Permanent Redirect (experimental)",
      400: "Bad Request",
      401: "Unauthorized",
      402: "Payment Required",
      403: "Forbidden",
      404: "Not Found",
      405: "Method Not Allowed",
      406: "Not Acceptable",
      407: "Proxy Authentication Required",
      408: "Request Timeout",
      409: "Conflict",
      410: "Gone",
      411: "Length Required",
      412: "Precondition Failed",
      413: "Request Entity Too Large",
      414: "Request-URI Too Long",
      415: "Unsupported Media Type",
      416: "Requested Range Not Satisfiable",
      417: "Expectation Failed",
      418: "I'm a teapot (RFC 2324)",
      420: "Enhance Your Calm (Twitter)",
      422: "Unprocessable Entity (WebDAV)",
      423: "Locked (WebDAV)",
      424: "Failed Dependency (WebDAV)",
      425: "Reserved for WebDAV",
      426: "Upgrade Required",
      428: "Precondition Required",
      429: "Too Many Requests",
      431: "Request Header Fields Too Large",
      444: "No Response (Nginx)",
      449: "Retry With (Microsoft)",
      450: "Blocked by Windows Parental Controls (Microsoft)",
      451: "Unavailable For Legal Reasons",
      499: "Client Closed Request (Nginx)",
      500: "Internal Server Error",
      501: "Not Implemented",
      502: "Bad Gateway",
      503: "Service Unavailable",
      504: "Gateway Timeout",
      505: "HTTP Version Not Supported",
      506: "Variant Also Negotiates (Experimental)",
      507: "Insufficient Storage (WebDAV)",
      508: "Loop Detected (WebDAV)",
      509: "Bandwidth Limit Exceeded (Apache)",
      510: "Not Extended",
      511: "Network Authentication Required",
      598: "Network read timeout error",
      599: "Network connect timeout error"
    };
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/http/method.js
var require_method = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/http/method.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/http/index.js
var require_http = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/http/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_body(), exports2);
    __exportStar(require_status(), exports2);
    __exportStar(require_method(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/response/pengueno.js
var require_pengueno = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/response/pengueno.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.JsonResponse = exports2.PenguenoResponse = exports2.getResponseMetrics = void 0;
    var pengueno_1 = require_dist2();
    var getHeaders = (req, extraHeaders) => {
      const optHeaders = {
        ...req.getResponseHeaders(),
        ...extraHeaders
      };
      optHeaders["Content-Type"] = (optHeaders["Content-Type"] ?? "text/plain") + "; charset=utf-8";
      return optHeaders;
    };
    var ResponseCodeMetrics = [0, 1, 2, 3, 4, 5].map((x) => pengueno_1.Metric.fromName(`response.${x}xx`).asResult());
    var getResponseMetrics = (status, elapsedMs) => {
      const index = Math.floor(status / 100);
      return ResponseCodeMetrics.flatMap((metric, i) => pengueno_1.Optional.from(i).filter((i2) => i2 === index).map(() => [metric.count.withValue(1)]).flatMap((metricValues) => pengueno_1.Optional.from(elapsedMs).map((ms) => metricValues.concat(metric.time.withValue(ms))).orSome(() => metricValues)).orSome(() => [metric.count.withValue(0)]).get());
    };
    exports2.getResponseMetrics = getResponseMetrics;
    var PenguenoResponse = class {
      _body;
      statusText;
      status;
      headers;
      constructor(req, _body, opts) {
        this._body = _body;
        this.headers = getHeaders(req.get(), opts?.headers ?? {});
        this.status = opts.status;
        this.statusText = opts.statusText ?? pengueno_1.HttpStatusCodes[this.status];
        req.trace.trace((0, exports2.getResponseMetrics)(opts.status, req.get().elapsedTimeMs()));
      }
      body() {
        return this._body;
      }
    };
    exports2.PenguenoResponse = PenguenoResponse;
    var JsonResponse = class extends PenguenoResponse {
      constructor(req, e, _opts) {
        const opts = { ..._opts, headers: { ..._opts.headers, "Content-Type": "application/json" } };
        if ((0, pengueno_1.isEither)(e)) {
          super(req, JSON.stringify(e.fold((error) => ({ error, ok: void 0 }), (ok) => ({ ok }))), opts);
          return;
        }
        super(req, JSON.stringify(Math.floor(opts.status / 100) > 4 ? { error: e } : { ok: e }), opts);
      }
    };
    exports2.JsonResponse = JsonResponse;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/response/index.js
var require_response = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/response/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_pengueno(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/request/pengueno.js
var require_pengueno2 = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/request/pengueno.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.PenguenoRequest = void 0;
    var greetings = ["hewwo :D", "hiya cutie", "boop!", "sending virtual hugs!", "stay pawsitive"];
    var penguenoGreeting = () => greetings[Math.floor(Math.random() * greetings.length)];
    var PenguenoRequest = class _PenguenoRequest {
      req;
      id;
      at;
      constructor(req, id, at) {
        this.req = req;
        this.id = id;
        this.at = at;
      }
      elapsedTimeMs(after = () => Date.now()) {
        return after() - this.at.getTime();
      }
      getResponseHeaders() {
        const RequestId = this.id;
        const RequestReceivedUnix = this.at.getTime();
        const RequestHandleUnix = Date.now();
        const DeltaUnix = this.elapsedTimeMs(() => RequestHandleUnix);
        const Hai = penguenoGreeting();
        return Object.entries({
          RequestId,
          RequestReceivedUnix,
          RequestHandleUnix,
          DeltaUnix,
          Hai
        }).reduce((acc, [key, val]) => ({ ...acc, [key]: val.toString() }), {});
      }
      static from(request) {
        const id = crypto.randomUUID();
        return request.bimap((tRequest) => {
          const request2 = tRequest.get();
          const url = new URL(request2.url);
          const { pathname } = url;
          const trace = `RequestId = ${id}, Method = ${request2.method}, Path = ${pathname}`;
          return { item: new _PenguenoRequest(request2, id, /* @__PURE__ */ new Date()), trace };
        });
      }
    };
    exports2.PenguenoRequest = PenguenoRequest;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/request/index.js
var require_request = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/request/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_pengueno2(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/activity/health.js
var require_health = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/activity/health.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.HealthCheckActivityImpl = exports2.HealthCheckOutput = exports2.HealthCheckInput = void 0;
    var pengueno_1 = require_dist2();
    var HealthCheckInput;
    (function(HealthCheckInput2) {
      HealthCheckInput2[HealthCheckInput2["CHECK"] = 0] = "CHECK";
    })(HealthCheckInput || (exports2.HealthCheckInput = HealthCheckInput = {}));
    var HealthCheckOutput;
    (function(HealthCheckOutput2) {
      HealthCheckOutput2[HealthCheckOutput2["YAASSSLAYQUEEN"] = 0] = "YAASSSLAYQUEEN";
    })(HealthCheckOutput || (exports2.HealthCheckOutput = HealthCheckOutput = {}));
    var healthCheckMetric = pengueno_1.Metric.fromName("Health").asResult();
    var HealthCheckActivityImpl = class {
      check;
      constructor(check) {
        this.check = check;
      }
      checkHealth(req) {
        return req.flatMap(pengueno_1.TraceUtil.withFunctionTrace(this.checkHealth)).flatMap(pengueno_1.TraceUtil.withMetricTrace(healthCheckMetric)).flatMap((r) => r.move(HealthCheckInput.CHECK).map((input) => this.check(input))).peek(pengueno_1.TraceUtil.promiseify(pengueno_1.TraceUtil.traceResultingEither(healthCheckMetric))).map(pengueno_1.TraceUtil.promiseify((h) => {
          const { status, message } = h.get().fold(() => ({ status: 500, message: "err" }), () => ({ status: 200, message: "ok" }));
          return new pengueno_1.JsonResponse(req, message, { status });
        })).get();
      }
    };
    exports2.HealthCheckActivityImpl = HealthCheckActivityImpl;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/activity/fourohfour.js
var require_fourohfour = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/activity/fourohfour.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.FourOhFourActivityImpl = void 0;
    var pengueno_1 = require_dist2();
    var messages = [
      "D: meow-t found! your api call ran away!",
      "404-bidden! but like...in a cute way >:3 !",
      ":< your data went on a paw-sible vacation!",
      "uwu~ not found, but found our hearts instead!"
    ];
    var randomFourOhFour = () => messages[Math.floor(Math.random() * messages.length)];
    var FourOhFourActivityImpl = class {
      fourOhFour(req) {
        return req.move(new pengueno_1.JsonResponse(req, randomFourOhFour(), { status: 404 })).map((resp) => Promise.resolve(resp.get())).get();
      }
    };
    exports2.FourOhFourActivityImpl = FourOhFourActivityImpl;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/activity/index.js
var require_activity = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/activity/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_health(), exports2);
    __exportStar(require_fourohfour(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/filter/method.js
var require_method2 = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/filter/method.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.requireMethod = void 0;
    var pengueno_1 = require_dist2();
    var requireMethod = (methods) => (req) => req.flatMap(pengueno_1.TraceUtil.withFunctionTrace(exports2.requireMethod)).map((t) => {
      const { req: { method } } = t.get();
      if (!methods.includes(method)) {
        const msg = "that's not how you pet me (\u22DF\uFE4F\u22DE)~";
        t.trace.traceScope(pengueno_1.LogLevel.WARN).trace(msg);
        return pengueno_1.Either.left(new pengueno_1.PenguenoError(msg, 405));
      }
      return pengueno_1.Either.right(method);
    }).get();
    exports2.requireMethod = requireMethod;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/filter/json.js
var require_json = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/filter/json.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.jsonModel = void 0;
    var pengueno_1 = require_dist2();
    var ParseJsonMetric = pengueno_1.Metric.fromName("JsonParse").asResult();
    var jsonModel = (jsonTransformer) => (r) => r.flatMap(pengueno_1.TraceUtil.withFunctionTrace(exports2.jsonModel)).flatMap(pengueno_1.TraceUtil.withMetricTrace(ParseJsonMetric)).map((j) => pengueno_1.Either.fromFailableAsync(j.get().req.json()).then((either) => either.mapLeft((errReason) => {
      j.trace.traceScope(pengueno_1.LogLevel.WARN).trace(errReason);
      return new pengueno_1.PenguenoError("seems to be invalid JSON (>//<) can you fix?", 400);
    }))).flatMapAsync(pengueno_1.TraceUtil.promiseify(pengueno_1.TraceUtil.traceResultingEither(ParseJsonMetric))).map(pengueno_1.TraceUtil.promiseify((traceableEitherJson) => traceableEitherJson.get().mapRight((j) => traceableEitherJson.move(j)).flatMap(jsonTransformer))).get();
    exports2.jsonModel = jsonModel;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/filter/index.js
var require_filter = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/filter/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.PenguenoError = exports2.ErrorSource = void 0;
    var pengueno_1 = require_dist2();
    var ErrorSource;
    (function(ErrorSource2) {
      ErrorSource2["USER"] = "WARN";
      ErrorSource2["SYSTEM"] = "ERROR";
    })(ErrorSource || (exports2.ErrorSource = ErrorSource = {}));
    var PenguenoError = class extends Error {
      message;
      status;
      source;
      constructor(message, status) {
        super(message);
        this.message = message;
        this.status = status;
        this.source = Math.floor(status / 100) === 4 ? ErrorSource.USER : ErrorSource.SYSTEM;
      }
    };
    exports2.PenguenoError = PenguenoError;
    __exportStar(require_method2(), exports2);
    __exportStar(require_json(), exports2);
  }
});

// ../node_modules/@hono/node-server/dist/index.js
var require_dist = __commonJS({
  "../node_modules/@hono/node-server/dist/index.js"(exports2, module2) {
    "use strict";
    var __create2 = Object.create;
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __getProtoOf2 = Object.getPrototypeOf;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
      // If the importer is in node compatibility mode or this is not an ESM
      // file that has been converted to a CommonJS file using a Babel-
      // compatible transform (i.e. "__esModule" has not been set), then set
      // "default" to the CommonJS "module.exports" for node compatibility.
      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
      mod
    ));
    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var src_exports = {};
    __export(src_exports, {
      RequestError: () => RequestError,
      createAdaptorServer: () => createAdaptorServer,
      getRequestListener: () => getRequestListener,
      serve: () => serve
    });
    module2.exports = __toCommonJS(src_exports);
    var import_node_http = require("http");
    var import_node_http2 = require("http2");
    var import_node_stream = require("stream");
    var RequestError = class extends Error {
      constructor(message, options) {
        super(message, options);
        this.name = "RequestError";
      }
    };
    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_node_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 incomingUrl = incoming.url || "";
      if (incomingUrl[0] !== "/" && // short-circuit for performance. most requests are relative URL.
      (incomingUrl.startsWith("http://") || incomingUrl.startsWith("https://"))) {
        if (incoming instanceof import_node_http2.Http2ServerRequest) {
          throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
        }
        try {
          const url2 = new URL(incomingUrl);
          req[urlKey] = url2.href;
        } catch (e) {
          throw new RequestError("Invalid absolute URL", { cause: e });
        }
        return req;
      }
      const host = (incoming instanceof import_node_http2.Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
      if (!host) {
        throw new RequestError("Missing host header");
      }
      let scheme;
      if (incoming instanceof import_node_http2.Http2ServerRequest) {
        scheme = incoming.scheme;
        if (!(scheme === "http" || scheme === "https")) {
          throw new RequestError("Unsupported scheme");
        }
      } else {
        scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
      }
      const url = new URL(`${scheme}://${host}${incomingUrl}`);
      if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
        throw new RequestError("Invalid host header");
      }
      req[urlKey] = url.href;
      return req;
    };
    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) {
        let headers;
        this.#body = body;
        if (init instanceof _Response) {
          const cachedGlobalResponse = init[responseCache];
          if (cachedGlobalResponse) {
            this.#init = cachedGlobalResponse;
            this[getResponseCache]();
            return;
          } else {
            this.#init = init.#init;
            headers = new Headers(init.#init.headers);
          }
        } else {
          this.#init = init;
        }
        if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) {
          headers ||= init?.headers || { "content-type": "text/plain; charset=UTF-8" };
          this[cacheKey] = [init?.status || 200, body, headers];
        }
      }
      get headers() {
        const cache = this[cacheKey];
        if (cache) {
          if (!(cache[2] instanceof Headers)) {
            cache[2] = new Headers(cache[2]);
          }
          return cache[2];
        }
        return this[getResponseCache]().headers;
      }
      get status() {
        return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
      }
      get ok() {
        const status = this.status;
        return status >= 200 && status < 300;
      }
    };
    ["body", "bodyUsed", "redirected", "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);
    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 X_ALREADY_SENT = "x-hono-already-sent";
    var import_node_crypto = __toESM2(require("crypto"));
    var webFetch = global.fetch;
    if (typeof global.crypto === "undefined") {
      global.crypto = import_node_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 flushHeaders = (outgoing) => {
      if ("flushHeaders" in outgoing && outgoing.writable) {
        outgoing.flushHeaders();
      }
    };
    var responseViaCache = async (res, outgoing) => {
      let [status, body, header] = res[cacheKey];
      if (header instanceof Headers) {
        header = buildOutgoingHttpHeaders(header);
      }
      if (typeof body === "string") {
        header["Content-Length"] = Buffer.byteLength(body);
      } else if (body instanceof Uint8Array) {
        header["Content-Length"] = body.byteLength;
      } else if (body instanceof Blob) {
        header["Content-Length"] = body.size;
      }
      outgoing.writeHead(status, header);
      if (typeof body === "string" || body instanceof Uint8Array) {
        outgoing.end(body);
      } else if (body instanceof Blob) {
        outgoing.end(new Uint8Array(await body.arrayBuffer()));
      } else {
        flushHeaders(outgoing);
        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);
      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);
          flushHeaders(outgoing);
          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 await 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_node_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;
    };
  }
});

// ../node_modules/hono/dist/cjs/compose.js
var require_compose = __commonJS({
  "../node_modules/hono/dist/cjs/compose.js"(exports2, module2) {
    "use strict";
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var compose_exports = {};
    __export(compose_exports, {
      compose: () => compose
    });
    module2.exports = __toCommonJS(compose_exports);
    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;
        }
      };
    };
  }
});

// ../node_modules/hono/dist/cjs/request/constants.js
var require_constants = __commonJS({
  "../node_modules/hono/dist/cjs/request/constants.js"(exports2, module2) {
    "use strict";
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var constants_exports = {};
    __export(constants_exports, {
      GET_MATCH_RESULT: () => GET_MATCH_RESULT
    });
    module2.exports = __toCommonJS(constants_exports);
    var GET_MATCH_RESULT = Symbol();
  }
});

// ../node_modules/hono/dist/cjs/utils/body.js
var require_body2 = __commonJS({
  "../node_modules/hono/dist/cjs/utils/body.js"(exports2, module2) {
    "use strict";
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var body_exports = {};
    __export(body_exports, {
      parseBody: () => parseBody
    });
    module2.exports = __toCommonJS(body_exports);
    var import_request = require_request2();
    var parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
      const { all = false, dot = false } = options;
      const headers = request instanceof import_request.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 {
        if (!key.endsWith("[]")) {
          form[key] = value;
        } else {
          form[key] = [value];
        }
      }
    };
    var handleParsingNestedValues = (form, key, value) => {
      let nestedForm = form;
      const keys = key.split(".");
      keys.forEach((key2, index) => {
        if (index === keys.length - 1) {
          nestedForm[key2] = value;
        } else {
          if (!nestedForm[key2] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) {
            nestedForm[key2] = /* @__PURE__ */ Object.create(null);
          }
          nestedForm = nestedForm[key2];
        }
      });
    };
  }
});

// ../node_modules/hono/dist/cjs/utils/url.js
var require_url = __commonJS({
  "../node_modules/hono/dist/cjs/utils/url.js"(exports2, module2) {
    "use strict";
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var url_exports = {};
    __export(url_exports, {
      checkOptionalParameter: () => checkOptionalParameter,
      decodeURIComponent_: () => decodeURIComponent_,
      getPath: () => getPath,
      getPathNoStrict: () => getPathNoStrict,
      getPattern: () => getPattern,
      getQueryParam: () => getQueryParam,
      getQueryParams: () => getQueryParams,
      getQueryStrings: () => getQueryStrings,
      mergePath: () => mergePath,
      splitPath: () => splitPath,
      splitRoutingPath: () => splitRoutingPath,
      tryDecode: () => tryDecode
    });
    module2.exports = __toCommonJS(url_exports);
    var splitPath = (path) => {
      const paths = path.split("/");
      if (paths[0] === "") {
        paths.shift();
      }
      return paths;
    };
    var splitRoutingPath = (routePath) => {
      const { groups, path } = extractGroupsFromPath(routePath);
      const paths = splitPath(path);
      return replaceGroupMarks(paths, groups);
    };
    var extractGroupsFromPath = (path) => {
      const groups = [];
      path = path.replace(/\{[^}]+\}/g, (match, index) => {
        const mark = `@${index}`;
        groups.push([mark, match]);
        return mark;
      });
      return { groups, path };
    };
    var replaceGroupMarks = (paths, groups) => {
      for (let i = groups.length - 1; i >= 0; i--) {
        const [mark] = groups[i];
        for (let j = paths.length - 1; j >= 0; j--) {
          if (paths[j].includes(mark)) {
            paths[j] = paths[j].replace(mark, groups[i][1]);
            break;
          }
        }
      }
      return paths;
    };
    var patternCache = {};
    var getPattern = (label, next) => {
      if (label === "*") {
        return "*";
      }
      const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
      if (match) {
        const cacheKey = `${label}#${next}`;
        if (!patternCache[cacheKey]) {
          if (match[2]) {
            patternCache[cacheKey] = next && next[0] !== ":" && next[0] !== "*" ? [cacheKey, match[1], new RegExp(`^${match[2]}(?=/${next})`)] : [label, match[1], new RegExp(`^${match[2]}$`)];
          } else {
            patternCache[cacheKey] = [label, match[1], true];
          }
        }
        return patternCache[cacheKey];
      }
      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(
        "/",
        url.charCodeAt(9) === 58 ? 13 : 8
      );
      let i = start;
      for (; i < url.length; i++) {
        const charCode = url.charCodeAt(i);
        if (charCode === 37) {
          const queryIndex = url.indexOf("?", i);
          const path = url.slice(start, queryIndex === -1 ? void 0 : queryIndex);
          return tryDecodeURI(path.includes("%25") ? path.replace(/%25/g, "%2525") : path);
        } else if (charCode === 63) {
          break;
        }
      }
      return url.slice(start, i);
    };
    var getQueryStrings = (url) => {
      const queryIndex = url.indexOf("?", 8);
      return queryIndex === -1 ? "" : "?" + url.slice(queryIndex + 1);
    };
    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 = (path) => {
      if (path.charCodeAt(path.length - 1) !== 63 || !path.includes(":")) {
        return null;
      }
      const segments = path.split("/");
      const results = [];
      let basePath = "";
      segments.forEach((segment) => {
        if (segment !== "" && !/\:/.test(segment)) {
          basePath += "/" + segment;
        } else if (/\:/.test(segment)) {
          if (/\?/.test(segment)) {
            if (results.length === 0 && basePath === "") {
              results.push("/");
            } else {
              results.push(basePath);
            }
            const optionalSegment = segment.replace("?", "");
            basePath += "/" + optionalSegment;
            results.push(basePath);
          } else {
            basePath += "/" + segment;
          }
        }
      });
      return results.filter((v, i, a) => a.indexOf(v) === i);
    };
    var _decodeURI = (value) => {
      if (!/[%+]/.test(value)) {
        return value;
      }
      if (value.indexOf("+") !== -1) {
        value = value.replace(/\+/g, " ");
      }
      return value.indexOf("%") !== -1 ? tryDecode(value, decodeURIComponent_) : value;
    };
    var _getQueryParam = (url, key, multiple) => {
      let encoded;
      if (!multiple && key && !/[%+]/.test(key)) {
        let keyIndex2 = url.indexOf(`?${key}`, 8);
        if (keyIndex2 === -1) {
          keyIndex2 = url.indexOf(`&${key}`, 8);
        }
        while (keyIndex2 !== -1) {
          const trailingKeyCode = url.charCodeAt(keyIndex2 + key.length + 1);
          if (trailingKeyCode === 61) {
            const valueIndex = keyIndex2 + key.length + 2;
            const endIndex = url.indexOf("&", valueIndex);
            return _decodeURI(url.slice(valueIndex, endIndex === -1 ? void 0 : endIndex));
          } else if (trailingKeyCode == 38 || isNaN(trailingKeyCode)) {
            return "";
          }
          keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
        }
        encoded = /[%+]/.test(url);
        if (!encoded) {
          return void 0;
        }
      }
      const results = {};
      encoded ??= /[%+]/.test(url);
      let keyIndex = url.indexOf("?", 8);
      while (keyIndex !== -1) {
        const nextKeyIndex = url.indexOf("&", keyIndex + 1);
        let valueIndex = url.indexOf("=", keyIndex);
        if (valueIndex > nextKeyIndex && nextKeyIndex !== -1) {
          valueIndex = -1;
        }
        let name = url.slice(
          keyIndex + 1,
          valueIndex === -1 ? nextKeyIndex === -1 ? void 0 : nextKeyIndex : valueIndex
        );
        if (encoded) {
          name = _decodeURI(name);
        }
        keyIndex = nextKeyIndex;
        if (name === "") {
          continue;
        }
        let value;
        if (valueIndex === -1) {
          value = "";
        } else {
          value = url.slice(valueIndex + 1, nextKeyIndex === -1 ? void 0 : nextKeyIndex);
          if (encoded) {
            value = _decodeURI(value);
          }
        }
        if (multiple) {
          if (!(results[name] && Array.isArray(results[name]))) {
            results[name] = [];
          }
          ;
          results[name].push(value);
        } else {
          results[name] ??= value;
        }
      }
      return key ? results[key] : results;
    };
    var getQueryParam = _getQueryParam;
    var getQueryParams = (url, key) => {
      return _getQueryParam(url, key, true);
    };
    var decodeURIComponent_ = decodeURIComponent;
  }
});

// ../node_modules/hono/dist/cjs/request.js
var require_request2 = __commonJS({
  "../node_modules/hono/dist/cjs/request.js"(exports2, module2) {
    "use strict";
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var request_exports = {};
    __export(request_exports, {
      HonoRequest: () => HonoRequest
    });
    module2.exports = __toCommonJS(request_exports);
    var import_constants = require_constants();
    var import_body = require_body2();
    var import_url = require_url();
    var tryDecodeURIComponent = (str) => (0, import_url.tryDecode)(str, import_url.decodeURIComponent_);
    var HonoRequest = class {
      raw;
      #validatedData;
      #matchResult;
      routeIndex = 0;
      path;
      bodyCache = {};
      constructor(request, path = "/", matchResult = [[]]) {
        this.raw = request;
        this.path = path;
        this.#matchResult = matchResult;
        this.#validatedData = {};
      }
      param(key) {
        return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
      }
      #getDecodedParam(key) {
        const paramKey = this.#matchResult[0][this.routeIndex][1][key];
        const param = this.#getParamValue(paramKey);
        return param ? /\%/.test(param) ? 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 (0, import_url.getQueryParam)(this.url, key);
      }
      queries(key) {
        return (0, import_url.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 (0, import_body.parseBody)(this, options);
      }
      #cachedBody = (key) => {
        const { bodyCache, raw } = 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] = raw[key]();
      };
      json() {
        return this.#cachedBody("text").then((text) => JSON.parse(text));
      }
      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 [import_constants.GET_MATCH_RESULT]() {
        return this.#matchResult;
      }
      get matchedRoutes() {
        return this.#matchResult[0].map(([[, route]]) => route);
      }
      get routePath() {
        return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
      }
    };
  }
});

// ../node_modules/hono/dist/cjs/utils/html.js
var require_html = __commonJS({
  "../node_modules/hono/dist/cjs/utils/html.js"(exports2, module2) {
    "use strict";
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var html_exports = {};
    __export(html_exports, {
      HtmlEscapedCallbackPhase: () => HtmlEscapedCallbackPhase,
      escapeToBuffer: () => escapeToBuffer,
      raw: () => raw,
      resolveCallback: () => resolveCallback,
      resolveCallbackSync: () => resolveCallbackSync,
      stringBufferToString: () => stringBufferToString
    });
    module2.exports = __toCommonJS(html_exports);
    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 escapeRe = /[&<>'"]/;
    var stringBufferToString = async (buffer, callbacks) => {
      let str = "";
      callbacks ||= [];
      const resolvedBuffer = await Promise.all(buffer);
      for (let i = resolvedBuffer.length - 1; ; i--) {
        str += resolvedBuffer[i];
        i--;
        if (i < 0) {
          break;
        }
        let r = resolvedBuffer[i];
        if (typeof r === "object") {
          callbacks.push(...r.callbacks || []);
        }
        const isEscaped = r.isEscaped;
        r = await (typeof r === "object" ? r.toString() : r);
        if (typeof r === "object") {
          callbacks.push(...r.callbacks || []);
        }
        if (r.isEscaped ?? isEscaped) {
          str += r;
        } else {
          const buf = [str];
          escapeToBuffer(r, buf);
          str = buf[0];
        }
      }
      return raw(str, callbacks);
    };
    var escapeToBuffer = (str, buffer) => {
      const match = str.search(escapeRe);
      if (match === -1) {
        buffer[0] += str;
        return;
      }
      let escape;
      let index;
      let lastIndex = 0;
      for (index = match; index < str.length; index++) {
        switch (str.charCodeAt(index)) {
          case 34:
            escape = "&quot;";
            break;
          case 39:
            escape = "&#39;";
            break;
          case 38:
            escape = "&amp;";
            break;
          case 60:
            escape = "&lt;";
            break;
          case 62:
            escape = "&gt;";
            break;
          default:
            continue;
        }
        buffer[0] += str.substring(lastIndex, index) + escape;
        lastIndex = index + 1;
      }
      buffer[0] += str.substring(lastIndex, index);
    };
    var resolveCallbackSync = (str) => {
      const callbacks = str.callbacks;
      if (!callbacks?.length) {
        return str;
      }
      const buffer = [str];
      const context = {};
      callbacks.forEach((c) => c({ phase: HtmlEscapedCallbackPhase.Stringify, buffer, context }));
      return buffer[0];
    };
    var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
      if (typeof str === "object" && !(str instanceof String)) {
        if (!(str instanceof Promise)) {
          str = str.toString();
        }
        if (str instanceof Promise) {
          str = await str;
        }
      }
      const callbacks = str.callbacks;
      if (!callbacks?.length) {
        return Promise.resolve(str);
      }
      if (buffer) {
        buffer[0] += str;
      } else {
        buffer = [str];
      }
      const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then(
        (res) => Promise.all(
          res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))
        ).then(() => buffer[0])
      );
      if (preserveCallbacks) {
        return raw(await resStr, callbacks);
      } else {
        return resStr;
      }
    };
  }
});

// ../node_modules/hono/dist/cjs/context.js
var require_context = __commonJS({
  "../node_modules/hono/dist/cjs/context.js"(exports2, module2) {
    "use strict";
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var context_exports = {};
    __export(context_exports, {
      Context: () => Context,
      TEXT_PLAIN: () => TEXT_PLAIN
    });
    module2.exports = __toCommonJS(context_exports);
    var import_request = require_request2();
    var import_html = require_html();
    var TEXT_PLAIN = "text/plain; charset=UTF-8";
    var setDefaultContentType = (contentType, headers) => {
      return {
        "Content-Type": contentType,
        ...headers
      };
    };
    var Context = class {
      #rawRequest;
      #req;
      env = {};
      #var;
      finalized = false;
      error;
      #status;
      #executionCtx;
      #res;
      #layout;
      #renderer;
      #notFoundHandler;
      #preparedHeaders;
      #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 import_request.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() {
        return this.#res ||= new Response(null, {
          headers: this.#preparedHeaders ??= new Headers()
        });
      }
      set res(_res) {
        if (this.#res && _res) {
          _res = new Response(_res.body, _res);
          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);
            }
          }
        }
        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 (this.finalized) {
          this.#res = new Response(this.#res.body, this.#res);
        }
        const headers = this.#res ? this.#res.headers : this.#preparedHeaders ??= new Headers();
        if (value === void 0) {
          headers.delete(name);
        } else if (options?.append) {
          headers.append(name, value);
        } else {
          headers.set(name, value);
        }
      };
      status = (status) => {
        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) {
        const responseHeaders = this.#res ? new Headers(this.#res.headers) : this.#preparedHeaders ?? new Headers();
        if (typeof arg === "object" && "headers" in arg) {
          const argHeaders = arg.headers instanceof Headers ? arg.headers : new Headers(arg.headers);
          for (const [key, value] of argHeaders) {
            if (key.toLowerCase() === "set-cookie") {
              responseHeaders.append(key, value);
            } else {
              responseHeaders.set(key, value);
            }
          }
        }
        if (headers) {
          for (const [k, v] of Object.entries(headers)) {
            if (typeof v === "string") {
              responseHeaders.set(k, v);
            } else {
              responseHeaders.delete(k);
              for (const v2 of v) {
                responseHeaders.append(k, v2);
              }
            }
          }
        }
        const status = typeof arg === "number" ? arg : arg?.status ?? this.#status;
        return new Response(data, { status, headers: responseHeaders });
      }
      newResponse = (...args) => this.#newResponse(...args);
      body = (data, arg, headers) => this.#newResponse(data, arg, headers);
      text = (text, arg, headers) => {
        return !this.#preparedHeaders && !this.#status && !arg && !headers && !this.finalized ? new Response(text) : this.#newResponse(
          text,
          arg,
          setDefaultContentType(TEXT_PLAIN, headers)
        );
      };
      json = (object, arg, headers) => {
        return this.#newResponse(
          JSON.stringify(object),
          arg,
          setDefaultContentType("application/json", headers)
        );
      };
      html = (html, arg, headers) => {
        const res = (html2) => this.#newResponse(html2, arg, setDefaultContentType("text/html; charset=UTF-8", headers));
        return typeof html === "object" ? (0, import_html.resolveCallback)(html, import_html.HtmlEscapedCallbackPhase.Stringify, false, {}).then(res) : res(html);
      };
      redirect = (location, status) => {
        const locationString = String(location);
        this.header(
          "Location",
          !/[^\x00-\xFF]/.test(locationString) ? locationString : encodeURI(locationString)
        );
        return this.newResponse(null, status ?? 302);
      };
      notFound = () => {
        this.#notFoundHandler ??= () => new Response();
        return this.#notFoundHandler(this);
      };
    };
  }
});

// ../node_modules/hono/dist/cjs/router.js
var require_router = __commonJS({
  "../node_modules/hono/dist/cjs/router.js"(exports2, module2) {
    "use strict";
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var router_exports = {};
    __export(router_exports, {
      MESSAGE_MATCHER_IS_ALREADY_BUILT: () => MESSAGE_MATCHER_IS_ALREADY_BUILT,
      METHODS: () => METHODS,
      METHOD_NAME_ALL: () => METHOD_NAME_ALL,
      METHOD_NAME_ALL_LOWERCASE: () => METHOD_NAME_ALL_LOWERCASE,
      UnsupportedPathError: () => UnsupportedPathError
    });
    module2.exports = __toCommonJS(router_exports);
    var METHOD_NAME_ALL = "ALL";
    var METHOD_NAME_ALL_LOWERCASE = "all";
    var METHODS = ["get", "post", "put", "delete", "options", "patch"];
    var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
    var UnsupportedPathError = class extends Error {
    };
  }
});

// ../node_modules/hono/dist/cjs/utils/constants.js
var require_constants2 = __commonJS({
  "../node_modules/hono/dist/cjs/utils/constants.js"(exports2, module2) {
    "use strict";
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var constants_exports = {};
    __export(constants_exports, {
      COMPOSED_HANDLER: () => COMPOSED_HANDLER
    });
    module2.exports = __toCommonJS(constants_exports);
    var COMPOSED_HANDLER = "__COMPOSED_HANDLER";
  }
});

// ../node_modules/hono/dist/cjs/hono-base.js
var require_hono_base = __commonJS({
  "../node_modules/hono/dist/cjs/hono-base.js"(exports2, module2) {
    "use strict";
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var hono_base_exports = {};
    __export(hono_base_exports, {
      HonoBase: () => Hono2
    });
    module2.exports = __toCommonJS(hono_base_exports);
    var import_compose = require_compose();
    var import_context = require_context();
    var import_router = require_router();
    var import_constants = require_constants2();
    var import_url = require_url();
    var notFoundHandler = (c) => {
      return c.text("404 Not Found", 404);
    };
    var errorHandler = (err, c) => {
      if ("getResponse" in err) {
        const res = err.getResponse();
        return c.newResponse(res.body, res);
      }
      console.error(err);
      return c.text("Internal Server Error", 500);
    };
    var Hono2 = class _Hono {
      get;
      post;
      put;
      delete;
      options;
      patch;
      all;
      on;
      use;
      router;
      getPath;
      _basePath = "/";
      #path = "/";
      routes = [];
      constructor(options = {}) {
        const allMethods = [...import_router.METHODS, import_router.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, path, ...handlers) => {
          for (const p of [path].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(import_router.METHOD_NAME_ALL, this.#path, handler);
          });
          return this;
        };
        const { strict, ...optionsWithoutStrict } = options;
        Object.assign(this, optionsWithoutStrict);
        this.getPath = strict ?? true ? options.getPath ?? import_url.getPath : import_url.getPathNoStrict;
      }
      #clone() {
        const clone = new _Hono({
          router: this.router,
          getPath: this.getPath
        });
        clone.errorHandler = this.errorHandler;
        clone.#notFoundHandler = this.#notFoundHandler;
        clone.routes = this.routes;
        return clone;
      }
      #notFoundHandler = notFoundHandler;
      errorHandler = errorHandler;
      route(path, app) {
        const subApp = this.basePath(path);
        app.routes.map((r) => {
          let handler;
          if (app.errorHandler === errorHandler) {
            handler = r.handler;
          } else {
            handler = async (c, next) => (await (0, import_compose.compose)([], app.errorHandler)(c, () => r.handler(c, next))).res;
            handler[import_constants.COMPOSED_HANDLER] = r.handler;
          }
          subApp.#addRoute(r.method, r.path, handler);
        });
        return this;
      }
      basePath(path) {
        const subApp = this.#clone();
        subApp._basePath = (0, import_url.mergePath)(this._basePath, path);
        return subApp;
      }
      onError = (handler) => {
        this.errorHandler = handler;
        return this;
      };
      notFound = (handler) => {
        this.#notFoundHandler = handler;
        return this;
      };
      mount(path, applicationHandler, options) {
        let replaceRequest;
        let optionHandler;
        if (options) {
          if (typeof options === "function") {
            optionHandler = options;
          } else {
            optionHandler = options.optionHandler;
            if (options.replaceRequest === false) {
              replaceRequest = (request) => request;
            } else {
              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 = (0, import_url.mergePath)(this._basePath, path);
          const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
          return (request) => {
            const url = new URL(request.url);
            url.pathname = url.pathname.slice(pathPrefixLength) || "/";
            return new Request(url, request);
          };
        })();
        const handler = async (c, next) => {
          const res = await applicationHandler(replaceRequest(c.req.raw), ...getOptions(c));
          if (res) {
            return res;
          }
          await next();
        };
        this.#addRoute(import_router.METHOD_NAME_ALL, (0, import_url.mergePath)(path, "*"), handler);
        return this;
      }
      #addRoute(method, path, handler) {
        method = method.toUpperCase();
        path = (0, import_url.mergePath)(this._basePath, path);
        const r = { basePath: this._basePath, path, method, handler };
        this.router.add(method, path, [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 path = this.getPath(request, { env });
        const matchResult = this.router.match(method, path);
        const c = new import_context.Context(request, {
          path,
          matchResult,
          env,
          executionCtx,
          notFoundHandler: this.#notFoundHandler
        });
        if (matchResult[0].length === 1) {
          let res;
          try {
            res = matchResult[0][0][0][0](c, async () => {
              c.res = await this.#notFoundHandler(c);
            });
          } catch (err) {
            return this.#handleError(err, c);
          }
          return res instanceof Promise ? res.then(
            (resolved) => resolved || (c.finalized ? c.res : this.#notFoundHandler(c))
          ).catch((err) => this.#handleError(err, c)) : res ?? this.#notFoundHandler(c);
        }
        const composed = (0, import_compose.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${(0, import_url.mergePath)("/", input)}`,
            requestInit
          ),
          Env,
          executionCtx
        );
      };
      fire = () => {
        addEventListener("fetch", (event) => {
          event.respondWith(this.#dispatch(event.request, event, void 0, event.request.method));
        });
      };
    };
  }
});

// ../node_modules/hono/dist/cjs/router/reg-exp-router/node.js
var require_node = __commonJS({
  "../node_modules/hono/dist/cjs/router/reg-exp-router/node.js"(exports2, module2) {
    "use strict";
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var node_exports = {};
    __export(node_exports, {
      Node: () => Node,
      PATH_ERROR: () => PATH_ERROR
    });
    module2.exports = __toCommonJS(node_exports);
    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 _Node {
      #index;
      #varIndex;
      #children = /* @__PURE__ */ Object.create(null);
      insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
        if (tokens.length === 0) {
          if (this.#index !== void 0) {
            throw PATH_ERROR;
          }
          if (pathErrorCheckOnly) {
            return;
          }
          this.#index = index;
          return;
        }
        const [token, ...restTokens] = tokens;
        const pattern = token === "*" ? restTokens.length === 0 ? ["", "", ONLY_WILDCARD_REG_EXP_STR] : ["", "", LABEL_REG_EXP_STR] : token === "/*" ? ["", "", TAIL_WILDCARD_REG_EXP_STR] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
        let node;
        if (pattern) {
          const name = pattern[1];
          let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
          if (name && pattern[2]) {
            regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
            if (/\((?!\?:)/.test(regexpStr)) {
              throw PATH_ERROR;
            }
          }
          node = this.#children[regexpStr];
          if (!node) {
            if (Object.keys(this.#children).some(
              (k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
            )) {
              throw PATH_ERROR;
            }
            if (pathErrorCheckOnly) {
              return;
            }
            node = this.#children[regexpStr] = new _Node();
            if (name !== "") {
              node.#varIndex = context.varIndex++;
            }
          }
          if (!pathErrorCheckOnly && name !== "") {
            paramMap.push([name, node.#varIndex]);
          }
        } else {
          node = this.#children[token];
          if (!node) {
            if (Object.keys(this.#children).some(
              (k) => k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
            )) {
              throw PATH_ERROR;
            }
            if (pathErrorCheckOnly) {
              return;
            }
            node = this.#children[token] = new _Node();
          }
        }
        node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
      }
      buildRegExpStr() {
        const childKeys = Object.keys(this.#children).sort(compareKey);
        const strList = childKeys.map((k) => {
          const c = this.#children[k];
          return (typeof c.#varIndex === "number" ? `(${k})@${c.#varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
        });
        if (typeof this.#index === "number") {
          strList.unshift(`#${this.#index}`);
        }
        if (strList.length === 0) {
          return "";
        }
        if (strList.length === 1) {
          return strList[0];
        }
        return "(?:" + strList.join("|") + ")";
      }
    };
  }
});

// ../node_modules/hono/dist/cjs/router/reg-exp-router/trie.js
var require_trie = __commonJS({
  "../node_modules/hono/dist/cjs/router/reg-exp-router/trie.js"(exports2, module2) {
    "use strict";
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var trie_exports = {};
    __export(trie_exports, {
      Trie: () => Trie
    });
    module2.exports = __toCommonJS(trie_exports);
    var import_node = require_node();
    var Trie = class {
      #context = { varIndex: 0 };
      #root = new import_node.Node();
      insert(path, index, pathErrorCheckOnly) {
        const paramAssoc = [];
        const groups = [];
        for (let i = 0; ; ) {
          let replaced = false;
          path = path.replace(/\{[^}]+\}/g, (m) => {
            const mark = `@\\${i}`;
            groups[i] = [mark, m];
            i++;
            replaced = true;
            return mark;
          });
          if (!replaced) {
            break;
          }
        }
        const tokens = path.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
        for (let i = groups.length - 1; i >= 0; i--) {
          const [mark] = groups[i];
          for (let j = tokens.length - 1; j >= 0; j--) {
            if (tokens[j].indexOf(mark) !== -1) {
              tokens[j] = tokens[j].replace(mark, groups[i][1]);
              break;
            }
          }
        }
        this.#root.insert(tokens, index, paramAssoc, this.#context, pathErrorCheckOnly);
        return paramAssoc;
      }
      buildRegExp() {
        let regexp = this.#root.buildRegExpStr();
        if (regexp === "") {
          return [/^$/, [], []];
        }
        let captureIndex = 0;
        const indexReplacementMap = [];
        const paramReplacementMap = [];
        regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
          if (handlerIndex !== void 0) {
            indexReplacementMap[++captureIndex] = Number(handlerIndex);
            return "$()";
          }
          if (paramIndex !== void 0) {
            paramReplacementMap[Number(paramIndex)] = ++captureIndex;
            return "";
          }
          return "";
        });
        return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
      }
    };
  }
});

// ../node_modules/hono/dist/cjs/router/reg-exp-router/router.js
var require_router2 = __commonJS({
  "../node_modules/hono/dist/cjs/router/reg-exp-router/router.js"(exports2, module2) {
    "use strict";
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var router_exports = {};
    __export(router_exports, {
      RegExpRouter: () => RegExpRouter2
    });
    module2.exports = __toCommonJS(router_exports);
    var import_router = require_router();
    var import_url = require_url();
    var import_node = require_node();
    var import_trie = require_trie();
    var emptyParam = [];
    var nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
    var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
    function buildWildcardRegExp(path) {
      return wildcardRegExpCache[path] ??= new RegExp(
        path === "*" ? "" : `^${path.replace(
          /\/\*$|([.\\+*[^\]$()])/g,
          (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)"
        )}$`
      );
    }
    function clearWildcardRegExpCache() {
      wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
    }
    function buildMatcherFromPreprocessedRoutes(routes) {
      const trie = new import_trie.Trie();
      const handlerData = [];
      if (routes.length === 0) {
        return nullMatcher;
      }
      const routesWithStaticPathFlag = routes.map(
        (route) => [!/\*|\/:/.test(route[0]), ...route]
      ).sort(
        ([isStaticA, pathA], [isStaticB, pathB]) => isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length
      );
      const staticMap = /* @__PURE__ */ Object.create(null);
      for (let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++) {
        const [pathErrorCheckOnly, path, handlers] = routesWithStaticPathFlag[i];
        if (pathErrorCheckOnly) {
          staticMap[path] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
        } else {
          j++;
        }
        let paramAssoc;
        try {
          paramAssoc = trie.insert(path, j, pathErrorCheckOnly);
        } catch (e) {
          throw e === import_node.PATH_ERROR ? new import_router.UnsupportedPathError(path) : e;
        }
        if (pathErrorCheckOnly) {
          continue;
        }
        handlerData[j] = handlers.map(([h, paramCount]) => {
          const paramIndexMap = /* @__PURE__ */ Object.create(null);
          paramCount -= 1;
          for (; paramCount >= 0; paramCount--) {
            const [key, value] = paramAssoc[paramCount];
            paramIndexMap[key] = value;
          }
          return [h, paramIndexMap];
        });
      }
      const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
      for (let i = 0, len = handlerData.length; i < len; i++) {
        for (let j = 0, len2 = handlerData[i].length; j < len2; j++) {
          const map = handlerData[i][j]?.[1];
          if (!map) {
            continue;
          }
          const keys = Object.keys(map);
          for (let k = 0, len3 = keys.length; k < len3; k++) {
            map[keys[k]] = paramReplacementMap[map[keys[k]]];
          }
        }
      }
      const handlerMap = [];
      for (const i in indexReplacementMap) {
        handlerMap[i] = handlerData[indexReplacementMap[i]];
      }
      return [regexp, handlerMap, staticMap];
    }
    function findMiddleware(middleware, path) {
      if (!middleware) {
        return void 0;
      }
      for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
        if (buildWildcardRegExp(k).test(path)) {
          return [...middleware[k]];
        }
      }
      return void 0;
    }
    var RegExpRouter2 = class {
      name = "RegExpRouter";
      #middleware;
      #routes;
      constructor() {
        this.#middleware = { [import_router.METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
        this.#routes = { [import_router.METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
      }
      add(method, path, handler) {
        const middleware = this.#middleware;
        const routes = this.#routes;
        if (!middleware || !routes) {
          throw new Error(import_router.MESSAGE_MATCHER_IS_ALREADY_BUILT);
        }
        if (!middleware[method]) {
          ;
          [middleware, routes].forEach((handlerMap) => {
            handlerMap[method] = /* @__PURE__ */ Object.create(null);
            Object.keys(handlerMap[import_router.METHOD_NAME_ALL]).forEach((p) => {
              handlerMap[method][p] = [...handlerMap[import_router.METHOD_NAME_ALL][p]];
            });
          });
        }
        if (path === "/*") {
          path = "*";
        }
        const paramCount = (path.match(/\/:/g) || []).length;
        if (/\*$/.test(path)) {
          const re = buildWildcardRegExp(path);
          if (method === import_router.METHOD_NAME_ALL) {
            Object.keys(middleware).forEach((m) => {
              middleware[m][path] ||= findMiddleware(middleware[m], path) || findMiddleware(middleware[import_router.METHOD_NAME_ALL], path) || [];
            });
          } else {
            middleware[method][path] ||= findMiddleware(middleware[method], path) || findMiddleware(middleware[import_router.METHOD_NAME_ALL], path) || [];
          }
          Object.keys(middleware).forEach((m) => {
            if (method === import_router.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 === import_router.METHOD_NAME_ALL || method === m) {
              Object.keys(routes[m]).forEach(
                (p) => re.test(p) && routes[m][p].push([handler, paramCount])
              );
            }
          });
          return;
        }
        const paths = (0, import_url.checkOptionalParameter)(path) || [path];
        for (let i = 0, len = paths.length; i < len; i++) {
          const path2 = paths[i];
          Object.keys(routes).forEach((m) => {
            if (method === import_router.METHOD_NAME_ALL || method === m) {
              routes[m][path2] ||= [
                ...findMiddleware(middleware[m], path2) || findMiddleware(middleware[import_router.METHOD_NAME_ALL], path2) || []
              ];
              routes[m][path2].push([handler, paramCount - len + i + 1]);
            }
          });
        }
      }
      match(method, path) {
        clearWildcardRegExpCache();
        const matchers = this.#buildAllMatchers();
        this.match = (method2, path2) => {
          const matcher = matchers[method2] || matchers[import_router.METHOD_NAME_ALL];
          const staticMatch = matcher[2][path2];
          if (staticMatch) {
            return staticMatch;
          }
          const match = path2.match(matcher[0]);
          if (!match) {
            return [[], emptyParam];
          }
          const index = match.indexOf("", 1);
          return [matcher[1][index], match];
        };
        return this.match(method, path);
      }
      #buildAllMatchers() {
        const matchers = /* @__PURE__ */ Object.create(null);
        Object.keys(this.#routes).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 === import_router.METHOD_NAME_ALL;
        [this.#middleware, this.#routes].forEach((r) => {
          const ownRoute = r[method] ? Object.keys(r[method]).map((path) => [path, r[method][path]]) : [];
          if (ownRoute.length !== 0) {
            hasOwnRoute ||= true;
            routes.push(...ownRoute);
          } else if (method !== import_router.METHOD_NAME_ALL) {
            routes.push(
              ...Object.keys(r[import_router.METHOD_NAME_ALL]).map((path) => [path, r[import_router.METHOD_NAME_ALL][path]])
            );
          }
        });
        if (!hasOwnRoute) {
          return null;
        } else {
          return buildMatcherFromPreprocessedRoutes(routes);
        }
      }
    };
  }
});

// ../node_modules/hono/dist/cjs/router/reg-exp-router/index.js
var require_reg_exp_router = __commonJS({
  "../node_modules/hono/dist/cjs/router/reg-exp-router/index.js"(exports2, module2) {
    "use strict";
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var reg_exp_router_exports = {};
    __export(reg_exp_router_exports, {
      RegExpRouter: () => import_router.RegExpRouter
    });
    module2.exports = __toCommonJS(reg_exp_router_exports);
    var import_router = require_router2();
  }
});

// ../node_modules/hono/dist/cjs/router/smart-router/router.js
var require_router3 = __commonJS({
  "../node_modules/hono/dist/cjs/router/smart-router/router.js"(exports2, module2) {
    "use strict";
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var router_exports = {};
    __export(router_exports, {
      SmartRouter: () => SmartRouter2
    });
    module2.exports = __toCommonJS(router_exports);
    var import_router = require_router();
    var SmartRouter2 = class {
      name = "SmartRouter";
      #routers = [];
      #routes = [];
      constructor(init) {
        this.#routers = init.routers;
      }
      add(method, path, handler) {
        if (!this.#routes) {
          throw new Error(import_router.MESSAGE_MATCHER_IS_ALREADY_BUILT);
        }
        this.#routes.push([method, path, handler]);
      }
      match(method, path) {
        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, path);
          } catch (e) {
            if (e instanceof import_router.UnsupportedPathError) {
              continue;
            }
            throw e;
          }
          this.match = router.match.bind(router);
          this.#routers = [router];
          this.#routes = void 0;
          break;
        }
        if (i === len) {
          throw new Error("Fatal error");
        }
        this.name = `SmartRouter + ${this.activeRouter.name}`;
        return res;
      }
      get activeRouter() {
        if (this.#routes || this.#routers.length !== 1) {
          throw new Error("No active router has been determined yet.");
        }
        return this.#routers[0];
      }
    };
  }
});

// ../node_modules/hono/dist/cjs/router/smart-router/index.js
var require_smart_router = __commonJS({
  "../node_modules/hono/dist/cjs/router/smart-router/index.js"(exports2, module2) {
    "use strict";
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var smart_router_exports = {};
    __export(smart_router_exports, {
      SmartRouter: () => import_router.SmartRouter
    });
    module2.exports = __toCommonJS(smart_router_exports);
    var import_router = require_router3();
  }
});

// ../node_modules/hono/dist/cjs/router/trie-router/node.js
var require_node2 = __commonJS({
  "../node_modules/hono/dist/cjs/router/trie-router/node.js"(exports2, module2) {
    "use strict";
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var node_exports = {};
    __export(node_exports, {
      Node: () => Node
    });
    module2.exports = __toCommonJS(node_exports);
    var import_router = require_router();
    var import_url = require_url();
    var emptyParams = /* @__PURE__ */ Object.create(null);
    var Node = class _Node {
      #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, path, handler) {
        this.#order = ++this.#order;
        let curNode = this;
        const parts = (0, import_url.splitRoutingPath)(path);
        const possibleKeys = [];
        for (let i = 0, len = parts.length; i < len; i++) {
          const p = parts[i];
          const nextP = parts[i + 1];
          const pattern = (0, import_url.getPattern)(p, nextP);
          const key = Array.isArray(pattern) ? pattern[0] : p;
          if (key in curNode.#children) {
            curNode = curNode.#children[key];
            if (pattern) {
              possibleKeys.push(pattern[1]);
            }
            continue;
          }
          curNode.#children[key] = new _Node();
          if (pattern) {
            curNode.#patterns.push(pattern);
            possibleKeys.push(pattern[1]);
          }
          curNode = curNode.#children[key];
        }
        curNode.#methods.push({
          [method]: {
            handler,
            possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
            score: this.#order
          }
        });
        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[import_router.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, path) {
        const handlerSets = [];
        this.#params = emptyParams;
        const curNode = this;
        let curNodes = [curNode];
        const parts = (0, import_url.splitPath)(path);
        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])];
      }
    };
  }
});

// ../node_modules/hono/dist/cjs/router/trie-router/router.js
var require_router4 = __commonJS({
  "../node_modules/hono/dist/cjs/router/trie-router/router.js"(exports2, module2) {
    "use strict";
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var router_exports = {};
    __export(router_exports, {
      TrieRouter: () => TrieRouter2
    });
    module2.exports = __toCommonJS(router_exports);
    var import_url = require_url();
    var import_node = require_node2();
    var TrieRouter2 = class {
      name = "TrieRouter";
      #node;
      constructor() {
        this.#node = new import_node.Node();
      }
      add(method, path, handler) {
        const results = (0, import_url.checkOptionalParameter)(path);
        if (results) {
          for (let i = 0, len = results.length; i < len; i++) {
            this.#node.insert(method, results[i], handler);
          }
          return;
        }
        this.#node.insert(method, path, handler);
      }
      match(method, path) {
        return this.#node.search(method, path);
      }
    };
  }
});

// ../node_modules/hono/dist/cjs/router/trie-router/index.js
var require_trie_router = __commonJS({
  "../node_modules/hono/dist/cjs/router/trie-router/index.js"(exports2, module2) {
    "use strict";
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var trie_router_exports = {};
    __export(trie_router_exports, {
      TrieRouter: () => import_router.TrieRouter
    });
    module2.exports = __toCommonJS(trie_router_exports);
    var import_router = require_router4();
  }
});

// ../node_modules/hono/dist/cjs/hono.js
var require_hono = __commonJS({
  "../node_modules/hono/dist/cjs/hono.js"(exports2, module2) {
    "use strict";
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var hono_exports = {};
    __export(hono_exports, {
      Hono: () => Hono2
    });
    module2.exports = __toCommonJS(hono_exports);
    var import_hono_base = require_hono_base();
    var import_reg_exp_router = require_reg_exp_router();
    var import_smart_router = require_smart_router();
    var import_trie_router = require_trie_router();
    var Hono2 = class extends import_hono_base.HonoBase {
      constructor(options = {}) {
        super(options);
        this.router = options.router ?? new import_smart_router.SmartRouter({
          routers: [new import_reg_exp_router.RegExpRouter(), new import_trie_router.TrieRouter()]
        });
      }
    };
  }
});

// ../node_modules/hono/dist/cjs/index.js
var require_cjs = __commonJS({
  "../node_modules/hono/dist/cjs/index.js"(exports2, module2) {
    "use strict";
    var __defProp2 = Object.defineProperty;
    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
    var __getOwnPropNames2 = Object.getOwnPropertyNames;
    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
    var __export = (target, all) => {
      for (var name in all)
        __defProp2(target, name, { get: all[name], enumerable: true });
    };
    var __copyProps2 = (to, from, except, desc) => {
      if (from && typeof from === "object" || typeof from === "function") {
        for (let key of __getOwnPropNames2(from))
          if (!__hasOwnProp2.call(to, key) && key !== except)
            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
      }
      return to;
    };
    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
    var src_exports = {};
    __export(src_exports, {
      Hono: () => import_hono.Hono
    });
    module2.exports = __toCommonJS(src_exports);
    var import_hono = require_hono();
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/hono/proxy.js
var require_proxy = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/hono/proxy.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.HonoProxy = void 0;
    var pengueno_1 = require_dist2();
    var node_server_1 = require_dist();
    var hono_1 = require_cjs();
    var AppLifetimeMetric = pengueno_1.Metric.fromName("HonoAppLifetime").asResult();
    var AppRequestMetric = pengueno_1.Metric.fromName("HonoAppRequest");
    var HonoProxy = class {
      server;
      app = pengueno_1.LogMetricTraceable.of(new hono_1.Hono()).flatMap(pengueno_1.TraceUtil.withTrace(`AppId = ${crypto.randomUUID()}`)).flatMap(pengueno_1.TraceUtil.withMetricTrace(AppLifetimeMetric));
      constructor(server) {
        this.server = server;
      }
      async serve(port, hostname) {
        return this.app.map((tApp) => pengueno_1.Either.fromFailable(() => {
          const app = tApp.get();
          app.all("*", async (c) => tApp.flatMap(pengueno_1.TraceUtil.withMetricTrace(AppRequestMetric)).move(c.req).flatMap((tRequest) => pengueno_1.PenguenoRequest.from(tRequest)).map((req) => this.server.serve(req)).map(pengueno_1.TraceUtil.promiseify((tResponse) => {
            tResponse.trace.trace(AppRequestMetric.count.withValue(1));
            return new Response(tResponse.get().body(), tResponse.get());
          })).get());
          return (0, node_server_1.serve)({
            fetch: (_r) => app.fetch(_r),
            port,
            hostname
          });
        })).peek(pengueno_1.TraceUtil.traceResultingEither()).peek((tServe) => tServe.get().mapRight(() => tServe.trace.trace(`haii im still listening at http://${hostname}:${port} ~uwu dont think i forgot`))).map((tEitherServer) => tEitherServer.get().mapRight((server) => tEitherServer.move(server)).flatMapAsync((tServer) => pengueno_1.Signals.awaitClose(tServer))).peek(pengueno_1.TraceUtil.promiseify(pengueno_1.TraceUtil.traceResultingEither(AppLifetimeMetric))).get();
      }
    };
    exports2.HonoProxy = HonoProxy;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/hono/index.js
var require_hono2 = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/hono/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_proxy(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/index.js
var require_server = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_http(), exports2);
    __exportStar(require_response(), exports2);
    __exportStar(require_request(), exports2);
    __exportStar(require_activity(), exports2);
    __exportStar(require_filter(), exports2);
    __exportStar(require_hono2(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/index.js
var require_dist2 = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_leftpadesque(), exports2);
    __exportStar(require_types(), exports2);
    __exportStar(require_trace4(), exports2);
    __exportStar(require_process(), exports2);
    __exportStar(require_server(), exports2);
  }
});

// ../model/job/index.ts
var import_pengueno = __toESM(require_dist2(), 1);
var JobTypes = [
  "fetch_code",
  "ci_pipeline",
  "build_docker_image.js",
  "ansible_playbook.js",
  "checkout_ci.js",
  "npm_publish.js"
];
var isJobType = (j) => typeof j === "string" && JobTypes.includes(j);
var isJob = (j) => !!((0, import_pengueno.isObject)(j) && "arguments" in j && (0, import_pengueno.isObject)(j.arguments) && "type" in j && isJobType(j.type) && j);

// ../model/pipeline/index.ts
var import_pengueno3 = __toESM(require_dist2(), 1);

// ../model/pipeline/builder.ts
var BasePipelineBuilder = class {
  stages = [];
  addStage(stage) {
    this.stages.push(stage);
    return this;
  }
  build() {
    return new PipelineImpl(this.stages);
  }
};
var DefaultGitHookPipelineBuilder = class extends BasePipelineBuilder {
  constructor(remoteUrl = process.env.remote, rev = process.env.rev, refname = process.env.refname) {
    super();
    this.remoteUrl = remoteUrl;
    this.refname = refname;
    this.addStage({
      parallelJobs: [
        {
          type: "fetch_code",
          arguments: {
            remoteUrl,
            checkout: rev,
            path: this.getSourceDestination()
          }
        }
      ]
    });
  }
  getSourceDestination() {
    return this.remoteUrl.replace(".git", "").split("/").at(-1) ?? "src";
  }
  getBranch() {
    const branchRefPrefix = "refs/heads/";
    return this.refname.split(branchRefPrefix).at(1);
  }
};

// ../model/pipeline/impl.ts
var import_pengueno2 = __toESM(require_dist2(), 1);
var PipelineImpl = class _PipelineImpl {
  constructor(serialJobs) {
    this.serialJobs = serialJobs;
  }
  serialize() {
    return JSON.stringify({ serialJobs: this.serialJobs });
  }
  static from(s) {
    return import_pengueno2.Either.fromFailable(() => JSON.parse(s)).flatMap(
      (eitherPipelineJson) => isPipeline(eitherPipelineJson) ? import_pengueno2.Either.right(eitherPipelineJson) : import_pengueno2.Either.left(new Error("oh noes D: its a bad pipewine :(("))
    ).mapRight((pipeline) => new _PipelineImpl(pipeline.serialJobs));
  }
};

// ../model/pipeline/index.ts
var isPipelineStage = (t) => (0, import_pengueno3.isObject)(t) && "parallelJobs" in t && Array.isArray(t.parallelJobs) && t.parallelJobs.every((j) => isJob(j));
var isPipeline = (t) => (0, import_pengueno3.isObject)(t) && "serialJobs" in t && Array.isArray(t.serialJobs) && t.serialJobs.every((p) => isPipelineStage(p));

// dist/ci.js
var import_path = require("path");
var REGISTRY = "oci.liz.coffee";
var NAMESPACE = "emprespresso";
var IMG = "ci";
var REMOTE = "ssh://src.liz.coffee:2222";
var getPipeline = () => {
  const gitHookPipeline = new DefaultGitHookPipelineBuilder();
  const branch = gitHookPipeline.getBranch();
  if (!branch)
    return gitHookPipeline.build();
  const commonBuildArgs = {
    context: gitHookPipeline.getSourceDestination(),
    registry: REGISTRY,
    namespace: NAMESPACE,
    imageTag: branch
  };
  const baseCiPackageBuild = {
    type: "build_docker_image.js",
    arguments: {
      ...commonBuildArgs,
      repository: IMG + "_base",
      buildTarget: IMG + "_base",
      dockerfile: "Dockerfile"
    }
  };
  gitHookPipeline.addStage({
    parallelJobs: [baseCiPackageBuild]
  });
  const subPackages = ["worker", "server"].map((_package) => ({
    type: "build_docker_image.js",
    arguments: {
      ...commonBuildArgs,
      repository: `${IMG}_${_package}`,
      buildTarget: _package,
      dockerfile: `${_package}/Dockerfile`
    }
  }));
  subPackages.push({
    type: "build_docker_image.js",
    arguments: {
      ...commonBuildArgs,
      repository: `${IMG}_packpub_npm`,
      buildTarget: "packpub_npm",
      dockerfile: `Dockerfile`,
      context: (0, import_path.join)(commonBuildArgs.context, "packpub/npm")
    }
  });
  gitHookPipeline.addStage({
    parallelJobs: subPackages
  });
  const isRelease = branch === "release";
  if (!isRelease) {
    return gitHookPipeline.build();
  }
  const fetchAnsibleCode = {
    type: "fetch_code",
    arguments: {
      remoteUrl: `${REMOTE}/infra`,
      checkout: "main",
      path: "infra"
    }
  };
  const thenDeploy = {
    type: "ansible_playbook.js",
    arguments: {
      path: "infra",
      playbooks: "playbooks/ci.yml"
    }
  };
  [fetchAnsibleCode, thenDeploy].forEach((deploymentStage) => gitHookPipeline.addStage({ parallelJobs: [deploymentStage] }));
  return gitHookPipeline.build();
};
var main = () => {
  const data = getPipeline().serialize();
  process.stdout.write(data);
};
main();