ui

app/code/node_modules/ipaddr.js/Changes.md

@@ -0,0 +1,20 @@
+
+### 2.0.1 - 2020-01-DD
+
+- add support for deprecated IPv4 compatible IPv6 addresses #142
+- drop node 8 testing, add v14
+- fix parseInt for decimal, octal, hex
+- add support for classful (2,3 octet) IPv4
+
+
+### 2.0.0 - 2019-10-13
+
+- use es6 templates instead of concatenated strings
+- lint: update tests with no-var
+- lint: allow no-cond-assign with extra parens
+- es6: replace var with const/let
+- update README with es6 examples #125
+- replace nodeunit with mocha
+- rewrite in JS, drop CoffeeScript
+
+### 1.9.1 - 2019-07-03

app/code/node_modules/ipaddr.js/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2011-2017 whitequark <whitequark@whitequark.org>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

app/code/node_modules/ipaddr.js/README.md

@@ -0,0 +1,226 @@
+# ipaddr.js — an IPv6 and IPv4 address manipulation library [![Build Status](https://travis-ci.org/whitequark/ipaddr.js.svg)](https://travis-ci.org/whitequark/ipaddr.js)
+
+ipaddr.js is a small (1.9K minified and gzipped) library for manipulating
+IP addresses in JavaScript environments. It runs on both CommonJS runtimes
+(e.g. [nodejs]) and in a web browser.
+
+ipaddr.js allows you to verify and parse string representation of an IP
+address, match it against a CIDR range or range list, determine if it falls
+into some reserved ranges (examples include loopback and private ranges),
+and convert between IPv4 and IPv4-mapped IPv6 addresses.
+
+[nodejs]: http://nodejs.org
+
+## Installation
+
+`npm install ipaddr.js`
+
+or
+
+`bower install ipaddr.js`
+
+## Older Node support
+
+Use 2.x release for nodejs versions 10+.
+Use the 1.x release for versions of nodejs older than 10.
+
+## API
+
+ipaddr.js defines one object in the global scope: `ipaddr`. In CommonJS,
+it is exported from the module:
+
+```js
+const ipaddr = require('ipaddr.js');
+```
+
+The API consists of several global methods and two classes: ipaddr.IPv6 and ipaddr.IPv4.
+
+### Global methods
+
+There are three global methods defined: `ipaddr.isValid`, `ipaddr.parse` and
+`ipaddr.process`. All of them receive a string as a single parameter.
+
+The `ipaddr.isValid` method returns `true` if the address is a valid IPv4 or
+IPv6 address, and `false` otherwise. It does not throw any exceptions.
+
+The `ipaddr.parse` method returns an object representing the IP address,
+or throws an `Error` if the passed string is not a valid representation of an
+IP address.
+
+The `ipaddr.process` method works just like the `ipaddr.parse` one, but it
+automatically converts IPv4-mapped IPv6 addresses to their IPv4 counterparts
+before returning. It is useful when you have a Node.js instance listening
+on an IPv6 socket, and the `net.ivp6.bindv6only` sysctl parameter (or its
+equivalent on non-Linux OS) is set to 0. In this case, you can accept IPv4
+connections on your IPv6-only socket, but the remote address will be mangled.
+Use `ipaddr.process` method to automatically demangle it.
+
+### Object representation
+
+Parsing methods return an object which descends from `ipaddr.IPv6` or
+`ipaddr.IPv4`. These objects share some properties, but most of them differ.
+
+#### Shared properties
+
+One can determine the type of address by calling `addr.kind()`. It will return
+either `"ipv6"` or `"ipv4"`.
+
+An address can be converted back to its string representation with `addr.toString()`.
+Note that this method:
+ * does not return the original string used to create the object (in fact, there is
+   no way of getting that string)
+ * returns a compact representation (when it is applicable)
+
+A `match(range, bits)` method can be used to check if the address falls into a
+certain CIDR range. Note that an address can be (obviously) matched only against an address of the same type.
+
+For example:
+
+```js
+const addr  = ipaddr.parse('2001:db8:1234::1');
+const range = ipaddr.parse('2001:db8::');
+
+addr.match(range, 32); // => true
+```
+
+Alternatively, `match` can also be called as `match([range, bits])`. In this way, it can be used together with the `parseCIDR(string)` method, which parses an IP address together with a CIDR range.
+
+For example:
+
+```js
+const addr = ipaddr.parse('2001:db8:1234::1');
+
+addr.match(ipaddr.parseCIDR('2001:db8::/32')); // => true
+```
+
+A `range()` method returns one of predefined names for several special ranges defined by IP protocols. The exact names (and their respective CIDR ranges) can be looked up in the source: [IPv6 ranges] and [IPv4 ranges]. Some common ones include `"unicast"` (the default one) and `"reserved"`.
+
+You can match against your own range list by using
+`ipaddr.subnetMatch(address, rangeList, defaultName)` method. It can work with a mix of IPv6 or IPv4 addresses, and accepts a name-to-subnet map as the range list. For example:
+
+```js
+const rangeList = {
+  documentationOnly: [ ipaddr.parse('2001:db8::'), 32 ],
+  tunnelProviders: [
+    [ ipaddr.parse('2001:470::'), 32 ], // he.net
+    [ ipaddr.parse('2001:5c0::'), 32 ]  // freenet6
+  ]
+};
+ipaddr.subnetMatch(ipaddr.parse('2001:470:8:66::1'), rangeList, 'unknown'); // => "tunnelProviders"
+```
+
+The addresses can be converted to their byte representation with `toByteArray()`. (Actually, JavaScript mostly does not know about byte buffers. They are emulated with arrays of numbers, each in range of 0..255.)
+
+```js
+const bytes = ipaddr.parse('2a00:1450:8007::68').toByteArray(); // ipv6.google.com
+bytes // => [42, 0x00, 0x14, 0x50, 0x80, 0x07, 0x00, <zeroes...>, 0x00, 0x68 ]
+```
+
+The `ipaddr.IPv4` and `ipaddr.IPv6` objects have some methods defined, too. All of them have the same interface for both protocols, and are similar to global methods.
+
+`ipaddr.IPvX.isValid(string)` can be used to check if the string is a valid address for particular protocol, and `ipaddr.IPvX.parse(string)` is the error-throwing parser.
+
+`ipaddr.IPvX.isValid(string)` uses the same format for parsing as the POSIX `inet_ntoa` function, which accepts unusual formats like `0xc0.168.1.1` or `0x10000000`. The function `ipaddr.IPv4.isValidFourPartDecimal(string)` validates the IPv4 address and also ensures that it is written in four-part decimal format.
+
+[IPv6 ranges]: https://github.com/whitequark/ipaddr.js/blob/master/src/ipaddr.coffee#L186
+[IPv4 ranges]: https://github.com/whitequark/ipaddr.js/blob/master/src/ipaddr.coffee#L71
+
+#### IPv6 properties
+
+Sometimes you will want to convert IPv6 not to a compact string representation (with the `::` substitution); the `toNormalizedString()` method will return an address where all zeroes are explicit.
+
+For example:
+
+```js
+const addr = ipaddr.parse('2001:0db8::0001');
+addr.toString(); // => '2001:db8::1'
+addr.toNormalizedString(); // => '2001:db8:0:0:0:0:0:1'
+```
+
+The `isIPv4MappedAddress()` method will return `true` if this address is an IPv4-mapped
+one, and `toIPv4Address()` will return an IPv4 object address.
+
+To access the underlying binary representation of the address, use `addr.parts`.
+
+```js
+const addr = ipaddr.parse('2001:db8:10::1234:DEAD');
+addr.parts // => [0x2001, 0xdb8, 0x10, 0, 0, 0, 0x1234, 0xdead]
+```
+
+A IPv6 zone index can be accessed via `addr.zoneId`:
+
+```js
+const addr = ipaddr.parse('2001:db8::%eth0');
+addr.zoneId // => 'eth0'
+```
+
+#### IPv4 properties
+
+`toIPv4MappedAddress()` will return a corresponding IPv4-mapped IPv6 address.
+
+To access the underlying representation of the address, use `addr.octets`.
+
+```js
+const addr = ipaddr.parse('192.168.1.1');
+addr.octets // => [192, 168, 1, 1]
+```
+
+`prefixLengthFromSubnetMask()` will return a CIDR prefix length for a valid IPv4 netmask or
+null if the netmask is not valid.
+
+```js
+ipaddr.IPv4.parse('255.255.255.240').prefixLengthFromSubnetMask() == 28
+ipaddr.IPv4.parse('255.192.164.0').prefixLengthFromSubnetMask()  == null
+```
+
+`subnetMaskFromPrefixLength()` will return an IPv4 netmask for a valid CIDR prefix length.
+
+```js
+ipaddr.IPv4.subnetMaskFromPrefixLength(24) == '255.255.255.0'
+ipaddr.IPv4.subnetMaskFromPrefixLength(29) == '255.255.255.248'
+```
+
+`broadcastAddressFromCIDR()` will return the broadcast address for a given IPv4 interface and netmask in CIDR notation.
+```js
+ipaddr.IPv4.broadcastAddressFromCIDR('172.0.0.1/24') == '172.0.0.255'
+```
+`networkAddressFromCIDR()` will return the network address for a given IPv4 interface and netmask in CIDR notation.
+```js
+ipaddr.IPv4.networkAddressFromCIDR('172.0.0.1/24') == '172.0.0.0'
+```
+
+#### Conversion
+
+IPv4 and IPv6 can be converted bidirectionally to and from network byte order (MSB) byte arrays.
+
+The `fromByteArray()` method will take an array and create an appropriate IPv4 or IPv6 object
+if the input satisfies the requirements. For IPv4 it has to be an array of four 8-bit values,
+while for IPv6 it has to be an array of sixteen 8-bit values.
+
+For example:
+```js
+const addr = ipaddr.fromByteArray([0x7f, 0, 0, 1]);
+addr.toString(); // => '127.0.0.1'
+```
+
+or
+
+```js
+const addr = ipaddr.fromByteArray([0x20, 1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
+addr.toString(); // => '2001:db8::1'
+```
+
+Both objects also offer a `toByteArray()` method, which returns an array in network byte order (MSB).
+
+For example:
+```js
+const addr = ipaddr.parse('127.0.0.1');
+addr.toByteArray(); // => [0x7f, 0, 0, 1]
+```
+
+or
+
+```js
+const addr = ipaddr.parse('2001:db8::1');
+addr.toByteArray(); // => [0x20, 1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
+```

