chore: disable delete confirmation in VS Code explorer
Disable the confirmation dialog when deleting files in the VS Code explorer to streamline the development workflow and reduce friction during file management operations.
This commit is contained in:
Falck
19
website/node_modules/ipaddr.js/LICENSE
generated
vendored
Normal file
19
website/node_modules/ipaddr.js/LICENSE
generated
vendored
Normal file
@@ -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.
|
||||
233
website/node_modules/ipaddr.js/README.md
generated
vendored
Normal file
233
website/node_modules/ipaddr.js/README.md
generated
vendored
Normal file
@@ -0,0 +1,233 @@
|
||||
# ipaddr.js — an IPv6 and IPv4 address manipulation library [](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`
|
||||
|
||||
## API
|
||||
|
||||
ipaddr.js defines one object in the global scope: `ipaddr`. In CommonJS,
|
||||
it is exported from the module:
|
||||
|
||||
```js
|
||||
var 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
|
||||
var addr = ipaddr.parse("2001:db8:1234::1");
|
||||
var 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
|
||||
var 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
|
||||
var 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
|
||||
var 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
|
||||
var 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
|
||||
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.
|
||||
|
||||
To access the underlying representation of the address, use `addr.octets`.
|
||||
|
||||
```js
|
||||
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]
|
||||
```
|
||||
1
website/node_modules/ipaddr.js/ipaddr.min.js
generated
vendored
Normal file
1
website/node_modules/ipaddr.js/ipaddr.min.js
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
673
website/node_modules/ipaddr.js/lib/ipaddr.js
generated
vendored
Normal file
673
website/node_modules/ipaddr.js/lib/ipaddr.js
generated
vendored
Normal file
@@ -0,0 +1,673 @@
|
||||
(function() {
|
||||
var expandIPv6, ipaddr, ipv4Part, ipv4Regexes, ipv6Part, ipv6Regexes, matchCIDR, root, zoneIndex;
|
||||
|
||||
ipaddr = {};
|
||||
|
||||
root = this;
|
||||
|
||||
if ((typeof module !== "undefined" && module !== null) && module.exports) {
|
||||
module.exports = ipaddr;
|
||||
} else {
|
||||
root['ipaddr'] = ipaddr;
|
||||
}
|
||||
|
||||
matchCIDR = function(first, second, partSize, cidrBits) {
|
||||
var part, shift;
|
||||
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;
|
||||
if (shift < 0) {
|
||||
shift = 0;
|
||||
}
|
||||
if (first[part] >> shift !== second[part] >> shift) {
|
||||
return false;
|
||||
}
|
||||
cidrBits -= partSize;
|
||||
part += 1;
|
||||
}
|
||||
return true;
|
||||
};
|
||||
|
||||
ipaddr.subnetMatch = function(address, rangeList, defaultName) {
|
||||
var k, len, rangeName, rangeSubnets, subnet;
|
||||
if (defaultName == null) {
|
||||
defaultName = 'unicast';
|
||||
}
|
||||
for (rangeName in rangeList) {
|
||||
rangeSubnets = rangeList[rangeName];
|
||||
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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return defaultName;
|
||||
};
|
||||
|
||||
ipaddr.IPv4 = (function() {
|
||||
function IPv4(octets) {
|
||||
var k, len, octet;
|
||||
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];
|
||||
if (!((0 <= octet && octet <= 255))) {
|
||||
throw new Error("ipaddr: ipv4 octet should fit in 8 bits");
|
||||
}
|
||||
}
|
||||
this.octets = octets;
|
||||
}
|
||||
|
||||
IPv4.prototype.kind = function() {
|
||||
return 'ipv4';
|
||||
};
|
||||
|
||||
IPv4.prototype.toString = function() {
|
||||
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;
|
||||
if (cidrRange === void 0) {
|
||||
ref = other, other = ref[0], cidrRange = ref[1];
|
||||
}
|
||||
if (other.kind() !== 'ipv4') {
|
||||
throw new Error("ipaddr: cannot match ipv4 address with non-ipv4 one");
|
||||
}
|
||||
return matchCIDR(this.octets, other.octets, 8, cidrRange);
|
||||
};
|
||||
|
||||
IPv4.prototype.SpecialRanges = {
|
||||
unspecified: [[new IPv4([0, 0, 0, 0]), 8]],
|
||||
broadcast: [[new IPv4([255, 255, 255, 255]), 32]],
|
||||
multicast: [[new IPv4([224, 0, 0, 0]), 4]],
|
||||
linkLocal: [[new IPv4([169, 254, 0, 0]), 16]],
|
||||
loopback: [[new IPv4([127, 0, 0, 0]), 8]],
|
||||
carrierGradeNat: [[new IPv4([100, 64, 0, 0]), 10]],
|
||||
"private": [[new IPv4([10, 0, 0, 0]), 8], [new IPv4([172, 16, 0, 0]), 12], [new IPv4([192, 168, 0, 0]), 16]],
|
||||
reserved: [[new IPv4([192, 0, 0, 0]), 24], [new IPv4([192, 0, 2, 0]), 24], [new IPv4([192, 88, 99, 0]), 24], [new IPv4([198, 51, 100, 0]), 24], [new IPv4([203, 0, 113, 0]), 24], [new IPv4([240, 0, 0, 0]), 4]]
|
||||
};
|
||||
|
||||
IPv4.prototype.range = function() {
|
||||
return ipaddr.subnetMatch(this, this.SpecialRanges);
|
||||
};
|
||||
|
||||
IPv4.prototype.toIPv4MappedAddress = function() {
|
||||
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;
|
||||
|
||||
})();
|
||||
|
||||
ipv4Part = "(0?\\d+|0x[a-f0-9]+)";
|
||||
|
||||
ipv4Regexes = {
|
||||
fourOctet: new RegExp("^" + ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part + "\\." + ipv4Part + "$", 'i'),
|
||||
longValue: new RegExp("^" + ipv4Part + "$", 'i')
|
||||
};
|
||||
|
||||
ipaddr.IPv4.parser = function(string) {
|
||||
var match, parseIntAuto, part, shift, value;
|
||||
parseIntAuto = function(string) {
|
||||
if (string[0] === "0" && string[1] !== "x") {
|
||||
return parseInt(string, 8);
|
||||
} else {
|
||||
return parseInt(string);
|
||||
}
|
||||
};
|
||||
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));
|
||||
}
|
||||
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() {
|
||||
var k, results;
|
||||
results = [];
|
||||
for (shift = k = 0; k <= 24; shift = k += 8) {
|
||||
results.push((value >> shift) & 0xff);
|
||||
}
|
||||
return results;
|
||||
})()).reverse();
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
|
||||
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");
|
||||
}
|
||||
ref = this.parts;
|
||||
for (l = 0, len = ref.length; l < len; l++) {
|
||||
part = ref[l];
|
||||
if (!((0 <= part && part <= 0xffff))) {
|
||||
throw new Error("ipaddr: ipv6 part should fit in 16 bits");
|
||||
}
|
||||
}
|
||||
if (zoneId) {
|
||||
this.zoneId = zoneId;
|
||||
}
|
||||
}
|
||||
|
||||
IPv6.prototype.kind = function() {
|
||||
return 'ipv6';
|
||||
};
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
if (bestMatchLength < 0) {
|
||||
return string;
|
||||
}
|
||||
return string.substring(0, bestMatchIndex) + '::' + string.substring(bestMatchIndex + bestMatchLength);
|
||||
};
|
||||
|
||||
IPv6.prototype.toByteArray = function() {
|
||||
var bytes, k, len, part, ref;
|
||||
bytes = [];
|
||||
ref = this.parts;
|
||||
for (k = 0, len = ref.length; k < len; k++) {
|
||||
part = ref[k];
|
||||
bytes.push(part >> 8);
|
||||
bytes.push(part & 0xff);
|
||||
}
|
||||
return bytes;
|
||||
};
|
||||
|
||||
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));
|
||||
}
|
||||
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;
|
||||
if (cidrRange === void 0) {
|
||||
ref = other, other = ref[0], cidrRange = ref[1];
|
||||
}
|
||||
if (other.kind() !== 'ipv6') {
|
||||
throw new Error("ipaddr: cannot match ipv6 address with non-ipv6 one");
|
||||
}
|
||||
return matchCIDR(this.parts, other.parts, 16, cidrRange);
|
||||
};
|
||||
|
||||
IPv6.prototype.SpecialRanges = {
|
||||
unspecified: [new IPv6([0, 0, 0, 0, 0, 0, 0, 0]), 128],
|
||||
linkLocal: [new IPv6([0xfe80, 0, 0, 0, 0, 0, 0, 0]), 10],
|
||||
multicast: [new IPv6([0xff00, 0, 0, 0, 0, 0, 0, 0]), 8],
|
||||
loopback: [new IPv6([0, 0, 0, 0, 0, 0, 0, 1]), 128],
|
||||
uniqueLocal: [new IPv6([0xfc00, 0, 0, 0, 0, 0, 0, 0]), 7],
|
||||
ipv4Mapped: [new IPv6([0, 0, 0, 0, 0, 0xffff, 0, 0]), 96],
|
||||
rfc6145: [new IPv6([0, 0, 0, 0, 0xffff, 0, 0, 0]), 96],
|
||||
rfc6052: [new IPv6([0x64, 0xff9b, 0, 0, 0, 0, 0, 0]), 96],
|
||||
'6to4': [new IPv6([0x2002, 0, 0, 0, 0, 0, 0, 0]), 16],
|
||||
teredo: [new IPv6([0x2001, 0, 0, 0, 0, 0, 0, 0]), 32],
|
||||
reserved: [[new IPv6([0x2001, 0xdb8, 0, 0, 0, 0, 0, 0]), 32]]
|
||||
};
|
||||
|
||||
IPv6.prototype.range = function() {
|
||||
return ipaddr.subnetMatch(this, this.SpecialRanges);
|
||||
};
|
||||
|
||||
IPv6.prototype.isIPv4MappedAddress = function() {
|
||||
return this.range() === 'ipv4Mapped';
|
||||
};
|
||||
|
||||
IPv6.prototype.toIPv4Address = function() {
|
||||
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];
|
||||
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')
|
||||
};
|
||||
|
||||
expandIPv6 = function(string, parts) {
|
||||
var colonCount, lastColon, part, replacement, replacementCount, zoneId;
|
||||
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) {
|
||||
colonCount++;
|
||||
}
|
||||
if (string.substr(0, 2) === '::') {
|
||||
colonCount--;
|
||||
}
|
||||
if (string.substr(-2, 2) === '::') {
|
||||
colonCount--;
|
||||
}
|
||||
if (colonCount > parts) {
|
||||
return null;
|
||||
}
|
||||
replacementCount = parts - colonCount;
|
||||
replacement = ':';
|
||||
while (replacementCount--) {
|
||||
replacement += '0:';
|
||||
}
|
||||
string = string.replace('::', replacement);
|
||||
if (string[0] === ':') {
|
||||
string = string.slice(1);
|
||||
}
|
||||
if (string[string.length - 1] === ':') {
|
||||
string = string.slice(0, -1);
|
||||
}
|
||||
parts = (function() {
|
||||
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 results;
|
||||
})();
|
||||
return {
|
||||
parts: parts,
|
||||
zoneId: zoneId
|
||||
};
|
||||
};
|
||||
|
||||
ipaddr.IPv6.parser = function(string) {
|
||||
var addr, k, len, match, octet, octets, zoneId;
|
||||
if (ipv6Regexes['native'].test(string)) {
|
||||
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
|
||||
};
|
||||
}
|
||||
}
|
||||
return null;
|
||||
};
|
||||
|
||||
ipaddr.IPv4.isIPv4 = ipaddr.IPv6.isIPv6 = function(string) {
|
||||
return this.parser(string) !== null;
|
||||
};
|
||||
|
||||
ipaddr.IPv4.isValid = function(string) {
|
||||
var e;
|
||||
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 {
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
ipaddr.IPv6.isValid = function(string) {
|
||||
var addr, e;
|
||||
if (typeof string === "string" && string.indexOf(":") === -1) {
|
||||
return false;
|
||||
}
|
||||
try {
|
||||
addr = this.parser(string);
|
||||
new this(addr.parts, addr.zoneId);
|
||||
return true;
|
||||
} catch (error1) {
|
||||
e = error1;
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
ipaddr.IPv4.parse = function(string) {
|
||||
var parts;
|
||||
parts = this.parser(string);
|
||||
if (parts === null) {
|
||||
throw new Error("ipaddr: string is not formatted like ip address");
|
||||
}
|
||||
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;
|
||||
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;
|
||||
}
|
||||
}
|
||||
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;
|
||||
if (match = string.match(/^(.+)\/(\d+)$/)) {
|
||||
maskLength = parseInt(match[2]);
|
||||
if (maskLength >= 0 && maskLength <= 128) {
|
||||
parsed = [this.parse(match[1]), maskLength];
|
||||
Object.defineProperty(parsed, 'toString', {
|
||||
value: function() {
|
||||
return this.join('/');
|
||||
}
|
||||
});
|
||||
return parsed;
|
||||
}
|
||||
}
|
||||
throw new Error("ipaddr: string is not formatted like an IPv6 CIDR range");
|
||||
};
|
||||
|
||||
ipaddr.isValid = function(string) {
|
||||
return ipaddr.IPv6.isValid(string) || ipaddr.IPv4.isValid(string);
|
||||
};
|
||||
|
||||
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");
|
||||
}
|
||||
};
|
||||
|
||||
ipaddr.parseCIDR = function(string) {
|
||||
var e;
|
||||
try {
|
||||
return ipaddr.IPv6.parseCIDR(string);
|
||||
} catch (error1) {
|
||||
e = error1;
|
||||
try {
|
||||
return ipaddr.IPv4.parseCIDR(string);
|
||||
} catch (error1) {
|
||||
e = error1;
|
||||
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);
|
||||
if (addr.kind() === 'ipv6' && addr.isIPv4MappedAddress()) {
|
||||
return addr.toIPv4Address();
|
||||
} else {
|
||||
return addr;
|
||||
}
|
||||
};
|
||||
|
||||
}).call(this);
|
||||
68
website/node_modules/ipaddr.js/lib/ipaddr.js.d.ts
generated
vendored
Normal file
68
website/node_modules/ipaddr.js/lib/ipaddr.js.d.ts
generated
vendored
Normal file
@@ -0,0 +1,68 @@
|
||||
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;
|
||||
}
|
||||
35
website/node_modules/ipaddr.js/package.json
generated
vendored
Normal file
35
website/node_modules/ipaddr.js/package.json
generated
vendored
Normal file
@@ -0,0 +1,35 @@
|
||||
{
|
||||
"name": "ipaddr.js",
|
||||
"description": "A library for manipulating IPv4 and IPv6 addresses in JavaScript.",
|
||||
"version": "1.9.1",
|
||||
"author": "whitequark <whitequark@whitequark.org>",
|
||||
"directories": {
|
||||
"lib": "./lib"
|
||||
},
|
||||
"dependencies": {},
|
||||
"devDependencies": {
|
||||
"coffee-script": "~1.12.6",
|
||||
"nodeunit": "^0.11.3",
|
||||
"uglify-js": "~3.0.19"
|
||||
},
|
||||
"scripts": {
|
||||
"test": "cake build test"
|
||||
},
|
||||
"files": [
|
||||
"lib/",
|
||||
"LICENSE",
|
||||
"ipaddr.min.js"
|
||||
],
|
||||
"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"
|
||||
}
|
||||
Reference in New Issue
Block a user