@tool-bridge/server 0.21.1 → 0.22.1

package/dist/chunk-U7B6DS2O.js

@@ -1,977 +0,0 @@
-import {
-  TBError
-} from "./chunk-UZM2RXZH.js";
-import {
-  __commonJS,
-  __toESM
-} from "./chunk-U67V476Y.js";
-
-// ../../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) {
-    "use strict";
-    (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
-        };
-      }
-      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 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;
-        }
-        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: function() {
-                return this.join("/");
-              }
-            });
-            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;
-          }
-        }
-        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: function() {
-                return this.join("/");
-              }
-            });
-            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);
-  }
-});
-
-// ../plugins/src/_runtime/ipPolicy.ts
-var import_ipaddr = __toESM(require_ipaddr(), 1);
-function isStrictIpv4(value) {
-  return import_ipaddr.default.IPv4.isValidFourPartDecimal(value) && value.split(".").every((part) => part === "0" || !part.startsWith("0"));
-}
-function parseAddress(value) {
-  let text = value;
-  if (text.startsWith("[") && text.endsWith("]")) text = text.slice(1, -1);
-  const embeddedIpv4 = text.includes(".") ? text.slice(text.lastIndexOf(":") + 1) : void 0;
-  if (embeddedIpv4 !== void 0 && !isStrictIpv4(embeddedIpv4)) return void 0;
-  try {
-    if (isStrictIpv4(text)) return import_ipaddr.default.IPv4.parse(text);
-    if (import_ipaddr.default.IPv6.isValid(text)) return import_ipaddr.default.IPv6.parse(text);
-  } catch {
-  }
-  return void 0;
-}
-function classifyIpv4(octets) {
-  const a = octets[0];
-  const b = octets[1];
-  const c = octets[2];
-  if (a === 0) return "blocked";
-  if (a === 10) return "blocked";
-  if (a === 127) return "blocked";
-  if (a === 169 && b === 254) return "blocked";
-  if (a === 172 && b >= 16 && b <= 31) return "blocked";
-  if (a === 192 && b === 0 && c === 0) return "blocked";
-  if (a === 192 && b === 0 && c === 2) return "blocked";
-  if (a === 192 && b === 168) return "blocked";
-  if (a === 198 && (b === 18 || b === 19)) return "blocked";
-  if (a === 198 && b === 51 && c === 100) return "blocked";
-  if (a === 203 && b === 0 && c === 113) return "blocked";
-  if (a === 100 && b >= 64 && b <= 127) return "blocked";
-  if (a >= 224) return "blocked";
-  return "public";
-}
-function classifyIpv6(bytes) {
-  const isZero = bytes.every((byte) => byte === 0);
-  if (isZero) return "blocked";
-  if (bytes.slice(0, 15).every((byte) => byte === 0) && bytes[15] === 1) return "blocked";
-  const v4Mapped = bytes.slice(0, 10).every((byte) => byte === 0) && (bytes[10] === 255 && bytes[11] === 255 || bytes[10] === 0 && bytes[11] === 0);
-  if (v4Mapped) {
-    return classifyIpv4([bytes[12], bytes[13], bytes[14], bytes[15]]);
-  }
-  const first = bytes[0];
-  if ((first & 254) === 252) return "blocked";
-  if (first === 254 && (bytes[1] & 192) === 128) return "blocked";
-  if (first === 255) return "blocked";
-  if (first === 32 && bytes[1] === 1 && bytes[2] === 13 && bytes[3] === 184) return "blocked";
-  return "public";
-}
-function isIpAddress(value) {
-  return parseAddress(value) !== void 0;
-}
-function classifyIpAddress(address) {
-  const parsed = parseAddress(address);
-  if (parsed === void 0) return "blocked";
-  if (parsed instanceof import_ipaddr.default.IPv4) return classifyIpv4(parsed.octets);
-  const bytes = new Uint8Array(parsed.toByteArray());
-  if (parsed.isIPv4MappedAddress()) return classifyIpv4(parsed.toIPv4Address().octets);
-  return classifyIpv6(bytes);
-}
-
-// ../plugins/src/_runtime/guardedFetch.ts
-var MAX_REDIRECTS = 5;
-var CROSS_ORIGIN_STRIPPED_HEADERS = [
-  "authorization",
-  "cookie",
-  "proxy-authorization"
-  // 各家自定义的密钥头没有统一命名,凡是名字里带 key/token/secret 的一律剥掉:
-  // 宁可让跨源跳转少带一个无关头,也不能漏带走一个凭证。
-];
-var REQUEST_BODY_HEADERS = [
-  "content-encoding",
-  "content-language",
-  "content-location",
-  "content-type"
-];
-function looksLikeCredentialHeader(name) {
-  return /(?:^|-)(?:api[-_]?key|key|token|secret|auth)(?:$|-)/i.test(name);
-}
-function stripCredentials(headers, sensitiveHeaders) {
-  const next = new Headers(headers);
-  for (const [name] of headers) {
-    if (CROSS_ORIGIN_STRIPPED_HEADERS.includes(name.toLowerCase()) || looksLikeCredentialHeader(name) || sensitiveHeaders.has(name.toLowerCase())) {
-      next.delete(name);
-    }
-  }
-  return next;
-}
-var EgressBlockedError = class extends TBError {
-  constructor(message) {
-    super("invalid_argument", message);
-    this.name = "EgressBlockedError";
-  }
-};
-function assertPublicHttpUrl(value) {
-  let url;
-  try {
-    url = value instanceof URL ? value : new URL(value);
-  } catch {
-    throw new EgressBlockedError(`\u51FA\u7AD9\u76EE\u6807\u4E0D\u662F\u5408\u6CD5 URL: ${String(value)}`);
-  }
-  if (url.protocol !== "https:" && url.protocol !== "http:") {
-    throw new EgressBlockedError(`\u51FA\u7AD9\u76EE\u6807\u534F\u8BAE\u4E0D\u88AB\u5141\u8BB8: ${url.protocol}`);
-  }
-  const hostname = url.hostname.startsWith("[") && url.hostname.endsWith("]") ? url.hostname.slice(1, -1) : url.hostname;
-  if (hostname === "") throw new EgressBlockedError("\u51FA\u7AD9\u76EE\u6807\u7F3A\u5C11\u4E3B\u673A\u540D");
-  if (isIpAddress(hostname) && classifyIpAddress(hostname) === "blocked") {
-    throw new EgressBlockedError("\u51FA\u7AD9\u76EE\u6807\u6307\u5411\u79C1\u6709\u6216\u4FDD\u7559\u5730\u5740");
-  }
-  return url;
-}
-function createGuardedFetch(options = {}) {
-  const crossOriginRedirect = options.crossOriginRedirect ?? "error";
-  const maxRedirects = options.maxRedirects ?? MAX_REDIRECTS;
-  const sensitiveHeaders = new Set(
-    (options.sensitiveHeaders ?? []).map((name) => name.toLowerCase())
-  );
-  return async function guardedFetch2(input, init) {
-    const transport = options.fetch ?? globalThis.fetch;
-    const initial = input instanceof Request ? input.url : String(input);
-    let url = assertPublicHttpUrl(initial);
-    let request = input instanceof Request ? new Request(url, new Request(input, init)) : new Request(url, { ...init, redirect: "manual" });
-    for (let hop = 0; ; hop += 1) {
-      const response = await transport(new Request(request.clone(), { redirect: "manual" }));
-      const location = response.headers.get("location");
-      if (response.status < 300 || response.status > 399 || location === null) return response;
-      if (hop >= maxRedirects) {
-        throw new EgressBlockedError(`\u51FA\u7AD9\u91CD\u5B9A\u5411\u8D85\u8FC7 ${maxRedirects} \u8DF3`);
-      }
-      const previousOrigin = new URL(request.url).origin;
-      url = assertPublicHttpUrl(new URL(location, url));
-      const crossesOrigin = url.origin !== previousOrigin;
-      if (crossesOrigin && crossOriginRedirect === "error") {
-        throw new EgressBlockedError("\u643A\u5E26\u654F\u611F\u4FE1\u606F\u7684\u51FA\u7AD9\u8BF7\u6C42\u4E0D\u5141\u8BB8\u8DE8\u6E90\u91CD\u5B9A\u5411");
-      }
-      const headers = !crossesOrigin ? request.headers : stripCredentials(request.headers, sensitiveHeaders);
-      const downgrade = (response.status === 301 || response.status === 302) && request.method === "POST" || response.status === 303 && request.method !== "GET" && request.method !== "HEAD";
-      if (downgrade) {
-        const redirectedHeaders = new Headers(headers);
-        for (const name of REQUEST_BODY_HEADERS) redirectedHeaders.delete(name);
-        request = new Request(url, { method: "GET", headers: redirectedHeaders, redirect: "manual" });
-      } else {
-        const redirected = new Request(url, request);
-        request = crossesOrigin ? new Request(redirected, { headers, redirect: "manual" }) : redirected;
-      }
-    }
-  };
-}
-var guardedFetch = createGuardedFetch();
-
-export {
-  assertPublicHttpUrl,
-  createGuardedFetch,
-  guardedFetch
-};