TheCoreDev/mia
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Changements dans les modules (nouvelle version Express, mysql, ..)

Browse Source
This commit is contained in:
TheCoreDev
2023-11-23 13:21:05 +01:00
parent 6af45b3ee2
commit bdab795506
820 changed files with 82281 additions and 35986 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
node_modules/ipaddr.js/.npmignore generated vendored Normal file
View File

@@ -0,0 +1,2 @@
.idea
node_modules

10
node_modules/ipaddr.js/.travis.yml generated vendored Normal file
View File

@@ -0,0 +1,10 @@
language: node_js
node_js:
- "0.10"
- "0.11"
- "0.12"
- "4.0"
- "4.1"
- "4.2"
- "5"

18
node_modules/ipaddr.js/Cakefile generated vendored Normal file
View File

@@ -0,0 +1,18 @@
fs = require 'fs'
CoffeeScript = require 'coffee-script'
nodeunit = require 'nodeunit'
UglifyJS = require 'uglify-js'
task 'build', 'build the JavaScript files from CoffeeScript source', build = (cb) ->
source = fs.readFileSync 'src/ipaddr.coffee'
fs.writeFileSync 'lib/ipaddr.js', CoffeeScript.compile source.toString()
invoke 'test'
invoke 'compress'
task 'test', 'run the bundled tests', (cb) ->
nodeunit.reporters.default.run ['test']
task 'compress', 'uglify the resulting javascript', (cb) ->
result = UglifyJS.minify('lib/ipaddr.js')
fs.writeFileSync('ipaddr.min.js', result.code)

4
node_modules/ipaddr.js/LICENSE generated vendored
View File

@@ -1,4 +1,4 @@
Copyright (C) 2011-2017 whitequark <whitequark@whitequark.org>
Copyright (C) 2011 Peter Zotov <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
@@ -16,4 +16,4 @@ 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.
THE SOFTWARE.

80
node_modules/ipaddr.js/README.md generated vendored
View File

