@blotout/qinto-cli 0.1.16 → 0.1.17

package/dist/worker-artifact/proxy-wfp/index.js

@@ -0,0 +1,1311 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/ipaddr.js@2.5.0/node_modules/ipaddr.js/lib/ipaddr.js
+var require_ipaddr = __commonJS({
+  "../../node_modules/.pnpm/ipaddr.js@2.5.0/node_modules/ipaddr.js/lib/ipaddr.js"(exports, module) {
+    (function(root) {
+      "use strict";
+      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(ref[i].length > 4 ? NaN : parseInt(ref[i], 16));
+          }
+          return results;
+        })();
+        return {
+          parts,
+          zoneId
+        };
+      }
+      __name(expandIPv6, "expandIPv6");
+      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;
+      }
+      __name(matchCIDR, "matchCIDR");
+      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);
+      }
+      __name(parseIntAuto, "parseIntAuto");
+      function padPart(part, length) {
+        while (part.length < length) {
+          part = `0${part}`;
+        }
+        return part;
+      }
+      __name(padPart, "padPart");
+      const ipaddr2 = {};
+      ipaddr2.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;
+        }
+        __name(IPv4, "IPv4");
+        IPv4.prototype.SpecialRanges = {
+          unspecified: [[new IPv4([0, 0, 0, 0]), 8]],
+          broadcast: [[new IPv4([255, 255, 255, 255]), 32]],
+          // RFC3171
+          multicast: [[new IPv4([224, 0, 0, 0]), 4]],
+          // RFC3927
+          linkLocal: [[new IPv4([169, 254, 0, 0]), 16]],
+          // RFC5735
+          loopback: [[new IPv4([127, 0, 0, 0]), 8]],
+          // RFC6598
+          carrierGradeNat: [[new IPv4([100, 64, 0, 0]), 10]],
+          // RFC1918
+          "private": [
+            [new IPv4([10, 0, 0, 0]), 8],
+            [new IPv4([172, 16, 0, 0]), 12],
+            [new IPv4([192, 168, 0, 0]), 16]
+          ],
+          // Reserved and testing-only ranges; RFCs 5735, 5737, 2544, 1700
+          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]
+          ],
+          // RFC7534, RFC7535
+          as112: [
+            [new IPv4([192, 175, 48, 0]), 24],
+            [new IPv4([192, 31, 196, 0]), 24]
+          ],
+          // RFC7450
+          amt: [
+            [new IPv4([192, 52, 193, 0]), 24]
+          ]
+        };
+        IPv4.prototype.kind = function() {
+          return "ipv4";
+        };
+        IPv4.prototype.match = function(other, cidrRange) {
+          let ref;
+          if (cidrRange === void 0) {
+            ref = other;
+            other = ref[0];
+            cidrRange = ref[1];
+          }
+          if (other.kind() !== "ipv4") {
+            throw new Error("ipaddr: cannot match ipv4 address with non-ipv4 one");
+          }
+          return matchCIDR(this.octets, other.octets, 8, cidrRange);
+        };
+        IPv4.prototype.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 ipaddr2.subnetMatch(this, this.SpecialRanges);
+        };
+        IPv4.prototype.toByteArray = function() {
+          return this.octets.slice(0);
+        };
+        IPv4.prototype.toIPv4MappedAddress = function() {
+          return ipaddr2.IPv6.parse(`::ffff:${this.toString()}`);
+        };
+        IPv4.prototype.toNormalizedString = function() {
+          return this.toString();
+        };
+        IPv4.prototype.toString = function() {
+          return this.octets.join(".");
+        };
+        return IPv4;
+      })();
+      ipaddr2.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", { cause: e });
+        }
+      };
+      ipaddr2.IPv4.isIPv4 = function(string) {
+        return this.parser(string) !== null;
+      };
+      ipaddr2.IPv4.isValid = function(string) {
+        try {
+          new this(this.parser(string));
+          return true;
+        } catch {
+          return false;
+        }
+      };
+      ipaddr2.IPv4.isValidCIDR = function(string) {
+        try {
+          this.parseCIDR(string);
+          return true;
+        } catch {
+          return false;
+        }
+      };
+      ipaddr2.IPv4.isValidFourPartDecimal = function(string) {
+        if (ipaddr2.IPv4.isValid(string) && string.match(/^(0|[1-9]\d*)(\.(0|[1-9]\d*)){3}$/)) {
+          return true;
+        } else {
+          return false;
+        }
+      };
+      ipaddr2.IPv4.isValidCIDRFourPartDecimal = function(string) {
+        const match = string.match(/^(.+)\/(\d+)$/);
+        if (!ipaddr2.IPv4.isValidCIDR(string) || !match) {
+          return false;
+        }
+        return ipaddr2.IPv4.isValidFourPartDecimal(match[1]);
+      };
+      ipaddr2.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", { cause: e });
+        }
+      };
+      ipaddr2.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);
+      };
+      ipaddr2.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: /* @__PURE__ */ __name(function() {
+                return this.join("/");
+              }, "value")
+            });
+            return parsed;
+          }
+        }
+        throw new Error("ipaddr: string is not formatted like an IPv4 CIDR range");
+      };
+      ipaddr2.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;
+        }
+      };
+      ipaddr2.IPv4.subnetMaskFromPrefixLength = function(prefix) {
+        prefix = parseInt(prefix);
+        if (Number.isNaN(prefix) || 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);
+      };
+      ipaddr2.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;
+          }
+        }
+        __name(IPv6, "IPv6");
+        IPv6.prototype.SpecialRanges = {
+          // RFC4291, here and after
+          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],
+          // RFC3879
+          deprecatedSiteLocal: [new IPv6([65216, 0, 0, 0, 0, 0, 0, 0]), 10],
+          // RFC6666
+          discard: [new IPv6([256, 0, 0, 0, 0, 0, 0, 0]), 64],
+          // RFC6145
+          rfc6145: [new IPv6([0, 0, 0, 0, 65535, 0, 0, 0]), 96],
+          rfc6052: [
+            // RFC6052
+            [new IPv6([100, 65435, 0, 0, 0, 0, 0, 0]), 96],
+            // RFC8215
+            [new IPv6([100, 65435, 1, 0, 0, 0, 0, 0]), 48]
+          ],
+          // RFC3056
+          "6to4": [new IPv6([8194, 0, 0, 0, 0, 0, 0, 0]), 16],
+          // RFC6052, RFC6146
+          teredo: [new IPv6([8193, 0, 0, 0, 0, 0, 0, 0]), 32],
+          // RFC5180
+          benchmarking: [new IPv6([8193, 2, 0, 0, 0, 0, 0, 0]), 48],
+          // RFC7450
+          amt: [new IPv6([8193, 3, 0, 0, 0, 0, 0, 0]), 32],
+          as112v6: [
+            // RFC7535
+            [new IPv6([8193, 4, 274, 0, 0, 0, 0, 0]), 48],
+            // RFC7534
+            [new IPv6([9760, 79, 32768, 0, 0, 0, 0, 0]), 48]
+          ],
+          // RFC4843
+          deprecatedOrchid: [new IPv6([8193, 16, 0, 0, 0, 0, 0, 0]), 28],
+          // RFC7343
+          orchid2: [new IPv6([8193, 32, 0, 0, 0, 0, 0, 0]), 28],
+          // RFC9374
+          droneRemoteIdProtocolEntityTags: [new IPv6([8193, 48, 0, 0, 0, 0, 0, 0]), 28],
+          // RFC9602
+          segmentRouting: [new IPv6([24320, 0, 0, 0, 0, 0, 0, 0]), 16],
+          reserved: [
+            // RFC3849
+            [new IPv6([8193, 0, 0, 0, 0, 0, 0, 0]), 23],
+            // RFC2928
+            [new IPv6([8193, 3512, 0, 0, 0, 0, 0, 0]), 32],
+            // RFC9637
+            [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 === void 0) {
+            ref = other;
+            other = ref[0];
+            cidrRange = ref[1];
+          }
+          if (other.kind() !== "ipv6") {
+            throw new Error("ipaddr: cannot match ipv6 address with non-ipv6 one");
+          }
+          return matchCIDR(this.parts, other.parts, 16, cidrRange);
+        };
+        IPv6.prototype.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 ipaddr2.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 ipaddr2.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;
+          let suffix = "";
+          if (this.zoneId) {
+            suffix = `%${this.zoneId}`;
+          }
+          const normalized = this.toNormalizedString();
+          const string = normalized.slice(0, normalized.length - suffix.length);
+          let bestMatchIndex = 0;
+          let bestMatchLength = -1;
+          let bestMatchGroups = -1;
+          let match;
+          while (match = regex.exec(string)) {
+            const groups = (match[0].match(/0/g) || []).length;
+            if (groups > bestMatchGroups) {
+              bestMatchGroups = groups;
+              bestMatchIndex = match.index;
+              bestMatchLength = match[0].length;
+            }
+          }
+          if (bestMatchLength < 0) {
+            return string + suffix;
+          }
+          return `${string.substring(0, bestMatchIndex)}::${string.substring(bestMatchIndex + bestMatchLength)}${suffix}`;
+        };
+        IPv6.prototype.toString = function() {
+          return this.toRFC5952String();
+        };
+        return IPv6;
+      })();
+      ipaddr2.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", { cause: e });
+        }
+      };
+      ipaddr2.IPv6.isIPv6 = function(string) {
+        return this.parser(string) !== null;
+      };
+      ipaddr2.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 {
+          return false;
+        }
+      };
+      ipaddr2.IPv6.isValidCIDR = function(string) {
+        if (typeof string === "string" && string.indexOf(":") === -1) {
+          return false;
+        }
+        try {
+          this.parseCIDR(string);
+          return true;
+        } catch {
+          return false;
+        }
+      };
+      ipaddr2.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", { cause: e });
+        }
+      };
+      ipaddr2.IPv6.parse = function(string) {
+        const addr = this.parser(string);
+        if (addr === null) {
+          throw new Error("ipaddr: string is not formatted like an IPv6 Address");
+        }
+        return new this(addr.parts, addr.zoneId);
+      };
+      ipaddr2.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: /* @__PURE__ */ __name(function() {
+                return this.join("/");
+              }, "value")
+            });
+            return parsed;
+          }
+        }
+        throw new Error("ipaddr: string is not formatted like an IPv6 CIDR range");
+      };
+      ipaddr2.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 && 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;
+      };
+      ipaddr2.IPv6.subnetMaskFromPrefixLength = function(prefix) {
+        prefix = parseInt(prefix);
+        if (Number.isNaN(prefix) || 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);
+      };
+      ipaddr2.fromByteArray = function(bytes) {
+        const length = bytes.length;
+        if (length === 4) {
+          return new ipaddr2.IPv4(bytes);
+        } else if (length === 16) {
+          return new ipaddr2.IPv6(bytes);
+        } else {
+          throw new Error("ipaddr: the binary input is neither an IPv6 nor IPv4 address");
+        }
+      };
+      ipaddr2.isValid = function(string) {
+        return ipaddr2.IPv6.isValid(string) || ipaddr2.IPv4.isValid(string);
+      };
+      ipaddr2.isValidCIDR = function(string) {
+        return ipaddr2.IPv6.isValidCIDR(string) || ipaddr2.IPv4.isValidCIDR(string);
+      };
+      ipaddr2.parse = function(string) {
+        if (ipaddr2.IPv6.isValid(string)) {
+          return ipaddr2.IPv6.parse(string);
+        } else if (ipaddr2.IPv4.isValid(string)) {
+          return ipaddr2.IPv4.parse(string);
+        } else {
+          throw new Error("ipaddr: the address has neither IPv6 nor IPv4 format");
+        }
+      };
+      ipaddr2.parseCIDR = function(string) {
+        try {
+          return ipaddr2.IPv6.parseCIDR(string);
+        } catch {
+          try {
+            return ipaddr2.IPv4.parseCIDR(string);
+          } catch (e) {
+            throw new Error("ipaddr: the address has neither IPv6 nor IPv4 CIDR format", { cause: e });
+          }
+        }
+      };
+      ipaddr2.process = function(string) {
+        const addr = this.parse(string);
+        if (addr.kind() === "ipv6" && addr.isIPv4MappedAddress()) {
+          return addr.toIPv4Address();
+        } else {
+          return addr;
+        }
+      };
+      ipaddr2.subnetMatch = function(address, rangeList, defaultName) {
+        let i, rangeName, rangeSubnets, subnet;
+        if (defaultName === void 0 || 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 = ipaddr2;
+      } else {
+        root.ipaddr = ipaddr2;
+      }
+    })(exports);
+  }
+});
+
+// ../../libs/deploy-id/src/deploy-id.ts
+var MAX_DEPLOY_ID = 63;
+var HASH_LENGTH = 16;
+var hostnameHash = /* @__PURE__ */ __name(async (hostname) => {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(hostname));
+  return Array.from(new Uint8Array(digest)).map((byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, HASH_LENGTH);
+}, "hostnameHash");
+var deployIdFromHostname = /* @__PURE__ */ __name(async (hostname) => {
+  const canonical = hostname.toLowerCase();
+  const budget = MAX_DEPLOY_ID - HASH_LENGTH - 1;
+  const prefix = canonical.replace(/[^a-z0-9-]/g, "").slice(0, budget).replace(/-+$/, "");
+  return `${prefix}-${await hostnameHash(canonical)}`;
+}, "deployIdFromHostname");
+
+// ../../libs/honeycomb/src/ids.ts
+var HEX = "0123456789abcdef";
+var randomHex = /* @__PURE__ */ __name((bytes) => {
+  const buffer = new Uint8Array(bytes);
+  crypto.getRandomValues(buffer);
+  let out = "";
+  for (const byte of buffer) {
+    out += HEX[byte >> 4];
+    out += HEX[byte & 15];
+  }
+  return out;
+}, "randomHex");
+var newSpanId = /* @__PURE__ */ __name(() => {
+  return randomHex(8);
+}, "newSpanId");
+var nowUnixNano = /* @__PURE__ */ __name(() => {
+  return String(BigInt(Date.now()) * 1000000n);
+}, "nowUnixNano");
+
+// ../../libs/honeycomb/src/metric.ts
+var HISTOGRAM_BOUNDS = [5e-3, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10];
+var streamKey = /* @__PURE__ */ __name((name, attributes) => {
+  const pairs = Object.entries(attributes).map(([key, value]) => `${key}=${String(value)}`).sort();
+  return JSON.stringify([name, pairs]);
+}, "streamKey");
+var bucketFor = /* @__PURE__ */ __name((value) => {
+  const index = HISTOGRAM_BOUNDS.findIndex((bound) => value <= bound);
+  return index === -1 ? HISTOGRAM_BOUNDS.length : index;
+}, "bucketFor");
+var observed = /* @__PURE__ */ __name((bucketCounts, value) => {
+  const target = bucketFor(value);
+  return bucketCounts.map((count, index) => index === target ? count + 1 : count);
+}, "observed");
+var recordHistogram = /* @__PURE__ */ __name((buffer, instrument, value) => {
+  const key = streamKey(instrument.name, instrument.attributes);
+  const existing = buffer.histograms.get(key);
+  if (existing === void 0) {
+    const empty = new Array(HISTOGRAM_BOUNDS.length + 1).fill(0);
+    buffer.histograms.set(key, { ...instrument, count: 1, sum: value, min: value, max: value, bucketCounts: observed(empty, value) });
+    return;
+  }
+  existing.count += 1;
+  existing.sum += value;
+  existing.min = Math.min(existing.min, value);
+  existing.max = Math.max(existing.max, value);
+  existing.bucketCounts = observed(existing.bucketCounts, value);
+}, "recordHistogram");
+
+// ../../libs/honeycomb/src/scope.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var scopes = new AsyncLocalStorage();
+var runInScope = /* @__PURE__ */ __name((scope, run) => {
+  return scopes.run(scope, run);
+}, "runInScope");
+var currentScope = /* @__PURE__ */ __name(() => {
+  return scopes.getStore();
+}, "currentScope");
+var currentSpan = /* @__PURE__ */ __name(() => {
+  return scopes.getStore()?.span;
+}, "currentSpan");
+
+// ../../libs/honeycomb/src/span.ts
+var startSpan = /* @__PURE__ */ __name(({ traceId, parentSpanId, name, kind, attributes }) => {
+  return {
+    traceId,
+    spanId: newSpanId(),
+    parentSpanId,
+    name,
+    kind,
+    startTimeUnixNano: nowUnixNano(),
+    endTimeUnixNano: nowUnixNano(),
+    attributes: { ...attributes },
+    events: [],
+    failed: false,
+    statusMessage: void 0
+  };
+}, "startSpan");
+var MAX_CAUSE_DEPTH = 5;
+var causeChain = /* @__PURE__ */ __name((error) => {
+  const chain = [error];
+  let current = error?.cause;
+  while (current !== void 0 && current !== null && chain.length < MAX_CAUSE_DEPTH) {
+    chain.push(current);
+    current = current.cause;
+  }
+  return chain;
+}, "causeChain");
+var linkMessage = /* @__PURE__ */ __name((error) => {
+  if (!(error instanceof Error)) {
+    return String(error);
+  }
+  const code = error.code;
+  return typeof code === "string" ? `${error.message} [${code}]` : error.message;
+}, "linkMessage");
+var errorMessage = /* @__PURE__ */ __name((error) => {
+  return causeChain(error).map(linkMessage).join(": ");
+}, "errorMessage");
+var exceptionType = /* @__PURE__ */ __name((error) => {
+  return error instanceof Error ? error.name : typeof error;
+}, "exceptionType");
+var exceptionAttributes = /* @__PURE__ */ __name((error) => {
+  const attributes = {
+    "exception.type": exceptionType(error),
+    "exception.message": errorMessage(error)
+  };
+  const stack = error instanceof Error ? error.stack : void 0;
+  if (stack !== void 0) {
+    attributes["exception.stacktrace"] = stack;
+  }
+  return attributes;
+}, "exceptionAttributes");
+var exceptionEvent = /* @__PURE__ */ __name((error) => {
+  return { name: "exception", timeUnixNano: nowUnixNano(), attributes: exceptionAttributes(error) };
+}, "exceptionEvent");
+
+// ../../libs/honeycomb/src/trace.ts
+var durationSeconds = /* @__PURE__ */ __name((span) => {
+  return Number(BigInt(span.endTimeUnixNano) - BigInt(span.startTimeUnixNano)) / 1e9;
+}, "durationSeconds");
+var measure = /* @__PURE__ */ __name((scope, span, options, errorType) => {
+  const seconds = durationSeconds(span);
+  const attributes = errorType === void 0 ? options.attributes : { ...options.attributes, "error.type": errorType };
+  recordHistogram(scope.buffer.metrics, { name: options.metric, unit: options.unit, attributes }, seconds);
+  return span.failed || seconds >= options.slowSeconds || scope.keepMeasuredSpans;
+}, "measure");
+var traced = /* @__PURE__ */ __name(async (name, options, run) => {
+  const scope = currentScope();
+  if (scope === void 0) {
+    return await run();
+  }
+  const span = startSpan({
+    traceId: scope.traceId,
+    parentSpanId: scope.span?.spanId,
+    name,
+    kind: options.kind ?? "internal",
+    attributes: options.attributes ?? {}
+  });
+  let errorType;
+  try {
+    return await runInScope({ ...scope, span }, run);
+  } catch (error) {
+    span.events.push(exceptionEvent(error));
+    span.attributes["error"] = true;
+    span.failed = true;
+    span.statusMessage = errorMessage(error);
+    errorType = exceptionType(error);
+    throw error;
+  } finally {
+    span.endTimeUnixNano = nowUnixNano();
+    if (options.measure === void 0 || measure(scope, span, options.measure, errorType)) {
+      scope.buffer.spans.push(span);
+    }
+  }
+}, "traced");
+var setSpanAttributes = /* @__PURE__ */ __name((attributes) => {
+  const span = currentSpan();
+  if (span === void 0) {
+    return;
+  }
+  Object.assign(span.attributes, attributes);
+}, "setSpanAttributes");
+
+// ../../libs/honeycomb/src/fetch.ts
+var targetUrl = /* @__PURE__ */ __name((input) => {
+  if (typeof input === "string") {
+    return input;
+  }
+  return input instanceof URL ? input.href : input.url;
+}, "targetUrl");
+var targetMethod = /* @__PURE__ */ __name((input, init) => {
+  if (init?.method !== void 0) {
+    return init.method;
+  }
+  return typeof input === "string" || input instanceof URL ? "GET" : input.method;
+}, "targetMethod");
+var tracedFetch = /* @__PURE__ */ __name(async (input, init, options) => {
+  const url = targetUrl(input);
+  const method = targetMethod(input, init);
+  const parsed = new URL(url);
+  const urlFull = options?.traceQuery === false ? `${parsed.origin}${parsed.pathname}` : url;
+  return await traced(
+    `${method} ${parsed.host}`,
+    { kind: "client", attributes: { "http.request.method": method, "url.full": urlFull } },
+    async () => {
+      const response = await fetch(input, init);
+      setSpanAttributes({ "http.response.status_code": response.status });
+      return response;
+    }
+  );
+}, "tracedFetch");
+
+// ../../libs/honeycomb/src/redact.ts
+var SENSITIVE_URL_PARAMS = /* @__PURE__ */ new Set([
+  "access_token",
+  "api_key",
+  "api_secret",
+  "client_secret",
+  "code",
+  "code_verifier",
+  "key",
+  "password",
+  "refresh_token",
+  "secret",
+  "session",
+  "session_id",
+  "token"
+]);
+var SENSITIVE_URL_PARAM_SUFFIXES = ["token", "secret", "password"];
+var PARAM_MATCHER = /(^|[?&])([^=&?]+)=[^&]*/g;
+var redactUrlParams = /* @__PURE__ */ __name((value) => {
+  return value.replaceAll(PARAM_MATCHER, (match, separator, param) => {
+    const name = param.toLowerCase();
+    const sensitive = SENSITIVE_URL_PARAMS.has(name) || SENSITIVE_URL_PARAM_SUFFIXES.some((suffix) => name.endsWith(suffix));
+    return sensitive ? `${separator}${param}=[REDACTED]` : match;
+  });
+}, "redactUrlParams");
+
+// ../../libs/honeycomb/src/logger.ts
+var append = /* @__PURE__ */ __name((severity, body, attributes) => {
+  const scope = currentScope();
+  if (scope === void 0) {
+    return;
+  }
+  const span = currentSpan();
+  scope.buffer.logs.push({
+    timeUnixNano: nowUnixNano(),
+    severity,
+    body: redactUrlParams(body),
+    attributes,
+    traceId: scope.traceId,
+    spanId: span?.spanId
+  });
+}, "append");
+var logger = {
+  /**
+   * Logs at debug severity.
+   * @param message The log body; sensitive URL parameters in it are redacted before export.
+   * @param attributes Extra attributes to set on the log record.
+   */
+  debug: /* @__PURE__ */ __name((message, attributes = {}) => {
+    console.debug(message);
+    append("debug", message, attributes);
+  }, "debug"),
+  /**
+   * Logs at info severity.
+   * @param message The log body; sensitive URL parameters in it are redacted before export.
+   * @param attributes Extra attributes to set on the log record.
+   */
+  info: /* @__PURE__ */ __name((message, attributes = {}) => {
+    console.info(message);
+    append("info", message, attributes);
+  }, "info"),
+  /**
+   * Logs at warn severity.
+   * @param message The log body; sensitive URL parameters in it are redacted before export.
+   * @param attributes Extra attributes to set on the log record.
+   */
+  warn: /* @__PURE__ */ __name((message, attributes = {}) => {
+    console.warn(message);
+    append("warn", message, attributes);
+  }, "warn"),
+  /**
+   * Logs at error severity.
+   * @param message The log body; sensitive URL parameters in it are redacted before export.
+   * @param error The error to report — its message joins the body, and it is attached to the active span as an exception when there is one.
+   * @param attributes Extra attributes to set on the log record.
+   */
+  error: /* @__PURE__ */ __name((message, error, attributes = {}) => {
+    if (error === void 0) {
+      console.error(message);
+      append("error", message, attributes);
+      return;
+    }
+    console.error(message, error);
+    const span = currentSpan();
+    if (span !== void 0) {
+      span.events.push(exceptionEvent(error));
+      span.attributes["error"] = true;
+    }
+    append("error", `${message}: ${errorMessage(error)}`, { ...attributes, ...exceptionAttributes(error) });
+  }, "error")
+};
+
+// ../../libs/proxy-ingress/src/ingress.ts
+var PROXY_INGRESS_HEADER = "x-qinto-proxy-ingress";
+var PROXY_ORIGIN_HEADER = "x-qinto-proxy-origin";
+var encodeProxyIngress = /* @__PURE__ */ __name((ingress) => {
+  const cf = ingress.cf;
+  return JSON.stringify({
+    requestId: ingress.requestId,
+    traceId: ingress.traceId,
+    rayId: ingress.rayId,
+    visitorIp: ingress.visitorIp,
+    cf: {
+      country: cf.country,
+      continent: cf.continent,
+      city: cf.city,
+      region: cf.region,
+      regionCode: cf.regionCode,
+      timezone: cf.timezone,
+      postalCode: cf.postalCode,
+      latitude: cf.latitude,
+      longitude: cf.longitude,
+      isEUCountry: cf.isEUCountry,
+      colo: cf.colo,
+      asn: cf.asn,
+      asOrganization: cf.asOrganization,
+      botManagement: { score: cf.botManagement?.score, verifiedBot: cf.botManagement?.verifiedBot }
+    }
+  }).replace(/[\u0080-\uffff]/g, (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}, "encodeProxyIngress");
+
+// ../../libs/proxy-rules/src/cidr.ts
+var import_ipaddr = __toESM(require_ipaddr(), 1);
+var normalizeIp = /* @__PURE__ */ __name((raw) => {
+  if (raw.includes("%") || raw.includes(".") && !import_ipaddr.default.IPv4.isValidFourPartDecimal(raw.slice(raw.lastIndexOf(":") + 1)) || !(import_ipaddr.default.IPv4.isValidFourPartDecimal(raw) || import_ipaddr.default.IPv6.isValid(raw))) {
+    return null;
+  }
+  const address = import_ipaddr.default.process(raw);
+  return { family: address.kind() === "ipv4" ? 4 : 6, bytes: address.toByteArray(), text: address.toString() };
+}, "normalizeIp");
+
+// src/visitor-ip.ts
+var visitorIpFrom = /* @__PURE__ */ __name((headers) => {
+  const raw = headers.get("cf-connecting-ip");
+  if (raw === "2a06:98c0:3600::103") {
+    return { kind: "unavailable", reason: "synthetic_ip" };
+  }
+  if (headers.has("cf-worker") || headers.has("cf-connecting-o2o")) {
+    return { kind: "unavailable", reason: "untrusted_source" };
+  }
+  const address = raw === null ? null : normalizeIp(raw);
+  if (address === null) {
+    return { kind: "unavailable", reason: "not_provided" };
+  }
+  if (address.family === 4 && address.bytes[0] >= 240) {
+    return { kind: "unavailable", reason: "untrusted_source" };
+  }
+  return { kind: "value", value: address.text };
+}, "visitorIpFrom");
+
+// src/dispatch.ts
+var dispatchRequest = /* @__PURE__ */ __name(async (request, env) => {
+  const hostname = new URL(request.url).hostname;
+  const workerId = await deployIdFromHostname(hostname);
+  const ingress = {
+    requestId: crypto.randomUUID(),
+    traceId: crypto.randomUUID().replaceAll("-", ""),
+    rayId: request.headers.get("cf-ray"),
+    visitorIp: visitorIpFrom(request.headers),
+    cf: request.cf ?? {}
+  };
+  const headers = new Headers(request.headers);
+  headers.set(PROXY_INGRESS_HEADER, encodeProxyIngress(ingress));
+  const forwarded = new Request(request, { headers, redirect: "manual" });
+  try {
+    return await env.PROXY.get(workerId).fetch(forwarded);
+  } catch (error) {
+    const missing = error instanceof Error && error.message.includes("Worker not found");
+    const code = missing ? "worker_missing" : "dispatch_error";
+    try {
+      env.DISPATCH_ANALYTICS.writeDataPoint({
+        indexes: [workerId],
+        blobs: [hostname, code, ingress.requestId, ingress.traceId]
+      });
+    } catch {
+      logger.error("Proxy dispatcher measurement failed", void 0, { requestId: ingress.requestId, code });
+    }
+    return new Response(missing ? "Not found" : "Proxy unavailable", { status: missing ? 404 : 503 });
+  }
+}, "dispatchRequest");
+
+// src/origin-connection.ts
+import { WorkerEntrypoint } from "cloudflare:workers";
+
+// src/origin.ts
+var transportFor = /* @__PURE__ */ __name((kind) => {
+  switch (kind) {
+    case "custom": {
+      return { preserveHost: true, adaptLocation: false };
+    }
+    case "external": {
+      return { preserveHost: false, adaptLocation: false };
+    }
+    case "shopify":
+    case "webflow": {
+      return { preserveHost: false, adaptLocation: true };
+    }
+    default: {
+      throw new Error(`Unsupported origin kind: ${String(kind)}`);
+    }
+  }
+}, "transportFor");
+var adaptProviderLocation = /* @__PURE__ */ __name((response, origin, publicHost) => {
+  const location = response.headers.get("location");
+  if (location === null || !/^(https?:)?\/\//i.test(location) || !URL.canParse(location, origin.href)) {
+    return response;
+  }
+  const target = new URL(location, origin);
+  if (target.host !== origin.host || target.username !== "" || target.password !== "") {
+    return response;
+  }
+  const headers = new Headers(response.headers);
+  headers.set("location", location.replace(/^((?:https?:)?\/\/)[^/?#]+/i, `$1${publicHost}`));
+  return new Response(response.body, { status: response.status, statusText: response.statusText, headers });
+}, "adaptProviderLocation");
+var forwardOrigin = /* @__PURE__ */ __name(async (request, destination) => {
+  const origin = new URL(destination.baseUrl);
+  const { preserveHost, adaptLocation } = transportFor(destination.kind);
+  if (preserveHost && (origin.port !== "" || new URL(request.url).port !== "")) {
+    throw new Error("Custom origin transport requires default HTTP/HTTPS ports");
+  }
+  const url = preserveHost ? request.url.replace(/^http:/, "https:") : request.url.replace(/^https?:\/\/[^/]+/, origin.origin);
+  const upstream = new Request(url, request);
+  upstream.headers.delete(PROXY_ORIGIN_HEADER);
+  if (!preserveHost) {
+    upstream.headers.set("host", origin.host);
+  }
+  const response = await tracedFetch(upstream, {
+    redirect: "manual",
+    signal: request.signal,
+    cf: {
+      ...preserveHost ? { resolveOverride: origin.hostname } : {},
+      cacheTtlByStatus: { "100-599": -1 }
+    }
+  });
+  if (!adaptLocation || response.status === 101) {
+    return response;
+  }
+  return adaptProviderLocation(response, origin, new URL(request.url).host);
+}, "forwardOrigin");
+
+// src/origin-connection.ts
+var OriginConnection = class extends WorkerEntrypoint {
+  static {
+    __name(this, "OriginConnection");
+  }
+  fetch(request) {
+    const destination = JSON.parse(request.headers.get(PROXY_ORIGIN_HEADER) ?? "");
+    return forwardOrigin(request, destination);
+  }
+};
+
+// src/index.ts
+var index_default = { fetch: dispatchRequest };
+export {
+  OriginConnection,
+  index_default as default
+};