@lynx-js/rspeedy-canary 0.11.3-canary-20250919-f4528d19 → 0.11.3-canary-20250919-8c33d3e1

package/dist/1~vendors-node_modules_pnpm_ipaddr_js_2_2_0_node_modules_ipaddr_js_lib_ipaddr_js.js

@@ -0,0 +1,1068 @@
+export const __webpack_id__ = "vendors-node_modules_pnpm_ipaddr_js_2_2_0_node_modules_ipaddr_js_lib_ipaddr_js";
+export const __webpack_ids__ = [
+    "vendors-node_modules_pnpm_ipaddr_js_2_2_0_node_modules_ipaddr_js_lib_ipaddr_js"
+];
+export const __webpack_modules__ = {
+    "../../../node_modules/.pnpm/ipaddr.js@2.2.0/node_modules/ipaddr.js/lib/ipaddr.js": function(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(parseInt(ref[i], 16));
+                    return results;
+                }();
+                return {
+                    parts: parts,
+                    zoneId: 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 ('0' === string[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 (4 !== octets.length) 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 (void 0 === cidrRange) {
+                        ref = other;
+                        other = ref[0];
+                        cidrRange = ref[1];
+                    }
+                    if ('ipv4' !== other.kind()) 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)) return null;
+                        zeros = zerotable[octet];
+                        if (stop && 0 !== zeros) return null;
+                        if (8 !== zeros) stop = true;
+                        cidr += zeros;
+                    }
+                    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) | 255 ^ 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.isIPv4 = function(string) {
+                return null !== this.parser(string);
+            };
+            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;
+                return false;
+            };
+            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 (null === parts) 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;
+                }();
+                if (match = string.match(ipv4Regexes.longValue)) {
+                    value = parseIntAuto(match[1]);
+                    if (value > 0xffffffff || 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 & 0xff);
+                        return results;
+                    })().reverse();
+                }
+                if (match = string.match(ipv4Regexes.twoOctet)) return function() {
+                    const ref = match.slice(1, 4);
+                    const results = [];
+                    value = parseIntAuto(ref[1]);
+                    if (value > 0xffffff || value < 0) throw new Error('ipaddr: address outside defined range');
+                    results.push(parseIntAuto(ref[0]));
+                    results.push(value >> 16 & 0xff);
+                    results.push(value >> 8 & 0xff);
+                    results.push(0xff & value);
+                    return results;
+                }();
+                if (match = string.match(ipv4Regexes.threeOctet)) return function() {
+                    const ref = match.slice(1, 5);
+                    const results = [];
+                    value = parseIntAuto(ref[2]);
+                    if (value > 0xffff || value < 0) throw new Error('ipaddr: address outside defined range');
+                    results.push(parseIntAuto(ref[0]));
+                    results.push(parseIntAuto(ref[1]));
+                    results.push(value >> 8 & 0xff);
+                    results.push(0xff & value);
+                    return results;
+                }();
+                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 (16 === parts.length) {
+                        this.parts = [];
+                        for(i = 0; i <= 14; i += 2)this.parts.push(parts[i] << 8 | parts[i + 1]);
+                    } else if (8 === parts.length) 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 <= 0xffff)) 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([
+                            0xfe80,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        10
+                    ],
+                    multicast: [
+                        new IPv6([
+                            0xff00,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        8
+                    ],
+                    loopback: [
+                        new IPv6([
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            1
+                        ]),
+                        128
+                    ],
+                    uniqueLocal: [
+                        new IPv6([
+                            0xfc00,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        7
+                    ],
+                    ipv4Mapped: [
+                        new IPv6([
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0xffff,
+                            0,
+                            0
+                        ]),
+                        96
+                    ],
+                    discard: [
+                        new IPv6([
+                            0x100,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        64
+                    ],
+                    rfc6145: [
+                        new IPv6([
+                            0,
+                            0,
+                            0,
+                            0,
+                            0xffff,
+                            0,
+                            0,
+                            0
+                        ]),
+                        96
+                    ],
+                    rfc6052: [
+                        new IPv6([
+                            0x64,
+                            0xff9b,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        96
+                    ],
+                    '6to4': [
+                        new IPv6([
+                            0x2002,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        16
+                    ],
+                    teredo: [
+                        new IPv6([
+                            0x2001,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        32
+                    ],
+                    benchmarking: [
+                        new IPv6([
+                            0x2001,
+                            0x2,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        48
+                    ],
+                    amt: [
+                        new IPv6([
+                            0x2001,
+                            0x3,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        32
+                    ],
+                    as112v6: [
+                        [
+                            new IPv6([
+                                0x2001,
+                                0x4,
+                                0x112,
+                                0,
+                                0,
+                                0,
+                                0,
+                                0
+                            ]),
+                            48
+                        ],
+                        [
+                            new IPv6([
+                                0x2620,
+                                0x4f,
+                                0x8000,
+                                0,
+                                0,
+                                0,
+                                0,
+                                0
+                            ]),
+                            48
+                        ]
+                    ],
+                    deprecated: [
+                        new IPv6([
+                            0x2001,
+                            0x10,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        28
+                    ],
+                    orchid2: [
+                        new IPv6([
+                            0x2001,
+                            0x20,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        28
+                    ],
+                    droneRemoteIdProtocolEntityTags: [
+                        new IPv6([
+                            0x2001,
+                            0x30,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        28
+                    ],
+                    reserved: [
+                        [
+                            new IPv6([
+                                0x2001,
+                                0,
+                                0,
+                                0,
+                                0,
+                                0,
+                                0,
+                                0
+                            ]),
+                            23
+                        ],
+                        [
+                            new IPv6([
+                                0x2001,
+                                0xdb8,
+                                0,
+                                0,
+                                0,
+                                0,
+                                0,
+                                0
+                            ]),
+                            32
+                        ]
+                    ]
+                };
+                IPv6.prototype.isIPv4MappedAddress = function() {
+                    return 'ipv4Mapped' === this.range();
+                };
+                IPv6.prototype.kind = function() {
+                    return 'ipv6';
+                };
+                IPv6.prototype.match = function(other, cidrRange) {
+                    let ref;
+                    if (void 0 === cidrRange) {
+                        ref = other;
+                        other = ref[0];
+                        cidrRange = ref[1];
+                    }
+                    if ('ipv6' !== other.kind()) 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)) return null;
+                        zeros = zerotable[part];
+                        if (stop && 0 !== zeros) return null;
+                        if (16 !== zeros) stop = true;
+                        cidr += zeros;
+                    }
+                    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(0xff & part);
+                    }
+                    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,
+                        0xff & high,
+                        low >> 8,
+                        0xff & low
+                    ]);
+                };
+                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) | 255 ^ 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.isIPv6 = function(string) {
+                return null !== this.parser(string);
+            };
+            ipaddr.IPv6.isValid = function(string) {
+                if ('string' == typeof string && -1 === string.indexOf(':')) 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 ('string' == typeof string && -1 === string.indexOf(':')) 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 (null === addr.parts) 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 (4 === length) return new ipaddr.IPv4(bytes);
+                if (16 === length) return new ipaddr.IPv6(bytes);
+                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);
+                if (ipaddr.IPv4.isValid(string)) return ipaddr.IPv4.parse(string);
+                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 ('ipv6' === addr.kind() && addr.isIPv4MappedAddress()) return addr.toIPv4Address();
+                return addr;
+            };
+            ipaddr.subnetMatch = function(address, rangeList, defaultName) {
+                let i, rangeName, rangeSubnets, subnet;
+                if (null == defaultName) 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 (module.exports) module.exports = ipaddr;
+            else root.ipaddr = ipaddr;
+        })(this);
+    }
+};