@@ -15,10 +15,6 @@ and convert between IPv4 and IPv4-mapped IPv6 addresses.
`npm install ipaddr.js`
or
`bower install ipaddr.js`
## API
ipaddr.js defines one object in the global scope: `ipaddr`. In CommonJS,
@@ -43,7 +39,7 @@ 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
automatically converts IPv4-mapped IPv6 addresses to their IPv4 couterparts
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
@@ -97,7 +93,8 @@ in the source: [IPv6 ranges] and [IPv4 ranges]. Some common ones include `"unica
(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:
`ipaddr.subnetMatch(address, rangeList, defaultName)` method. It can work with both
IPv6 and IPv4 addresses, and accepts a name-to-subnet map as the range list. For example:
```js
var rangeList = {
@@ -107,7 +104,7 @@ var rangeList = {
[ ipaddr.parse('2001:5c0::'), 32 ] // freenet6
]
};
ipaddr.subnetMatch(ipaddr.parse('2001:470:8:66::1'), rangeList, 'unknown'); // => "tunnelProviders"
ipaddr.subnetMatch(ipaddr.parse('2001:470:8:66::1'), rangeList, 'unknown'); // => "he.net"
```
The addresses can be converted to their byte representation with `toByteArray()`.
@@ -125,8 +122,6 @@ 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
@@ -154,13 +149,6 @@ var 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
var addr = ipaddr.parse("2001:db8::%eth0");
addr.zoneId // => 'eth0'
```
#### IPv4 properties
`toIPv4MappedAddress()` will return a corresponding IPv4-mapped IPv6 address.
@@ -171,63 +159,3 @@ To access the underlying representation of the address, use `addr.octets`.
var 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
var addr = ipaddr.fromByteArray([0x7f, 0, 0, 1]);
addr.toString(); // => "127.0.0.1"
```
or
```js
var 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
var addr = ipaddr.parse("127.0.0.1");
addr.toByteArray(); // => [0x7f, 0, 0, 1]
```
or
```js
var addr = ipaddr.parse("2001:db8::1");
addr.toByteArray(); // => [0x20, 1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
```

29
node_modules/ipaddr.js/bower.json generated vendored Normal file
View File

@@ -0,0 +1,29 @@
{
"name": "ipaddr.js",
"version": "1.0.5",
"homepage": "https://github.com/whitequark/ipaddr.js",
"authors": [
"whitequark <whitequark@whitequark.org>"
],
"description": "IP address manipulation library in JavaScript (CoffeeScript, actually)",
"main": "lib/ipaddr.js",
"moduleType": [
"globals",
"node"
],
"keywords": [
"javscript",
"ip",
"address",
"ipv4",
"ipv6"
],
"license": "MIT",
"ignore": [
"**/.*",
"node_modules",
"bower_components",
"test",
"tests"
]
}

2
node_modules/ipaddr.js/ipaddr.min.js generated vendored
View File

File diff suppressed because one or more lines are too long

464
node_modules/ipaddr.js/lib/ipaddr.js generated vendored
View File

@@ -1,5 +1,5 @@
(function() {
var expandIPv6, ipaddr, ipv4Part, ipv4Regexes, ipv6Part, ipv6Regexes, matchCIDR, root, zoneIndex;
var expandIPv6, ipaddr, ipv4Part, ipv4Regexes, ipv6Part, ipv6Regexes, matchCIDR, root;
ipaddr = {};
@@ -32,7 +32,7 @@
};
ipaddr.subnetMatch = function(address, rangeList, defaultName) {
var k, len, rangeName, rangeSubnets, subnet;
var rangeName, rangeSubnets, subnet, _i, _len;
if (defaultName == null) {
defaultName = 'unicast';
}
@@ -41,12 +41,10 @@
if (rangeSubnets[0] && !(rangeSubnets[0] instanceof Array)) {
rangeSubnets = [rangeSubnets];
}
for (k = 0, len = rangeSubnets.length; k < len; k++) {
subnet = rangeSubnets[k];
if (address.kind() === subnet[0].kind()) {
if (address.match.apply(address, subnet)) {
return rangeName;
}
for (_i = 0, _len = rangeSubnets.length; _i < _len; _i++) {
subnet = rangeSubnets[_i];
if (address.match.apply(address, subnet)) {
return rangeName;
}
}
}
@@ -55,14 +53,14 @@
ipaddr.IPv4 = (function() {
function IPv4(octets) {
var k, len, octet;
var octet, _i, _len;
if (octets.length !== 4) {
throw new Error("ipaddr: ipv4 octet count should be 4");
}
for (k = 0, len = octets.length; k < len; k++) {
octet = octets[k];
for (_i = 0, _len = octets.length; _i < _len; _i++) {
octet = octets[_i];
if (!((0 <= octet && octet <= 255))) {
throw new Error("ipaddr: ipv4 octet should fit in 8 bits");
throw new Error("ipaddr: ipv4 octet is a byte");
}
}
this.octets = octets;
@@ -76,18 +74,14 @@
return this.octets.join(".");
};
IPv4.prototype.toNormalizedString = function() {
return this.toString();
};
IPv4.prototype.toByteArray = function() {
return this.octets.slice(0);
};
IPv4.prototype.match = function(other, cidrRange) {
var ref;
var _ref;
if (cidrRange === void 0) {
ref = other, other = ref[0], cidrRange = ref[1];
_ref = other, other = _ref[0], cidrRange = _ref[1];
}
if (other.kind() !== 'ipv4') {
throw new Error("ipaddr: cannot match ipv4 address with non-ipv4 one");
@@ -101,7 +95,6 @@
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, 51, 100, 0]), 24], [new IPv4([203, 0, 113, 0]), 24], [new IPv4([240, 0, 0, 0]), 4]]
};
@@ -114,39 +107,6 @@
return ipaddr.IPv6.parse("::ffff:" + (this.toString()));
};
IPv4.prototype.prefixLengthFromSubnetMask = function() {
var cidr, i, k, octet, stop, zeros, zerotable;
zerotable = {
0: 8,
128: 7,
192: 6,
224: 5,
240: 4,
248: 3,
252: 2,
254: 1,
255: 0
};
cidr = 0;
stop = false;
for (i = k = 3; k >= 0; i = k += -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;
};
return IPv4;
})();
@@ -169,14 +129,14 @@
};
if (match = string.match(ipv4Regexes.fourOctet)) {
return (function() {
var k, len, ref, results;
ref = match.slice(1, 6);
results = [];
for (k = 0, len = ref.length; k < len; k++) {
part = ref[k];
results.push(parseIntAuto(part));
var _i, _len, _ref, _results;
_ref = match.slice(1, 6);
_results = [];
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
part = _ref[_i];
_results.push(parseIntAuto(part));
}
return results;
return _results;
})();
} else if (match = string.match(ipv4Regexes.longValue)) {
value = parseIntAuto(match[1]);
@@ -184,12 +144,12 @@
throw new Error("ipaddr: address outside defined range");
}
return ((function() {
var k, results;
results = [];
for (shift = k = 0; k <= 24; shift = k += 8) {
results.push((value >> shift) & 0xff);
var _i, _results;
_results = [];
for (shift = _i = 0; _i <= 24; shift = _i += 8) {
_results.push((value >> shift) & 0xff);
}
return results;
return _results;
})()).reverse();
} else {
return null;
@@ -197,28 +157,18 @@
};
ipaddr.IPv6 = (function() {
function IPv6(parts, zoneId) {
var i, k, l, len, part, ref;
if (parts.length === 16) {
this.parts = [];
for (i = k = 0; k <= 14; i = k += 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");
function IPv6(parts) {
var part, _i, _len;
if (parts.length !== 8) {
throw new Error("ipaddr: ipv6 part count should be 8");
}
ref = this.parts;
for (l = 0, len = ref.length; l < len; l++) {
part = ref[l];
for (_i = 0, _len = parts.length; _i < _len; _i++) {
part = parts[_i];
if (!((0 <= part && part <= 0xffff))) {
throw new Error("ipaddr: ipv6 part should fit in 16 bits");
throw new Error("ipaddr: ipv6 part should fit to two octets");
}
}
if (zoneId) {
this.zoneId = zoneId;
}
this.parts = parts;
}
IPv6.prototype.kind = function() {
@@ -226,33 +176,64 @@
};
IPv6.prototype.toString = function() {
return this.toNormalizedString().replace(/((^|:)(0(:|$))+)/, '::');
};
IPv6.prototype.toRFC5952String = function() {
var bestMatchIndex, bestMatchLength, match, regex, string;
regex = /((^|:)(0(:|$)){2,})/g;
string = this.toNormalizedString();
bestMatchIndex = 0;
bestMatchLength = -1;
while ((match = regex.exec(string))) {
if (match[0].length > bestMatchLength) {
bestMatchIndex = match.index;
bestMatchLength = match[0].length;
var compactStringParts, part, pushPart, state, stringParts, _i, _len;
stringParts = (function() {
var _i, _len, _ref, _results;
_ref = this.parts;
_results = [];
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
part = _ref[_i];
_results.push(part.toString(16));
}
return _results;
}).call(this);
compactStringParts = [];
pushPart = function(part) {
return compactStringParts.push(part);
};
state = 0;
for (_i = 0, _len = stringParts.length; _i < _len; _i++) {
part = stringParts[_i];
switch (state) {
case 0:
if (part === '0') {
pushPart('');
} else {
pushPart(part);
}
state = 1;
break;
case 1:
if (part === '0') {
state = 2;
} else {
pushPart(part);
}
break;
case 2:
if (part !== '0') {
pushPart('');
pushPart(part);
state = 3;
}
break;
case 3:
pushPart(part);
}
}
if (bestMatchLength < 0) {
return string;
if (state === 2) {
pushPart('');
pushPart('');
}
return string.substring(0, bestMatchIndex) + '::' + string.substring(bestMatchIndex + bestMatchLength);
return compactStringParts.join(":");
};
IPv6.prototype.toByteArray = function() {
var bytes, k, len, part, ref;
var bytes, part, _i, _len, _ref;
bytes = [];
ref = this.parts;
for (k = 0, len = ref.length; k < len; k++) {
part = ref[k];
_ref = this.parts;
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
part = _ref[_i];
bytes.push(part >> 8);
bytes.push(part & 0xff);
}
@@ -260,47 +241,23 @@
};
IPv6.prototype.toNormalizedString = function() {
var addr, part, suffix;
addr = ((function() {
var k, len, ref, results;
ref = this.parts;
results = [];
for (k = 0, len = ref.length; k < len; k++) {
part = ref[k];
results.push(part.toString(16));
var part;
return ((function() {
var _i, _len, _ref, _results;
_ref = this.parts;
_results = [];
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
part = _ref[_i];
_results.push(part.toString(16));
}
return results;
return _results;
}).call(this)).join(":");
suffix = '';
if (this.zoneId) {
suffix = '%' + this.zoneId;
}
return addr + suffix;
};
IPv6.prototype.toFixedLengthString = function() {
var addr, part, suffix;
addr = ((function() {
var k, len, ref, results;
ref = this.parts;
results = [];
for (k = 0, len = ref.length; k < len; k++) {
part = ref[k];
results.push(part.toString(16).padStart(4, '0'));
}
return results;
}).call(this)).join(":");
suffix = '';
if (this.zoneId) {
suffix = '%' + this.zoneId;
}
return addr + suffix;
};
IPv6.prototype.match = function(other, cidrRange) {
var ref;
var _ref;
if (cidrRange === void 0) {
ref = other, other = ref[0], cidrRange = ref[1];
_ref = other, other = _ref[0], cidrRange = _ref[1];
}
if (other.kind() !== 'ipv6') {
throw new Error("ipaddr: cannot match ipv6 address with non-ipv6 one");
@@ -331,79 +288,30 @@
};
IPv6.prototype.toIPv4Address = function() {
var high, low, ref;
var high, low, _ref;
if (!this.isIPv4MappedAddress()) {
throw new Error("ipaddr: trying to convert a generic ipv6 address to ipv4");
}
ref = this.parts.slice(-2), high = ref[0], low = ref[1];
_ref = this.parts.slice(-2), high = _ref[0], low = _ref[1];
return new ipaddr.IPv4([high >> 8, high & 0xff, low >> 8, low & 0xff]);
};
IPv6.prototype.prefixLengthFromSubnetMask = function() {
var cidr, i, k, part, stop, zeros, zerotable;
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
};
cidr = 0;
stop = false;
for (i = k = 7; k >= 0; i = k += -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;
};
return IPv6;
})();
ipv6Part = "(?:[0-9a-f]+::?)+";
zoneIndex = "%[0-9a-z]{1,}";
ipv6Regexes = {
zoneIndex: new RegExp(zoneIndex, 'i'),
"native": new RegExp("^(::)?(" + ipv6Part + ")?([0-9a-f]+)?(::)?(" + zoneIndex + ")?$", 'i'),
transitional: new RegExp(("^((?:" + ipv6Part + ")|(?:::)(?:" + ipv6Part + ")?)") + (ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part) + ("(" + zoneIndex + ")?$"), 'i')
"native": new RegExp("^(::)?(" + ipv6Part + ")?([0-9a-f]+)?(::)?$", 'i'),
transitional: new RegExp(("^((?:" + ipv6Part + ")|(?:::)(?:" + ipv6Part + ")?)") + ("" + ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part + "$"), 'i')
};
expandIPv6 = function(string, parts) {
var colonCount, lastColon, part, replacement, replacementCount, zoneId;
var colonCount, lastColon, part, replacement, replacementCount;
if (string.indexOf('::') !== string.lastIndexOf('::')) {
return null;
}
zoneId = (string.match(ipv6Regexes['zoneIndex']) || [])[0];
if (zoneId) {
zoneId = zoneId.substring(1);
string = string.replace(/%.+$/, '');
}
colonCount = 0;
lastColon = -1;
while ((lastColon = string.indexOf(':', lastColon + 1)) >= 0) {
@@ -430,43 +338,28 @@
if (string[string.length - 1] === ':') {
string = string.slice(0, -1);
}
parts = (function() {
var k, len, ref, results;
ref = string.split(":");
results = [];
for (k = 0, len = ref.length; k < len; k++) {
part = ref[k];
results.push(parseInt(part, 16));
return (function() {
var _i, _len, _ref, _results;
_ref = string.split(":");
_results = [];
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
part = _ref[_i];
_results.push(parseInt(part, 16));
}
return results;
return _results;
})();
return {
parts: parts,
zoneId: zoneId
};
};
ipaddr.IPv6.parser = function(string) {
var addr, k, len, match, octet, octets, zoneId;
if (ipv6Regexes['native'].test(string)) {
var match, parts;
if (string.match(ipv6Regexes['native'])) {
return expandIPv6(string, 8);
} else 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 (k = 0, len = octets.length; k < len; k++) {
octet = octets[k];
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
};
parts = expandIPv6(match[1].slice(0, -1), 6);
if (parts) {
parts.push(parseInt(match[2]) << 8 | parseInt(match[3]));
parts.push(parseInt(match[4]) << 8 | parseInt(match[5]));
return parts;
}
}
return null;
@@ -481,36 +374,27 @@
try {
new this(this.parser(string));
return true;
} catch (error1) {
e = error1;
return false;
}
};
ipaddr.IPv4.isValidFourPartDecimal = function(string) {
if (ipaddr.IPv4.isValid(string) && string.match(/^(0|[1-9]\d*)(\.(0|[1-9]\d*)){3}$/)) {
return true;
} else {
} catch (_error) {
e = _error;
return false;
}
};
ipaddr.IPv6.isValid = function(string) {
var addr, e;
var e;
if (typeof string === "string" && string.indexOf(":") === -1) {
return false;
}
try {
addr = this.parser(string);
new this(addr.parts, addr.zoneId);
new this(this.parser(string));
return true;
} catch (error1) {
e = error1;
} catch (_error) {
e = _error;
return false;
}
};
ipaddr.IPv4.parse = function(string) {
ipaddr.IPv4.parse = ipaddr.IPv6.parse = function(string) {
var parts;
parts = this.parser(string);
if (parts === null) {
@@ -519,101 +403,23 @@
return new this(parts);
};
ipaddr.IPv6.parse = function(string) {
var addr;
addr = this.parser(string);
if (addr.parts === null) {
throw new Error("ipaddr: string is not formatted like ip address");
}
return new this(addr.parts, addr.zoneId);
};
ipaddr.IPv4.parseCIDR = function(string) {
var maskLength, match, parsed;
var maskLength, match;
if (match = string.match(/^(.+)\/(\d+)$/)) {
maskLength = parseInt(match[2]);
if (maskLength >= 0 && maskLength <= 32) {
parsed = [this.parse(match[1]), maskLength];
Object.defineProperty(parsed, 'toString', {
value: function() {
return this.join('/');
}
});
return parsed;
return [this.parse(match[1]), maskLength];
}
}
throw new Error("ipaddr: string is not formatted like an IPv4 CIDR range");
};
ipaddr.IPv4.subnetMaskFromPrefixLength = function(prefix) {
var filledOctetCount, j, octets;
prefix = parseInt(prefix);
if (prefix < 0 || prefix > 32) {
throw new Error('ipaddr: invalid IPv4 prefix length');
}
octets = [0, 0, 0, 0];
j = 0;
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.IPv4.broadcastAddressFromCIDR = function(string) {
var cidr, error, 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) ^ 255);
i++;
}
return new this(octets);
} catch (error1) {
error = error1;
throw new Error('ipaddr: the address does not have IPv4 CIDR format');
}
};
ipaddr.IPv4.networkAddressFromCIDR = function(string) {
var cidr, error, 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 (error1) {
error = error1;
throw new Error('ipaddr: the address does not have IPv4 CIDR format');
}
};
ipaddr.IPv6.parseCIDR = function(string) {
var maskLength, match, parsed;
var maskLength, match;
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;
return [this.parse(match[1]), maskLength];
}
}
throw new Error("ipaddr: string is not formatted like an IPv6 CIDR range");
@@ -637,29 +443,17 @@
var e;
try {
return ipaddr.IPv6.parseCIDR(string);
} catch (error1) {
e = error1;
} catch (_error) {
e = _error;
try {
return ipaddr.IPv4.parseCIDR(string);
} catch (error1) {
e = error1;
} catch (_error) {
e = _error;
throw new Error("ipaddr: the address has neither IPv6 nor IPv4 CIDR format");
}
}
};
ipaddr.fromByteArray = function(bytes) {
var length;
length = bytes.length;
if (length === 4) {
return new ipaddr.IPv4(bytes);
} else if (length === 16) {
return new ipaddr.IPv6(bytes);
} else {
throw new Error("ipaddr: the binary input is neither an IPv6 nor IPv4 address");
}
};
ipaddr.process = function(string) {
var addr;
addr = this.parse(string);

68
node_modules/ipaddr.js/lib/ipaddr.js.d.ts generated vendored
View File

@@ -1,68 +0,0 @@
declare module "ipaddr.js" {
type IPv4Range = 'unicast' | 'unspecified' | 'broadcast' | 'multicast' | 'linkLocal' | 'loopback' | 'carrierGradeNat' | 'private' | 'reserved';
type IPv6Range = 'unicast' | 'unspecified' | 'linkLocal' | 'multicast' | 'loopback' | 'uniqueLocal' | 'ipv4Mapped' | 'rfc6145' | 'rfc6052' | '6to4' | 'teredo' | 'reserved';
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 isValid(addr: string): boolean;
export function fromByteArray(bytes: number[]): IPv4 | IPv6;
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, rangeList: RangeList<IPv4>, defaultName?: string): string;
export function subnetMatch(addr: IPv6, rangeList: RangeList<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(addr: IPv4, bits: number): boolean;
match(mask: [IPv4, 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 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(addr: IPv6, bits: number): boolean;
match(mask: [IPv6, number]): boolean;
range(): IPv6Range;
subnetMatch(rangeList: RangeList<IPv6>, defaultName?: string): string;
toIPv4Address(): IPv4;
}
}
export = Address;
}

28
node_modules/ipaddr.js/package.json generated vendored
View File

@@ -1,35 +1,23 @@
{
"name": "ipaddr.js",
"description": "A library for manipulating IPv4 and IPv6 addresses in JavaScript.",
"version": "1.9.1",
"version": "1.0.5",
"author": "whitequark <whitequark@whitequark.org>",
"directories": {
"lib": "./lib"
},
"dependencies": {},
"devDependencies": {
"coffee-script": "~1.12.6",
"nodeunit": "^0.11.3",
"uglify-js": "~3.0.19"
"coffee-script": "~1.6",
"nodeunit": ">=0.8.2 <0.8.7",
"uglify-js": "latest"
},
"scripts": {
"test": "cake build test"
},
"files": [
"lib/",
"LICENSE",
"ipaddr.min.js"
],
"keywords": [
"ip",
"ipv4",
"ipv6"
],
"keywords": ["ip", "ipv4", "ipv6"],
"repository": "git://github.com/whitequark/ipaddr.js",
"main": "./lib/ipaddr.js",
"engines": {
"node": ">= 0.10"
},
"license": "MIT",
"types": "./lib/ipaddr.js.d.ts"
"main": "./lib/ipaddr",
"engines": { "node": ">= 0.10" },
"license": "MIT"
}

396
node_modules/ipaddr.js/src/ipaddr.coffee generated vendored Normal file
View File

@@ -0,0 +1,396 @@
# Define the main object
ipaddr = {}
root = this
# Export for both the CommonJS and browser-like environment
if module? && module.exports
module.exports = ipaddr
else
root['ipaddr'] = ipaddr
# A generic CIDR (Classless Inter-Domain Routing) RFC1518 range matcher.
matchCIDR = (first, second, partSize, cidrBits) ->
if first.length != second.length
throw new Error "ipaddr: cannot match CIDR for objects with different lengths"
part = 0
while cidrBits > 0
shift = partSize - cidrBits
shift = 0 if shift < 0
if first[part] >> shift != second[part] >> shift
return false
cidrBits -= partSize
part += 1
return true
# An utility function to ease named range matching. See examples below.
ipaddr.subnetMatch = (address, rangeList, defaultName='unicast') ->
for rangeName, rangeSubnets of rangeList
# ECMA5 Array.isArray isn't available everywhere
if rangeSubnets[0] && !(rangeSubnets[0] instanceof Array)
rangeSubnets = [ rangeSubnets ]
for subnet in rangeSubnets
return rangeName if address.match.apply(address, subnet)
return defaultName
# An IPv4 address (RFC791).
class ipaddr.IPv4
# Constructs a new IPv4 address from an array of four octets.
# Verifies the input.
constructor: (octets) ->
if octets.length != 4
throw new Error "ipaddr: ipv4 octet count should be 4"
for octet in octets
if !(0 <= octet <= 255)
throw new Error "ipaddr: ipv4 octet is a byte"
@octets = octets
# The 'kind' method exists on both IPv4 and IPv6 classes.
kind: ->
return 'ipv4'
# Returns the address in convenient, decimal-dotted format.
toString: ->
return @octets.join "."
# Returns an array of byte-sized values in network order
toByteArray: ->
return @octets.slice(0) # octets.clone
# Checks if this address matches other one within given CIDR range.
match: (other, cidrRange) ->
if cidrRange == undefined
[other, cidrRange] = other
if other.kind() != 'ipv4'
throw new Error "ipaddr: cannot match ipv4 address with non-ipv4 one"
return matchCIDR(this.octets, other.octets, 8, cidrRange)
# Special IPv4 address ranges.
SpecialRanges:
unspecified: [
[ new IPv4([0, 0, 0, 0]), 8 ]
]
broadcast: [
[ new IPv4([255, 255, 255, 255]), 32 ]
]
multicast: [ # RFC3171
[ new IPv4([224, 0, 0, 0]), 4 ]
]
linkLocal: [ # RFC3927
[ new IPv4([169, 254, 0, 0]), 16 ]
]
loopback: [ # RFC5735
[ new IPv4([127, 0, 0, 0]), 8 ]
]
private: [ # RFC1918
[ new IPv4([10, 0, 0, 0]), 8 ]
[ new IPv4([172, 16, 0, 0]), 12 ]
[ new IPv4([192, 168, 0, 0]), 16 ]
]
reserved: [ # Reserved and testing-only ranges; RFCs 5735, 5737, 2544, 1700
[ 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 ]
]
# Checks if the address corresponds to one of the special ranges.
range: ->
return ipaddr.subnetMatch(this, @SpecialRanges)
# Convrets this IPv4 address to an IPv4-mapped IPv6 address.
toIPv4MappedAddress: ->
return ipaddr.IPv6.parse "::ffff:#{@toString()}"
# 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.
ipv4Part = "(0?\\d+|0x[a-f0-9]+)"
ipv4Regexes =
fourOctet: new RegExp "^#{ipv4Part}\\.#{ipv4Part}\\.#{ipv4Part}\\.#{ipv4Part}$", 'i'
longValue: new RegExp "^#{ipv4Part}$", 'i'
# 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 = (string) ->
parseIntAuto = (string) ->
if string[0] == "0" && string[1] != "x"
parseInt(string, 8)
else
parseInt(string)
# parseInt recognizes all that octal & hexadecimal weirdness for us
if match = string.match(ipv4Regexes.fourOctet)
return (parseIntAuto(part) for part in match[1..5])
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 ((value >> shift) & 0xff for shift in [0..24] by 8).reverse()
else
return null
# An IPv6 address (RFC2460)
class ipaddr.IPv6
# Constructs an IPv6 address from an array of eight 16-bit parts.
# Throws an error if the input is invalid.
constructor: (parts) ->
if parts.length != 8
throw new Error "ipaddr: ipv6 part count should be 8"
for part in parts
if !(0 <= part <= 0xffff)
throw new Error "ipaddr: ipv6 part should fit to two octets"
@parts = parts
# The 'kind' method exists on both IPv4 and IPv6 classes.
kind: ->
return 'ipv6'
# Returns the address in compact, human-readable format like
# 2001:db8:8:66::1
toString: ->
stringParts = (part.toString(16) for part in @parts)
compactStringParts = []
pushPart = (part) -> compactStringParts.push part
state = 0
for part in stringParts
switch state
when 0
if part == '0'
pushPart('')
else
pushPart(part)
state = 1
when 1
if part == '0'
state = 2
else
pushPart(part)
when 2
unless part == '0'
pushPart('')
pushPart(part)
state = 3
when 3
pushPart(part)
if state == 2
pushPart('')
pushPart('')
return compactStringParts.join ":"
# Returns an array of byte-sized values in network order
toByteArray: ->
bytes = []
for part in @parts
bytes.push(part >> 8)
bytes.push(part & 0xff)
return bytes
# Returns the address in expanded format with all zeroes included, like
# 2001:db8:8:66:0:0:0:1
toNormalizedString: ->
return (part.toString(16) for part in @parts).join ":"
# Checks if this address matches other one within given CIDR range.
match: (other, cidrRange) ->
if cidrRange == undefined
[other, cidrRange] = other
if other.kind() != 'ipv6'
throw new Error "ipaddr: cannot match ipv6 address with non-ipv6 one"
return matchCIDR(this.parts, other.parts, 16, cidrRange)
# Special IPv6 ranges
SpecialRanges:
unspecified: [ new IPv6([0, 0, 0, 0, 0, 0, 0, 0]), 128 ] # RFC4291, here and after
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: [ new IPv6([0, 0, 0, 0, 0xffff, 0, 0, 0]), 96 ] # RFC6145
rfc6052: [ new IPv6([0x64, 0xff9b, 0, 0, 0, 0, 0, 0]), 96 ] # RFC6052
'6to4': [ new IPv6([0x2002, 0, 0, 0, 0, 0, 0, 0]), 16 ] # RFC3056
teredo: [ new IPv6([0x2001, 0, 0, 0, 0, 0, 0, 0]), 32 ] # RFC6052, RFC6146
reserved: [
[ new IPv6([ 0x2001, 0xdb8, 0, 0, 0, 0, 0, 0]), 32 ] # RFC4291
]
# Checks if the address corresponds to one of the special ranges.
range: ->
return ipaddr.subnetMatch(this, @SpecialRanges)
# Checks if this address is an IPv4-mapped IPv6 address.
isIPv4MappedAddress: ->
return @range() == 'ipv4Mapped'
# Converts this address to IPv4 address if it is an IPv4-mapped IPv6 address.
# Throws an error otherwise.
toIPv4Address: ->
unless @isIPv4MappedAddress()
throw new Error "ipaddr: trying to convert a generic ipv6 address to ipv4"
[high, low] = @parts[-2..-1]
return new ipaddr.IPv4([high >> 8, high & 0xff, low >> 8, low & 0xff])
# 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.
ipv6Part = "(?:[0-9a-f]+::?)+"
ipv6Regexes =
native: new RegExp "^(::)?(#{ipv6Part})?([0-9a-f]+)?(::)?$", 'i'
transitional: new RegExp "^((?:#{ipv6Part})|(?:::)(?:#{ipv6Part})?)" +
"#{ipv4Part}\\.#{ipv4Part}\\.#{ipv4Part}\\.#{ipv4Part}$", 'i'
# Expand :: in an IPv6 address or address part consisting of `parts` groups.
expandIPv6 = (string, parts) ->
# More than one '::' means invalid adddress
if string.indexOf('::') != string.lastIndexOf('::')
return null
# How many parts do we already have?
colonCount = 0
lastColon = -1
while (lastColon = string.indexOf(':', lastColon + 1)) >= 0
colonCount++
# 0::0 is two parts more than ::
colonCount-- if string.substr(0, 2) == '::'
colonCount-- if string.substr(-2, 2) == '::'
# 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 string
string = string[1..-1] if string[0] == ':'
string = string[0..-2] if string[string.length-1] == ':'
return (parseInt(part, 16) for part in string.split(":"))
# Parse an IPv6 address.
ipaddr.IPv6.parser = (string) ->
if string.match(ipv6Regexes['native'])
return expandIPv6(string, 8)
else if match = string.match(ipv6Regexes['transitional'])
parts = expandIPv6(match[1][0..-2], 6)
if parts
parts.push(parseInt(match[2]) << 8 | parseInt(match[3]))
parts.push(parseInt(match[4]) << 8 | parseInt(match[5]))
return parts
return null
# Checks if a given string is formatted like IPv4/IPv6 address.
ipaddr.IPv4.isIPv4 = ipaddr.IPv6.isIPv6 = (string) ->
return @parser(string) != null
# Checks if a given string is a valid IPv4/IPv6 address.
ipaddr.IPv4.isValid = (string) ->
try
new this(@parser(string))
return true
catch e
return false
ipaddr.IPv6.isValid = (string) ->
# Since IPv6.isValid is always called first, this shortcut
# provides a substantial performance gain.
if typeof string == "string" and string.indexOf(":") == -1
return false
try
new this(@parser(string))
return true
catch e
return false
# Tries to parse and validate a string with IPv4/IPv6 address.
# Throws an error if it fails.
ipaddr.IPv4.parse = ipaddr.IPv6.parse = (string) ->
parts = @parser(string)
if parts == null
throw new Error "ipaddr: string is not formatted like ip address"
return new this(parts)
ipaddr.IPv4.parseCIDR = (string) ->
if match = string.match(/^(.+)\/(\d+)$/)
maskLength = parseInt(match[2])
if maskLength >= 0 and maskLength <= 32
return [@parse(match[1]), maskLength]
throw new Error "ipaddr: string is not formatted like an IPv4 CIDR range"
ipaddr.IPv6.parseCIDR = (string) ->
if match = string.match(/^(.+)\/(\d+)$/)
maskLength = parseInt(match[2])
if maskLength >= 0 and maskLength <= 128
return [@parse(match[1]), maskLength]
throw new Error "ipaddr: string is not formatted like an IPv6 CIDR range"
# Checks if the address is valid IP address
ipaddr.isValid = (string) ->
return ipaddr.IPv6.isValid(string) || ipaddr.IPv4.isValid(string)
# Try to parse an address and throw an error if it is impossible
ipaddr.parse = (string) ->
if ipaddr.IPv6.isValid(string)
return ipaddr.IPv6.parse(string)
else if ipaddr.IPv4.isValid(string)
return ipaddr.IPv4.parse(string)
else
throw new Error "ipaddr: the address has neither IPv6 nor IPv4 format"
ipaddr.parseCIDR = (string) ->
try
return ipaddr.IPv6.parseCIDR(string)
catch e
try
return ipaddr.IPv4.parseCIDR(string)
catch e
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 = (string) ->
addr = @parse(string)
if addr.kind() == 'ipv6' && addr.isIPv4MappedAddress()
return addr.toIPv4Address()
else
return addr

282
node_modules/ipaddr.js/test/ipaddr.test.coffee generated vendored Normal file
View File

@@ -0,0 +1,282 @@
ipaddr = require '../lib/ipaddr'
module.exports =
'should define main classes': (test) ->
test.ok(ipaddr.IPv4?, 'defines IPv4 class')
test.ok(ipaddr.IPv6?, 'defines IPv6 class')
test.done()
'can construct IPv4 from octets': (test) ->
test.doesNotThrow ->
new ipaddr.IPv4([192, 168, 1, 2])
test.done()
'refuses to construct invalid IPv4': (test) ->
test.throws ->
new ipaddr.IPv4([300, 1, 2, 3])
test.throws ->
new ipaddr.IPv4([8, 8, 8])
test.done()
'converts IPv4 to string correctly': (test) ->
addr = new ipaddr.IPv4([192, 168, 1, 1])
test.equal(addr.toString(), '192.168.1.1')
test.done()
'returns correct kind for IPv4': (test) ->
addr = new ipaddr.IPv4([1, 2, 3, 4])
test.equal(addr.kind(), 'ipv4')
test.done()
'allows to access IPv4 octets': (test) ->
addr = new ipaddr.IPv4([42, 0, 0, 0])
test.equal(addr.octets[0], 42)
test.done()
'checks IPv4 address format': (test) ->
test.equal(ipaddr.IPv4.isIPv4('192.168.007.0xa'), true)
test.equal(ipaddr.IPv4.isIPv4('1024.0.0.1'), true)
test.equal(ipaddr.IPv4.isIPv4('8.0xa.wtf.6'), false)
test.done()
'validates IPv4 addresses': (test) ->
test.equal(ipaddr.IPv4.isValid('192.168.007.0xa'), true)
test.equal(ipaddr.IPv4.isValid('1024.0.0.1'), false)
test.equal(ipaddr.IPv4.isValid('8.0xa.wtf.6'), false)
test.done()
'parses IPv4 in several weird formats': (test) ->
test.deepEqual(ipaddr.IPv4.parse('192.168.1.1').octets, [192, 168, 1, 1])
test.deepEqual(ipaddr.IPv4.parse('0xc0.168.1.1').octets, [192, 168, 1, 1])
test.deepEqual(ipaddr.IPv4.parse('192.0250.1.1').octets, [192, 168, 1, 1])
test.deepEqual(ipaddr.IPv4.parse('0xc0a80101').octets, [192, 168, 1, 1])
test.deepEqual(ipaddr.IPv4.parse('030052000401').octets, [192, 168, 1, 1])
test.deepEqual(ipaddr.IPv4.parse('3232235777').octets, [192, 168, 1, 1])
test.done()
'barfs at invalid IPv4': (test) ->
test.throws ->
ipaddr.IPv4.parse('10.0.0.wtf')
test.done()
'matches IPv4 CIDR correctly': (test) ->
addr = new ipaddr.IPv4([10, 5, 0, 1])
test.equal(addr.match(ipaddr.IPv4.parse('0.0.0.0'), 0), true)
test.equal(addr.match(ipaddr.IPv4.parse('11.0.0.0'), 8), false)
test.equal(addr.match(ipaddr.IPv4.parse('10.0.0.0'), 8), true)
test.equal(addr.match(ipaddr.IPv4.parse('10.0.0.1'), 8), true)
test.equal(addr.match(ipaddr.IPv4.parse('10.0.0.10'), 8), true)
test.equal(addr.match(ipaddr.IPv4.parse('10.5.5.0'), 16), true)
test.equal(addr.match(ipaddr.IPv4.parse('10.4.5.0'), 16), false)
test.equal(addr.match(ipaddr.IPv4.parse('10.4.5.0'), 15), true)
test.equal(addr.match(ipaddr.IPv4.parse('10.5.0.2'), 32), false)
test.equal(addr.match(addr, 32), true)
test.done()
'parses IPv4 CIDR correctly': (test) ->
addr = new ipaddr.IPv4([10, 5, 0, 1])
test.equal(addr.match(ipaddr.IPv4.parseCIDR('0.0.0.0/0')), true)
test.equal(addr.match(ipaddr.IPv4.parseCIDR('11.0.0.0/8')), false)
test.equal(addr.match(ipaddr.IPv4.parseCIDR('10.0.0.0/8')), true)
test.equal(addr.match(ipaddr.IPv4.parseCIDR('10.0.0.1/8')), true)
test.equal(addr.match(ipaddr.IPv4.parseCIDR('10.0.0.10/8')), true)
test.equal(addr.match(ipaddr.IPv4.parseCIDR('10.5.5.0/16')), true)
test.equal(addr.match(ipaddr.IPv4.parseCIDR('10.4.5.0/16')), false)
test.equal(addr.match(ipaddr.IPv4.parseCIDR('10.4.5.0/15')), true)
test.equal(addr.match(ipaddr.IPv4.parseCIDR('10.5.0.2/32')), false)
test.equal(addr.match(ipaddr.IPv4.parseCIDR('10.5.0.1/32')), true)
test.throws ->
ipaddr.IPv4.parseCIDR('10.5.0.1')
test.throws ->
ipaddr.IPv4.parseCIDR('0.0.0.0/-1')
test.throws ->
ipaddr.IPv4.parseCIDR('0.0.0.0/33')
test.done()
'detects reserved IPv4 networks': (test) ->
test.equal(ipaddr.IPv4.parse('0.0.0.0').range(), 'unspecified')
test.equal(ipaddr.IPv4.parse('0.1.0.0').range(), 'unspecified')
test.equal(ipaddr.IPv4.parse('10.1.0.1').range(), 'private')
test.equal(ipaddr.IPv4.parse('192.168.2.1').range(), 'private')
test.equal(ipaddr.IPv4.parse('224.100.0.1').range(), 'multicast')
test.equal(ipaddr.IPv4.parse('169.254.15.0').range(), 'linkLocal')
test.equal(ipaddr.IPv4.parse('127.1.1.1').range(), 'loopback')
test.equal(ipaddr.IPv4.parse('255.255.255.255').range(), 'broadcast')
test.equal(ipaddr.IPv4.parse('240.1.2.3').range(), 'reserved')
test.equal(ipaddr.IPv4.parse('8.8.8.8').range(), 'unicast')
test.done()
'can construct IPv6 from parts': (test) ->
test.doesNotThrow ->
new ipaddr.IPv6([0x2001, 0xdb8, 0xf53a, 0, 0, 0, 0, 1])
test.done()
'refuses to construct invalid IPv6': (test) ->
test.throws ->
new ipaddr.IPv6([0xfffff, 0, 0, 0, 0, 0, 0, 1])
test.throws ->
new ipaddr.IPv6([0xfffff, 0, 0, 0, 0, 0, 1])
test.done()
'converts IPv6 to string correctly': (test) ->
addr = new ipaddr.IPv6([0x2001, 0xdb8, 0xf53a, 0, 0, 0, 0, 1])
test.equal(addr.toNormalizedString(), '2001:db8:f53a:0:0:0:0:1')
test.equal(addr.toString(), '2001:db8:f53a::1')
test.equal(new ipaddr.IPv6([0, 0, 0, 0, 0, 0, 0, 1]).toString(), '::1')
test.equal(new ipaddr.IPv6([0x2001, 0xdb8, 0, 0, 0, 0, 0, 0]).toString(), '2001:db8::')
test.done()
'returns correct kind for IPv6': (test) ->
addr = new ipaddr.IPv6([0x2001, 0xdb8, 0xf53a, 0, 0, 0, 0, 1])
test.equal(addr.kind(), 'ipv6')
test.done()
'allows to access IPv6 address parts': (test) ->
addr = new ipaddr.IPv6([0x2001, 0xdb8, 0xf53a, 0, 0, 42, 0, 1])
test.equal(addr.parts[5], 42)
test.done()
'checks IPv6 address format': (test) ->
test.equal(ipaddr.IPv6.isIPv6('2001:db8:F53A::1'), true)
test.equal(ipaddr.IPv6.isIPv6('200001::1'), true)
test.equal(ipaddr.IPv6.isIPv6('::ffff:192.168.1.1'), true)
test.equal(ipaddr.IPv6.isIPv6('::ffff:300.168.1.1'), true)
test.equal(ipaddr.IPv6.isIPv6('::ffff:300.168.1.1:0'), false)
test.equal(ipaddr.IPv6.isIPv6('fe80::wtf'), false)
test.done()
'validates IPv6 addresses': (test) ->
test.equal(ipaddr.IPv6.isValid('2001:db8:F53A::1'), true)
test.equal(ipaddr.IPv6.isValid('200001::1'), false)
test.equal(ipaddr.IPv6.isValid('::ffff:192.168.1.1'), true)
test.equal(ipaddr.IPv6.isValid('::ffff:300.168.1.1'), false)
test.equal(ipaddr.IPv6.isValid('::ffff:300.168.1.1:0'), false)
test.equal(ipaddr.IPv6.isValid('2001:db8::F53A::1'), false)
test.equal(ipaddr.IPv6.isValid('fe80::wtf'), false)
test.equal(ipaddr.IPv6.isValid('2002::2:'), false)
test.equal(ipaddr.IPv6.isValid(undefined), false)
test.done()
'parses IPv6 in different formats': (test) ->
test.deepEqual(ipaddr.IPv6.parse('2001:db8:F53A:0:0:0:0:1').parts, [0x2001, 0xdb8, 0xf53a, 0, 0, 0, 0, 1])
test.deepEqual(ipaddr.IPv6.parse('fe80::10').parts, [0xfe80, 0, 0, 0, 0, 0, 0, 0x10])
test.deepEqual(ipaddr.IPv6.parse('2001:db8:F53A::').parts, [0x2001, 0xdb8, 0xf53a, 0, 0, 0, 0, 0])
test.deepEqual(ipaddr.IPv6.parse('::1').parts, [0, 0, 0, 0, 0, 0, 0, 1])
test.deepEqual(ipaddr.IPv6.parse('::').parts, [0, 0, 0, 0, 0, 0, 0, 0])
test.done()
'barfs at invalid IPv6': (test) ->
test.throws ->
ipaddr.IPv6.parse('fe80::0::1')
test.done()
'matches IPv6 CIDR correctly': (test) ->
addr = ipaddr.IPv6.parse('2001:db8:f53a::1')
test.equal(addr.match(ipaddr.IPv6.parse('::'), 0), true)
test.equal(addr.match(ipaddr.IPv6.parse('2001:db8:f53a::1:1'), 64), true)
test.equal(addr.match(ipaddr.IPv6.parse('2001:db8:f53b::1:1'), 48), false)
test.equal(addr.match(ipaddr.IPv6.parse('2001:db8:f531::1:1'), 44), true)
test.equal(addr.match(ipaddr.IPv6.parse('2001:db8:f500::1'), 40), true)
test.equal(addr.match(ipaddr.IPv6.parse('2001:db9:f500::1'), 40), false)
test.equal(addr.match(addr, 128), true)
test.done()
'parses IPv6 CIDR correctly': (test) ->
addr = ipaddr.IPv6.parse('2001:db8:f53a::1')
test.equal(addr.match(ipaddr.IPv6.parseCIDR('::/0')), true)
test.equal(addr.match(ipaddr.IPv6.parseCIDR('2001:db8:f53a::1:1/64')), true)
test.equal(addr.match(ipaddr.IPv6.parseCIDR('2001:db8:f53b::1:1/48')), false)
test.equal(addr.match(ipaddr.IPv6.parseCIDR('2001:db8:f531::1:1/44')), true)
test.equal(addr.match(ipaddr.IPv6.parseCIDR('2001:db8:f500::1/40')), true)
test.equal(addr.match(ipaddr.IPv6.parseCIDR('2001:db9:f500::1/40')), false)
test.equal(addr.match(ipaddr.IPv6.parseCIDR('2001:db8:f53a::1/128')), true)
test.throws ->
ipaddr.IPv6.parseCIDR('2001:db8:f53a::1')
test.throws ->
ipaddr.IPv6.parseCIDR('2001:db8:f53a::1/-1')
test.throws ->
ipaddr.IPv6.parseCIDR('2001:db8:f53a::1/129')
test.done()
'converts between IPv4-mapped IPv6 addresses and IPv4 addresses': (test) ->
addr = ipaddr.IPv4.parse('77.88.21.11')
mapped = addr.toIPv4MappedAddress()
test.deepEqual(mapped.parts, [0, 0, 0, 0, 0, 0xffff, 0x4d58, 0x150b])
test.deepEqual(mapped.toIPv4Address().octets, addr.octets)
test.done()
'refuses to convert non-IPv4-mapped IPv6 address to IPv4 address': (test) ->
test.throws ->
ipaddr.IPv6.parse('2001:db8::1').toIPv4Address()
test.done()
'detects reserved IPv6 networks': (test) ->
test.equal(ipaddr.IPv6.parse('::').range(), 'unspecified')
test.equal(ipaddr.IPv6.parse('fe80::1234:5678:abcd:0123').range(), 'linkLocal')
test.equal(ipaddr.IPv6.parse('ff00::1234').range(), 'multicast')
test.equal(ipaddr.IPv6.parse('::1').range(), 'loopback')
test.equal(ipaddr.IPv6.parse('fc00::').range(), 'uniqueLocal')
test.equal(ipaddr.IPv6.parse('::ffff:192.168.1.10').range(), 'ipv4Mapped')
test.equal(ipaddr.IPv6.parse('::ffff:0:192.168.1.10').range(), 'rfc6145')
test.equal(ipaddr.IPv6.parse('64:ff9b::1234').range(), 'rfc6052')
test.equal(ipaddr.IPv6.parse('2002:1f63:45e8::1').range(), '6to4')
test.equal(ipaddr.IPv6.parse('2001::4242').range(), 'teredo')
test.equal(ipaddr.IPv6.parse('2001:db8::3210').range(), 'reserved')
test.equal(ipaddr.IPv6.parse('2001:470:8:66::1').range(), 'unicast')
test.done()
'is able to determine IP address type': (test) ->
test.equal(ipaddr.parse('8.8.8.8').kind(), 'ipv4')
test.equal(ipaddr.parse('2001:db8:3312::1').kind(), 'ipv6')
test.done()
'throws an error if tried to parse an invalid address': (test) ->
test.throws ->
ipaddr.parse('::some.nonsense')
test.done()
'correctly processes IPv4-mapped addresses': (test) ->
test.equal(ipaddr.process('8.8.8.8').kind(), 'ipv4')
test.equal(ipaddr.process('2001:db8:3312::1').kind(), 'ipv6')
test.equal(ipaddr.process('::ffff:192.168.1.1').kind(), 'ipv4')
test.done()
'correctly converts IPv6 and IPv4 addresses to byte arrays': (test) ->
test.deepEqual(ipaddr.parse('1.2.3.4').toByteArray(),
[0x1, 0x2, 0x3, 0x4]);
# Fuck yeah. The first byte of Google's IPv6 address is 42. 42!
test.deepEqual(ipaddr.parse('2a00:1450:8007::68').toByteArray(),
[42, 0x00, 0x14, 0x50, 0x80, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68 ])
test.done()
'correctly parses 1 as an IPv4 address': (test) ->
test.equal(ipaddr.IPv6.isValid('1'), false)
test.equal(ipaddr.IPv4.isValid('1'), true)
test.deepEqual(new ipaddr.IPv4([0, 0, 0, 1]), ipaddr.parse('1'))
test.done()
'correctly detects IPv4 and IPv6 CIDR addresses': (test) ->
test.deepEqual([ipaddr.IPv6.parse('fc00::'), 64],
ipaddr.parseCIDR('fc00::/64'))
test.deepEqual([ipaddr.IPv4.parse('1.2.3.4'), 5],
ipaddr.parseCIDR('1.2.3.4/5'))
test.done()
'does not consider a very large or very small number a valid IP address': (test) ->
test.equal(ipaddr.isValid('4999999999'), false)
test.equal(ipaddr.isValid('-1'), false)
test.done()
'does not hang on ::8:8:8:8:8:8:8:8:8': (test) ->
test.equal(ipaddr.IPv6.isValid('::8:8:8:8:8:8:8:8:8'), false)
test.done()
'subnetMatch does not fail on empty range': (test) ->
ipaddr.subnetMatch(new ipaddr.IPv4([1,2,3,4]), {}, false)
ipaddr.subnetMatch(new ipaddr.IPv4([1,2,3,4]), {subnet: []}, false)
test.done()
'subnetMatch returns default subnet on empty range': (test) ->
test.equal(ipaddr.subnetMatch(new ipaddr.IPv4([1,2,3,4]), {}, false), false)
test.equal(ipaddr.subnetMatch(new ipaddr.IPv4([1,2,3,4]), {subnet: []}, false), false)
test.done()