app/code/node_modules/ipaddr.js/lib/ipaddr.js

@@ -0,0 +1,996 @@
+(function (root) {
+    'use strict';
+    // A list of regular expressions that match arbitrary IPv4 addresses,
+    // for which a number of weird notations exist.
+    // Note that an address like 0010.0xa5.1.1 is considered legal.
+    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')
+    };
+
+    // Regular Expression for checking Octal numbers
+    const octalRegex = new RegExp(`^0[0-7]+$`, 'i');
+    const hexRegex = new RegExp(`^0x[a-f0-9]+$`, 'i');
+
+    const zoneIndex = '%[0-9a-z]{1,}';
+
+    // IPv6-matching regular expressions.
+    // For IPv6, the task is simpler: it is enough to match the colon-delimited
+    // hexadecimal IPv6 and a transitional variant with dotted-decimal IPv4 at
+    // the end.
+    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')
+    };
+
+    // Expand :: in an IPv6 address or address part consisting of `parts` groups.
+    function expandIPv6 (string, parts) {
+        // More than one '::' means invalid adddress
+        if (string.indexOf('::') !== string.lastIndexOf('::')) {
+            return null;
+        }
+
+        let colonCount = 0;
+        let lastColon = -1;
+        let zoneId = (string.match(ipv6Regexes.zoneIndex) || [])[0];
+        let replacement, replacementCount;
+
+        // Remove zone index and save it for later
+        if (zoneId) {
+            zoneId = zoneId.substring(1);
+            string = string.replace(/%.+$/, '');
+        }
+
+        // How many parts do we already have?
+        while ((lastColon = string.indexOf(':', lastColon + 1)) >= 0) {
+            colonCount++;
+        }
+
+        // 0::0 is two parts more than ::
+        if (string.substr(0, 2) === '::') {
+            colonCount--;
+        }
+
+        if (string.substr(-2, 2) === '::') {
+            colonCount--;
+        }
+
+        // The following loop would hang if colonCount > parts
+        if (colonCount > parts) {
+            return null;
+        }
+
+        // replacement = ':' + '0:' * (parts - colonCount)
+        replacementCount = parts - colonCount;
+        replacement = ':';
+        while (replacementCount--) {
+            replacement += '0:';
+        }
+
+        // Insert the missing zeroes
+        string = string.replace('::', replacement);
+
+        // Trim any garbage which may be hanging around if :: was at the edge in
+        // the source strin
+        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
+        };
+    }
+
+    // A generic CIDR (Classless Inter-Domain Routing) RFC1518 range matcher.
+    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) {
+        // Hexadedimal base 16 (0x#)
+        if (hexRegex.test(string)) {
+            return parseInt(string, 16);
+        }
+        // While octal representation is discouraged by ECMAScript 3
+        // and forbidden by ECMAScript 5, we silently allow it to
+        // work only if the rest of the string has numbers less than 8.
+        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`);
+        }
+        // Always include the base 10 radix!
+        return parseInt(string, 10);
+    }
+
+    function padPart (part, length) {
+        while (part.length < length) {
+            part = `0${part}`;
+        }
+
+        return part;
+    }
+
+    const ipaddr = {};
+
+    // An IPv4 address (RFC791).
+    ipaddr.IPv4 = (function () {
+        // Constructs a new IPv4 address from an array of four octets
+        // in network order (MSB first)
+        // Verifies the input.
+        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;
+        }
+
+        // Special IPv4 address ranges.
+        // See also https://en.wikipedia.org/wiki/Reserved_IP_addresses
+        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, 51, 100, 0]), 24],
+                [new IPv4([203, 0, 113, 0]), 24],
+                [new IPv4([240, 0, 0, 0]), 4]
+            ]
+        };
+
+        // The 'kind' method exists on both IPv4 and IPv6 classes.
+        IPv4.prototype.kind = function () {
+            return 'ipv4';
+        };
+
+        // Checks if this address matches other one within given CIDR range.
+        IPv4.prototype.match = function (other, cidrRange) {
+            let ref;
+            if (cidrRange === undefined) {
+                ref = other;
+                other = ref[0];
+                cidrRange = ref[1];
+            }
+
+            if (other.kind() !== 'ipv4') {
+                throw new Error('ipaddr: cannot match ipv4 address with non-ipv4 one');
+            }
+
+            return matchCIDR(this.octets, other.octets, 8, cidrRange);
+        };
+
+        // returns a number of leading ones in IPv4 address, making sure that
+        // the rest is a solid sequence of 0's (valid netmask)
+        // returns either the CIDR length or null if mask is not valid
+        IPv4.prototype.prefixLengthFromSubnetMask = function () {
+            let cidr = 0;
+            // non-zero encountered stop scanning for zeroes
+            let stop = false;
+            // number of zeroes in octet
+            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;
+        };
+
+        // Checks if the address corresponds to one of the special ranges.
+        IPv4.prototype.range = function () {
+            return ipaddr.subnetMatch(this, this.SpecialRanges);
+        };
+
+        // Returns an array of byte-sized values in network order (MSB first)
+        IPv4.prototype.toByteArray = function () {
+            return this.octets.slice(0);
+        };
+
+        // Converts this IPv4 address to an IPv4-mapped IPv6 address.
+        IPv4.prototype.toIPv4MappedAddress = function () {
+            return ipaddr.IPv6.parse(`::ffff:${this.toString()}`);
+        };
+
+        // Symmetrical method strictly for aligning with the IPv6 methods.
+        IPv4.prototype.toNormalizedString = function () {
+            return this.toString();
+        };
+
+        // Returns the address in convenient, decimal-dotted format.
+        IPv4.prototype.toString = function () {
+            return this.octets.join('.');
+        };
+
+        return IPv4;
+    })();
+
+    // A utility function to return broadcast address given the IPv4 interface and prefix length in CIDR notation
+    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) {
+                // Broadcast address is bitwise OR between ip interface and inverted mask
+                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');
+        }
+    };
+
+    // Checks if a given string is formatted like IPv4 address.
+    ipaddr.IPv4.isIPv4 = function (string) {
+        return this.parser(string) !== null;
+    };
+
+    // Checks if a given string is a valid IPv4 address.
+    ipaddr.IPv4.isValid = function (string) {
+        try {
+            new this(this.parser(string));
+            return true;
+        } catch (e) {
+            return false;
+        }
+    };
+
+    // Checks if a given string is a full four-part IPv4 Address.
+    ipaddr.IPv4.isValidFourPartDecimal = function (string) {
+        if (ipaddr.IPv4.isValid(string) && string.match(/^(0|[1-9]\d*)(\.(0|[1-9]\d*)){3}$/)) {
+            return true;
+        } else {
+            return false;
+        }
+    };
+
+    // A utility function to return network address given the IPv4 interface and prefix length in CIDR notation
+    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) {
+                // Network address is bitwise AND between ip interface and mask
+                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');
+        }
+    };
+
+    // Tries to parse and validate a string with IPv4 address.
+    // Throws an error if it fails.
+    ipaddr.IPv4.parse = function (string) {
+        const parts = this.parser(string);
+
+        if (parts === null) {
+            throw new Error('ipaddr: string is not formatted like an IPv4 Address');
+        }
+
+        return new this(parts);
+    };
+
+    // Parses the string as an IPv4 Address with CIDR Notation.
+    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');
+    };
+
+    // Classful variants (like a.b, where a is an octet, and b is a 24-bit
+    // value representing last three octets; this corresponds to a class C
+    // address) are omitted due to classless nature of modern Internet.
+    ipaddr.IPv4.parser = function (string) {
+        let match, part, value;
+
+        // parseInt recognizes all that octal & hexadecimal weirdness for us
+        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 > 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();
+        } else 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( value        & 0xff);
+
+                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 > 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( value       & 0xff);
+
+                return results;
+            })();
+        } else {
+            return null;
+        }
+    };
+
+    // A utility function to return subnet mask in IPv4 format given the prefix length
+    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);
+    };
+
+    // An IPv6 address (RFC2460)
+    ipaddr.IPv6 = (function () {
+        // Constructs an IPv6 address from an array of eight 16 - bit parts
+        // or sixteen 8 - bit parts in network order(MSB first).
+        // Throws an error if the input is invalid.
+        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 <= 0xffff))) {
+                    throw new Error('ipaddr: ipv6 part should fit in 16 bits');
+                }
+            }
+
+            if (zoneId) {
+                this.zoneId = zoneId;
+            }
+        }
+
+        // Special IPv6 ranges
+        IPv6.prototype.SpecialRanges = {
+            // RFC4291, here and after
+            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],
+            // RFC6145
+            rfc6145: [new IPv6([0, 0, 0, 0, 0xffff, 0, 0, 0]), 96],
+            // RFC6052
+            rfc6052: [new IPv6([0x64, 0xff9b, 0, 0, 0, 0, 0, 0]), 96],
+            // RFC3056
+            '6to4': [new IPv6([0x2002, 0, 0, 0, 0, 0, 0, 0]), 16],
+            // RFC6052, RFC6146
+            teredo: [new IPv6([0x2001, 0, 0, 0, 0, 0, 0, 0]), 32],
+            // RFC4291
+            reserved: [[new IPv6([0x2001, 0xdb8, 0, 0, 0, 0, 0, 0]), 32]]
+        };
+
+        // Checks if this address is an IPv4-mapped IPv6 address.
+        IPv6.prototype.isIPv4MappedAddress = function () {
+            return this.range() === 'ipv4Mapped';
+        };
+
+        // The 'kind' method exists on both IPv4 and IPv6 classes.
+        IPv6.prototype.kind = function () {
+            return 'ipv6';
+        };
+
+        // Checks if this address matches other one within given CIDR range.
+        IPv6.prototype.match = function (other, cidrRange) {
+            let ref;
+
+            if (cidrRange === undefined) {
+                ref = other;
+                other = ref[0];
+                cidrRange = ref[1];
+            }
+
+            if (other.kind() !== 'ipv6') {
+                throw new Error('ipaddr: cannot match ipv6 address with non-ipv6 one');
+            }
+
+            return matchCIDR(this.parts, other.parts, 16, cidrRange);
+        };
+
+        // returns a number of leading ones in IPv6 address, making sure that
+        // the rest is a solid sequence of 0's (valid netmask)
+        // returns either the CIDR length or null if mask is not valid
+        IPv6.prototype.prefixLengthFromSubnetMask = function () {
+            let cidr = 0;
+            // non-zero encountered stop scanning for zeroes
+            let stop = false;
+            // number of zeroes in octet
+            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;
+        };
+
+
+        // Checks if the address corresponds to one of the special ranges.
+        IPv6.prototype.range = function () {
+            return ipaddr.subnetMatch(this, this.SpecialRanges);
+        };
+
+        // Returns an array of byte-sized values in network order (MSB first)
+        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 & 0xff);
+            }
+
+            return bytes;
+        };
+
+        // Returns the address in expanded format with all zeroes included, like
+        // 2001:0db8:0008:0066:0000:0000:0000:0001
+        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;
+        };
+
+        // Converts this address to IPv4 address if it is an IPv4-mapped IPv6 address.
+        // Throws an error otherwise.
+        IPv6.prototype.toIPv4Address = function () {
+            if (!this.isIPv4MappedAddress()) {
+                throw new Error('ipaddr: trying to convert a generic ipv6 address to ipv4');
+            }
+
+            const ref = this.parts.slice(-2);
+            const high = ref[0];
+            const low = ref[1];
+
+            return new ipaddr.IPv4([high >> 8, high & 0xff, low >> 8, low & 0xff]);
+        };
+
+        // Returns the address in expanded format with all zeroes included, like
+        // 2001:db8:8:66:0:0:0:1
+        //
+        // Deprecated: use toFixedLengthString() instead.
+        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;
+        };
+
+        // Returns the address in compact, human-readable format like
+        // 2001:db8:8:66::1
+        // in line with RFC 5952 (see https://tools.ietf.org/html/rfc5952#section-4)
+        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)}`;
+        };
+
+        // Returns the address in compact, human-readable format like
+        // 2001:db8:8:66::1
+        //
+        // Deprecated: use toRFC5952String() instead.
+        IPv6.prototype.toString = function () {
+            // Replace the first sequence of 1 or more '0' parts with '::'
+            return this.toNormalizedString().replace(/((^|:)(0(:|$))+)/, '::');
+        };
+
+        return IPv6;
+
+    })();
+
+    // A utility function to return broadcast address given the IPv6 interface and prefix length in CIDR notation
+    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) {
+                // Broadcast address is bitwise OR between ip interface and inverted mask
+                octets.push(parseInt(ipInterfaceOctets[i], 10) | parseInt(subnetMaskOctets[i], 10) ^ 255);
+                i++;
+            }
+
+            return new this(octets);
+        } catch (e) {
+            throw new Error(`ipaddr: the address does not have IPv6 CIDR format (${e})`);
+        }
+    };
+
+    // Checks if a given string is formatted like IPv6 address.
+    ipaddr.IPv6.isIPv6 = function (string) {
+        return this.parser(string) !== null;
+    };
+
+    // Checks to see if string is a valid IPv6 Address
+    ipaddr.IPv6.isValid = function (string) {
+
+        // Since IPv6.isValid is always called first, this shortcut
+        // provides a substantial performance gain.
+        if (typeof string === 'string' && string.indexOf(':') === -1) {
+            return false;
+        }
+
+        try {
+            const addr = this.parser(string);
+            new this(addr.parts, addr.zoneId);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    };
+
+    // A utility function to return network address given the IPv6 interface and prefix length in CIDR notation
+    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) {
+                // Network address is bitwise AND between ip interface and mask
+                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})`);
+        }
+    };
+
+    // Tries to parse and validate a string with IPv6 address.
+    // Throws an error if it fails.
+    ipaddr.IPv6.parse = function (string) {
+        const addr = this.parser(string);
+
+        if (addr.parts === null) {
+            throw new Error('ipaddr: string is not formatted like an IPv6 Address');
+        }
+
+        return new this(addr.parts, addr.zoneId);
+    };
+
+    ipaddr.IPv6.parseCIDR = function (string) {
+        let maskLength, match, parsed;
+
+        if ((match = string.match(/^(.+)\/(\d+)$/))) {
+            maskLength = parseInt(match[2]);
+            if (maskLength >= 0 && maskLength <= 128) {
+                parsed = [this.parse(match[1]), maskLength];
+                Object.defineProperty(parsed, 'toString', {
+                    value: function () {
+                        return this.join('/');
+                    }
+                });
+                return parsed;
+            }
+        }
+
+        throw new Error('ipaddr: string is not formatted like an IPv6 CIDR range');
+    };
+
+    // Parse an IPv6 address.
+    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 = expandIPv6(match[1].slice(0, -1) + 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;
+    };
+
+    // A utility function to return subnet mask in IPv6 format given the prefix length
+    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);
+    };
+
+    // Try to parse an array in network order (MSB first) for IPv4 and IPv6
+    ipaddr.fromByteArray = function (bytes) {
+        const length = bytes.length;
+
+        if (length === 4) {
+            return new ipaddr.IPv4(bytes);
+        } else if (length === 16) {
+            return new ipaddr.IPv6(bytes);
+        } else {
+            throw new Error('ipaddr: the binary input is neither an IPv6 nor IPv4 address');
+        }
+    };
+
+    // Checks if the address is valid IP address
+    ipaddr.isValid = function (string) {
+        return ipaddr.IPv6.isValid(string) || ipaddr.IPv4.isValid(string);
+    };
+
+
+    // Attempts to parse an IP Address, first through IPv6 then IPv4.
+    // Throws an error if it could not be parsed.
+    ipaddr.parse = function (string) {
+        if (ipaddr.IPv6.isValid(string)) {
+            return ipaddr.IPv6.parse(string);
+        } else if (ipaddr.IPv4.isValid(string)) {
+            return ipaddr.IPv4.parse(string);
+        } else {
+            throw new Error('ipaddr: the address has neither IPv6 nor IPv4 format');
+        }
+    };
+
+    // Attempt to parse CIDR notation, first through IPv6 then IPv4.
+    // Throws an error if it could not be parsed.
+    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');
+            }
+        }
+    };
+
+    // Parse an address and return plain IPv4 address if it is an IPv4-mapped address
+    ipaddr.process = function (string) {
+        const addr = this.parse(string);
+
+        if (addr.kind() === 'ipv6' && addr.isIPv4MappedAddress()) {
+            return addr.toIPv4Address();
+        } else {
+            return addr;
+        }
+    };
+
+    // An utility function to ease named range matching. See examples below.
+    // rangeList can contain both IPv4 and IPv6 subnet entries and will not throw errors
+    // on matching IPv4 addresses to IPv6 ranges or vice versa.
+    ipaddr.subnetMatch = function (address, rangeList, defaultName) {
+        let i, rangeName, rangeSubnets, subnet;
+
+        if (defaultName === undefined || defaultName === null) {
+            defaultName = 'unicast';
+        }
+
+        for (rangeName in rangeList) {
+            if (Object.prototype.hasOwnProperty.call(rangeList, rangeName)) {
+                rangeSubnets = rangeList[rangeName];
+                // ECMA5 Array.isArray isn't available everywhere
+                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;
+    };
+
+    // Export for both the CommonJS and browser-like environment
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = ipaddr;
+
+    } else {
+        root.ipaddr = ipaddr;
+    }
+
+}(this));

app/code/node_modules/ipaddr.js/lib/ipaddr.js.d.ts

@@ -0,0 +1,68 @@
+declare module "ipaddr.js" {
+    type IPvXRangeDefaults = 'unicast' | 'unspecified' | 'multicast' | 'linkLocal' | 'loopback' | 'reserved';
+    type IPv4Range = IPvXRangeDefaults | 'broadcast' | 'carrierGradeNat' | 'private';
+    type IPv6Range = IPvXRangeDefaults | 'uniqueLocal' | 'ipv4Mapped' | 'rfc6145' | 'rfc6052' | '6to4' | 'teredo';
+
+    interface RangeList<T> {
+        [name: string]: [T, number] | [T, number][];
+    }
+
+    // Common methods/properties for IPv4 and IPv6 classes.
+    class IP {
+        prefixLengthFromSubnetMask(): number | null;
+        toByteArray(): number[];
+        toNormalizedString(): string;
+        toString(): string;
+    }
+
+    namespace Address {
+        export function fromByteArray(bytes: number[]): IPv4 | IPv6;
+        export function isValid(addr: string): boolean;
+        export function parse(addr: string): IPv4 | IPv6;
+        export function parseCIDR(mask: string): [IPv4 | IPv6, number];
+        export function process(addr: string): IPv4 | IPv6;
+        export function subnetMatch(addr: IPv4 | IPv6, rangeList: RangeList<IPv4 | IPv6>, defaultName?: string): string;
+
+        export class IPv4 extends IP {
+            static broadcastAddressFromCIDR(addr: string): IPv4;
+            static isIPv4(addr: string): boolean;
+            static isValidFourPartDecimal(addr: string): boolean;
+            static isValid(addr: string): boolean;
+            static networkAddressFromCIDR(addr: string): IPv4;
+            static parse(addr: string): IPv4;
+            static parseCIDR(addr: string): [IPv4, number];
+            static subnetMaskFromPrefixLength(prefix: number): IPv4;
+            constructor(octets: number[]);
+            octets: number[]
+
+            kind(): 'ipv4';
+            match(what: IPv4 | IPv6 | [IPv4 | IPv6, number], bits?: number): boolean;
+            range(): IPv4Range;
+            subnetMatch(rangeList: RangeList<IPv4>, defaultName?: string): string;
+            toIPv4MappedAddress(): IPv6;
+        }
+
+        export class IPv6 extends IP {
+            static broadcastAddressFromCIDR(addr: string): IPv6;
+            static isIPv6(addr: string): boolean;
+            static isValid(addr: string): boolean;
+            static networkAddressFromCIDR(addr: string): IPv6;
+            static parse(addr: string): IPv6;
+            static parseCIDR(addr: string): [IPv6, number];
+            static subnetMaskFromPrefixLength(prefix: number): IPv6;
+            constructor(parts: number[]);
+            parts: number[]
+            zoneId?: string
+
+            isIPv4MappedAddress(): boolean;
+            kind(): 'ipv6';
+            match(what: IPv4 | IPv6 | [IPv4 | IPv6, number], bits?: number): boolean;
+            range(): IPv6Range;
+            subnetMatch(rangeList: RangeList<IPv6>, defaultName?: string): string;
+            toIPv4Address(): IPv4;
+            toRFC5952String(): string;
+        }
+    }
+
+    export = Address;
+}

app/code/node_modules/ipaddr.js/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "ipaddr.js",
+  "description": "A library for manipulating IPv4 and IPv6 addresses in JavaScript.",
+  "version": "2.0.1",
+  "author": "whitequark <whitequark@whitequark.org>",
+  "directories": {
+    "lib": "./lib"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "eslint": "*",
+    "mocha": "*",
+    "uglify-es": "*"
+  },
+  "scripts": {
+    "lint": "npx eslint lib test",
+    "lintfix": "npx eslint --fix lib test",
+    "build": "npx uglifyjs --compress --mangle --wrap=window -o ipaddr.min.js lib/ipaddr.js",
+    "test": "npx _mocha"
+  },
+  "files": [
+    "lib/",
+    "LICENSE",
+    "ipaddr.min.js"
+  ],
+  "keywords": [
+    "ip",
+    "ipv4",
+    "ipv6"
+  ],
+  "repository": "git://github.com/whitequark/ipaddr.js",
+  "main": "./lib/ipaddr.js",
+  "engines": {
+    "node": ">= 10"
+  },
+  "license": "MIT",
+  "types": "./lib/ipaddr.js.d.ts"
+}