codebay 0.0.1 → 0.2.0

package/.mochi/svelte-compile/chunk-v6796ga4.js

@@ -0,0 +1,3295 @@
+// @bun
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-we0ggtws.js";
+
+// node_modules/ipaddr.js/lib/ipaddr.js
+var require_ipaddr = __commonJS((exports, module) => {
+  (function(root) {
+    const ipv4Part = "(0?\\d+|0x[a-f0-9]+)";
+    const ipv4Regexes = {
+      fourOctet: new RegExp(`^${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}$`, "i"),
+      threeOctet: new RegExp(`^${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}$`, "i"),
+      twoOctet: new RegExp(`^${ipv4Part}\\.${ipv4Part}$`, "i"),
+      longValue: new RegExp(`^${ipv4Part}$`, "i")
+    };
+    const octalRegex = new RegExp(`^0[0-7]+$`, "i");
+    const hexRegex = new RegExp(`^0x[a-f0-9]+$`, "i");
+    const zoneIndex = "%[0-9a-z]{1,}";
+    const ipv6Part = "(?:[0-9a-f]+::?)+";
+    const ipv6Regexes = {
+      zoneIndex: new RegExp(zoneIndex, "i"),
+      native: new RegExp(`^(::)?(${ipv6Part})?([0-9a-f]+)?(::)?(${zoneIndex})?$`, "i"),
+      deprecatedTransitional: new RegExp(`^(?:::)(${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}(${zoneIndex})?)$`, "i"),
+      transitional: new RegExp(`^((?:${ipv6Part})|(?:::)(?:${ipv6Part})?)${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}(${zoneIndex})?$`, "i")
+    };
+    function expandIPv6(string, parts) {
+      if (string.indexOf("::") !== string.lastIndexOf("::")) {
+        return null;
+      }
+      let colonCount = 0;
+      let lastColon = -1;
+      let zoneId = (string.match(ipv6Regexes.zoneIndex) || [])[0];
+      let replacement, replacementCount;
+      if (zoneId) {
+        zoneId = zoneId.substring(1);
+        string = string.replace(/%.+$/, "");
+      }
+      while ((lastColon = string.indexOf(":", lastColon + 1)) >= 0) {
+        colonCount++;
+      }
+      if (string.substr(0, 2) === "::") {
+        colonCount--;
+      }
+      if (string.substr(-2, 2) === "::") {
+        colonCount--;
+      }
+      if (colonCount > parts) {
+        return null;
+      }
+      replacementCount = parts - colonCount;
+      replacement = ":";
+      while (replacementCount--) {
+        replacement += "0:";
+      }
+      string = string.replace("::", replacement);
+      if (string[0] === ":") {
+        string = string.slice(1);
+      }
+      if (string[string.length - 1] === ":") {
+        string = string.slice(0, -1);
+      }
+      parts = function() {
+        const ref = string.split(":");
+        const results = [];
+        for (let i = 0;i < ref.length; i++) {
+          results.push(parseInt(ref[i], 16));
+        }
+        return results;
+      }();
+      return {
+        parts,
+        zoneId
+      };
+    }
+    function matchCIDR(first, second, partSize, cidrBits) {
+      if (first.length !== second.length) {
+        throw new Error("ipaddr: cannot match CIDR for objects with different lengths");
+      }
+      let part = 0;
+      let shift;
+      while (cidrBits > 0) {
+        shift = partSize - cidrBits;
+        if (shift < 0) {
+          shift = 0;
+        }
+        if (first[part] >> shift !== second[part] >> shift) {
+          return false;
+        }
+        cidrBits -= partSize;
+        part += 1;
+      }
+      return true;
+    }
+    function parseIntAuto(string) {
+      if (hexRegex.test(string)) {
+        return parseInt(string, 16);
+      }
+      if (string[0] === "0" && !isNaN(parseInt(string[1], 10))) {
+        if (octalRegex.test(string)) {
+          return parseInt(string, 8);
+        }
+        throw new Error(`ipaddr: cannot parse ${string} as octal`);
+      }
+      return parseInt(string, 10);
+    }
+    function padPart(part, length) {
+      while (part.length < length) {
+        part = `0${part}`;
+      }
+      return part;
+    }
+    const ipaddr = {};
+    ipaddr.IPv4 = function() {
+      function IPv4(octets) {
+        if (octets.length !== 4) {
+          throw new Error("ipaddr: ipv4 octet count should be 4");
+        }
+        let i, octet;
+        for (i = 0;i < octets.length; i++) {
+          octet = octets[i];
+          if (!(0 <= octet && octet <= 255)) {
+            throw new Error("ipaddr: ipv4 octet should fit in 8 bits");
+          }
+        }
+        this.octets = octets;
+      }
+      IPv4.prototype.SpecialRanges = {
+        unspecified: [[new IPv4([0, 0, 0, 0]), 8]],
+        broadcast: [[new IPv4([255, 255, 255, 255]), 32]],
+        multicast: [[new IPv4([224, 0, 0, 0]), 4]],
+        linkLocal: [[new IPv4([169, 254, 0, 0]), 16]],
+        loopback: [[new IPv4([127, 0, 0, 0]), 8]],
+        carrierGradeNat: [[new IPv4([100, 64, 0, 0]), 10]],
+        private: [
+          [new IPv4([10, 0, 0, 0]), 8],
+          [new IPv4([172, 16, 0, 0]), 12],
+          [new IPv4([192, 168, 0, 0]), 16]
+        ],
+        reserved: [
+          [new IPv4([192, 0, 0, 0]), 24],
+          [new IPv4([192, 0, 2, 0]), 24],
+          [new IPv4([192, 88, 99, 0]), 24],
+          [new IPv4([198, 18, 0, 0]), 15],
+          [new IPv4([198, 51, 100, 0]), 24],
+          [new IPv4([203, 0, 113, 0]), 24],
+          [new IPv4([240, 0, 0, 0]), 4]
+        ],
+        as112: [
+          [new IPv4([192, 175, 48, 0]), 24],
+          [new IPv4([192, 31, 196, 0]), 24]
+        ],
+        amt: [
+          [new IPv4([192, 52, 193, 0]), 24]
+        ]
+      };
+      IPv4.prototype.kind = function() {
+        return "ipv4";
+      };
+      IPv4.prototype.match = function(other, cidrRange) {
+        let ref;
+        if (cidrRange === undefined) {
+          ref = other;
+          other = ref[0];
+          cidrRange = ref[1];
+        }
+        if (other.kind() !== "ipv4") {
+          throw new Error("ipaddr: cannot match ipv4 address with non-ipv4 one");
+        }
+        return matchCIDR(this.octets, other.octets, 8, cidrRange);
+      };
+      IPv4.prototype.prefixLengthFromSubnetMask = function() {
+        let cidr = 0;
+        let stop = false;
+        const zerotable = {
+          0: 8,
+          128: 7,
+          192: 6,
+          224: 5,
+          240: 4,
+          248: 3,
+          252: 2,
+          254: 1,
+          255: 0
+        };
+        let i, octet, zeros;
+        for (i = 3;i >= 0; i -= 1) {
+          octet = this.octets[i];
+          if (octet in zerotable) {
+            zeros = zerotable[octet];
+            if (stop && zeros !== 0) {
+              return null;
+            }
+            if (zeros !== 8) {
+              stop = true;
+            }
+            cidr += zeros;
+          } else {
+            return null;
+          }
+        }
+        return 32 - cidr;
+      };
+      IPv4.prototype.range = function() {
+        return ipaddr.subnetMatch(this, this.SpecialRanges);
+      };
+      IPv4.prototype.toByteArray = function() {
+        return this.octets.slice(0);
+      };
+      IPv4.prototype.toIPv4MappedAddress = function() {
+        return ipaddr.IPv6.parse(`::ffff:${this.toString()}`);
+      };
+      IPv4.prototype.toNormalizedString = function() {
+        return this.toString();
+      };
+      IPv4.prototype.toString = function() {
+        return this.octets.join(".");
+      };
+      return IPv4;
+    }();
+    ipaddr.IPv4.broadcastAddressFromCIDR = function(string) {
+      try {
+        const cidr = this.parseCIDR(string);
+        const ipInterfaceOctets = cidr[0].toByteArray();
+        const subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray();
+        const octets = [];
+        let i = 0;
+        while (i < 4) {
+          octets.push(parseInt(ipInterfaceOctets[i], 10) | parseInt(subnetMaskOctets[i], 10) ^ 255);
+          i++;
+        }
+        return new this(octets);
+      } catch (e) {
+        throw new Error("ipaddr: the address does not have IPv4 CIDR format");
+      }
+    };
+    ipaddr.IPv4.isIPv4 = function(string) {
+      return this.parser(string) !== null;
+    };
+    ipaddr.IPv4.isValid = function(string) {
+      try {
+        new this(this.parser(string));
+        return true;
+      } catch (e) {
+        return false;
+      }
+    };
+    ipaddr.IPv4.isValidCIDR = function(string) {
+      try {
+        this.parseCIDR(string);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    };
+    ipaddr.IPv4.isValidFourPartDecimal = function(string) {
+      if (ipaddr.IPv4.isValid(string) && string.match(/^(0|[1-9]\d*)(\.(0|[1-9]\d*)){3}$/)) {
+        return true;
+      } else {
+        return false;
+      }
+    };
+    ipaddr.IPv4.isValidCIDRFourPartDecimal = function(string) {
+      const match = string.match(/^(.+)\/(\d+)$/);
+      if (!ipaddr.IPv4.isValidCIDR(string) || !match) {
+        return false;
+      }
+      return ipaddr.IPv4.isValidFourPartDecimal(match[1]);
+    };
+    ipaddr.IPv4.networkAddressFromCIDR = function(string) {
+      let cidr, i, ipInterfaceOctets, octets, subnetMaskOctets;
+      try {
+        cidr = this.parseCIDR(string);
+        ipInterfaceOctets = cidr[0].toByteArray();
+        subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray();
+        octets = [];
+        i = 0;
+        while (i < 4) {
+          octets.push(parseInt(ipInterfaceOctets[i], 10) & parseInt(subnetMaskOctets[i], 10));
+          i++;
+        }
+        return new this(octets);
+      } catch (e) {
+        throw new Error("ipaddr: the address does not have IPv4 CIDR format");
+      }
+    };
+    ipaddr.IPv4.parse = function(string) {
+      const parts = this.parser(string);
+      if (parts === null) {
+        throw new Error("ipaddr: string is not formatted like an IPv4 Address");
+      }
+      return new this(parts);
+    };
+    ipaddr.IPv4.parseCIDR = function(string) {
+      let match;
+      if (match = string.match(/^(.+)\/(\d+)$/)) {
+        const maskLength = parseInt(match[2]);
+        if (maskLength >= 0 && maskLength <= 32) {
+          const parsed = [this.parse(match[1]), maskLength];
+          Object.defineProperty(parsed, "toString", {
+            value: function() {
+              return this.join("/");
+            }
+          });
+          return parsed;
+        }
+      }
+      throw new Error("ipaddr: string is not formatted like an IPv4 CIDR range");
+    };
+    ipaddr.IPv4.parser = function(string) {
+      let match, part, value;
+      if (match = string.match(ipv4Regexes.fourOctet)) {
+        return function() {
+          const ref = match.slice(1, 6);
+          const results = [];
+          for (let i = 0;i < ref.length; i++) {
+            part = ref[i];
+            results.push(parseIntAuto(part));
+          }
+          return results;
+        }();
+      } else if (match = string.match(ipv4Regexes.longValue)) {
+        value = parseIntAuto(match[1]);
+        if (value > 4294967295 || value < 0) {
+          throw new Error("ipaddr: address outside defined range");
+        }
+        return function() {
+          const results = [];
+          let shift;
+          for (shift = 0;shift <= 24; shift += 8) {
+            results.push(value >> shift & 255);
+          }
+          return results;
+        }().reverse();
+      } else if (match = string.match(ipv4Regexes.twoOctet)) {
+        return function() {
+          const ref = match.slice(1, 4);
+          const results = [];
+          value = parseIntAuto(ref[1]);
+          if (value > 16777215 || value < 0) {
+            throw new Error("ipaddr: address outside defined range");
+          }
+          results.push(parseIntAuto(ref[0]));
+          results.push(value >> 16 & 255);
+          results.push(value >> 8 & 255);
+          results.push(value & 255);
+          return results;
+        }();
+      } else if (match = string.match(ipv4Regexes.threeOctet)) {
+        return function() {
+          const ref = match.slice(1, 5);
+          const results = [];
+          value = parseIntAuto(ref[2]);
+          if (value > 65535 || value < 0) {
+            throw new Error("ipaddr: address outside defined range");
+          }
+          results.push(parseIntAuto(ref[0]));
+          results.push(parseIntAuto(ref[1]));
+          results.push(value >> 8 & 255);
+          results.push(value & 255);
+          return results;
+        }();
+      } else {
+        return null;
+      }
+    };
+    ipaddr.IPv4.subnetMaskFromPrefixLength = function(prefix) {
+      prefix = parseInt(prefix);
+      if (prefix < 0 || prefix > 32) {
+        throw new Error("ipaddr: invalid IPv4 prefix length");
+      }
+      const octets = [0, 0, 0, 0];
+      let j = 0;
+      const filledOctetCount = Math.floor(prefix / 8);
+      while (j < filledOctetCount) {
+        octets[j] = 255;
+        j++;
+      }
+      if (filledOctetCount < 4) {
+        octets[filledOctetCount] = Math.pow(2, prefix % 8) - 1 << 8 - prefix % 8;
+      }
+      return new this(octets);
+    };
+    ipaddr.IPv6 = function() {
+      function IPv6(parts, zoneId) {
+        let i, part;
+        if (parts.length === 16) {
+          this.parts = [];
+          for (i = 0;i <= 14; i += 2) {
+            this.parts.push(parts[i] << 8 | parts[i + 1]);
+          }
+        } else if (parts.length === 8) {
+          this.parts = parts;
+        } else {
+          throw new Error("ipaddr: ipv6 part count should be 8 or 16");
+        }
+        for (i = 0;i < this.parts.length; i++) {
+          part = this.parts[i];
+          if (!(0 <= part && part <= 65535)) {
+            throw new Error("ipaddr: ipv6 part should fit in 16 bits");
+          }
+        }
+        if (zoneId) {
+          this.zoneId = zoneId;
+        }
+      }
+      IPv6.prototype.SpecialRanges = {
+        unspecified: [new IPv6([0, 0, 0, 0, 0, 0, 0, 0]), 128],
+        linkLocal: [new IPv6([65152, 0, 0, 0, 0, 0, 0, 0]), 10],
+        multicast: [new IPv6([65280, 0, 0, 0, 0, 0, 0, 0]), 8],
+        loopback: [new IPv6([0, 0, 0, 0, 0, 0, 0, 1]), 128],
+        uniqueLocal: [new IPv6([64512, 0, 0, 0, 0, 0, 0, 0]), 7],
+        ipv4Mapped: [new IPv6([0, 0, 0, 0, 0, 65535, 0, 0]), 96],
+        deprecatedSiteLocal: [new IPv6([65216, 0, 0, 0, 0, 0, 0, 0]), 10],
+        discard: [new IPv6([256, 0, 0, 0, 0, 0, 0, 0]), 64],
+        rfc6145: [new IPv6([0, 0, 0, 0, 65535, 0, 0, 0]), 96],
+        rfc6052: [
+          [new IPv6([100, 65435, 0, 0, 0, 0, 0, 0]), 96],
+          [new IPv6([100, 65435, 1, 0, 0, 0, 0, 0]), 48]
+        ],
+        "6to4": [new IPv6([8194, 0, 0, 0, 0, 0, 0, 0]), 16],
+        teredo: [new IPv6([8193, 0, 0, 0, 0, 0, 0, 0]), 32],
+        benchmarking: [new IPv6([8193, 2, 0, 0, 0, 0, 0, 0]), 48],
+        amt: [new IPv6([8193, 3, 0, 0, 0, 0, 0, 0]), 32],
+        as112v6: [
+          [new IPv6([8193, 4, 274, 0, 0, 0, 0, 0]), 48],
+          [new IPv6([9760, 79, 32768, 0, 0, 0, 0, 0]), 48]
+        ],
+        deprecatedOrchid: [new IPv6([8193, 16, 0, 0, 0, 0, 0, 0]), 28],
+        orchid2: [new IPv6([8193, 32, 0, 0, 0, 0, 0, 0]), 28],
+        droneRemoteIdProtocolEntityTags: [new IPv6([8193, 48, 0, 0, 0, 0, 0, 0]), 28],
+        segmentRouting: [new IPv6([24320, 0, 0, 0, 0, 0, 0, 0]), 16],
+        reserved: [
+          [new IPv6([8193, 0, 0, 0, 0, 0, 0, 0]), 23],
+          [new IPv6([8193, 3512, 0, 0, 0, 0, 0, 0]), 32],
+          [new IPv6([16383, 0, 0, 0, 0, 0, 0, 0]), 20]
+        ]
+      };
+      IPv6.prototype.isIPv4MappedAddress = function() {
+        return this.range() === "ipv4Mapped";
+      };
+      IPv6.prototype.kind = function() {
+        return "ipv6";
+      };
+      IPv6.prototype.match = function(other, cidrRange) {
+        let ref;
+        if (cidrRange === undefined) {
+          ref = other;
+          other = ref[0];
+          cidrRange = ref[1];
+        }
+        if (other.kind() !== "ipv6") {
+          throw new Error("ipaddr: cannot match ipv6 address with non-ipv6 one");
+        }
+        return matchCIDR(this.parts, other.parts, 16, cidrRange);
+      };
+      IPv6.prototype.prefixLengthFromSubnetMask = function() {
+        let cidr = 0;
+        let stop = false;
+        const zerotable = {
+          0: 16,
+          32768: 15,
+          49152: 14,
+          57344: 13,
+          61440: 12,
+          63488: 11,
+          64512: 10,
+          65024: 9,
+          65280: 8,
+          65408: 7,
+          65472: 6,
+          65504: 5,
+          65520: 4,
+          65528: 3,
+          65532: 2,
+          65534: 1,
+          65535: 0
+        };
+        let part, zeros;
+        for (let i = 7;i >= 0; i -= 1) {
+          part = this.parts[i];
+          if (part in zerotable) {
+            zeros = zerotable[part];
+            if (stop && zeros !== 0) {
+              return null;
+            }
+            if (zeros !== 16) {
+              stop = true;
+            }
+            cidr += zeros;
+          } else {
+            return null;
+          }
+        }
+        return 128 - cidr;
+      };
+      IPv6.prototype.range = function() {
+        return ipaddr.subnetMatch(this, this.SpecialRanges);
+      };
+      IPv6.prototype.toByteArray = function() {
+        let part;
+        const bytes = [];
+        const ref = this.parts;
+        for (let i = 0;i < ref.length; i++) {
+          part = ref[i];
+          bytes.push(part >> 8);
+          bytes.push(part & 255);
+        }
+        return bytes;
+      };
+      IPv6.prototype.toFixedLengthString = function() {
+        const addr = function() {
+          const results = [];
+          for (let i = 0;i < this.parts.length; i++) {
+            results.push(padPart(this.parts[i].toString(16), 4));
+          }
+          return results;
+        }.call(this).join(":");
+        let suffix = "";
+        if (this.zoneId) {
+          suffix = `%${this.zoneId}`;
+        }
+        return addr + suffix;
+      };
+      IPv6.prototype.toIPv4Address = function() {
+        if (!this.isIPv4MappedAddress()) {
+          throw new Error("ipaddr: trying to convert a generic ipv6 address to ipv4");
+        }
+        const ref = this.parts.slice(-2);
+        const high = ref[0];
+        const low = ref[1];
+        return new ipaddr.IPv4([high >> 8, high & 255, low >> 8, low & 255]);
+      };
+      IPv6.prototype.toNormalizedString = function() {
+        const addr = function() {
+          const results = [];
+          for (let i = 0;i < this.parts.length; i++) {
+            results.push(this.parts[i].toString(16));
+          }
+          return results;
+        }.call(this).join(":");
+        let suffix = "";
+        if (this.zoneId) {
+          suffix = `%${this.zoneId}`;
+        }
+        return addr + suffix;
+      };
+      IPv6.prototype.toRFC5952String = function() {
+        const regex = /((^|:)(0(:|$)){2,})/g;
+        const string = this.toNormalizedString();
+        let bestMatchIndex = 0;
+        let bestMatchLength = -1;
+        let match;
+        while (match = regex.exec(string)) {
+          if (match[0].length > bestMatchLength) {
+            bestMatchIndex = match.index;
+            bestMatchLength = match[0].length;
+          }
+        }
+        if (bestMatchLength < 0) {
+          return string;
+        }
+        return `${string.substring(0, bestMatchIndex)}::${string.substring(bestMatchIndex + bestMatchLength)}`;
+      };
+      IPv6.prototype.toString = function() {
+        return this.toRFC5952String();
+      };
+      return IPv6;
+    }();
+    ipaddr.IPv6.broadcastAddressFromCIDR = function(string) {
+      try {
+        const cidr = this.parseCIDR(string);
+        const ipInterfaceOctets = cidr[0].toByteArray();
+        const subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray();
+        const octets = [];
+        let i = 0;
+        while (i < 16) {
+          octets.push(parseInt(ipInterfaceOctets[i], 10) | parseInt(subnetMaskOctets[i], 10) ^ 255);
+          i++;
+        }
+        return new this(octets);
+      } catch (e) {
+        throw new Error(`ipaddr: the address does not have IPv6 CIDR format (${e})`);
+      }
+    };
+    ipaddr.IPv6.isIPv6 = function(string) {
+      return this.parser(string) !== null;
+    };
+    ipaddr.IPv6.isValid = function(string) {
+      if (typeof string === "string" && string.indexOf(":") === -1) {
+        return false;
+      }
+      try {
+        const addr = this.parser(string);
+        new this(addr.parts, addr.zoneId);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    };
+    ipaddr.IPv6.isValidCIDR = function(string) {
+      if (typeof string === "string" && string.indexOf(":") === -1) {
+        return false;
+      }
+      try {
+        this.parseCIDR(string);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    };
+    ipaddr.IPv6.networkAddressFromCIDR = function(string) {
+      let cidr, i, ipInterfaceOctets, octets, subnetMaskOctets;
+      try {
+        cidr = this.parseCIDR(string);
+        ipInterfaceOctets = cidr[0].toByteArray();
+        subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray();
+        octets = [];
+        i = 0;
+        while (i < 16) {
+          octets.push(parseInt(ipInterfaceOctets[i], 10) & parseInt(subnetMaskOctets[i], 10));
+          i++;
+        }
+        return new this(octets);
+      } catch (e) {
+        throw new Error(`ipaddr: the address does not have IPv6 CIDR format (${e})`);
+      }
+    };
+    ipaddr.IPv6.parse = function(string) {
+      const addr = this.parser(string);
+      if (addr.parts === null) {
+        throw new Error("ipaddr: string is not formatted like an IPv6 Address");
+      }
+      return new this(addr.parts, addr.zoneId);
+    };
+    ipaddr.IPv6.parseCIDR = function(string) {
+      let maskLength, match, parsed;
+      if (match = string.match(/^(.+)\/(\d+)$/)) {
+        maskLength = parseInt(match[2]);
+        if (maskLength >= 0 && maskLength <= 128) {
+          parsed = [this.parse(match[1]), maskLength];
+          Object.defineProperty(parsed, "toString", {
+            value: function() {
+              return this.join("/");
+            }
+          });
+          return parsed;
+        }
+      }
+      throw new Error("ipaddr: string is not formatted like an IPv6 CIDR range");
+    };
+    ipaddr.IPv6.parser = function(string) {
+      let addr, i, match, octet, octets, zoneId;
+      if (match = string.match(ipv6Regexes.deprecatedTransitional)) {
+        return this.parser(`::ffff:${match[1]}`);
+      }
+      if (ipv6Regexes.native.test(string)) {
+        return expandIPv6(string, 8);
+      }
+      if (match = string.match(ipv6Regexes.transitional)) {
+        zoneId = match[6] || "";
+        addr = match[1];
+        if (!match[1].endsWith("::")) {
+          addr = addr.slice(0, -1);
+        }
+        addr = expandIPv6(addr + zoneId, 6);
+        if (addr.parts) {
+          octets = [
+            parseInt(match[2]),
+            parseInt(match[3]),
+            parseInt(match[4]),
+            parseInt(match[5])
+          ];
+          for (i = 0;i < octets.length; i++) {
+            octet = octets[i];
+            if (!(0 <= octet && octet <= 255)) {
+              return null;
+            }
+          }
+          addr.parts.push(octets[0] << 8 | octets[1]);
+          addr.parts.push(octets[2] << 8 | octets[3]);
+          return {
+            parts: addr.parts,
+            zoneId: addr.zoneId
+          };
+        }
+      }
+      return null;
+    };
+    ipaddr.IPv6.subnetMaskFromPrefixLength = function(prefix) {
+      prefix = parseInt(prefix);
+      if (prefix < 0 || prefix > 128) {
+        throw new Error("ipaddr: invalid IPv6 prefix length");
+      }
+      const octets = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+      let j = 0;
+      const filledOctetCount = Math.floor(prefix / 8);
+      while (j < filledOctetCount) {
+        octets[j] = 255;
+        j++;
+      }
+      if (filledOctetCount < 16) {
+        octets[filledOctetCount] = Math.pow(2, prefix % 8) - 1 << 8 - prefix % 8;
+      }
+      return new this(octets);
+    };
+    ipaddr.fromByteArray = function(bytes) {
+      const length = bytes.length;
+      if (length === 4) {
+        return new ipaddr.IPv4(bytes);
+      } else if (length === 16) {
+        return new ipaddr.IPv6(bytes);
+      } else {
+        throw new Error("ipaddr: the binary input is neither an IPv6 nor IPv4 address");
+      }
+    };
+    ipaddr.isValid = function(string) {
+      return ipaddr.IPv6.isValid(string) || ipaddr.IPv4.isValid(string);
+    };
+    ipaddr.isValidCIDR = function(string) {
+      return ipaddr.IPv6.isValidCIDR(string) || ipaddr.IPv4.isValidCIDR(string);
+    };
+    ipaddr.parse = function(string) {
+      if (ipaddr.IPv6.isValid(string)) {
+        return ipaddr.IPv6.parse(string);
+      } else if (ipaddr.IPv4.isValid(string)) {
+        return ipaddr.IPv4.parse(string);
+      } else {
+        throw new Error("ipaddr: the address has neither IPv6 nor IPv4 format");
+      }
+    };
+    ipaddr.parseCIDR = function(string) {
+      try {
+        return ipaddr.IPv6.parseCIDR(string);
+      } catch (e) {
+        try {
+          return ipaddr.IPv4.parseCIDR(string);
+        } catch (e2) {
+          throw new Error("ipaddr: the address has neither IPv6 nor IPv4 CIDR format");
+        }
+      }
+    };
+    ipaddr.process = function(string) {
+      const addr = this.parse(string);
+      if (addr.kind() === "ipv6" && addr.isIPv4MappedAddress()) {
+        return addr.toIPv4Address();
+      } else {
+        return addr;
+      }
+    };
+    ipaddr.subnetMatch = function(address, rangeList, defaultName) {
+      let i, rangeName, rangeSubnets, subnet;
+      if (defaultName === undefined || defaultName === null) {
+        defaultName = "unicast";
+      }
+      for (rangeName in rangeList) {
+        if (Object.prototype.hasOwnProperty.call(rangeList, rangeName)) {
+          rangeSubnets = rangeList[rangeName];
+          if (rangeSubnets[0] && !(rangeSubnets[0] instanceof Array)) {
+            rangeSubnets = [rangeSubnets];
+          }
+          for (i = 0;i < rangeSubnets.length; i++) {
+            subnet = rangeSubnets[i];
+            if (address.kind() === subnet[0].kind() && address.match.apply(address, subnet)) {
+              return rangeName;
+            }
+          }
+        }
+      }
+      return defaultName;
+    };
+    if (typeof module !== "undefined" && module.exports) {
+      module.exports = ipaddr;
+    } else {
+      root.ipaddr = ipaddr;
+    }
+  })(exports);
+});
+
+// node_modules/negotiator/lib/charset.js
+var require_charset = __commonJS((exports, module) => {
+  module.exports = preferredCharsets;
+  module.exports.preferredCharsets = preferredCharsets;
+  var simpleCharsetRegExp = /^\s*([^\s;]+)\s*(?:;(.*))?$/;
+  function parseAcceptCharset(accept) {
+    var accepts = accept.split(",");
+    for (var i = 0, j = 0;i < accepts.length; i++) {
+      var charset = parseCharset(accepts[i].trim(), i);
+      if (charset) {
+        accepts[j++] = charset;
+      }
+    }
+    accepts.length = j;
+    return accepts;
+  }
+  function parseCharset(str, i) {
+    var match = simpleCharsetRegExp.exec(str);
+    if (!match)
+      return null;
+    var charset = match[1];
+    var q = 1;
+    if (match[2]) {
+      var params = match[2].split(";");
+      for (var j = 0;j < params.length; j++) {
+        var p = params[j].trim().split("=");
+        if (p[0] === "q") {
+          q = parseFloat(p[1]);
+          break;
+        }
+      }
+    }
+    return {
+      charset,
+      q,
+      i
+    };
+  }
+  function getCharsetPriority(charset, accepted, index) {
+    var priority = { o: -1, q: 0, s: 0 };
+    for (var i = 0;i < accepted.length; i++) {
+      var spec = specify(charset, accepted[i], index);
+      if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) {
+        priority = spec;
+      }
+    }
+    return priority;
+  }
+  function specify(charset, spec, index) {
+    var s = 0;
+    if (spec.charset.toLowerCase() === charset.toLowerCase()) {
+      s |= 1;
+    } else if (spec.charset !== "*") {
+      return null;
+    }
+    return {
+      i: index,
+      o: spec.i,
+      q: spec.q,
+      s
+    };
+  }
+  function preferredCharsets(accept, provided) {
+    var accepts = parseAcceptCharset(accept === undefined ? "*" : accept || "");
+    if (!provided) {
+      return accepts.filter(isQuality).sort(compareSpecs).map(getFullCharset);
+    }
+    var priorities = provided.map(function getPriority(type, index) {
+      return getCharsetPriority(type, accepts, index);
+    });
+    return priorities.filter(isQuality).sort(compareSpecs).map(function getCharset(priority) {
+      return provided[priorities.indexOf(priority)];
+    });
+  }
+  function compareSpecs(a, b) {
+    return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i || 0;
+  }
+  function getFullCharset(spec) {
+    return spec.charset;
+  }
+  function isQuality(spec) {
+    return spec.q > 0;
+  }
+});
+
+// node_modules/negotiator/lib/encoding.js
+var require_encoding = __commonJS((exports, module) => {
+  module.exports = preferredEncodings;
+  module.exports.preferredEncodings = preferredEncodings;
+  var simpleEncodingRegExp = /^\s*([^\s;]+)\s*(?:;(.*))?$/;
+  function parseAcceptEncoding(accept) {
+    var accepts = accept.split(",");
+    var hasIdentity = false;
+    var minQuality = 1;
+    for (var i = 0, j = 0;i < accepts.length; i++) {
+      var encoding = parseEncoding(accepts[i].trim(), i);
+      if (encoding) {
+        accepts[j++] = encoding;
+        hasIdentity = hasIdentity || specify("identity", encoding);
+        minQuality = Math.min(minQuality, encoding.q || 1);
+      }
+    }
+    if (!hasIdentity) {
+      accepts[j++] = {
+        encoding: "identity",
+        q: minQuality,
+        i
+      };
+    }
+    accepts.length = j;
+    return accepts;
+  }
+  function parseEncoding(str, i) {
+    var match = simpleEncodingRegExp.exec(str);
+    if (!match)
+      return null;
+    var encoding = match[1];
+    var q = 1;
+    if (match[2]) {
+      var params = match[2].split(";");
+      for (var j = 0;j < params.length; j++) {
+        var p = params[j].trim().split("=");
+        if (p[0] === "q") {
+          q = parseFloat(p[1]);
+          break;
+        }
+      }
+    }
+    return {
+      encoding,
+      q,
+      i
+    };
+  }
+  function getEncodingPriority(encoding, accepted, index) {
+    var priority = { encoding, o: -1, q: 0, s: 0 };
+    for (var i = 0;i < accepted.length; i++) {
+      var spec = specify(encoding, accepted[i], index);
+      if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) {
+        priority = spec;
+      }
+    }
+    return priority;
+  }
+  function specify(encoding, spec, index) {
+    var s = 0;
+    if (spec.encoding.toLowerCase() === encoding.toLowerCase()) {
+      s |= 1;
+    } else if (spec.encoding !== "*") {
+      return null;
+    }
+    return {
+      encoding,
+      i: index,
+      o: spec.i,
+      q: spec.q,
+      s
+    };
+  }
+  function preferredEncodings(accept, provided, preferred) {
+    var accepts = parseAcceptEncoding(accept || "");
+    var comparator = preferred ? function comparator2(a, b) {
+      if (a.q !== b.q) {
+        return b.q - a.q;
+      }
+      var aPreferred = preferred.indexOf(a.encoding);
+      var bPreferred = preferred.indexOf(b.encoding);
+      if (aPreferred === -1 && bPreferred === -1) {
+        return b.s - a.s || a.o - b.o || a.i - b.i;
+      }
+      if (aPreferred !== -1 && bPreferred !== -1) {
+        return aPreferred - bPreferred;
+      }
+      return aPreferred === -1 ? 1 : -1;
+    } : compareSpecs;
+    if (!provided) {
+      return accepts.filter(isQuality).sort(comparator).map(getFullEncoding);
+    }
+    var priorities = provided.map(function getPriority(type, index) {
+      return getEncodingPriority(type, accepts, index);
+    });
+    return priorities.filter(isQuality).sort(comparator).map(function getEncoding(priority) {
+      return provided[priorities.indexOf(priority)];
+    });
+  }
+  function compareSpecs(a, b) {
+    return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i;
+  }
+  function getFullEncoding(spec) {
+    return spec.encoding;
+  }
+  function isQuality(spec) {
+    return spec.q > 0;
+  }
+});
+
+// node_modules/negotiator/lib/language.js
+var require_language = __commonJS((exports, module) => {
+  module.exports = preferredLanguages;
+  module.exports.preferredLanguages = preferredLanguages;
+  var simpleLanguageRegExp = /^\s*([^\s\-;]+)(?:-([^\s;]+))?\s*(?:;(.*))?$/;
+  function parseAcceptLanguage(accept) {
+    var accepts = accept.split(",");
+    for (var i = 0, j = 0;i < accepts.length; i++) {
+      var language = parseLanguage(accepts[i].trim(), i);
+      if (language) {
+        accepts[j++] = language;
+      }
+    }
+    accepts.length = j;
+    return accepts;
+  }
+  function parseLanguage(str, i) {
+    var match = simpleLanguageRegExp.exec(str);
+    if (!match)
+      return null;
+    var prefix = match[1];
+    var suffix = match[2];
+    var full = prefix;
+    if (suffix)
+      full += "-" + suffix;
+    var q = 1;
+    if (match[3]) {
+      var params = match[3].split(";");
+      for (var j = 0;j < params.length; j++) {
+        var p = params[j].split("=");
+        if (p[0] === "q")
+          q = parseFloat(p[1]);
+      }
+    }
+    return {
+      prefix,
+      suffix,
+      q,
+      i,
+      full
+    };
+  }
+  function getLanguagePriority(language, accepted, index) {
+    var priority = { o: -1, q: 0, s: 0 };
+    for (var i = 0;i < accepted.length; i++) {
+      var spec = specify(language, accepted[i], index);
+      if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) {
+        priority = spec;
+      }
+    }
+    return priority;
+  }
+  function specify(language, spec, index) {
+    var p = parseLanguage(language);
+    if (!p)
+      return null;
+    var s = 0;
+    if (spec.full.toLowerCase() === p.full.toLowerCase()) {
+      s |= 4;
+    } else if (spec.prefix.toLowerCase() === p.full.toLowerCase()) {
+      s |= 2;
+    } else if (spec.full.toLowerCase() === p.prefix.toLowerCase()) {
+      s |= 1;
+    } else if (spec.full !== "*") {
+      return null;
+    }
+    return {
+      i: index,
+      o: spec.i,
+      q: spec.q,
+      s
+    };
+  }
+  function preferredLanguages(accept, provided) {
+    var accepts = parseAcceptLanguage(accept === undefined ? "*" : accept || "");
+    if (!provided) {
+      return accepts.filter(isQuality).sort(compareSpecs).map(getFullLanguage);
+    }
+    var priorities = provided.map(function getPriority(type, index) {
+      return getLanguagePriority(type, accepts, index);
+    });
+    return priorities.filter(isQuality).sort(compareSpecs).map(function getLanguage(priority) {
+      return provided[priorities.indexOf(priority)];
+    });
+  }
+  function compareSpecs(a, b) {
+    return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i || 0;
+  }
+  function getFullLanguage(spec) {
+    return spec.full;
+  }
+  function isQuality(spec) {
+    return spec.q > 0;
+  }
+});
+
+// node_modules/negotiator/lib/mediaType.js
+var require_mediaType = __commonJS((exports, module) => {
+  module.exports = preferredMediaTypes;
+  module.exports.preferredMediaTypes = preferredMediaTypes;
+  var simpleMediaTypeRegExp = /^\s*([^\s\/;]+)\/([^;\s]+)\s*(?:;(.*))?$/;
+  function parseAccept(accept) {
+    var accepts = splitMediaTypes(accept);
+    for (var i = 0, j = 0;i < accepts.length; i++) {
+      var mediaType = parseMediaType(accepts[i].trim(), i);
+      if (mediaType) {
+        accepts[j++] = mediaType;
+      }
+    }
+    accepts.length = j;
+    return accepts;
+  }
+  function parseMediaType(str, i) {
+    var match = simpleMediaTypeRegExp.exec(str);
+    if (!match)
+      return null;
+    var params = Object.create(null);
+    var q = 1;
+    var subtype = match[2];
+    var type = match[1];
+    if (match[3]) {
+      var kvps = splitParameters(match[3]).map(splitKeyValuePair);
+      for (var j = 0;j < kvps.length; j++) {
+        var pair = kvps[j];
+        var key = pair[0].toLowerCase();
+        var val = pair[1];
+        var value = val && val[0] === '"' && val[val.length - 1] === '"' ? val.slice(1, -1) : val;
+        if (key === "q") {
+          q = parseFloat(value);
+          break;
+        }
+        params[key] = value;
+      }
+    }
+    return {
+      type,
+      subtype,
+      params,
+      q,
+      i
+    };
+  }
+  function getMediaTypePriority(type, accepted, index) {
+    var priority = { o: -1, q: 0, s: 0 };
+    for (var i = 0;i < accepted.length; i++) {
+      var spec = specify(type, accepted[i], index);
+      if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) {
+        priority = spec;
+      }
+    }
+    return priority;
+  }
+  function specify(type, spec, index) {
+    var p = parseMediaType(type);
+    var s = 0;
+    if (!p) {
+      return null;
+    }
+    if (spec.type.toLowerCase() == p.type.toLowerCase()) {
+      s |= 4;
+    } else if (spec.type != "*") {
+      return null;
+    }
+    if (spec.subtype.toLowerCase() == p.subtype.toLowerCase()) {
+      s |= 2;
+    } else if (spec.subtype != "*") {
+      return null;
+    }
+    var keys = Object.keys(spec.params);
+    if (keys.length > 0) {
+      if (keys.every(function(k) {
+        return spec.params[k] == "*" || (spec.params[k] || "").toLowerCase() == (p.params[k] || "").toLowerCase();
+      })) {
+        s |= 1;
+      } else {
+        return null;
+      }
+    }
+    return {
+      i: index,
+      o: spec.i,
+      q: spec.q,
+      s
+    };
+  }
+  function preferredMediaTypes(accept, provided) {
+    var accepts = parseAccept(accept === undefined ? "*/*" : accept || "");
+    if (!provided) {
+      return accepts.filter(isQuality).sort(compareSpecs).map(getFullType);
+    }
+    var priorities = provided.map(function getPriority(type, index) {
+      return getMediaTypePriority(type, accepts, index);
+    });
+    return priorities.filter(isQuality).sort(compareSpecs).map(function getType(priority) {
+      return provided[priorities.indexOf(priority)];
+    });
+  }
+  function compareSpecs(a, b) {
+    return b.q - a.q || b.s - a.s || a.o - b.o || a.i - b.i || 0;
+  }
+  function getFullType(spec) {
+    return spec.type + "/" + spec.subtype;
+  }
+  function isQuality(spec) {
+    return spec.q > 0;
+  }
+  function quoteCount(string) {
+    var count = 0;
+    var index = 0;
+    while ((index = string.indexOf('"', index)) !== -1) {
+      count++;
+      index++;
+    }
+    return count;
+  }
+  function splitKeyValuePair(str) {
+    var index = str.indexOf("=");
+    var key;
+    var val;
+    if (index === -1) {
+      key = str;
+    } else {
+      key = str.slice(0, index);
+      val = str.slice(index + 1);
+    }
+    return [key, val];
+  }
+  function splitMediaTypes(accept) {
+    var accepts = accept.split(",");
+    for (var i = 1, j = 0;i < accepts.length; i++) {
+      if (quoteCount(accepts[j]) % 2 == 0) {
+        accepts[++j] = accepts[i];
+      } else {
+        accepts[j] += "," + accepts[i];
+      }
+    }
+    accepts.length = j + 1;
+    return accepts;
+  }
+  function splitParameters(str) {
+    var parameters = str.split(";");
+    for (var i = 1, j = 0;i < parameters.length; i++) {
+      if (quoteCount(parameters[j]) % 2 == 0) {
+        parameters[++j] = parameters[i];
+      } else {
+        parameters[j] += ";" + parameters[i];
+      }
+    }
+    parameters.length = j + 1;
+    for (var i = 0;i < parameters.length; i++) {
+      parameters[i] = parameters[i].trim();
+    }
+    return parameters;
+  }
+});
+
+// node_modules/negotiator/index.js
+var require_negotiator = __commonJS((exports, module) => {
+  /*!
+   * negotiator
+   * Copyright(c) 2012 Federico Romero
+   * Copyright(c) 2012-2014 Isaac Z. Schlueter
+   * Copyright(c) 2015 Douglas Christopher Wilson
+   * MIT Licensed
+   */
+  var preferredCharsets = require_charset();
+  var preferredEncodings = require_encoding();
+  var preferredLanguages = require_language();
+  var preferredMediaTypes = require_mediaType();
+  module.exports = Negotiator;
+  module.exports.Negotiator = Negotiator;
+  function Negotiator(request) {
+    if (!(this instanceof Negotiator)) {
+      return new Negotiator(request);
+    }
+    this.request = request;
+  }
+  Negotiator.prototype.charset = function charset(available) {
+    var set = this.charsets(available);
+    return set && set[0];
+  };
+  Negotiator.prototype.charsets = function charsets(available) {
+    return preferredCharsets(this.request.headers["accept-charset"], available);
+  };
+  Negotiator.prototype.encoding = function encoding(available, opts) {
+    var set = this.encodings(available, opts);
+    return set && set[0];
+  };
+  Negotiator.prototype.encodings = function encodings(available, options) {
+    var opts = options || {};
+    return preferredEncodings(this.request.headers["accept-encoding"], available, opts.preferred);
+  };
+  Negotiator.prototype.language = function language(available) {
+    var set = this.languages(available);
+    return set && set[0];
+  };
+  Negotiator.prototype.languages = function languages(available) {
+    return preferredLanguages(this.request.headers["accept-language"], available);
+  };
+  Negotiator.prototype.mediaType = function mediaType(available) {
+    var set = this.mediaTypes(available);
+    return set && set[0];
+  };
+  Negotiator.prototype.mediaTypes = function mediaTypes(available) {
+    return preferredMediaTypes(this.request.headers.accept, available);
+  };
+  Negotiator.prototype.preferredCharset = Negotiator.prototype.charset;
+  Negotiator.prototype.preferredCharsets = Negotiator.prototype.charsets;
+  Negotiator.prototype.preferredEncoding = Negotiator.prototype.encoding;
+  Negotiator.prototype.preferredEncodings = Negotiator.prototype.encodings;
+  Negotiator.prototype.preferredLanguage = Negotiator.prototype.language;
+  Negotiator.prototype.preferredLanguages = Negotiator.prototype.languages;
+  Negotiator.prototype.preferredMediaType = Negotiator.prototype.mediaType;
+  Negotiator.prototype.preferredMediaTypes = Negotiator.prototype.mediaTypes;
+});
+// node_modules/devalue/src/base64.js
+function encode_native(array_buffer) {
+  return new Uint8Array(array_buffer).toBase64();
+}
+function encode_buffer(array_buffer) {
+  return Buffer.from(array_buffer).toString("base64");
+}
+function encode_legacy(array_buffer) {
+  const array = new Uint8Array(array_buffer);
+  let binary = "";
+  const chunk_size = 32768;
+  for (let i = 0;i < array.length; i += chunk_size) {
+    const chunk = array.subarray(i, i + chunk_size);
+    binary += String.fromCharCode.apply(null, chunk);
+  }
+  return btoa(binary);
+}
+var native = typeof Uint8Array.fromBase64 === "function";
+var buffer = typeof process === "object" && process.versions?.node !== undefined;
+var encode64 = native ? encode_native : buffer ? encode_buffer : encode_legacy;
+
+// node_modules/devalue/src/constants.js
+var UNDEFINED = -1;
+var HOLE = -2;
+var NAN = -3;
+var POSITIVE_INFINITY = -4;
+var NEGATIVE_INFINITY = -5;
+var NEGATIVE_ZERO = -6;
+var SPARSE = -7;
+var MAX_ARRAY_LEN = 2 ** 32 - 1;
+var MAX_ARRAY_INDEX = MAX_ARRAY_LEN - 1;
+
+// node_modules/devalue/src/utils.js
+class DevalueError extends Error {
+  constructor(message, keys, value, root) {
+    super(message);
+    this.name = "DevalueError";
+    this.path = keys.join("");
+    this.value = value;
+    this.root = root;
+  }
+}
+function is_primitive(thing) {
+  return thing === null || typeof thing !== "object" && typeof thing !== "function";
+}
+var object_proto_names = /* @__PURE__ */ Object.getOwnPropertyNames(Object.prototype).sort().join("\x00");
+function is_plain_object(thing) {
+  const proto = Object.getPrototypeOf(thing);
+  return proto === Object.prototype || proto === null || Object.getPrototypeOf(proto) === null || Object.getOwnPropertyNames(proto).sort().join("\x00") === object_proto_names;
+}
+function get_type(thing) {
+  return Object.prototype.toString.call(thing).slice(8, -1);
+}
+function get_escaped_char(char) {
+  switch (char) {
+    case '"':
+      return "\\\"";
+    case "<":
+      return "\\u003C";
+    case "\\":
+      return "\\\\";
+    case `
+`:
+      return "\\n";
+    case "\r":
+      return "\\r";
+    case "\t":
+      return "\\t";
+    case "\b":
+      return "\\b";
+    case "\f":
+      return "\\f";
+    case "\u2028":
+      return "\\u2028";
+    case "\u2029":
+      return "\\u2029";
+    default:
+      return char < " " ? `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}` : "";
+  }
+}
+function stringify_string(str) {
+  let result = "";
+  let last_pos = 0;
+  const len = str.length;
+  for (let i = 0;i < len; i += 1) {
+    const char = str[i];
+    const replacement = get_escaped_char(char);
+    if (replacement) {
+      result += str.slice(last_pos, i) + replacement;
+      last_pos = i + 1;
+    }
+  }
+  return `"${last_pos === 0 ? str : result + str.slice(last_pos)}"`;
+}
+function enumerable_symbols(object) {
+  return Object.getOwnPropertySymbols(object).filter((symbol) => Object.getOwnPropertyDescriptor(object, symbol).enumerable);
+}
+var is_identifier = /^[a-zA-Z_$][a-zA-Z_$0-9]*$/;
+function stringify_key(key) {
+  return is_identifier.test(key) ? "." + key : "[" + JSON.stringify(key) + "]";
+}
+function is_valid_array_index(n) {
+  if (!Number.isInteger(n))
+    return false;
+  if (n < 0)
+    return false;
+  if (n > MAX_ARRAY_INDEX)
+    return false;
+  return true;
+}
+function is_valid_array_index_string(s) {
+  if (s.length === 0)
+    return false;
+  if (s.length > 1 && s.charCodeAt(0) === 48)
+    return false;
+  for (let i = 0;i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c < 48 || c > 57)
+      return false;
+  }
+  return is_valid_array_index(+s);
+}
+function valid_array_indices(array) {
+  const keys = Object.keys(array);
+  for (var i = keys.length - 1;i >= 0; i--) {
+    if (is_valid_array_index_string(keys[i])) {
+      break;
+    }
+  }
+  keys.length = i + 1;
+  return keys;
+}
+
+// node_modules/devalue/src/stringify.js
+function stringify(value, reducers) {
+  const stringified = run(false, value, reducers);
+  return typeof stringified === "string" ? stringified : `[${stringified.join(",")}]`;
+}
+function run(async, value, reducers) {
+  const stringified = [];
+  const indexes = new Map;
+  const custom = [];
+  if (reducers) {
+    for (const key of Object.getOwnPropertyNames(reducers)) {
+      custom.push({ key, fn: reducers[key] });
+    }
+  }
+  const keys = [];
+  let p = 0;
+  function flatten(thing, index2) {
+    if (thing === undefined)
+      return UNDEFINED;
+    if (Number.isNaN(thing))
+      return NAN;
+    if (thing === Infinity)
+      return POSITIVE_INFINITY;
+    if (thing === -Infinity)
+      return NEGATIVE_INFINITY;
+    if (thing === 0 && 1 / thing < 0)
+      return NEGATIVE_ZERO;
+    if (indexes.has(thing))
+      return indexes.get(thing);
+    index2 ??= p++;
+    indexes.set(thing, index2);
+    for (const { key, fn } of custom) {
+      const value2 = fn(thing);
+      if (value2) {
+        stringified[index2] = `["${key}",${flatten(value2)}]`;
+        return index2;
+      }
+    }
+    if (typeof thing === "function") {
+      throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
+    } else if (typeof thing === "symbol") {
+      throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
+    }
+    let str = "";
+    if (is_primitive(thing)) {
+      str = stringify_primitive(thing);
+    } else if (typeof thing.then === "function") {
+      if (!async) {
+        throw new DevalueError(`Cannot stringify a Promise or thenable \u2014 use stringifyAsync instead`, keys, thing, value);
+      }
+      str = Promise.resolve(thing).then((value2) => {
+        const i = flatten(value2, index2);
+        if (i < 0)
+          stringified[index2] = i;
+      });
+    } else {
+      const type = get_type(thing);
+      switch (type) {
+        case "Number":
+        case "String":
+        case "Boolean":
+        case "BigInt":
+          str = `["Object",${flatten(thing.valueOf())}]`;
+          break;
+        case "Date":
+          const valid = !isNaN(thing.getDate());
+          str = `["Date","${valid ? thing.toISOString() : ""}"]`;
+          break;
+        case "URL":
+          str = `["URL",${stringify_string(thing.toString())}]`;
+          break;
+        case "URLSearchParams":
+          str = `["URLSearchParams",${stringify_string(thing.toString())}]`;
+          break;
+        case "RegExp":
+          const { source, flags } = thing;
+          str = flags ? `["RegExp",${stringify_string(source)},"${flags}"]` : `["RegExp",${stringify_string(source)}]`;
+          break;
+        case "Array": {
+          let mostly_dense = false;
+          str = "[";
+          for (let i = 0;i < thing.length; i += 1) {
+            if (i > 0)
+              str += ",";
+            if (Object.hasOwn(thing, i)) {
+              keys.push(`[${i}]`);
+              str += flatten(thing[i]);
+              keys.pop();
+            } else if (mostly_dense) {
+              str += HOLE;
+            } else {
+              const populated_keys = valid_array_indices(thing);
+              const population = populated_keys.length;
+              const d = String(thing.length).length;
+              const hole_cost = (thing.length - population) * 3;
+              const sparse_cost = 4 + d + population * (d + 1);
+              if (hole_cost > sparse_cost) {
+                str = "[" + SPARSE + "," + thing.length;
+                for (let j = 0;j < populated_keys.length; j++) {
+                  const key = populated_keys[j];
+                  keys.push(`[${key}]`);
+                  str += "," + key + "," + flatten(thing[key]);
+                  keys.pop();
+                }
+                break;
+              } else {
+                mostly_dense = true;
+                str += HOLE;
+              }
+            }
+          }
+          str += "]";
+          break;
+        }
+        case "Set":
+          str = '["Set"';
+          for (const value2 of thing) {
+            str += `,${flatten(value2)}`;
+          }
+          str += "]";
+          break;
+        case "Map":
+          str = '["Map"';
+          for (const [key, value2] of thing) {
+            keys.push(`.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`);
+            str += `,${flatten(key)},${flatten(value2)}`;
+            keys.pop();
+          }
+          str += "]";
+          break;
+        case "Int8Array":
+        case "Uint8Array":
+        case "Uint8ClampedArray":
+        case "Int16Array":
+        case "Uint16Array":
+        case "Float16Array":
+        case "Int32Array":
+        case "Uint32Array":
+        case "Float32Array":
+        case "Float64Array":
+        case "BigInt64Array":
+        case "BigUint64Array": {
+          const typedArray = thing;
+          str = '["' + type + '",' + flatten(typedArray.buffer);
+          if (typedArray.byteLength !== typedArray.buffer.byteLength) {
+            str += `,${typedArray.byteOffset},${typedArray.length}`;
+          }
+          str += "]";
+          break;
+        }
+        case "DataView": {
+          const view = thing;
+          str = '["' + type + '",' + flatten(view.buffer);
+          if (view.byteLength !== view.buffer.byteLength) {
+            str += `,${view.byteOffset},${view.byteLength}`;
+          }
+          str += "]";
+          break;
+        }
+        case "ArrayBuffer": {
+          const arraybuffer = thing;
+          const base64 = encode64(arraybuffer);
+          str = `["ArrayBuffer","${base64}"]`;
+          break;
+        }
+        case "Temporal.Duration":
+        case "Temporal.Instant":
+        case "Temporal.PlainDate":
+        case "Temporal.PlainTime":
+        case "Temporal.PlainDateTime":
+        case "Temporal.PlainMonthDay":
+        case "Temporal.PlainYearMonth":
+        case "Temporal.ZonedDateTime":
+          str = `["${type}",${stringify_string(thing.toString())}]`;
+          break;
+        default:
+          if (!is_plain_object(thing)) {
+            throw new DevalueError(`Cannot stringify arbitrary non-POJOs`, keys, thing, value);
+          }
+          if (enumerable_symbols(thing).length > 0) {
+            throw new DevalueError(`Cannot stringify POJOs with symbolic keys`, keys, thing, value);
+          }
+          if (Object.getPrototypeOf(thing) === null) {
+            str = '["null"';
+            for (const key of Object.keys(thing)) {
+              if (key === "__proto__") {
+                throw new DevalueError(`Cannot stringify objects with __proto__ keys`, keys, thing, value);
+              }
+              keys.push(stringify_key(key));
+              str += `,${stringify_string(key)},${flatten(thing[key])}`;
+              keys.pop();
+            }
+            str += "]";
+          } else {
+            str = "{";
+            let started = false;
+            for (const key of Object.keys(thing)) {
+              if (key === "__proto__") {
+                throw new DevalueError(`Cannot stringify objects with __proto__ keys`, keys, thing, value);
+              }
+              if (started)
+                str += ",";
+              started = true;
+              keys.push(stringify_key(key));
+              str += `${stringify_string(key)}:${flatten(thing[key])}`;
+              keys.pop();
+            }
+            str += "}";
+          }
+      }
+    }
+    stringified[index2] = str;
+    return index2;
+  }
+  const index = flatten(value);
+  if (index < 0)
+    return `${index}`;
+  return stringified;
+}
+function stringify_primitive(thing) {
+  const type = typeof thing;
+  if (type === "string")
+    return stringify_string(thing);
+  if (thing === undefined)
+    return UNDEFINED.toString();
+  if (thing === 0 && 1 / thing < 0)
+    return NEGATIVE_ZERO.toString();
+  if (type === "bigint")
+    return `["BigInt","${thing}"]`;
+  return String(thing);
+}
+// node_modules/mochi-framework/src/runtime/requestContext.ts
+import { AsyncLocalStorage } from "async_hooks";
+
+// node_modules/mochi-framework/src/utils/globalState.ts
+function pinGlobal(key, factory) {
+  const slot = globalThis;
+  slot[key] ??= factory();
+  return slot[key];
+}
+
+// node_modules/mochi-framework/src/utils/serverOnly.ts
+var IS_CLIENT_BUNDLE = typeof MOCHI_CLIENT !== "undefined" && MOCHI_CLIENT === true;
+function assertServerOnly(api, why) {
+  if (IS_CLIENT_BUNDLE) {
+    throw new Error(`[mochi] ${api} was called in the browser. ${why}`);
+  }
+}
+
+// node_modules/mochi-framework/src/runtime/requestContext.ts
+var requestContext = pinGlobal("__mochi_request_context__", () => new AsyncLocalStorage);
+var SERVER_ONLY_REASON = "The request context is server-only. Read what you need during SSR and pass it down as a prop, or through Svelte\u2019s hydratable().";
+function getRequestContext() {
+  assertServerOnly("getRequestContext()", SERVER_ONLY_REASON);
+  const ctx = requestContext.getStore();
+  if (!ctx) {
+    throw new Error("getRequestContext() called outside of a request. " + "It is only available in server-side code running within a Mochi request handler.");
+  }
+  return ctx;
+}
+
+// node_modules/mochi-framework/src/islands/islandPropsRegistry.ts
+function emitIslandProps(value) {
+  const json = stringify(value);
+  const ctx = getRequestContext();
+  let entry = ctx.islandProps.get(json);
+  if (!entry) {
+    entry = { id: `mochi-props-${ctx.islandProps.size}`, emitCount: 0 };
+    ctx.islandProps.set(json, entry);
+  }
+  entry.emitCount++;
+  return entry.id;
+}
+
+// node_modules/mochi-framework/src/utils/log.ts
+var LEVELS = {
+  silent: 0,
+  error: 1,
+  warn: 2,
+  info: 3,
+  log: 4,
+  debug: 5
+};
+var PREFIX = "[mochi]";
+var red = (s) => `\x1B[31m${s}\x1B[39m`;
+var yellow = (s) => `\x1B[33m${s}\x1B[39m`;
+var green = (s) => `\x1B[32m${s}\x1B[39m`;
+var dim = (s) => `\x1B[2m${s}\x1B[22m`;
+var DEFAULT_LOG_LEVEL = "warn";
+var state = pinGlobal("__mochi_log_state__", () => ({ level: DEFAULT_LOG_LEVEL }));
+var logger = {
+  error: (...args) => {
+    if (LEVELS[state.level] < LEVELS.error) {
+      return;
+    }
+    console.error(red(PREFIX), ...args);
+  },
+  warn: (...args) => {
+    if (LEVELS[state.level] < LEVELS.warn) {
+      return;
+    }
+    console.warn(yellow(PREFIX), ...args);
+  },
+  info: (...args) => {
+    if (LEVELS[state.level] < LEVELS.info) {
+      return;
+    }
+    console.info(green(PREFIX), ...args);
+  },
+  log: (...args) => {
+    if (LEVELS[state.level] < LEVELS.log) {
+      return;
+    }
+    console.log(dim(PREFIX), ...args);
+  },
+  debug: (...args) => {
+    if (LEVELS[state.level] < LEVELS.debug) {
+      return;
+    }
+    console.debug(dim(PREFIX), ...args);
+  }
+};
+// node_modules/mochi-framework/src/islands/isHydratable.ts
+import { getContext } from "svelte";
+var HYDRATABLE_CONTEXT_KEY = Symbol.for("mochi:hydratable");
+// node_modules/mitt/dist/mitt.mjs
+function mitt_default(n) {
+  return { all: n = n || new Map, on: function(t, e) {
+    var i = n.get(t);
+    i ? i.push(e) : n.set(t, [e]);
+  }, off: function(t, e) {
+    var i = n.get(t);
+    i && (e ? i.splice(i.indexOf(e) >>> 0, 1) : n.set(t, []));
+  }, emit: function(t, e) {
+    var i = n.get(t);
+    i && i.slice().map(function(n2) {
+      n2(e);
+    }), (i = n.get("*")) && i.slice().map(function(n2) {
+      n2(t, e);
+    });
+  } };
+}
+
+// node_modules/mochi-framework/src/cache/cache.ts
+import { randomUUID } from "crypto";
+
+// node_modules/mochi-framework/src/cache/cache-storage.ts
+import { mkdirSync, rmSync } from "fs";
+import { mkdir, open, readdir, rename, rm, stat, unlink } from "fs/promises";
+import { join, relative } from "path";
+
+// node_modules/mochi-framework/src/events.ts
+var mochiEvents = pinGlobal("__mochi_events__", () => {
+  const base = mitt_default();
+  const byName = new Map;
+  base.setHandler = (name, type, handler) => {
+    const prior = byName.get(name);
+    if (prior) {
+      base.off(prior.type, prior.handler);
+    }
+    byName.set(name, {
+      type,
+      handler
+    });
+    base.on(type, handler);
+  };
+  base.removeHandler = (name) => {
+    const prior = byName.get(name);
+    if (!prior) {
+      return;
+    }
+    base.off(prior.type, prior.handler);
+    byName.delete(name);
+  };
+  return base;
+});
+
+// node_modules/mochi-framework/src/cache/cache-storage.ts
+function isBlobRef(value) {
+  return typeof value === "object" && value !== null && value.__mochiBlobRef === true;
+}
+async function readBlobRef(ref) {
+  return new Uint8Array(await Bun.file(ref.path).arrayBuffer());
+}
+function isBinary(value) {
+  return value instanceof Uint8Array;
+}
+function isBlobPointer(value) {
+  return typeof value === "object" && value !== null && typeof value.__mochiBlob === "string";
+}
+function isInlineBinary(value) {
+  return typeof value === "object" && value !== null && typeof value.__mochiBinary === "string";
+}
+function isKeyedEnvelope(value) {
+  return typeof value === "object" && value !== null && "__mochiValue" in value && typeof value.__mochiKey === "string";
+}
+
+class MemoryStorage {
+  store = new Map;
+  maxAge;
+  intervalTimer;
+  constructor(options = {}) {
+    this.maxAge = options.maxAge;
+    if (options.purgeInterval && options.purgeInterval > 0) {
+      this.startSweeper(options.purgeInterval);
+    }
+  }
+  getItem(key) {
+    return this.store.get(key)?.value ?? null;
+  }
+  setItem(key, value) {
+    this.store.set(key, { value, writtenAt: Date.now() });
+  }
+  removeItem(key) {
+    this.store.delete(key);
+  }
+  clear() {
+    this.store.clear();
+  }
+  count() {
+    return this.store.size;
+  }
+  keys() {
+    return [...this.store.keys()];
+  }
+  sweep(now = Date.now(), options = {}) {
+    if (this.maxAge === undefined) {
+      return options.reportKeys ? { removed: 0, removedKeys: [] } : { removed: 0 };
+    }
+    const removedKeys = [];
+    let removed = 0;
+    for (const [key, entry] of this.store) {
+      if (now - entry.writtenAt > this.maxAge) {
+        this.store.delete(key);
+        removed++;
+        if (options.reportKeys) {
+          removedKeys.push(key);
+        }
+      }
+    }
+    return options.reportKeys ? { removed, removedKeys } : { removed };
+  }
+  dispose() {
+    if (this.intervalTimer) {
+      clearInterval(this.intervalTimer);
+    }
+    this.intervalTimer = undefined;
+  }
+  startSweeper(intervalMs) {
+    this.intervalTimer = setInterval(() => {
+      const start = Date.now();
+      const { removed } = this.sweep(start);
+      mochiEvents.emit("cache:sweep", { removed, durationMs: Date.now() - start });
+    }, intervalMs);
+    this.intervalTimer.unref?.();
+  }
+}
+var isENOENT = (err) => err?.code === "ENOENT";
+async function writeFileDurable(path, data) {
+  const fh = await open(path, "w");
+  try {
+    await fh.write(data);
+    await fh.sync();
+  } finally {
+    await fh.close();
+  }
+}
+var RENAME_RETRY_CODES = new Set(["EPERM", "EACCES", "EBUSY", "ENOENT"]);
+async function renameWithRetry(from, to) {
+  if (process.platform !== "win32") {
+    return rename(from, to);
+  }
+  for (let attempt = 0;; attempt++) {
+    try {
+      return await rename(from, to);
+    } catch (err) {
+      const code = err.code ?? "";
+      if (attempt >= 50 || !RENAME_RETRY_CODES.has(code)) {
+        throw err;
+      }
+      await Bun.sleep(Math.min(100, 10 * (attempt + 1)));
+    }
+  }
+}
+var DIR_FSYNC_UNSUPPORTED = new Set(["EINVAL", "ENOTSUP", "EPERM", "EISDIR"]);
+async function fsyncDir(dir) {
+  let fh;
+  try {
+    fh = await open(dir, "r");
+    await fh.sync();
+  } catch (err) {
+    if (!DIR_FSYNC_UNSUPPORTED.has(err.code ?? "")) {
+      throw err;
+    }
+  } finally {
+    await fh?.close();
+  }
+}
+var ORPHAN_BLOB_GRACE_MS = 1e4;
+
+class FileStorage {
+  directory;
+  maxAge;
+  offloadBinary;
+  initialTimer;
+  intervalTimer;
+  constructor(options) {
+    this.directory = options.directory;
+    this.maxAge = options.maxAge ?? 600000;
+    this.offloadBinary = options.offloadBinary ?? false;
+    if (options.purgeOnInit) {
+      rmSync(this.directory, { recursive: true, force: true });
+    }
+    mkdirSync(this.directory, { recursive: true });
+    const purgeInterval = options.purgeInterval ?? 60000;
+    if (purgeInterval > 0) {
+      this.startSweeper(purgeInterval);
+    }
+  }
+  async getItem(key) {
+    let text;
+    try {
+      text = await Bun.file(this.pathFor(key)).text();
+    } catch (err) {
+      if (isENOENT(err)) {
+        return null;
+      }
+      throw err;
+    }
+    const parsed = JSON.parse(text);
+    if (!isKeyedEnvelope(parsed)) {
+      return null;
+    }
+    return this.decodeBlobs(parsed.__mochiValue);
+  }
+  async setItem(key, value) {
+    const hash = this.hashKey(key);
+    const path = join(this.directory, `${hash}.json`);
+    const blobs = [];
+    const json = this.encodeBlobs(value, hash, blobs);
+    if (blobs.length > 0) {
+      const blobDir = join(this.directory, hash);
+      await mkdir(blobDir, { recursive: true });
+      for (const b of blobs) {
+        const blobPath = join(this.directory, b.relPath);
+        if (await Bun.file(blobPath).exists()) {
+          continue;
+        }
+        const blobTmp = `${blobPath}.${crypto.randomUUID()}.tmp`;
+        await writeFileDurable(blobTmp, b.data);
+        await renameWithRetry(blobTmp, blobPath);
+      }
+      await fsyncDir(blobDir);
+    }
+    const tmp = `${path}.${crypto.randomUUID()}.tmp`;
+    const envelope = { __mochiKey: key, __mochiValue: json };
+    await writeFileDurable(tmp, new TextEncoder().encode(JSON.stringify(envelope)));
+    await renameWithRetry(tmp, path);
+    await fsyncDir(this.directory);
+  }
+  async removeItem(key) {
+    const hash = this.hashKey(key);
+    try {
+      await unlink(join(this.directory, `${hash}.json`));
+    } catch (err) {
+      if (!isENOENT(err)) {
+        throw err;
+      }
+    }
+    await rm(join(this.directory, hash), { recursive: true, force: true });
+  }
+  async clear() {
+    const entries = await readdir(this.directory, { withFileTypes: true }).catch((err) => {
+      if (isENOENT(err)) {
+        return [];
+      }
+      throw err;
+    });
+    await Promise.all(entries.map((entry) => {
+      const p = join(this.directory, entry.name);
+      if (entry.isDirectory()) {
+        return rm(p, { recursive: true, force: true });
+      }
+      if (entry.name.endsWith(".json") || entry.name.endsWith(".tmp")) {
+        return unlink(p).catch((err) => isENOENT(err) ? undefined : Promise.reject(err));
+      }
+      return;
+    }));
+  }
+  async count() {
+    const entries = await readdir(this.directory, { withFileTypes: true }).catch((err) => {
+      if (isENOENT(err)) {
+        return [];
+      }
+      throw err;
+    });
+    return entries.filter((entry) => !entry.isDirectory() && entry.name.endsWith(".json")).length;
+  }
+  async keys() {
+    const entries = await readdir(this.directory, { withFileTypes: true }).catch((err) => {
+      if (isENOENT(err)) {
+        return [];
+      }
+      throw err;
+    });
+    const files = entries.filter((entry) => !entry.isDirectory() && entry.name.endsWith(".json"));
+    const keys = await Promise.all(files.map((entry) => this.readKey(join(this.directory, entry.name))));
+    return keys.filter((key) => key !== null);
+  }
+  async sweep(now = Date.now(), options = {}) {
+    const entries = await readdir(this.directory, { withFileTypes: true }).catch((err) => {
+      if (isENOENT(err)) {
+        return [];
+      }
+      throw err;
+    });
+    let removed = 0;
+    const removedKeys = [];
+    await Promise.all(entries.filter((entry) => !entry.isDirectory() && (entry.name.endsWith(".json") || entry.name.endsWith(".tmp"))).map(async (entry) => {
+      const filePath = join(this.directory, entry.name);
+      const threshold = entry.name.endsWith(".tmp") ? ORPHAN_BLOB_GRACE_MS : this.maxAge;
+      try {
+        const info = await stat(filePath);
+        if (now - info.mtimeMs > threshold) {
+          if (options.reportKeys && entry.name.endsWith(".json")) {
+            const key = await this.readKey(filePath);
+            if (key !== null) {
+              removedKeys.push(key);
+            }
+          }
+          await unlink(filePath);
+          removed++;
+          if (entry.name.endsWith(".json")) {
+            const blobDir = join(this.directory, entry.name.slice(0, -".json".length));
+            await rm(blobDir, { recursive: true, force: true });
+          }
+        }
+      } catch (err) {
+        if (!isENOENT(err)) {
+          throw err;
+        }
+      }
+    }));
+    await Promise.all(entries.filter((entry) => entry.isDirectory()).map(async (entry) => {
+      const ownerExists = await Bun.file(join(this.directory, `${entry.name}.json`)).exists();
+      if (!ownerExists) {
+        const dir = join(this.directory, entry.name);
+        try {
+          if (now - (await stat(dir)).mtimeMs <= ORPHAN_BLOB_GRACE_MS) {
+            return;
+          }
+        } catch {
+          return;
+        }
+        await rm(dir, { recursive: true, force: true });
+      }
+    }));
+    return options.reportKeys ? { removed, removedKeys } : { removed };
+  }
+  dispose() {
+    if (this.initialTimer) {
+      clearTimeout(this.initialTimer);
+    }
+    if (this.intervalTimer) {
+      clearInterval(this.intervalTimer);
+    }
+    this.initialTimer = undefined;
+    this.intervalTimer = undefined;
+  }
+  async readKey(filePath) {
+    try {
+      const parsed = JSON.parse(await Bun.file(filePath).text());
+      return isKeyedEnvelope(parsed) ? parsed.__mochiKey : null;
+    } catch {
+      return null;
+    }
+  }
+  hashKey(key) {
+    return new Bun.CryptoHasher("sha256").update(key).digest("hex");
+  }
+  pathFor(key) {
+    return join(this.directory, `${this.hashKey(key)}.json`);
+  }
+  pathForKey(key) {
+    return this.pathFor(key);
+  }
+  encodeBlobs(value, hash, blobs) {
+    if (isBinary(value)) {
+      if (!this.offloadBinary) {
+        return { __mochiBinary: Buffer.from(value).toString("base64") };
+      }
+      const digest = new Bun.CryptoHasher("sha256").update(value).digest("hex");
+      const relPath = `${hash}/${digest}.bin`;
+      blobs.push({ relPath, data: value });
+      return { __mochiBlob: relPath, bytes: value.byteLength };
+    }
+    if (isBlobRef(value)) {
+      const relPath = relative(this.directory, value.path);
+      return { __mochiBlob: relPath, bytes: value.bytes };
+    }
+    if (Array.isArray(value)) {
+      return value.map((v) => this.encodeBlobs(v, hash, blobs));
+    }
+    if (value !== null && typeof value === "object") {
+      const out = {};
+      for (const [k, v] of Object.entries(value)) {
+        out[k] = this.encodeBlobs(v, hash, blobs);
+      }
+      return out;
+    }
+    return value;
+  }
+  decodeBlobs(value) {
+    if (isBlobPointer(value)) {
+      return { __mochiBlobRef: true, path: join(this.directory, value.__mochiBlob), bytes: value.bytes };
+    }
+    if (isInlineBinary(value)) {
+      return new Uint8Array(Buffer.from(value.__mochiBinary, "base64"));
+    }
+    if (Array.isArray(value)) {
+      return value.map((v) => this.decodeBlobs(v));
+    }
+    if (value !== null && typeof value === "object") {
+      const out = {};
+      for (const [k, v] of Object.entries(value)) {
+        out[k] = this.decodeBlobs(v);
+      }
+      return out;
+    }
+    return value;
+  }
+  startSweeper(intervalMs) {
+    const run2 = async () => {
+      const start = Date.now();
+      try {
+        const { removed } = await this.sweep(start);
+        mochiEvents.emit("cache:sweep", { removed, durationMs: Date.now() - start });
+      } catch (err) {
+        logger.warn(`Cache sweep failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    };
+    this.initialTimer = setTimeout(run2, 1000);
+    this.intervalTimer = setInterval(run2, intervalMs);
+    this.initialTimer.unref?.();
+    this.intervalTimer.unref?.();
+  }
+}
+
+// node_modules/mochi-framework/src/cache/cache.ts
+var identity = (value) => value;
+function withTimeout(work, ms, key) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`MochiCache: recompute for "${key}" timed out after ${ms}ms`)), ms);
+  });
+  return Promise.race([work, timeout]).finally(() => clearTimeout(timer));
+}
+
+class MochiCache {
+  storage;
+  minTimeToStale;
+  maxTimeToLive;
+  serialize;
+  deserialize;
+  inflightTimeout;
+  crossProcessInflight;
+  inflight = new Map;
+  constructor(options = {}) {
+    this.storage = options.storage ?? new MemoryStorage;
+    this.minTimeToStale = options.minTimeToStale ?? 5000;
+    this.maxTimeToLive = options.maxTimeToLive ?? 600000;
+    this.serialize = options.serialize ?? identity;
+    this.deserialize = options.deserialize ?? identity;
+    this.inflightTimeout = options.inflightTimeout ?? 3600000;
+    this.crossProcessInflight = options.crossProcessInflight ?? false;
+    if (this.minTimeToStale >= this.maxTimeToLive) {
+      throw new Error(`MochiCache: minTimeToStale (${this.minTimeToStale}) must be less than maxTimeToLive (${this.maxTimeToLive}).`);
+    }
+  }
+  async fetch(key, fn) {
+    const result = await this.fetchWithStatus(key, fn);
+    return result.value;
+  }
+  async fetchWithStatus(key, fn) {
+    const entry = await this.read(key);
+    if (entry == null) {
+      const value2 = await this.run(key, fn);
+      return this.emitRead(key, value2, "miss");
+    }
+    const cached = entry.value;
+    const age = this.now() - entry.createdAt;
+    if (age < this.minTimeToStale) {
+      return this.emitRead(key, cached, "fresh");
+    }
+    if (age < this.maxTimeToLive) {
+      if (await this.deferToPeer(key)) {
+        return this.emitRead(key, cached, "stale");
+      }
+      mochiEvents.emit("cache:revalidate", { key });
+      this.run(key, fn).catch((error) => {
+        mochiEvents.emit("cache:revalidate:failed", { key, error });
+      });
+      return this.emitRead(key, cached, "stale");
+    }
+    if (age < this.maxTimeToLive + this.inflightTimeout && await this.deferToPeer(key)) {
+      return this.emitRead(key, cached, "stale");
+    }
+    const value = await this.run(key, fn);
+    return this.emitRead(key, value, "expired");
+  }
+  async delete(key) {
+    this.inflight.delete(key);
+    try {
+      await this.storage.removeItem(key);
+    } catch (error) {
+      mochiEvents.emit("cache:error", { key, operation: "remove", error });
+      throw error;
+    }
+    await this.removeMarker(key);
+    mochiEvents.emit("cache:delete", { key });
+  }
+  async peek(key) {
+    const entry = await this.read(key);
+    if (entry == null) {
+      return null;
+    }
+    const age = this.now() - entry.createdAt;
+    const status = age < this.minTimeToStale ? "fresh" : age < this.maxTimeToLive ? "stale" : "expired";
+    return { value: entry.value, status };
+  }
+  async set(key, value) {
+    this.inflight.delete(key);
+    const entry = this.serialize({ value, createdAt: this.now() });
+    try {
+      await this.storage.setItem(key, entry);
+    } catch (error) {
+      mochiEvents.emit("cache:error", { key, operation: "set", error });
+      throw error;
+    }
+  }
+  async markStale(key) {
+    this.inflight.delete(key);
+    let raw;
+    try {
+      raw = await this.storage.getItem(key);
+    } catch (error) {
+      mochiEvents.emit("cache:error", { key, operation: "get", error });
+      return;
+    }
+    if (raw == null) {
+      return;
+    }
+    const entry = this.deserialize(raw);
+    const staleCreatedAt = this.now() - this.minTimeToStale;
+    if (entry.createdAt <= staleCreatedAt) {
+      return;
+    }
+    const next = this.serialize({ value: entry.value, createdAt: staleCreatedAt });
+    try {
+      await this.storage.setItem(key, next);
+    } catch (error) {
+      mochiEvents.emit("cache:error", { key, operation: "set", error });
+    }
+  }
+  async clearItems() {
+    this.inflight.clear();
+    try {
+      await this.storage.clear();
+    } catch (error) {
+      mochiEvents.emit("cache:error", { key: "*", operation: "clear", error });
+      throw error;
+    }
+  }
+  async read(key) {
+    let raw;
+    try {
+      raw = await this.storage.getItem(key);
+    } catch (error) {
+      mochiEvents.emit("cache:error", { key, operation: "get", error });
+      return null;
+    }
+    return raw == null ? null : this.deserialize(raw);
+  }
+  run(key, fn) {
+    const existing = this.inflight.get(key);
+    if (existing) {
+      return existing;
+    }
+    const ref = { current: null };
+    const runId = randomUUID();
+    const work = (async () => {
+      await this.writeMarker(key, runId);
+      try {
+        const value = await fn();
+        const serialized = this.serialize({ value, createdAt: this.now() });
+        if (this.inflight.get(key) === ref.current) {
+          try {
+            await this.storage.setItem(key, serialized);
+          } catch (error) {
+            mochiEvents.emit("cache:error", { key, operation: "set", error });
+          }
+        }
+        return this.deserialize(serialized).value;
+      } finally {
+        await this.removeMarker(key, runId);
+      }
+    })();
+    const guarded = this.inflightTimeout > 0 && Number.isFinite(this.inflightTimeout) ? withTimeout(work, this.inflightTimeout, key) : work;
+    const promise = guarded.finally(() => {
+      if (this.inflight.get(key) === ref.current) {
+        this.inflight.delete(key);
+      }
+    });
+    ref.current = promise;
+    this.inflight.set(key, promise);
+    return promise;
+  }
+  markerKey(key) {
+    return `mochi:inflight:${key}`;
+  }
+  markerLeaseEnabled() {
+    return this.crossProcessInflight && this.inflightTimeout > 0 && Number.isFinite(this.inflightTimeout);
+  }
+  async deferToPeer(key) {
+    if (!this.markerLeaseEnabled() || this.inflight.has(key)) {
+      return false;
+    }
+    let raw;
+    try {
+      raw = await this.storage.getItem(this.markerKey(key));
+    } catch {
+      return false;
+    }
+    const marker = raw;
+    if (marker == null || typeof marker.startedAt !== "number") {
+      return false;
+    }
+    if (this.now() - marker.startedAt >= this.inflightTimeout) {
+      return false;
+    }
+    mochiEvents.emit("cache:inflight:deferred", { key });
+    return true;
+  }
+  async writeMarker(key, runId) {
+    if (!this.markerLeaseEnabled()) {
+      return;
+    }
+    try {
+      await this.storage.setItem(this.markerKey(key), { startedAt: this.now(), runId });
+    } catch (error) {
+      mochiEvents.emit("cache:error", { key, operation: "set", error });
+    }
+  }
+  async removeMarker(key, runId) {
+    if (!this.markerLeaseEnabled()) {
+      return;
+    }
+    try {
+      if (runId !== undefined) {
+        const raw = await this.storage.getItem(this.markerKey(key));
+        if (raw != null && raw.runId !== undefined && raw.runId !== runId) {
+          return;
+        }
+      }
+      await this.storage.removeItem(this.markerKey(key));
+    } catch (error) {
+      mochiEvents.emit("cache:error", { key, operation: "remove", error });
+    }
+  }
+  emitRead(key, value, status) {
+    mochiEvents.emit("cache:read", { key, status });
+    return { value, status };
+  }
+  now() {
+    return Date.now();
+  }
+}
+// node_modules/mochi-framework/src/lifecycle.ts
+var milestones = pinGlobal("__mochi_startup_milestones__", () => new Set);
+
+// node_modules/mochi-framework/src/extensions.ts
+var STARTUP_MILESTONE_HOOKS = new Set(["mochi:init", "mochi:listening", "mochi:queuesMounted", "mochi:ready"]);
+var FILTER_KINDS = {
+  "csrf:formContentTypes": "sync",
+  "csrf:protectedMethods": "sync",
+  "csrf:trustedOrigins": "sync",
+  "csrf:check": "sync",
+  "trailingSlash:redirect": "sync",
+  "cookie:defaults": "sync",
+  "html:shell": "sync",
+  "serverIsland:secretKey": "async",
+  "payload:compressMinBytes": "sync",
+  "compile:preprocessors": "sync",
+  "publicDir:scan": "async",
+  "consoleLogger:level": "sync",
+  "consoleLogger:line": "sync",
+  "barrel:warn": "sync",
+  "image:maxRedirects": "sync",
+  "image:url": "sync",
+  "image:fileFilter": "sync",
+  "image:localAssetFilename": "sync",
+  "image:localAssetUrl": "sync",
+  "email:message": "async",
+  "captcha:bits": "sync",
+  "captcha:minAgeMs": "sync",
+  "captcha:driftAllowanceMs": "sync",
+  "captcha:solveBudgetMs": "sync",
+  "queue:recoveryStallWarningMs": "sync",
+  "queue:lockDurationMs": "sync"
+};
+var registry = pinGlobal("__mochi_extensions_registry__", () => ({ eventHooks: {}, filters: {} }));
+var SERVER_ONLY_REASON2 = "Hooks and filters are server-only \u2014 the registry only exists in the server process, so this call could never see a registered entry.";
+function applyFilter(name, value, ctx) {
+  assertServerOnly(`applyFilter('${name}')`, SERVER_ONLY_REASON2);
+  const fn = registry.filters[name];
+  if (FILTER_KINDS[name] === "async") {
+    if (!fn) {
+      return Promise.resolve(value);
+    }
+    return fn(value, ctx);
+  }
+  if (!fn) {
+    return value;
+  }
+  return fn(value, ctx);
+}
+
+// node_modules/mochi-framework/src/mochiConfig.ts
+var GLOBAL_KEY = "__mochi_config__";
+var SERVER_ONLY_REASON3 = "The Mochi.serve() config singleton \u2014 and the secret key it holds \u2014 only exists in the server process.";
+function getMochiConfig() {
+  assertServerOnly("getMochiConfig()", SERVER_ONLY_REASON3);
+  const ctx = globalThis[GLOBAL_KEY];
+  if (!ctx) {
+    throw new Error("Mochi.serve() has not been called yet.");
+  }
+  return ctx;
+}
+
+// node_modules/mochi-framework/src/runtime/requestCache.ts
+function isThenable(value) {
+  return typeof value?.then === "function";
+}
+var warnedNoContext = false;
+function warnNoContext(label) {
+  if (warnedNoContext) {
+    return;
+  }
+  let development = true;
+  try {
+    development = getMochiConfig().options.development ?? true;
+  } catch {}
+  if (!development) {
+    return;
+  }
+  warnedNoContext = true;
+  logger.warn(`${label} was called outside of a request; the result is not cached. ` + "Request-cached helpers only memoize inside a Mochi request handler.");
+}
+function bumpKey(state2, key, kind) {
+  let tally = state2.perKey.get(key);
+  if (!tally) {
+    tally = { hits: 0, misses: 0 };
+    state2.perKey.set(key, tally);
+  }
+  tally[kind]++;
+}
+function getOrSetIn(state2, key, fn) {
+  if (state2.map.has(key)) {
+    state2.hits++;
+    bumpKey(state2, key, "hits");
+    return state2.map.get(key);
+  }
+  state2.misses++;
+  bumpKey(state2, key, "misses");
+  const value = fn();
+  state2.map.set(key, value);
+  if (isThenable(value)) {
+    Promise.resolve(value).then(undefined, () => {
+      if (state2.map.get(key) === value) {
+        state2.map.delete(key);
+      }
+    });
+  }
+  return value;
+}
+function currentState() {
+  const ctx = requestContext.getStore();
+  if (!ctx) {
+    return;
+  }
+  return ctx.requestCache ??= { map: new Map, hits: 0, misses: 0, perKey: new Map };
+}
+function cacheWith(key, fn, label) {
+  const state2 = currentState();
+  if (!state2) {
+    if (label) {
+      warnNoContext(label);
+    }
+    return fn();
+  }
+  return getOrSetIn(state2, key, fn);
+}
+var memoCounter = pinGlobal("__mochi_request_memo_counter__", () => ({ n: 0 }));
+function requestMemo(fn, options = {}) {
+  const namespace = options.namespace ?? `memo:${++memoCounter.n}`;
+  const keyOf = options.key ?? defaultKey;
+  const label = options.quiet ? undefined : `${fn.name || "A request-memoized function"}()`;
+  return (...args) => cacheWith(`${namespace}:${keyOf(...args)}`, () => fn(...args), label);
+}
+function defaultKey(...args) {
+  return args.map(keyPart).join("\x00");
+}
+function keyPart(arg) {
+  switch (typeof arg) {
+    case "string":
+      return `s:${arg}`;
+    case "number":
+      return `n:${arg}`;
+    case "boolean":
+      return `b:${arg}`;
+    case "bigint":
+      return `i:${arg}`;
+    case "undefined":
+      return "u";
+    case "object":
+      if (arg === null) {
+        return "null";
+      }
+      try {
+        return `o:${JSON.stringify(arg)}`;
+      } catch {
+        throw new Error("requestMemo() could not serialize an argument for the cache key. Pass a `key` function to build the key yourself.");
+      }
+    default:
+      throw new Error(`requestMemo() cannot key a ${typeof arg} argument. Pass a \`key\` function to build the key yourself.`);
+  }
+}
+// node_modules/mochi-framework/src/image/config.ts
+import { createHash as createHash2 } from "crypto";
+
+// node_modules/mochi-framework/src/image/imageCache.ts
+import { createHash } from "crypto";
+function hash(input) {
+  return createHash("sha256").update(input).digest("base64url").slice(0, 22);
+}
+function variantId(src, configHash) {
+  return hash(`variant:${configHash}:${src}`);
+}
+function originalId(src) {
+  return hash(`original:${src}`);
+}
+var ORIG_PREFIX = "MochiImage:Original:";
+var VAR_PREFIX = "MochiImage:Variant:";
+var PH_PREFIX = "MochiImage:Placeholder:";
+var origKey = (src) => ORIG_PREFIX + src;
+var varKey = (id) => VAR_PREFIX + id;
+var phKey = (src) => PH_PREFIX + src;
+function mapStatus(status) {
+  if (status === "expired" || status === "miss") {
+    return "miss";
+  }
+  return status;
+}
+function storedBytesLen(bytes) {
+  return isBlobRef(bytes) ? bytes.bytes : bytes.byteLength;
+}
+var cascadeSeq = 0;
+function pathForKey(storage, key) {
+  const withPath = storage;
+  return typeof withPath.pathForKey === "function" ? withPath.pathForKey(key) : key;
+}
+
+class ImageCache {
+  storage;
+  cache;
+  minTimeToStale;
+  maxTimeToLive;
+  sizes;
+  cascadeHandlerName;
+  constructor(options) {
+    this.minTimeToStale = options.minTimeToStale;
+    this.maxTimeToLive = options.maxTimeToLive;
+    this.sizes = options.sizes;
+    this.storage = options.storage ?? new FileStorage({ directory: options.cacheDir, maxAge: options.maxTimeToLive, purgeInterval: 0, offloadBinary: true });
+    this.cache = new MochiCache({
+      minTimeToStale: this.minTimeToStale,
+      maxTimeToLive: this.maxTimeToLive,
+      storage: this.storage,
+      inflightTimeout: 60000,
+      crossProcessInflight: true
+    });
+    this.cascadeHandlerName = `mochi-image:cache-delete:${++cascadeSeq}`;
+    mochiEvents.setHandler(this.cascadeHandlerName, "cache:delete", (event) => {
+      if (event.key.startsWith(ORIG_PREFIX)) {
+        this.cascadeSource(event.key.slice(ORIG_PREFIX.length), "invalidated").catch(() => {});
+      }
+    });
+  }
+  dispose() {
+    mochiEvents.removeHandler(this.cascadeHandlerName);
+    this.storage.dispose?.();
+  }
+  async toBytes(field) {
+    return isBlobRef(field) ? readBlobRef(field) : field;
+  }
+  metaFrom(src, value) {
+    return {
+      version: 1,
+      contentType: value.contentType,
+      etag: value.etag,
+      width: value.width,
+      height: value.height,
+      format: value.format,
+      createdAt: value.createdAt,
+      staleAt: value.createdAt + this.minTimeToStale,
+      evictAt: value.createdAt + this.maxTimeToLive,
+      src,
+      originalCreatedAt: value.originalCreatedAt
+    };
+  }
+  async getVariant(src, id, regenerate) {
+    const key = varKey(id);
+    const orig = await this.cache.peek(origKey(src));
+    if (!orig || orig.status === "expired") {
+      if (await this.cache.peek(key)) {
+        await this.cache.delete(key);
+      }
+    } else {
+      const existing = await this.cache.peek(key);
+      if (existing && existing.status === "fresh" && (orig.status === "stale" || existing.value.originalCreatedAt !== orig.value.createdAt)) {
+        await this.cache.markStale(key);
+      }
+    }
+    const { value, status } = await this.cache.fetchWithStatus(key, async () => {
+      const r = await regenerate();
+      const stored = {
+        createdAt: Date.now(),
+        contentType: r.contentType,
+        etag: id,
+        width: r.width,
+        height: r.height,
+        format: r.format,
+        bytes: r.bytes,
+        originalCreatedAt: r.originalCreatedAt
+      };
+      mochiEvents.emit("image:store", {
+        kind: "variant",
+        src,
+        path: pathForKey(this.storage, key),
+        id,
+        size: r.bytes.byteLength,
+        contentType: r.contentType,
+        width: r.width,
+        height: r.height,
+        format: r.format
+      });
+      return stored;
+    });
+    const bytes = await this.toBytes(value.bytes);
+    return { entry: { bytes, meta: this.metaFrom(src, value) }, status: mapStatus(status) };
+  }
+  async getOriginal(src, fetchFn) {
+    const key = origKey(src);
+    const { value, status } = await this.cache.fetchWithStatus(key, async () => {
+      const fetched = await fetchFn();
+      const contentType = fetched.contentType ?? "application/octet-stream";
+      const stored = {
+        createdAt: Date.now(),
+        contentType,
+        etag: originalId(src),
+        width: 0,
+        height: 0,
+        format: "",
+        bytes: fetched.bytes
+      };
+      mochiEvents.emit("image:store", {
+        kind: "original",
+        src,
+        path: pathForKey(this.storage, key),
+        id: originalId(src),
+        size: fetched.bytes.byteLength,
+        contentType,
+        width: 0,
+        height: 0,
+        format: ""
+      });
+      return stored;
+    });
+    const bytes = await this.toBytes(value.bytes);
+    return { entry: { bytes, meta: this.metaFrom(src, value) }, status: mapStatus(status) };
+  }
+  async invalidateOriginal(src, hard) {
+    const key = origKey(src);
+    if (!hard) {
+      await this.cache.markStale(key);
+      return;
+    }
+    const orig = await this.cache.peek(key);
+    await this.cascadeSource(src, "invalidated");
+    await this.cache.delete(key);
+    if (orig) {
+      mochiEvents.emit("image:delete", {
+        kind: "original",
+        src,
+        path: pathForKey(this.storage, key),
+        id: originalId(src),
+        size: storedBytesLen(orig.value.bytes),
+        reason: "invalidated"
+      });
+    }
+  }
+  async clearAll() {
+    await this.cache.clearItems();
+  }
+  async count() {
+    return await this.storage.count?.() ?? 0;
+  }
+  async keys() {
+    const keys = await this.storage.keys?.() ?? [];
+    return keys.filter((key) => !key.startsWith("mochi:inflight:"));
+  }
+  async inspect(key) {
+    return this.storage.getItem(key);
+  }
+  async cascadeSource(src, reason) {
+    const ph = await this.cache.peek(phKey(src));
+    if (ph) {
+      await this.cache.delete(phKey(src));
+      mochiEvents.emit("image:delete", {
+        kind: "placeholder",
+        src,
+        path: pathForKey(this.storage, phKey(src)),
+        id: originalId(src),
+        size: Buffer.byteLength(ph.value.dataUrl),
+        reason
+      });
+    }
+    for (const size of Object.values(this.sizes)) {
+      const id = variantId(src, size.configHash);
+      const variant = await this.cache.peek(varKey(id));
+      if (variant) {
+        await this.cache.delete(varKey(id));
+        mochiEvents.emit("image:delete", {
+          kind: "variant",
+          src,
+          path: pathForKey(this.storage, varKey(id)),
+          id,
+          size: storedBytesLen(variant.value.bytes),
+          reason
+        });
+      }
+    }
+  }
+  async sweep(now = Date.now()) {
+    const result = await this.storage.sweep?.(now, { reportKeys: true });
+    const removed = result?.removed ?? 0;
+    let removedOriginals = 0;
+    let removedVariants = 0;
+    for (const key of result?.removedKeys ?? []) {
+      if (key.startsWith(ORIG_PREFIX)) {
+        removedOriginals++;
+      } else if (key.startsWith(VAR_PREFIX) || key.startsWith(PH_PREFIX)) {
+        removedVariants++;
+      }
+    }
+    return { removedVariants, removedOriginals, removedOther: removed - removedVariants - removedOriginals };
+  }
+  async getPlaceholder(src) {
+    const cached = await this.cache.peek(phKey(src));
+    if (!cached || cached.status === "expired") {
+      return null;
+    }
+    const orig = await this.cache.peek(origKey(src));
+    if (orig && cached.value.originalCreatedAt !== orig.value.createdAt) {
+      return null;
+    }
+    return cached.value.dataUrl;
+  }
+  async setPlaceholder(src, dataUrl, originalCreatedAt) {
+    const key = phKey(src);
+    await this.cache.set(key, { dataUrl, originalCreatedAt });
+    mochiEvents.emit("image:store", {
+      kind: "placeholder",
+      src,
+      path: pathForKey(this.storage, key),
+      id: originalId(src),
+      size: Buffer.byteLength(dataUrl),
+      contentType: "",
+      width: 0,
+      height: 0,
+      format: ""
+    });
+  }
+}
+
+// node_modules/mochi-framework/src/image/config.ts
+var ALL_FORMATS = ["webp", "jpeg", "png", "avif"];
+var DEFAULT_INPUT_FORMATS = ["jpeg", "png", "webp", "avif", "gif"];
+function checkDimension(field, sizeName, value) {
+  if (value === undefined) {
+    return;
+  }
+  if (!Number.isFinite(value) || value < 1) {
+    throw new Error(`Image size "${sizeName}": ${field} must be a positive number, got ${value}`);
+  }
+  return Math.round(value);
+}
+function canonicalStringify(value) {
+  return JSON.stringify(value, (_key, v) => {
+    if (v !== null && typeof v === "object" && !Array.isArray(v)) {
+      return Object.fromEntries(Object.entries(v).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
+    }
+    return v;
+  });
+}
+function resolveSize(name, p, defaults) {
+  const format = p.format ?? defaults.format;
+  if (!defaults.outputFormats.includes(format)) {
+    throw new Error(`Image size "${name}": format "${format}" is not in outputFormats`);
+  }
+  const rawQuality = p.quality ?? defaults.quality;
+  if (!Number.isFinite(rawQuality)) {
+    throw new Error(`Image size "${name}": quality must be a finite number, got ${rawQuality}`);
+  }
+  const quality = Math.min(100, Math.max(1, Math.round(rawQuality)));
+  if (p.rotate !== undefined && !Number.isFinite(p.rotate)) {
+    throw new Error(`Image size "${name}": rotate must be a finite number, got ${p.rotate}`);
+  }
+  const resolved = {
+    name,
+    width: checkDimension("width", name, p.width),
+    height: checkDimension("height", name, p.height),
+    fit: p.fit ?? "inside",
+    withoutEnlargement: p.withoutEnlargement ?? false,
+    rotate: p.rotate,
+    flip: p.flip ?? false,
+    flop: p.flop ?? false,
+    modulate: p.modulate,
+    format,
+    quality,
+    autoOrient: p.autoOrient ?? defaults.autoOrient,
+    maxPixels: p.maxPixels ?? defaults.maxPixels,
+    configHash: ""
+  };
+  const { name: _n, configHash: _h, ...bytesAffecting } = resolved;
+  resolved.configHash = createHash2("sha256").update(canonicalStringify(bytesAffecting)).digest("base64url").slice(0, 16);
+  return resolved;
+}
+function resolveImageOptions(opts) {
+  const o = opts ?? {};
+  const defaultFormat = o.defaultFormat ?? "webp";
+  const defaultQuality = o.defaultQuality ?? 80;
+  const outputFormats = o.outputFormats ?? ALL_FORMATS;
+  const maxPixels = o.maxPixels ?? 50000000;
+  const autoOrient = o.autoOrient ?? true;
+  const sizes = Object.create(null);
+  for (const [name, p] of Object.entries(o.sizes ?? {})) {
+    sizes[name] = resolveSize(name, p, { format: defaultFormat, quality: defaultQuality, autoOrient, maxPixels, outputFormats });
+  }
+  return {
+    enabled: o.enabled ?? true,
+    sizes,
+    cacheDir: o.cacheDir ?? "./.mochi/image-cache",
+    storage: o.storage,
+    defaultFormat,
+    defaultQuality,
+    outputFormats,
+    inputFormats: o.inputFormats ?? DEFAULT_INPUT_FORMATS,
+    maxPixels,
+    autoOrient,
+    allowedHosts: o.allowedHosts,
+    blockPrivateNetworks: o.blockPrivateNetworks ?? true,
+    fetchTimeoutMs: o.fetchTimeoutMs ?? 1e4,
+    maxResponseBytes: o.maxResponseBytes ?? 20 * 1024 * 1024,
+    timeToStale: o.timeToStale ?? 14400000,
+    timeToEvict: o.timeToEvict ?? 86400000,
+    compressPayload: o.compressPayload ?? true,
+    sweepIntervalMs: o.sweepIntervalMs ?? 3600000
+  };
+}
+var GLOBAL_KEY2 = "__mochi_image_runtime__";
+function getImageRuntime() {
+  const g = globalThis;
+  let runtime = g[GLOBAL_KEY2];
+  if (!runtime) {
+    const { options } = getMochiConfig();
+    const resolved = resolveImageOptions(options.image);
+    runtime = {
+      options: resolved,
+      cache: new ImageCache({
+        cacheDir: resolved.cacheDir,
+        minTimeToStale: resolved.timeToStale,
+        maxTimeToLive: resolved.timeToEvict,
+        sizes: resolved.sizes,
+        storage: resolved.storage
+      })
+    };
+    g[GLOBAL_KEY2] = runtime;
+  }
+  return runtime;
+}
+
+// node_modules/mochi-framework/src/utils/assertPublicUrl.ts
+var import_ipaddr = __toESM(require_ipaddr(), 1);
+import { isIP } from "net";
+import { lookup } from "dns/promises";
+
+class SsrfGuardError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SsrfGuardError";
+  }
+}
+function hostMatches(hostname, pattern) {
+  const host = hostname.toLowerCase();
+  const pat = pattern.toLowerCase();
+  if (pat.startsWith("*.")) {
+    const suffix = pat.slice(1);
+    return host.endsWith(suffix) && host.length > suffix.length;
+  }
+  return host === pat;
+}
+function stripBrackets(hostname) {
+  return hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+}
+function isBlockedIp(ip) {
+  let addr;
+  try {
+    addr = import_ipaddr.default.process(ip);
+  } catch {
+    return true;
+  }
+  if (addr.kind() === "ipv6") {
+    const g = addr.parts;
+    if (g[0] === 0 && g[1] === 0 && g[2] === 0 && g[3] === 0 && g[4] === 0 && g[5] === 0) {
+      return true;
+    }
+  }
+  return addr.range() !== "unicast";
+}
+async function assertPublicUrl(src, opts) {
+  let url;
+  try {
+    url = new URL(src);
+  } catch {
+    throw new SsrfGuardError("Invalid source URL");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new SsrfGuardError("Source protocol must be http or https");
+  }
+  if (opts.allowedHosts && opts.allowedHosts.length > 0) {
+    if (!opts.allowedHosts.some((p) => hostMatches(url.hostname, p))) {
+      throw new SsrfGuardError("Source host is not in the allowlist");
+    }
+  }
+  if (opts.blockPrivateNetworks) {
+    if (url.hostname.toLowerCase() === "localhost") {
+      throw new SsrfGuardError("Source host resolves to a private address");
+    }
+    const host = stripBrackets(url.hostname);
+    let addresses;
+    if (isIP(host)) {
+      addresses = [host];
+    } else {
+      try {
+        const results = await lookup(host, { all: true });
+        addresses = results.map((r) => r.address);
+      } catch {
+        throw new SsrfGuardError("Could not resolve source host");
+      }
+    }
+    if (addresses.length === 0 || addresses.some(isBlockedIp)) {
+      throw new SsrfGuardError("Source host resolves to a private address");
+    }
+  }
+  return url;
+}
+
+// node_modules/mochi-framework/src/image/localAssetRegistry.ts
+var GLOBAL_KEY3 = "__mochi_local_image_assets__";
+function registry2() {
+  const g = globalThis;
+  let map = g[GLOBAL_KEY3];
+  if (!map) {
+    map = new Map;
+    g[GLOBAL_KEY3] = map;
+  }
+  return map;
+}
+function getLocalImageAsset(url) {
+  return registry2().get(url);
+}
+
+// node_modules/mochi-framework/src/image/types.ts
+class ImageError extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "ImageError";
+  }
+}
+
+// node_modules/mochi-framework/src/image/fetchSource.ts
+var DEFAULT_MAX_REDIRECTS = 5;
+async function fetchImageSource(src, opts) {
+  const local = getLocalImageAsset(src);
+  if (local) {
+    return { bytes: await Bun.file(local.diskPath).bytes(), contentType: local.contentType };
+  }
+  const signal = AbortSignal.timeout(opts.fetchTimeoutMs);
+  const maxRedirects = applyFilter("image:maxRedirects", DEFAULT_MAX_REDIRECTS, { src });
+  let target = src;
+  let res;
+  for (let hop = 0;; hop++) {
+    let url;
+    try {
+      url = await assertPublicUrl(target, {
+        allowedHosts: opts.allowedHosts,
+        blockPrivateNetworks: opts.blockPrivateNetworks
+      });
+    } catch (e) {
+      if (e instanceof SsrfGuardError) {
+        throw new ImageError(400, e.message);
+      }
+      throw e;
+    }
+    try {
+      res = await fetch(url, {
+        signal,
+        redirect: "manual",
+        headers: { Accept: "image/*" }
+      });
+    } catch {
+      throw new ImageError(502, "Failed to fetch source image");
+    }
+    const location = res.headers.get("location");
+    if (res.status >= 300 && res.status < 400 && location) {
+      if (hop >= maxRedirects) {
+        throw new ImageError(502, "Too many redirects");
+      }
+      await res.body?.cancel();
+      target = new URL(location, url).href;
+      continue;
+    }
+    break;
+  }
+  if (!res.ok) {
+    throw new ImageError(502, `Source responded with ${res.status}`);
+  }
+  const declaredLength = Number(res.headers.get("content-length"));
+  if (Number.isFinite(declaredLength) && declaredLength > opts.maxResponseBytes) {
+    throw new ImageError(413, "Source image exceeds the maximum size");
+  }
+  const bytes = await readWithMaxSize(res, opts.maxResponseBytes);
+  return { bytes, contentType: res.headers.get("content-type") };
+}
+async function readWithMaxSize(res, maxSizeInBytes) {
+  const chunks = [];
+  let total = 0;
+  for await (const chunk of res.body ?? []) {
+    if ((total += chunk.byteLength) > maxSizeInBytes) {
+      throw new ImageError(413, "Source image exceeds the maximum size");
+    }
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks);
+}
+
+// node_modules/mochi-framework/src/utils/index.ts
+var import_negotiator = __toESM(require_negotiator(), 1);
+
+// node_modules/mochi-framework/src/image/imageCodec.ts
+var ORIGINAL = 1 << 0;
+var HAS_SIZE = 1 << 1;
+var HTTPS_PREFIX = 1 << 2;
+var HTTP_PREFIX = 1 << 3;
+
+// node_modules/mochi-framework/src/image/resize.ts
+function imageCtor() {
+  const ctor = Bun.Image;
+  if (!ctor) {
+    throw new ImageError(500, "Bun.Image is unavailable; Bun >= 1.3.14 is required");
+  }
+  return ctor;
+}
+async function computePlaceholder(input, opts) {
+  const Image = imageCtor();
+  try {
+    return await new Image(input, { maxPixels: opts.maxPixels }).placeholder();
+  } catch {
+    throw new ImageError(422, "Could not compute placeholder");
+  }
+}
+
+// node_modules/mochi-framework/src/image/imageApi.ts
+var warnedUnknownSize = new Set;
+var getCachedOriginal = requestMemo(readCachedOriginal, {
+  namespace: "mochi:image:original",
+  key: (src) => src,
+  quiet: true
+});
+async function readCachedOriginal(src, resolved, cache) {
+  const { entry, status } = await cache.getOriginal(src, () => fetchImageSource(src, resolved));
+  return { bytes: entry.bytes, contentType: entry.meta.contentType, status, createdAt: entry.meta.createdAt };
+}
+var getImagePlaceholder = requestMemo(computeImagePlaceholder, {
+  namespace: "mochi:image:placeholder:blocking",
+  quiet: true
+});
+async function computeImagePlaceholder(src) {
+  const { options, cache } = getImageRuntime();
+  const cached = await cache.getPlaceholder(src);
+  if (cached) {
+    return cached;
+  }
+  try {
+    const { bytes, createdAt } = await getCachedOriginal(src, options, cache);
+    const dataUrl = await computePlaceholder(bytes, options);
+    await cache.setPlaceholder(src, dataUrl, createdAt);
+    return dataUrl;
+  } catch (err) {
+    logger.warn(`Could not compute image placeholder for ${src}: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
+var warmingPlaceholders = new Set;
+function warmImagePlaceholder(src) {
+  if (warmingPlaceholders.has(src)) {
+    return;
+  }
+  warmingPlaceholders.add(src);
+  getImagePlaceholder(src).catch(() => {}).finally(() => warmingPlaceholders.delete(src));
+}
+var imagePlaceholder = requestMemo(readPlaceholder, { namespace: "mochi:image:placeholder", quiet: true });
+async function readPlaceholder(src) {
+  const { cache } = getImageRuntime();
+  const cached = await cache.getPlaceholder(src);
+  if (cached) {
+    return cached;
+  }
+  warmImagePlaceholder(src);
+  return null;
+}
+// mochi-env:mochi-framework
+var isDev = false;
+function getRequestContext2() {
+  const ctx = globalThis.__mochi_request_context__?.getStore();
+  if (!ctx)
+    throw new Error("getRequestContext() called outside of a request.");
+  return ctx;
+}
+function __mochiCtxProxy(key) {
+  return new Proxy({}, {
+    get(_, p) {
+      const v = getRequestContext2()[key];
+      const r = v[p];
+      return typeof r === "function" ? r.bind(v) : r;
+    },
+    has(_, p) {
+      return p in getRequestContext2()[key];
+    },
+    ownKeys() {
+      return Reflect.ownKeys(getRequestContext2()[key]);
+    },
+    getOwnPropertyDescriptor(_, p) {
+      const d = Object.getOwnPropertyDescriptor(getRequestContext2()[key], p);
+      if (d)
+        d.configurable = true;
+      return d;
+    }
+  });
+}
+var cookies = __mochiCtxProxy("cookies");
+var params = __mochiCtxProxy("params");
+var url = __mochiCtxProxy("url");
+var locals = __mochiCtxProxy("locals");
+if (!globalThis.__mochi_events__)
+  globalThis.__mochi_events__ = mitt_default();
+var mochiEvents2 = globalThis.__mochi_events__;
+
+// node_modules/mochi-framework/src/islands/HydratableBoundary.svelte
+import"svelte/internal/flags/async";
+import * as $ from "svelte/internal/server";
+import { setContext } from "svelte";
+function HydratableBoundary($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    setContext(Symbol.for("mochi:hydratable"), true);
+    let { children } = $$props;
+    children?.($$renderer2);
+    $$renderer2.push(`<!---->`);
+  });
+}
+// node_modules/@lucide/svelte/dist/Icon.svelte
+import"svelte/internal/flags/async";
+import * as $2 from "svelte/internal/server";
+
+// node_modules/@lucide/svelte/dist/defaultAttributes.js
+var defaultAttributes = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: 24,
+  height: 24,
+  viewBox: "0 0 24 24",
+  fill: "none",
+  stroke: "currentColor",
+  "stroke-width": 2,
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round"
+};
+var defaultAttributes_default = defaultAttributes;
+
+// node_modules/@lucide/svelte/dist/utils/hasA11yProp.js
+var hasA11yProp = (props) => {
+  for (const prop in props) {
+    if (prop.startsWith("aria-") || prop === "role" || prop === "title") {
+      return true;
+    }
+  }
+  return false;
+};
+
+// node_modules/@lucide/svelte/dist/context.js
+import { getContext as getContext2, setContext as setContext2 } from "svelte";
+var LucideContext = Symbol("lucide-context");
+var getLucideContext = () => getContext2(LucideContext);
+
+// node_modules/@lucide/svelte/dist/Icon.svelte
+function Icon($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const globalProps = getLucideContext() ?? {};
+    const {
+      name,
+      color = globalProps.color ?? "currentColor",
+      size = globalProps.size ?? 24,
+      strokeWidth = globalProps.strokeWidth ?? 2,
+      absoluteStrokeWidth = globalProps.absoluteStrokeWidth ?? false,
+      iconNode = [],
+      children,
+      $$slots,
+      $$events,
+      ...props
+    } = $$props;
+    const calculatedStrokeWidth = $2.derived(() => absoluteStrokeWidth ? Number(strokeWidth) * 24 / Number(size) : strokeWidth);
+    $$renderer2.push(`<svg${$2.attributes({
+      ...defaultAttributes_default,
+      ...!children && !hasA11yProp(props) && { "aria-hidden": "true" },
+      ...props,
+      width: size,
+      height: size,
+      stroke: color,
+      "stroke-width": calculatedStrokeWidth(),
+      class: $2.clsx([
+        "lucide-icon lucide",
+        globalProps.class,
+        name && `lucide-${name}`,
+        props.class
+      ])
+    }, undefined, undefined, undefined, 3)}><!--[-->`);
+    const each_array = $2.ensure_array_like(iconNode);
+    for (let $$index = 0, $$length = each_array.length;$$index < $$length; $$index++) {
+      let [tag, attrs] = each_array[$$index];
+      $2.element($$renderer2, tag, () => {
+        $$renderer2.push(`${$2.attributes({ ...attrs }, undefined, undefined, undefined, 3)}`);
+      });
+    }
+    $$renderer2.push(`<!--]-->`);
+    children?.($$renderer2);
+    $$renderer2.push(`<!----></svg>`);
+  });
+}
+
+export { emitIslandProps, isDev, cookies, HydratableBoundary, Icon };