Intial Commit

nodered/rootfs/data/node_modules/ip-address/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2011 by Beau Gunderson
+
+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.

nodered/rootfs/data/node_modules/ip-address/README.md

@@ -0,0 +1,96 @@
+[![travis]](http://travis-ci.org/beaugunderson/ip-address)
+[![codecov]](https://codecov.io/github/beaugunderson/ip-address?branch=master)
+[![downloads]](https://www.npmjs.com/package/ip-address)
+[![npm]](https://www.npmjs.com/package/ip-address)
+[![greenkeeper]](https://greenkeeper.io/)
+
+[codecov]: https://codecov.io/github/beaugunderson/ip-address/coverage.svg?branch=master
+[downloads]: https://img.shields.io/npm/dm/ip-address.svg
+[greenkeeper]: https://badges.greenkeeper.io/beaugunderson/ip-address.svg
+[npm]: https://img.shields.io/npm/v/ip-address.svg
+[travis]: https://img.shields.io/travis/beaugunderson/ip-address.svg
+
+## ip-address
+
+`ip-address` is a library for validating and manipulating IPv4 and IPv6
+addresses in JavaScript.
+
+### Documentation
+
+Documentation is available at [ip-address.js.org](http://ip-address.js.org/).
+
+### Examples
+
+```js
+var Address6 = require('ip-address').Address6;
+
+var address = new Address6('2001:0:ce49:7601:e866:efff:62c3:fffe');
+
+address.isValid(); // true
+
+var teredo = address.inspectTeredo();
+
+teredo.client4;    // '157.60.0.1'
+```
+
+### Features
+
+- Parsing of all IPv6 notations
+- Parsing of IPv6 addresses and ports from URLs with `Address6.fromURL(url)`
+- Validity checking
+- Decoding of the [Teredo
+  information](http://en.wikipedia.org/wiki/Teredo_tunneling#IPv6_addressing)
+  in an address
+- Whether one address is a valid subnet of another
+- What special properties a given address has (multicast prefix, unique
+  local address prefix, etc.)
+- Number of subnets of a certain size in a given address
+- Display methods
+  - Hex, binary, and decimal
+  - Canonical form
+  - Correct form
+  - IPv4-compatible (i.e. `::ffff:192.168.0.1`)
+- Works in [node](http://nodejs.org/) and the browser (with browserify)
+- ~1,600 test cases
+
+### Used by
+
+- [anon](https://github.com/edsu/anon) which powers
+  [@congressedits](https://twitter.com/congressedits), among
+  [many others](https://github.com/edsu/anon#community)
+- [base85](https://github.com/noseglid/base85): base85 encoding/decoding
+- [contrail-web-core](https://github.com/Juniper/contrail-web-core): part of
+  Contrail, a network virtualization solution made by Juniper Networks
+- [dhcpjs](https://github.com/apaprocki/node-dhcpjs): a DHCP client and server
+- [epochtalk](https://github.com/epochtalk/epochtalk): next generation forum
+  software
+- [geoip-web](https://github.com/tfrce/node-geoip-web): a server for
+  quickly geolocating IP addresses
+- [hexabus](https://github.com/mysmartgrid/hexabus): an IPv6-based home
+  automation bus
+- [hubot-deploy](https://github.com/atmos/hubot-deploy): GitHub Flow via hubot
+- [heroku-portscanner](https://github.com/robison/heroku-portscanner): nmap
+  hosted on Heroku
+- [ipfs-swarm](https://github.com/diasdavid/node-ipfs-swarm): a swarm
+  implementation based on IPFS
+- [javascript-x-server](https://github.com/GothAck/javascript-x-server): an X
+  server written in JavaScript
+- [libnmap](https://github.com/jas-/node-libnmap): a node API for nmap
+- [mail-io](https://github.com/mofux/mail-io): a lightweight SMTP server
+- [maxmind-db-reader](https://github.com/PaddeK/node-maxmind-db): a library for
+  reading MaxMind database files
+- [proxy-protocol-v2](https://github.com/ably/proxy-protocol-v2): a proxy
+  protocol encoder/decoder built by [Ably](https://www.ably.io/)
+- [Samsara](https://github.com/mariusGundersen/Samsara): a Docker web interface
+- [sis-api](https://github.com/sis-cmdb/sis-api): a configuration management
+  database API
+- [socks5-client](https://github.com/mattcg/socks5-client): a SOCKS v5 client
+- [socksified](https://github.com/vially/node-socksified): a SOCKS v5 client
+- [socksv5](https://github.com/mscdex/socksv5): a SOCKS v5 server/client
+- [ssdapi](https://github.com/rsolomou/ssdapi): an API created by the
+  University of Portsmouth
+- [SwitchyOmega](https://github.com/FelisCatus/SwitchyOmega): a [Chrome
+  extension](https://chrome.google.com/webstore/detail/padekgcemlokbadohgkifijomclgjgif)
+  for switching between multiple proxies with ~311k users!
+- [swiz](https://github.com/racker/node-swiz): a serialization framework built
+  and used by [Rackspace](http://www.rackspace.com/)

nodered/rootfs/data/node_modules/ip-address/ip-address.js

@@ -0,0 +1,8 @@
+'use strict';
+
+exports.Address4 = require('./lib/ipv4.js');
+exports.Address6 = require('./lib/ipv6.js');
+
+exports.v6 = {
+  helpers: require('./lib/v6/helpers.js')
+};

nodered/rootfs/data/node_modules/ip-address/lib/common.js

@@ -0,0 +1,39 @@
+'use strict';
+
+// A wrapper function that returns false if the address is not valid; used to
+// avoid boilerplate checks for `if (!this.valid) { return false; }`
+var falseIfInvalid = exports.falseIfInvalid = function (fn) {
+  return function () {
+    if (!this.valid) {
+      return false;
+    }
+
+    return fn.apply(this, arguments);
+  };
+};
+
+exports.isInSubnet = falseIfInvalid(function (address) {
+  if (this.subnetMask < address.subnetMask) {
+    return false;
+  }
+
+  if (this.mask(address.subnetMask) === address.mask()) {
+    return true;
+  }
+
+  return false;
+});
+
+exports.isCorrect = function (defaultBits) {
+  return falseIfInvalid(function () {
+    if (this.addressMinusSuffix !== this.correctForm()) {
+      return false;
+    }
+
+    if (this.subnetMask === defaultBits && !this.parsedSubnet) {
+      return true;
+    }
+
+    return this.parsedSubnet === String(this.subnetMask);
+  });
+};

nodered/rootfs/data/node_modules/ip-address/lib/ipv4.js

@@ -0,0 +1,319 @@
+'use strict';
+
+var BigInteger = require('jsbn').BigInteger;
+var common = require('./common.js');
+var sprintf = require('sprintf-js').sprintf;
+var _ = require('lodash');
+
+var constants = require('./v4/constants.js');
+
+/**
+ * Represents an IPv4 address
+ * @class Address4
+ * @param {string} address - An IPv4 address string
+ */
+function Address4(address) {
+  this.valid = false;
+  this.address = address;
+  this.groups = constants.GROUPS;
+
+  this.v4 = true;
+
+  this.subnet = '/32';
+  this.subnetMask = 32;
+
+  var subnet = constants.RE_SUBNET_STRING.exec(address);
+
+  if (subnet) {
+    this.parsedSubnet = subnet[0].replace('/', '');
+    this.subnetMask = parseInt(this.parsedSubnet, 10);
+    this.subnet = '/' + this.subnetMask;
+
+    if (this.subnetMask < 0 || this.subnetMask > constants.BITS) {
+      this.valid = false;
+      this.error = 'Invalid subnet mask.';
+
+      return;
+    }
+
+    address = address.replace(constants.RE_SUBNET_STRING, '');
+  }
+
+  this.addressMinusSuffix = address;
+
+  this.parsedAddress = this.parse(address);
+}
+
+/*
+ * Parses a v4 address
+ */
+Address4.prototype.parse = function (address) {
+  var groups = address.split('.');
+
+  if (address.match(constants.RE_ADDRESS)) {
+    this.valid = true;
+  } else {
+    this.error = 'Invalid IPv4 address.';
+  }
+
+  return groups;
+};
+
+/**
+ * Return true if the address is valid
+ * @memberof Address4
+ * @instance
+ * @returns {Boolean}
+ */
+Address4.prototype.isValid = function () {
+  return this.valid;
+};
+
+/**
+ * Returns the correct form of an address
+ * @memberof Address4
+ * @instance
+ * @returns {String}
+ */
+Address4.prototype.correctForm = function () {
+  return this.parsedAddress.map(function (part) {
+    return parseInt(part, 10);
+  }).join('.');
+};
+
+/**
+ * Returns true if the address is correct, false otherwise
+ * @memberof Address4
+ * @instance
+ * @returns {Boolean}
+ */
+Address4.prototype.isCorrect = common.isCorrect(constants.BITS);
+
+/**
+ * Converts a hex string to an IPv4 address object
+ * @memberof Address4
+ * @static
+ * @param {string} hex - a hex string to convert
+ * @returns {Address4}
+ */
+Address4.fromHex = function (hex) {
+  var padded = _.padStart(hex.replace(/:/g, ''), 8, '0');
+  var groups = [];
+  var i;
+
+  for (i = 0; i < 8; i += 2) {
+    var h = padded.slice(i, i + 2);
+
+    groups.push(parseInt(h, 16));
+  }
+
+  return new Address4(groups.join('.'));
+};
+
+/**
+ * Converts an integer into a IPv4 address object
+ * @memberof Address4
+ * @static
+ * @param {integer} integer - a number to convert
+ * @returns {Address4}
+ */
+Address4.fromInteger = function (integer) {
+  return Address4.fromHex(integer.toString(16));
+};
+
+/**
+ * Converts an IPv4 address object to a hex string
+ * @memberof Address4
+ * @instance
+ * @returns {String}
+ */
+Address4.prototype.toHex = function () {
+  return this.parsedAddress.map(function (part) {
+    return sprintf('%02x', parseInt(part, 10));
+  }).join(':');
+};
+
+/**
+ * Converts an IPv4 address object to an array of bytes
+ * @memberof Address4
+ * @instance
+ * @returns {Array}
+ */
+Address4.prototype.toArray = function () {
+  return this.parsedAddress.map(function (part) {
+    return parseInt(part, 10);
+  });
+};
+
+/**
+ * Converts an IPv4 address object to an IPv6 address group
+ * @memberof Address4
+ * @instance
+ * @returns {String}
+ */
+Address4.prototype.toGroup6 = function () {
+  var output = [];
+  var i;
+
+  for (i = 0; i < constants.GROUPS; i += 2) {
+    var hex = sprintf('%02x%02x',
+      parseInt(this.parsedAddress[i], 10),
+      parseInt(this.parsedAddress[i + 1], 10));
+
+    output.push(sprintf('%x', parseInt(hex, 16)));
+  }
+
+  return output.join(':');
+};
+
+/**
+ * Returns the address as a BigInteger
+ * @memberof Address4
+ * @instance
+ * @returns {BigInteger}
+ */
+Address4.prototype.bigInteger = function () {
+  if (!this.valid) {
+    return null;
+  }
+
+  return new BigInteger(this.parsedAddress.map(function (n) {
+    return sprintf('%02x', parseInt(n, 10));
+  }).join(''), 16);
+};
+
+/**
+ * Helper function getting start address.
+ * @memberof Address4
+ * @instance
+ * @returns {BigInteger}
+ */
+Address4.prototype._startAddress = function () {
+  return new BigInteger(
+    this.mask() + _.repeat('0', constants.BITS - this.subnetMask), 2
+  );
+};
+
+/**
+ * The first address in the range given by this address' subnet.
+ * Often referred to as the Network Address.
+ * @memberof Address4
+ * @instance
+ * @returns {Address4}
+ */
+Address4.prototype.startAddress = function () {
+  return Address4.fromBigInteger(this._startAddress());
+};
+
+/**
+ * The first host address in the range given by this address's subnet ie
+ * the first address after the Network Address
+ * @memberof Address4
+ * @instance
+ * @returns {Address4}
+ */
+Address4.prototype.startAddressExclusive = function () {
+  var adjust = new BigInteger('1');
+  return Address4.fromBigInteger(this._startAddress().add(adjust));
+};
+
+/**
+ * Helper function getting end address.
+ * @memberof Address4
+ * @instance
+ * @returns {BigInteger}
+ */
+Address4.prototype._endAddress = function () {
+  return new BigInteger(
+    this.mask() + _.repeat('1', constants.BITS - this.subnetMask), 2
+  );
+};
+
+/**
+ * The last address in the range given by this address' subnet
+ * Often referred to as the Broadcast
+ * @memberof Address4
+ * @instance
+ * @returns {Address4}
+ */
+Address4.prototype.endAddress = function () {
+  return Address4.fromBigInteger(this._endAddress());
+};
+
+/**
+ * The last host address in the range given by this address's subnet ie
+ * the last address prior to the Broadcast Address
+ * @memberof Address4
+ * @instance
+ * @returns {Address4}
+ */
+Address4.prototype.endAddressExclusive = function () {
+  var adjust = new BigInteger('1');
+  return Address4.fromBigInteger(this._endAddress().subtract(adjust));
+};
+
+/**
+ * Converts a BigInteger to a v4 address object
+ * @memberof Address4
+ * @static
+ * @param {BigInteger} bigInteger - a BigInteger to convert
+ * @returns {Address4}
+ */
+Address4.fromBigInteger = function (bigInteger) {
+  return Address4.fromInteger(parseInt(bigInteger.toString(), 10));
+};
+
+/**
+ * Returns the first n bits of the address, defaulting to the
+ * subnet mask
+ * @memberof Address4
+ * @instance
+ * @returns {String}
+ */
+Address4.prototype.mask = function (optionalMask) {
+  if (optionalMask === undefined) {
+    optionalMask = this.subnetMask;
+  }
+
+  return this.getBitsBase2(0, optionalMask);
+};
+
+/**
+ * Returns the bits in the given range as a base-2 string
+ * @memberof Address4
+ * @instance
+ * @returns {string}
+ */
+Address4.prototype.getBitsBase2 = function (start, end) {
+  return this.binaryZeroPad().slice(start, end);
+};
+
+/**
+ * Returns true if the given address is in the subnet of the current address
+ * @memberof Address4
+ * @instance
+ * @returns {boolean}
+ */
+Address4.prototype.isInSubnet = common.isInSubnet;
+
+/**
+ * Returns true if the given address is a multicast address
+ * @memberof Address4
+ * @instance
+ * @returns {boolean}
+ */
+Address4.prototype.isMulticast = function () {
+  return this.isInSubnet(new Address4('224.0.0.0/4'));
+};
+
+/**
+ * Returns a zero-padded base-2 string representation of the address
+ * @memberof Address4
+ * @instance
+ * @returns {string}
+ */
+Address4.prototype.binaryZeroPad = function () {
+  return _.padStart(this.bigInteger().toString(2), constants.BITS, '0');
+};
+
+module.exports = Address4;

nodered/rootfs/data/node_modules/ip-address/lib/ipv6.js

@@ -0,0 +1,966 @@
+'use strict';
+
+var BigInteger = require('jsbn').BigInteger;
+var sprintf = require('sprintf-js').sprintf;
+var _ = require('lodash');
+
+var constants4 = require('./v4/constants.js');
+var constants6 = require('./v6/constants.js');
+
+var Address4 = require('./ipv4.js');
+
+function addCommas(number) {
+  var r = /(\d+)(\d{3})/;
+
+  while (r.test(number)) {
+    number = number.replace(r, '$1,$2');
+  }
+
+  return number;
+}
+
+function spanLeadingZeroes4(n) {
+  n = n.replace(/^(0{1,})([1-9]+)$/, '<span class="parse-error">$1</span>$2');
+  n = n.replace(/^(0{1,})(0)$/, '<span class="parse-error">$1</span>$2');
+
+  return n;
+}
+
+/**
+ * Represents an IPv6 address
+ * @class Address6
+ * @param {string} address - An IPv6 address string
+ * @param {number} [groups=8] - How many octets to parse
+ * @example
+ * var address = new Address6('2001::/32');
+ */
+function Address6(address, optionalGroups) {
+  if (optionalGroups === undefined) {
+    this.groups = constants6.GROUPS;
+  } else {
+    this.groups = optionalGroups;
+  }
+
+  this.v4 = false;
+
+  this.subnet = '/128';
+  this.subnetMask = 128;
+
+  this.zone = '';
+
+  this.address = address;
+
+  var subnet = constants6.RE_SUBNET_STRING.exec(address);
+
+  if (subnet) {
+    this.parsedSubnet = subnet[0].replace('/', '');
+    this.subnetMask = parseInt(this.parsedSubnet, 10);
+    this.subnet = '/' + this.subnetMask;
+
+    if (isNaN(this.subnetMask) ||
+      this.subnetMask < 0 ||
+      this.subnetMask > constants6.BITS) {
+      this.valid = false;
+      this.error = 'Invalid subnet mask.';
+
+      return;
+    }
+
+    address = address.replace(constants6.RE_SUBNET_STRING, '');
+  } else if (/\//.test(address)) {
+    this.valid = false;
+    this.error = 'Invalid subnet mask.';
+
+    return;
+  }
+
+  var zone = constants6.RE_ZONE_STRING.exec(address);
+
+  if (zone) {
+    this.zone = zone[0];
+
+    address = address.replace(constants6.RE_ZONE_STRING, '');
+  }
+
+  this.addressMinusSuffix = address;
+
+  this.parsedAddress = this.parse(this.addressMinusSuffix);
+}
+
+_.merge(Address6.prototype, require('./v6/attributes.js'));
+_.merge(Address6.prototype, require('./v6/html.js'));
+_.merge(Address6.prototype, require('./v6/regular-expressions.js'));
+
+/**
+ * Convert a BigInteger to a v6 address object
+ * @memberof Address6
+ * @static
+ * @param {BigInteger} bigInteger - a BigInteger to convert
+ * @returns {Address6}
+ * @example
+ * var bigInteger = new BigInteger('1000000000000');
+ * var address = Address6.fromBigInteger(bigInteger);
+ * address.correctForm(); // '::e8:d4a5:1000'
+ */
+Address6.fromBigInteger = function (bigInteger) {
+  var hex = _.padStart(bigInteger.toString(16), 32, '0');
+  var groups = [];
+  var i;
+
+  for (i = 0; i < constants6.GROUPS; i++) {
+    groups.push(hex.slice(i * 4, (i + 1) * 4));
+  }
+
+  return new Address6(groups.join(':'));
+};
+
+/**
+ * Convert a URL (with optional port number) to an address object
+ * @memberof Address6
+ * @static
+ * @param {string} url - a URL with optional port number
+ * @returns {Address6}
+ * @example
+ * var addressAndPort = Address6.fromURL('http://[ffff::]:8080/foo/');
+ * addressAndPort.address.correctForm(); // 'ffff::'
+ * addressAndPort.port; // 8080
+ */
+Address6.fromURL = function (url) {
+  var host;
+  var port;
+  var result;
+
+  // If we have brackets parse them and find a port
+  if (url.indexOf('[') !== -1 && url.indexOf(']:') !== -1) {
+    result = constants6.RE_URL_WITH_PORT.exec(url);
+
+    if (result === null) {
+      return {
+        error: 'failed to parse address with port',
+        address: null,
+        port: null
+      };
+    }
+
+    host = result[1];
+    port = result[2];
+  // If there's a URL extract the address
+  } else if (url.indexOf('/') !== -1) {
+    // Remove the protocol prefix
+    url = url.replace(/^[a-z0-9]+:\/\//, '');
+
+    // Parse the address
+    result = constants6.RE_URL.exec(url);
+
+    if (result === null) {
+      return {
+        error: 'failed to parse address from URL',
+        address: null,
+        port: null
+      };
+    }
+
+    host = result[1];
+  // Otherwise just assign the URL to the host and let the library parse it
+  } else {
+    host = url;
+  }
+
+  // If there's a port convert it to an integer
+  if (port) {
+    port = parseInt(port, 10);
+
+    //squelch out of range ports
+    if (port < 0 || port > 65536) {
+      port = null;
+    }
+  } else {
+    // Standardize `undefined` to `null`
+    port = null;
+  }
+
+  return {
+    address: new Address6(host),
+    port: port
+  };
+};
+
+/**
+ * Create an IPv6-mapped address given an IPv4 address
+ * @memberof Address6
+ * @static
+ * @param {string} address - An IPv4 address string
+ * @returns {Address6}
+ * @example
+ * var address = Address6.fromAddress4('192.168.0.1');
+ * address.correctForm(); // '::ffff:c0a8:1'
+ * address.to4in6(); // '::ffff:192.168.0.1'
+ */
+Address6.fromAddress4 = function (address4) {
+  var address4 = new Address4(address4);
+
+  var mask6 = constants6.BITS - (constants4.BITS - address4.subnetMask);
+
+  return new Address6('::ffff:' + address4.correctForm() + '/' + mask6);
+};
+
+/**
+ * Return an address from ip6.arpa form
+ * @memberof Address6
+ * @static
+ * @param {string} arpaFormAddress - an 'ip6.arpa' form address 
+ * @returns {Adress6}
+ * @example
+ * var address = Address6.fromArpa(e.f.f.f.3.c.2.6.f.f.f.e.6.6.8.e.1.0.6.7.9.4.e.c.0.0.0.0.1.0.0.2.ip6.arpa.)
+ * address.correctForm(); // '2001:0:ce49:7601:e866:efff:62c3:fffe'
+ */
+Address6.fromArpa = function (arpaFormAddress) {
+  //remove ending ".ip6.arpa." or just "."
+  var address = arpaFormAddress.replace(/(\.ip6\.arpa)?\.$/, '');
+  var semicolonAmount = 7;
+
+  //correct ip6.arpa form with ending removed will be 63 characters
+  if (address.length !== 63) {
+    address = {
+      error: "Not Valid 'ip6.arpa' form",
+      address: null
+    };
+    return address;
+  }
+
+  address = address.split('.').reverse();
+
+  for (var i = semicolonAmount; i > 0; i--) {
+    var insertIndex = i * 4;
+    address.splice(insertIndex, 0, ':');
+  }
+
+  address = address.join('');
+  return new Address6(address);
+};
+
+/*
+ * A helper function to compact an array
+ */
+function compact (address, slice) {
+  var s1 = [];
+  var s2 = [];
+  var i;
+
+  for (i = 0; i < address.length; i++) {
+    if (i < slice[0]) {
+      s1.push(address[i]);
+    } else if (i > slice[1]) {
+      s2.push(address[i]);
+    }
+  }
+
+  return s1.concat(['compact']).concat(s2);
+}
+
+/**
+ * Return the Microsoft UNC transcription of the address
+ * @memberof Address6
+ * @instance
+ * @returns {String} the Microsoft UNC transcription of the address
+ */
+Address6.prototype.microsoftTranscription = function () {
+  return sprintf('%s.ipv6-literal.net',
+    this.correctForm().replace(/:/g, '-'));
+};
+
+/**
+ * Return the first n bits of the address, defaulting to the subnet mask
+ * @memberof Address6
+ * @instance
+ * @param {number} [mask=subnet] - the number of bits to mask
+ * @returns {String} the first n bits of the address as a string
+ */
+Address6.prototype.mask = function (optionalMask) {
+  if (optionalMask === undefined) {
+    optionalMask = this.subnetMask;
+  }
+
+  return this.getBitsBase2(0, optionalMask);
+};
+
+/**
+ * Return the number of possible subnets of a given size in the address
+ * @memberof Address6
+ * @instance
+ * @param {number} [size=128] - the subnet size
+ * @returns {String}
+ */
+// TODO: probably useful to have a numeric version of this too
+Address6.prototype.possibleSubnets = function (optionalSubnetSize) {
+  if (optionalSubnetSize === undefined) {
+    optionalSubnetSize = 128;
+  }
+
+  var availableBits = constants6.BITS - this.subnetMask;
+  var subnetBits = Math.abs(optionalSubnetSize - constants6.BITS);
+  var subnetPowers = availableBits - subnetBits;
+
+  if (subnetPowers < 0) {
+    return '0';
+  }
+
+  return addCommas(new BigInteger('2', 10).pow(subnetPowers).toString(10));
+};
+
+/**
+ * Helper function getting start address.
+ * @memberof Address6
+ * @instance
+ * @returns {BigInteger}
+ */
+Address6.prototype._startAddress = function () {
+  return new BigInteger(
+    this.mask() + _.repeat('0', constants6.BITS - this.subnetMask), 2
+  );
+};
+
+/**
+ * The first address in the range given by this address' subnet
+ * Often referred to as the Network Address.
+ * @memberof Address6
+ * @instance
+ * @returns {Address6}
+ */
+Address6.prototype.startAddress = function () {
+  return Address6.fromBigInteger(this._startAddress());
+};
+
+/**
+ * The first host address in the range given by this address's subnet ie
+ * the first address after the Network Address
+ * @memberof Address6
+ * @instance
+ * @returns {Address6}
+ */
+Address6.prototype.startAddressExclusive = function () {
+  var adjust = new BigInteger('1');
+  return Address6.fromBigInteger(this._startAddress().add(adjust));
+};
+
+/**
+ * Helper function getting end address.
+ * @memberof Address6
+ * @instance
+ * @returns {BigInteger}
+ */
+Address6.prototype._endAddress = function () {
+  return new BigInteger(
+    this.mask() + _.repeat('1', constants6.BITS - this.subnetMask), 2
+  );
+};
+
+/**
+ * The last address in the range given by this address' subnet
+ * Often referred to as the Broadcast
+ * @memberof Address6
+ * @instance
+ * @returns {Address6}
+ */
+Address6.prototype.endAddress = function () {
+  return Address6.fromBigInteger(this._endAddress());
+};
+
+/**
+ * The last host address in the range given by this address's subnet ie
+ * the last address prior to the Broadcast Address
+ * @memberof Address6
+ * @instance
+ * @returns {Address6}
+ */
+Address6.prototype.endAddressExclusive = function () {
+  var adjust = new BigInteger('1');
+  return Address6.fromBigInteger(this._endAddress().subtract(adjust));
+};
+
+/**
+ * Return the scope of the address
+ * @memberof Address6
+ * @instance
+ * @returns {String}
+ */
+Address6.prototype.getScope = function () {
+  var scope = constants6.SCOPES[this.getBits(12, 16)];
+
+  if (this.getType() === 'Global unicast' &&
+      scope !== 'Link local') {
+    scope = 'Global';
+  }
+
+  return scope;
+};
+
+/**
+ * Return the type of the address
+ * @memberof Address6
+ * @instance
+ * @returns {String}
+ */
+Address6.prototype.getType = function () {
+  var self = this;
+
+  function isType(name, type) {
+    return self.isInSubnet(new Address6(type));
+  }
+
+  return _.find(constants6.TYPES, isType) || 'Global unicast';
+};
+
+/**
+ * Return the bits in the given range as a BigInteger
+ * @memberof Address6
+ * @instance
+ * @returns {BigInteger}
+ */
+Address6.prototype.getBits = function (start, end) {
+  return new BigInteger(this.getBitsBase2(start, end), 2);
+};
+
+/**
+ * Return the bits in the given range as a base-2 string
+ * @memberof Address6
+ * @instance
+ * @returns {String}
+ */
+Address6.prototype.getBitsBase2 = function (start, end) {
+  return this.binaryZeroPad().slice(start, end);
+};
+
+/**
+ * Return the bits in the given range as a base-16 string
+ * @memberof Address6
+ * @instance
+ * @returns {String}
+ */
+Address6.prototype.getBitsBase16 = function (start, end) {
+  var length = end - start;
+
+  if (length % 4 !== 0) {
+    return null;
+  }
+
+  return _.padStart(this.getBits(start, end).toString(16), length / 4, '0');
+};
+
+/**
+ * Return the bits that are set past the subnet mask length
+ * @memberof Address6
+ * @instance
+ * @returns {String}
+ */
+Address6.prototype.getBitsPastSubnet = function () {
+  return this.getBitsBase2(this.subnetMask, constants6.BITS);
+};
+
+/**
+ * Return the reversed ip6.arpa form of the address
+ * @memberof Address6
+ * @param {Object} options
+ * @param {boolean} options.omitSuffix - omit the "ip6.arpa" suffix
+ * @instance
+ * @returns {String}
+ */
+Address6.prototype.reverseForm = function (options) {
+  if (!options) {
+    options = {};
+  }
+
+  var characters = Math.floor(this.subnetMask / 4);
+
+  var reversed = this.canonicalForm()
+    .replace(/:/g, '')
+    .split('')
+    .slice(0, characters)
+    .reverse()
+    .join('.');
+
+  if (characters > 0) {
+    if (options.omitSuffix) {
+      return reversed;
+    }
+
+    return sprintf('%s.ip6.arpa.', reversed);
+  }
+
+  if (options.omitSuffix) {
+    return '';
+  }
+
+  return 'ip6.arpa.';
+};
+
+/**
+ * Return the correct form of the address
+ * @memberof Address6
+ * @instance
+ * @returns {String}
+ */
+Address6.prototype.correctForm = function () {
+  if (!this.parsedAddress) {
+    return null;
+  }
+
+  var i;
+  var groups = [];
+
+  var zeroCounter = 0;
+  var zeroes = [];
+
+  for (i = 0; i < this.parsedAddress.length; i++) {
+    var value = parseInt(this.parsedAddress[i], 16);
+
+    if (value === 0) {
+      zeroCounter++;
+    }
+
+    if (value !== 0 && zeroCounter > 0) {
+      if (zeroCounter > 1) {
+        zeroes.push([i - zeroCounter, i - 1]);
+      }
+
+      zeroCounter = 0;
+    }
+  }
+
+  // Do we end with a string of zeroes?
+  if (zeroCounter > 1) {
+    zeroes.push([this.parsedAddress.length - zeroCounter,
+      this.parsedAddress.length - 1]);
+  }
+
+  var zeroLengths = zeroes.map(function (n) {
+    return (n[1] - n[0]) + 1;
+  });
+
+  if (zeroes.length > 0) {
+    var index = zeroLengths.indexOf(_.max(zeroLengths));
+
+    groups = compact(this.parsedAddress, zeroes[index]);
+  } else {
+    groups = this.parsedAddress;
+  }
+
+  for (i = 0; i < groups.length; i++) {
+    if (groups[i] !== 'compact') {
+      groups[i] = parseInt(groups[i], 16).toString(16);
+    }
+  }
+
+  var correct = groups.join(':');
+
+  correct = correct.replace(/^compact$/, '::');
+  correct = correct.replace(/^compact|compact$/, ':');
+  correct = correct.replace(/compact/, '');
+
+  return correct;
+};
+
+/**
+ * Return a zero-padded base-2 string representation of the address
+ * @memberof Address6
+ * @instance
+ * @returns {String}
+ * @example
+ * var address = new Address6('2001:4860:4001:803::1011');
+ * address.binaryZeroPad();
+ * // '0010000000000001010010000110000001000000000000010000100000000011
+ * //  0000000000000000000000000000000000000000000000000001000000010001'
+ */
+Address6.prototype.binaryZeroPad = function () {
+  return _.padStart(this.bigInteger().toString(2), constants6.BITS, '0');
+};
+
+// TODO: Improve the semantics of this helper function
+Address6.prototype.parse4in6 = function (address) {
+  var groups = address.split(':');
+  var lastGroup = groups.slice(-1)[0];
+
+  var address4 = lastGroup.match(constants4.RE_ADDRESS);
+
+  if (address4) {
+    var temp4 = new Address4(address4[0]);
+
+    for (var i = 0; i < temp4.groups; i++) {
+      if (/^0[0-9]+/.test(temp4.parsedAddress[i])) {
+        this.valid = false;
+        this.error = 'IPv4 addresses can not have leading zeroes.';
+
+        this.parseError = address.replace(constants4.RE_ADDRESS,
+          temp4.parsedAddress.map(spanLeadingZeroes4).join('.'));
+
+        return null;
+      }
+    }
+
+    this.v4 = true;
+
+    groups[groups.length - 1] = temp4.toGroup6();
+
+    address = groups.join(':');
+  }
+
+  return address;
+};
+
+// TODO: Make private?
+Address6.prototype.parse = function (address) {
+  address = this.parse4in6(address);
+
+  if (this.error) {
+    return null;
+  }
+
+  var badCharacters = address.match(constants6.RE_BAD_CHARACTERS);
+
+  if (badCharacters) {
+    this.valid = false;
+    this.error = sprintf('Bad character%s detected in address: %s',
+      badCharacters.length > 1 ? 's' : '', badCharacters.join(''));
+
+    this.parseError = address.replace(constants6.RE_BAD_CHARACTERS,
+      '<span class="parse-error">$1</span>');
+
+    return null;
+  }
+
+  var badAddress = address.match(constants6.RE_BAD_ADDRESS);
+
+  if (badAddress) {
+    this.valid = false;
+    this.error = sprintf('Address failed regex: %s', badAddress.join(''));
+
+    this.parseError = address.replace(constants6.RE_BAD_ADDRESS,
+      '<span class="parse-error">$1</span>');
+
+    return null;
+  }
+
+  var groups = [];
+
+  var halves = address.split('::');
+
+  if (halves.length === 2) {
+    var first = halves[0].split(':');
+    var last = halves[1].split(':');
+
+    if (first.length === 1 &&
+      first[0] === '') {
+      first = [];
+    }
+
+    if (last.length === 1 &&
+      last[0] === '') {
+      last = [];
+    }
+
+    var remaining = this.groups - (first.length + last.length);
+
+    if (!remaining) {
+      this.valid = false;
+      this.error = 'Error parsing groups';
+
+      return null;
+    }
+
+    this.elidedGroups = remaining;
+
+    this.elisionBegin = first.length;
+    this.elisionEnd = first.length + this.elidedGroups;
+
+    first.forEach(function (group) {
+      groups.push(group);
+    });
+
+    for (var i = 0; i < remaining; i++) {
+      groups.push(0);
+    }
+
+    last.forEach(function (group) {
+      groups.push(group);
+    });
+  } else if (halves.length === 1) {
+    groups = address.split(':');
+
+    this.elidedGroups = 0;
+  } else {
+    this.valid = false;
+    this.error = 'Too many :: groups found';
+
+    return null;
+  }
+
+  groups = groups.map(function (g) {
+    return sprintf('%x', parseInt(g, 16));
+  });
+
+  if (groups.length !== this.groups) {
+    this.valid = false;
+    this.error = 'Incorrect number of groups found';
+
+    return null;
+  }
+
+  this.valid = true;
+
+  return groups;
+};
+
+function paddedHex(octet) {
+  return sprintf('%04x', parseInt(octet, 16));
+}
+
+/**
+ * Return the canonical form of the address
+ * @memberof Address6
+ * @instance
+ * @returns {String}
+ */
+Address6.prototype.canonicalForm = function () {
+  if (!this.valid) {
+    return null;
+  }
+
+  return this.parsedAddress.map(paddedHex).join(':');
+};
+
+/**
+ * Return the decimal form of the address
+ * @memberof Address6
+ * @instance
+ * @returns {String}
+ */
+Address6.prototype.decimal = function () {
+  if (!this.valid) {
+    return null;
+  }
+
+  return this.parsedAddress.map(function (n) {
+    return sprintf('%05d', parseInt(n, 16));
+  }).join(':');
+};
+
+/**
+ * Return the address as a BigInteger
+ * @memberof Address6
+ * @instance
+ * @returns {BigInteger}
+ */
+Address6.prototype.bigInteger = function () {
+  if (!this.valid) {
+    return null;
+  }
+
+  return new BigInteger(this.parsedAddress.map(paddedHex).join(''), 16);
+};
+
+/**
+ * Return the last two groups of this address as an IPv4 address string
+ * @memberof Address6
+ * @instance
+ * @returns {String}
+ * @example
+ * var address = new Address6('2001:4860:4001::1825:bf11');
+ * address.to4(); // '24.37.191.17'
+ */
+Address6.prototype.to4 = function () {
+  var binary = this.binaryZeroPad().split('');
+
+  return Address4.fromHex(new BigInteger(binary.slice(96, 128)
+    .join(''), 2).toString(16));
+};
+
+/**
+ * Return the v4-in-v6 form of the address
+ * @memberof Address6
+ * @instance
+ * @returns {String}
+ */
+Address6.prototype.to4in6 = function () {
+  var address4 = this.to4();
+  var address6 = new Address6(this.parsedAddress.slice(0, 6).join(':'), 6);
+
+  var correct = address6.correctForm();
+
+  var infix = '';
+
+  if (!/:$/.test(correct)) {
+    infix = ':';
+  }
+
+  return address6.correctForm() + infix + address4.address;
+};
+
+/**
+ * Return an object containing the Teredo properties of the address
+ * @memberof Address6
+ * @instance
+ * @returns {Object}
+ */
+Address6.prototype.inspectTeredo = function () {
+  /*
+  - Bits 0 to 31 are set to the Teredo prefix (normally 2001:0000::/32).
+  - Bits 32 to 63 embed the primary IPv4 address of the Teredo server that
+    is used.
+  - Bits 64 to 79 can be used to define some flags. Currently only the
+    higher order bit is used; it is set to 1 if the Teredo client is
+    located behind a cone NAT, 0 otherwise. For Microsoft's Windows Vista
+    and Windows Server 2008 implementations, more bits are used. In those
+    implementations, the format for these 16 bits is "CRAAAAUG AAAAAAAA",
+    where "C" remains the "Cone" flag. The "R" bit is reserved for future
+    use. The "U" bit is for the Universal/Local flag (set to 0). The "G" bit
+    is Individual/Group flag (set to 0). The A bits are set to a 12-bit
+    randomly generated number chosen by the Teredo client to introduce
+    additional protection for the Teredo node against IPv6-based scanning
+    attacks.
+  - Bits 80 to 95 contains the obfuscated UDP port number. This is the
+    port number that is mapped by the NAT to the Teredo client with all
+    bits inverted.
+  - Bits 96 to 127 contains the obfuscated IPv4 address. This is the
+    public IPv4 address of the NAT with all bits inverted.
+  */
+  var prefix = this.getBitsBase16(0, 32);
+
+  var udpPort = this.getBits(80, 96).xor(new BigInteger('ffff', 16)).toString();
+
+  var server4 = Address4.fromHex(this.getBitsBase16(32, 64));
+  var client4 = Address4.fromHex(this.getBits(96, 128)
+    .xor(new BigInteger('ffffffff', 16)).toString(16));
+
+  var flags = this.getBits(64, 80);
+  var flagsBase2 = this.getBitsBase2(64, 80);
+
+  var coneNat = flags.testBit(15);
+  var reserved = flags.testBit(14);
+  var groupIndividual = flags.testBit(8);
+  var universalLocal = flags.testBit(9);
+  var nonce = new BigInteger(flagsBase2.slice(2, 6) +
+    flagsBase2.slice(8, 16), 2).toString(10);
+
+  return {
+    prefix: sprintf('%s:%s', prefix.slice(0, 4), prefix.slice(4, 8)),
+    server4: server4.address,
+    client4: client4.address,
+    flags: flagsBase2,
+    coneNat: coneNat,
+    microsoft: {
+      reserved: reserved,
+      universalLocal: universalLocal,
+      groupIndividual: groupIndividual,
+      nonce: nonce
+    },
+    udpPort: udpPort
+  };
+};
+
+/**
+ * Return an object containing the 6to4 properties of the address
+ * @memberof Address6
+ * @instance
+ * @returns {Object}
+ */
+Address6.prototype.inspect6to4 = function () {
+  /*
+  - Bits 0 to 15 are set to the 6to4 prefix (2002::/16).
+  - Bits 16 to 48 embed the IPv4 address of the 6to4 gateway that is used.
+  */
+
+  var prefix = this.getBitsBase16(0, 16);
+
+  var gateway = Address4.fromHex(this.getBitsBase16(16, 48));
+
+  return {
+    prefix: sprintf('%s', prefix.slice(0, 4)),
+    gateway: gateway.address
+  };
+};
+
+/**
+ * Return a v6 6to4 address from a v6 v4inv6 address
+ * @memberof Address6
+ * @instance
+ * @returns {Address6}
+ */
+Address6.prototype.to6to4 = function () {
+  if (!this.is4()) {
+    return null;
+  }
+
+  var addr6to4 = [
+    '2002',
+    this.getBitsBase16(96, 112),
+    this.getBitsBase16(112, 128),
+    '',
+    '/16'
+  ].join(':');
+
+  return new Address6(addr6to4);
+};
+
+/**
+ * Return a byte array
+ * @memberof Address6
+ * @instance
+ * @returns {Array}
+ */
+Address6.prototype.toByteArray = function () {
+  var byteArray = this.bigInteger().toByteArray();
+
+  // work around issue where `toByteArray` returns a leading 0 element
+  if (byteArray.length === 17 && byteArray[0] === 0) {
+    return byteArray.slice(1);
+  }
+
+  return byteArray;
+};
+
+function unsignByte(b) {
+  return b & 0xFF;
+}
+
+/**
+ * Return an unsigned byte array
+ * @memberof Address6
+ * @instance
+ * @returns {Array}
+ */
+Address6.prototype.toUnsignedByteArray = function () {
+  return this.toByteArray().map(unsignByte);
+};
+
+/**
+ * Convert a byte array to an Address6 object
+ * @memberof Address6
+ * @static
+ * @returns {Address6}
+ */
+Address6.fromByteArray = function (bytes) {
+  return this.fromUnsignedByteArray(bytes.map(unsignByte));
+};
+
+/**
+ * Convert an unsigned byte array to an Address6 object
+ * @memberof Address6
+ * @static
+ * @returns {Address6}
+ */
+Address6.fromUnsignedByteArray = function (bytes) {
+  var BYTE_MAX = new BigInteger('256', 10);
+  var result = new BigInteger('0', 10);
+  var multiplier = new BigInteger('1', 10);
+
+  for (var i = bytes.length - 1; i >= 0; i--) {
+    result = result.add(
+      multiplier.multiply(new BigInteger(bytes[i].toString(10), 10)));
+
+    multiplier = multiplier.multiply(BYTE_MAX);
+  }
+
+  return Address6.fromBigInteger(result);
+};
+
+module.exports = Address6;

nodered/rootfs/data/node_modules/ip-address/lib/v4/constants.js

@@ -0,0 +1,6 @@
+exports.BITS = 32;
+exports.GROUPS = 4;
+
+exports.RE_ADDRESS = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/g;
+
+exports.RE_SUBNET_STRING = /\/\d{1,2}$/;

nodered/rootfs/data/node_modules/ip-address/lib/v6/attributes.js

@@ -0,0 +1,106 @@
+'use strict';
+
+var common = require('../common.js');
+var v6 = require('./constants.js');
+
+/**
+ * Returns true if the address is valid, false otherwise
+ * @memberof Address6
+ * @instance
+ * @returns {boolean}
+ */
+exports.isValid = function () {
+  return this.valid;
+};
+
+/**
+ * Returns true if the given address is in the subnet of the current address
+ * @memberof Address6
+ * @instance
+ * @returns {boolean}
+ */
+exports.isInSubnet = common.isInSubnet;
+
+/**
+ * Returns true if the address is correct, false otherwise
+ * @memberof Address6
+ * @instance
+ * @returns {boolean}
+ */
+exports.isCorrect = common.isCorrect(v6.BITS);
+
+/**
+ * Returns true if the address is in the canonical form, false otherwise
+ * @memberof Address6
+ * @instance
+ * @returns {boolean}
+ */
+exports.isCanonical = common.falseIfInvalid(function () {
+  return this.addressMinusSuffix === this.canonicalForm();
+});
+
+/**
+ * Returns true if the address is a link local address, false otherwise
+ * @memberof Address6
+ * @instance
+ * @returns {boolean}
+ */
+exports.isLinkLocal = common.falseIfInvalid(function () {
+  // Zeroes are required, i.e. we can't check isInSubnet with 'fe80::/10'
+  if (this.getBitsBase2(0, 64) ===
+    '1111111010000000000000000000000000000000000000000000000000000000') {
+    return true;
+  }
+
+  return false;
+});
+
+/**
+ * Returns true if the address is a multicast address, false otherwise
+ * @memberof Address6
+ * @instance
+ * @returns {boolean}
+ */
+exports.isMulticast = common.falseIfInvalid(function () {
+  return this.getType() === 'Multicast';
+});
+
+/**
+ * Returns true if the address is a v4-in-v6 address, false otherwise
+ * @memberof Address6
+ * @instance
+ * @returns {boolean}
+ */
+exports.is4 = common.falseIfInvalid(function () {
+  return this.v4;
+});
+
+/**
+ * Returns true if the address is a Teredo address, false otherwise
+ * @memberof Address6
+ * @instance
+ * @returns {boolean}
+ */
+exports.isTeredo = common.falseIfInvalid(function () {
+  return this.isInSubnet(new this.constructor('2001::/32'));
+});
+
+/**
+ * Returns true if the address is a 6to4 address, false otherwise
+ * @memberof Address6
+ * @instance
+ * @returns {boolean}
+ */
+exports.is6to4 = common.falseIfInvalid(function () {
+  return this.isInSubnet(new this.constructor('2002::/16'));
+});
+
+/**
+ * Returns true if the address is a loopback address, false otherwise
+ * @memberof Address6
+ * @instance
+ * @returns {boolean}
+ */
+exports.isLoopback = common.falseIfInvalid(function () {
+  return this.getType() === 'Loopback';
+});

nodered/rootfs/data/node_modules/ip-address/lib/v6/constants.js

@@ -0,0 +1,79 @@
+exports.BITS = 128;
+exports.GROUPS = 8;
+
+/**
+ * Represents IPv6 address scopes
+ * @memberof Address6
+ * @static
+ */
+exports.SCOPES = {
+  0: 'Reserved',
+  1: 'Interface local',
+  2: 'Link local',
+  4: 'Admin local',
+  5: 'Site local',
+  8: 'Organization local',
+  14: 'Global',
+  15: 'Reserved'
+};
+
+/**
+ * Represents IPv6 address types
+ * @memberof Address6
+ * @static
+ */
+exports.TYPES = {
+  'ff01::1/128': 'Multicast (All nodes on this interface)',
+  'ff01::2/128': 'Multicast (All routers on this interface)',
+  'ff02::1/128': 'Multicast (All nodes on this link)',
+  'ff02::2/128': 'Multicast (All routers on this link)',
+  'ff05::2/128': 'Multicast (All routers in this site)',
+  'ff02::5/128': 'Multicast (OSPFv3 AllSPF routers)',
+  'ff02::6/128': 'Multicast (OSPFv3 AllDR routers)',
+  'ff02::9/128': 'Multicast (RIP routers)',
+  'ff02::a/128': 'Multicast (EIGRP routers)',
+  'ff02::d/128': 'Multicast (PIM routers)',
+  'ff02::16/128': 'Multicast (MLDv2 reports)',
+  'ff01::fb/128': 'Multicast (mDNSv6)',
+  'ff02::fb/128': 'Multicast (mDNSv6)',
+  'ff05::fb/128': 'Multicast (mDNSv6)',
+  'ff02::1:2/128': 'Multicast (All DHCP servers and relay agents on this link)',
+  'ff05::1:2/128': 'Multicast (All DHCP servers and relay agents in this site)',
+  'ff02::1:3/128': 'Multicast (All DHCP servers on this link)',
+  'ff05::1:3/128': 'Multicast (All DHCP servers in this site)',
+  '::/128': 'Unspecified',
+  '::1/128': 'Loopback',
+  'ff00::/8': 'Multicast',
+  'fe80::/10': 'Link-local unicast'
+};
+
+/**
+ * A regular expression that matches bad characters in an IPv6 address
+ * @memberof Address6
+ * @static
+ */
+exports.RE_BAD_CHARACTERS = /([^0-9a-f:\/%])/ig;
+
+/**
+ * A regular expression that matches an incorrect IPv6 address
+ * @memberof Address6
+ * @static
+ */
+exports.RE_BAD_ADDRESS = /([0-9a-f]{5,}|:{3,}|[^:]:$|^:[^:]|\/$)/ig;
+
+/**
+ * A regular expression that matches an IPv6 subnet
+ * @memberof Address6
+ * @static
+ */
+exports.RE_SUBNET_STRING = /\/\d{1,3}(?=%|$)/;
+
+/**
+ * A regular expression that matches an IPv6 zone
+ * @memberof Address6
+ * @static
+ */
+exports.RE_ZONE_STRING = /%.*$/;
+
+exports.RE_URL = new RegExp(/^\[{0,1}([0-9a-f:]+)\]{0,1}/);
+exports.RE_URL_WITH_PORT = new RegExp(/\[([0-9a-f:]+)\]:([0-9]{1,5})/);

nodered/rootfs/data/node_modules/ip-address/lib/v6/helpers.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var sprintf = require('sprintf-js').sprintf;
+
+/**
+ * @returns {String} the string with all zeroes contained in a <span>
+ */
+var spanAllZeroes = exports.spanAllZeroes = function (s) {
+  return s.replace(/(0+)/g, '<span class="zero">$1</span>');
+};
+
+/**
+ * @returns {String} the string with each character contained in a <span>
+ */
+exports.spanAll = function (s, optionalOffset) {
+  if (optionalOffset === undefined) {
+    optionalOffset = 0;
+  }
+
+  var letters = s.split('');
+
+  return letters.map(function (n, i) {
+    return sprintf('<span class="digit value-%s position-%d">%s</span>', n,
+      i + optionalOffset,
+      spanAllZeroes(n)); // XXX Use #base-2 .value-0 instead?
+  }).join('');
+};
+
+function spanLeadingZeroesSimple(group) {
+  return group.replace(/^(0+)/, '<span class="zero">$1</span>');
+}
+
+/**
+ * @returns {String} the string with leading zeroes contained in a <span>
+ */
+exports.spanLeadingZeroes = function (address) {
+  var groups = address.split(':');
+
+  return groups.map(function (g) {
+    return spanLeadingZeroesSimple(g);
+  }).join(':');
+};
+
+/**
+ * Groups an address
+ * @returns {String} a grouped address
+ */
+exports.simpleGroup = function (addressString, offset) {
+  var groups = addressString.split(':');
+
+  if (!offset) {
+    offset = 0;
+  }
+
+  return groups.map(function (g, i) {
+    if (/group-v4/.test(g)) {
+      return g;
+    }
+
+    return sprintf('<span class="hover-group group-%d">%s</span>',
+      i + offset,
+      spanLeadingZeroesSimple(g));
+  }).join(':');
+};

nodered/rootfs/data/node_modules/ip-address/lib/v6/html.js

@@ -0,0 +1,107 @@
+'use strict';
+
+var constants4 = require('../v4/constants.js');
+var helpers = require('./helpers.js');
+var sprintf = require('sprintf-js').sprintf;
+
+/**
+ * @returns {String} the address in link form with a default port of 80
+ */
+exports.href = function (optionalPort) {
+  if (optionalPort === undefined) {
+    optionalPort = '';
+  } else {
+    optionalPort = sprintf(':%s', optionalPort);
+  }
+
+  return sprintf('http://[%s]%s/', this.correctForm(), optionalPort);
+};
+
+/**
+ * @returns {String} a link suitable for conveying the address via a URL hash
+ */
+exports.link = function (options) {
+  if (!options) {
+    options = {};
+  }
+
+  if (options.className === undefined) {
+    options.className = '';
+  }
+
+  if (options.prefix === undefined) {
+    options.prefix = '/#address=';
+  }
+
+  if (options.v4 === undefined) {
+    options.v4 = false;
+  }
+
+  var formFunction = this.correctForm;
+
+  if (options.v4) {
+    formFunction = this.to4in6;
+  }
+
+  if (options.className) {
+    return sprintf('<a href="%1$s%2$s" class="%3$s">%2$s</a>',
+      options.prefix, formFunction.call(this), options.className);
+  }
+
+  return sprintf('<a href="%1$s%2$s">%2$s</a>', options.prefix,
+    formFunction.call(this));
+};
+
+/**
+ * Groups an address
+ * @returns {String}
+ */
+exports.group = function () {
+  var address4 = this.address.match(constants4.RE_ADDRESS);
+  var i;
+
+  if (address4) {
+    // The IPv4 case
+    var segments = address4[0].split('.');
+
+    this.address = this.address.replace(constants4.RE_ADDRESS,
+      sprintf('<span class="hover-group group-v4 group-6">%s</span>' +
+        '.' +
+        '<span class="hover-group group-v4 group-7">%s</span>',
+        segments.slice(0, 2).join('.'),
+        segments.slice(2, 4).join('.')));
+  }
+
+  if (this.elidedGroups === 0) {
+    // The simple case
+    return helpers.simpleGroup(this.address);
+  }
+
+  // The elided case
+  var output = [];
+
+  var halves = this.address.split('::');
+
+  if (halves[0].length) {
+    output.push(helpers.simpleGroup(halves[0]));
+  } else {
+    output.push('');
+  }
+
+  var classes = ['hover-group'];
+
+  for (i = this.elisionBegin;
+       i < this.elisionBegin + this.elidedGroups; i++) {
+    classes.push(sprintf('group-%d', i));
+  }
+
+  output.push(sprintf('<span class="%s"></span>', classes.join(' ')));
+
+  if (halves[1].length) {
+    output.push(helpers.simpleGroup(halves[1], this.elisionEnd));
+  } else {
+    output.push('');
+  }
+
+  return output.join(':');
+};

nodered/rootfs/data/node_modules/ip-address/lib/v6/regular-expressions.js

@@ -0,0 +1,152 @@
+'use strict';
+
+var sprintf = require('sprintf-js').sprintf;
+
+var v6 = require('./constants.js');
+
+function groupPossibilities(possibilities) {
+  return sprintf('(%s)', possibilities.join('|'));
+}
+
+function padGroup(group) {
+  if (group.length < 4) {
+    return sprintf('0{0,%d}%s', 4 - group.length, group);
+  }
+
+  return group;
+}
+
+function simpleRegularExpression(groups) {
+  var zeroIndexes = [];
+
+  groups.forEach(function (group, i) {
+    var groupInteger = parseInt(group, 16);
+
+    if (groupInteger === 0) {
+      zeroIndexes.push(i);
+    }
+  });
+
+  // You can technically elide a single 0, this creates the regular expressions
+  // to match that eventuality
+  var possibilities = zeroIndexes.map(function (zeroIndex) {
+    return groups.map(function (group, i) {
+      if (i === zeroIndex) {
+        var elision = (i === 0 || i === v6.GROUPS - 1) ? ':' : '';
+
+        return groupPossibilities([padGroup(group), elision]);
+      }
+
+      return padGroup(group);
+    }).join(':');
+  });
+
+  // The simplest case
+  possibilities.push(groups.map(padGroup).join(':'));
+
+  return groupPossibilities(possibilities);
+}
+
+function possibleElisions(elidedGroups, moreLeft, moreRight) {
+  var left = moreLeft ? '' : ':';
+  var right = moreRight ? '' : ':';
+
+  var possibilities = [];
+
+  // 1. elision of everything (::)
+  if (!moreLeft && !moreRight) {
+    possibilities.push('::');
+  }
+
+  // 2. complete elision of the middle
+  if (moreLeft && moreRight) {
+    possibilities.push('');
+  }
+
+  if ((moreRight && !moreLeft) || (!moreRight && moreLeft)) {
+    // 3. complete elision of one side
+    possibilities.push(':');
+  }
+
+  // 4. elision from the left side
+  possibilities.push(sprintf('%s(:0{1,4}){1,%d}', left, elidedGroups - 1));
+
+  // 5. elision from the right side
+  possibilities.push(sprintf('(0{1,4}:){1,%d}%s', elidedGroups - 1, right));
+
+  // 6. no elision
+  possibilities.push(sprintf('(0{1,4}:){%d}0{1,4}', elidedGroups - 1));
+
+  // 7. elision (including sloppy elision) from the middle
+  for (var groups = 1; groups < elidedGroups - 1; groups++) {
+    for (var position = 1; position < elidedGroups - groups; position++) {
+      possibilities.push(sprintf('(0{1,4}:){%d}:(0{1,4}:){%d}0{1,4}',
+                                 position,
+                                 elidedGroups - position - groups - 1));
+    }
+  }
+
+  return groupPossibilities(possibilities);
+}
+
+/**
+ * Generate a regular expression string that can be used to find or validate
+ * all variations of this address
+ * @memberof Address6
+ * @instance
+ * @param {string} optionalSubString
+ * @returns {string}
+ */
+exports.regularExpressionString = function (optionalSubString) {
+  if (optionalSubString === undefined) {
+    optionalSubString = false;
+  }
+
+  var output = [];
+
+  // TODO: revisit why this is necessary
+  var address6 = new this.constructor(this.correctForm());
+
+  if (address6.elidedGroups === 0) {
+    // The simple case
+    output.push(simpleRegularExpression(address6.parsedAddress));
+  } else if (address6.elidedGroups === v6.GROUPS) {
+    // A completely elided address
+    output.push(possibleElisions(v6.GROUPS));
+  } else {
+    // A partially elided address
+    var halves = address6.address.split('::');
+
+    if (halves[0].length) {
+      output.push(simpleRegularExpression(halves[0].split(':')));
+    }
+
+    output.push(possibleElisions(address6.elidedGroups,
+                         halves[0].length !== 0,
+                         halves[1].length !== 0));
+
+    if (halves[1].length) {
+      output.push(simpleRegularExpression(halves[1].split(':')));
+    }
+
+    output = [output.join(':')];
+  }
+
+  if (!optionalSubString) {
+    output = [].concat('(?=^|\\b|[^\\w\\:])(', output, ')(?=[^\\w\\:]|\\b|$)');
+  }
+
+  return output.join('');
+};
+
+/**
+ * Generate a regular expression that can be used to find or validate all
+ * variations of this address.
+ * @memberof Address6
+ * @instance
+ * @param {string} optionalSubString
+ * @returns {RegExp}
+ */
+exports.regularExpression = function (optionalSubstring) {
+  return new RegExp(this.regularExpressionString(optionalSubstring), 'i');
+};

nodered/rootfs/data/node_modules/ip-address/node_modules/jsbn/.npmignore

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

nodered/rootfs/data/node_modules/ip-address/node_modules/jsbn/CHANGELOG.md

@@ -0,0 +1,16 @@
+# v1.1.0
+
+- Allow for es6 "default import", e.g. `import BigInteger from 'jsbn'`.
+- Updated license file to read MIT
+
+
+# v1.0.0
+
+- breaking change: `require('jsbn')` no longer returns `BigInteger`. Use `require('jsbn').BigInteger` instead.
+
+
+
+# v0.1.1
+
+- fixed backwards-incompatible change in v0.1.0 where `require('jsbn') != BigInteger`. This patch version allows for `var BigInteger = require('jsbn')` or `var BigInteger = require('jsbn').BigInteger`.
+

nodered/rootfs/data/node_modules/ip-address/node_modules/jsbn/LICENSE

@@ -0,0 +1,40 @@
+Licensing
+---------
+
+This software is covered under the following copyright:
+
+/*
+ * Copyright (c) 2003-2005  Tom Wu
+ * All Rights Reserved.
+ *
+ * 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" AND WITHOUT WARRANTY OF ANY KIND, 
+ * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
+ * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
+ *
+ * IN NO EVENT SHALL TOM WU BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
+ * INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF
+ * THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT
+ * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * In addition, the following condition applies:
+ *
+ * All redistributions must retain an intact copy of this copyright notice
+ * and disclaimer.
+ */
+
+Address all questions regarding this license to:
+
+  Tom Wu
+  tjw@cs.Stanford.EDU

nodered/rootfs/data/node_modules/ip-address/node_modules/jsbn/README.md

@@ -0,0 +1,173 @@
+# jsbn: javascript big number
+
+[Tom Wu's Original Website](http://www-cs-students.stanford.edu/~tjw/jsbn/)
+
+I felt compelled to put this on github and publish to npm. I haven't tested every other big integer library out there, but the few that I have tested in comparison to this one have not even come close in performance. I am aware of the `bi` module on npm, however it has been modified and I wanted to publish the original without modifications. This is jsbn and jsbn2 from Tom Wu's original website above, with the module pattern applied to prevent global leaks and to allow for use with node.js on the server side.
+
+## usage
+
+    var BigInteger = require('jsbn').BigInteger;
+
+    var bi = new BigInteger('91823918239182398123');
+    console.log(bi.bitLength()); // 67
+
+
+## API
+
+### bi.toString()
+
+returns the base-10 number as a string
+
+### bi.negate()
+
+returns a new BigInteger equal to the negation of `bi`
+
+### bi.abs
+
+returns new BI of absolute value
+
+### bi.compareTo
+
+
+
+### bi.bitLength
+
+
+
+### bi.mod
+
+
+
+### bi.modPowInt
+
+
+
+### bi.clone
+
+
+
+### bi.intValue
+
+
+
+### bi.byteValue
+
+
+
+### bi.shortValue
+
+
+
+### bi.signum
+
+
+
+### bi.toByteArray
+
+
+
+### bi.equals
+
+
+
+### bi.min
+
+
+
+### bi.max
+
+
+
+### bi.and
+
+
+
+### bi.or
+
+
+
+### bi.xor
+
+
+
+### bi.andNot
+
+
+
+### bi.not
+
+
+
+### bi.shiftLeft
+
+
+
+### bi.shiftRight
+
+
+
+### bi.getLowestSetBit
+
+
+
+### bi.bitCount
+
+
+
+### bi.testBit
+
+
+
+### bi.setBit
+
+
+
+### bi.clearBit
+
+
+
+### bi.flipBit
+
+
+
+### bi.add
+
+
+
+### bi.subtract
+
+
+
+### bi.multiply
+
+
+
+### bi.divide
+
+
+
+### bi.remainder
+
+
+
+### bi.divideAndRemainder
+
+
+
+### bi.modPow
+
+
+
+### bi.modInverse
+
+
+
+### bi.pow
+
+
+
+### bi.gcd
+
+
+
+### bi.isProbablePrime

nodered/rootfs/data/node_modules/ip-address/node_modules/jsbn/example.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="utf-8">
+        <title></title>
+    </head>
+    <body>
+      <script src="index.js"></script>
+      <script src="example.js"></script>
+    </body>
+</html>

nodered/rootfs/data/node_modules/ip-address/node_modules/jsbn/example.js

@@ -0,0 +1,5 @@
+(function () {
+  var BigInteger = jsbn.BigInteger;
+  var a = new BigInteger('91823918239182398123');
+  console.log(a.bitLength());
+}());

nodered/rootfs/data/node_modules/ip-address/node_modules/jsbn/index.js

@@ -0,0 +1,1361 @@
+(function(){
+
+    // Copyright (c) 2005  Tom Wu
+    // All Rights Reserved.
+    // See "LICENSE" for details.
+
+    // Basic JavaScript BN library - subset useful for RSA encryption.
+
+    // Bits per digit
+    var dbits;
+
+    // JavaScript engine analysis
+    var canary = 0xdeadbeefcafe;
+    var j_lm = ((canary&0xffffff)==0xefcafe);
+
+    // (public) Constructor
+    function BigInteger(a,b,c) {
+      if(a != null)
+        if("number" == typeof a) this.fromNumber(a,b,c);
+        else if(b == null && "string" != typeof a) this.fromString(a,256);
+        else this.fromString(a,b);
+    }
+
+    // return new, unset BigInteger
+    function nbi() { return new BigInteger(null); }
+
+    // am: Compute w_j += (x*this_i), propagate carries,
+    // c is initial carry, returns final carry.
+    // c < 3*dvalue, x < 2*dvalue, this_i < dvalue
+    // We need to select the fastest one that works in this environment.
+
+    // am1: use a single mult and divide to get the high bits,
+    // max digit bits should be 26 because
+    // max internal value = 2*dvalue^2-2*dvalue (< 2^53)
+    function am1(i,x,w,j,c,n) {
+      while(--n >= 0) {
+        var v = x*this[i++]+w[j]+c;
+        c = Math.floor(v/0x4000000);
+        w[j++] = v&0x3ffffff;
+      }
+      return c;
+    }
+    // am2 avoids a big mult-and-extract completely.
+    // Max digit bits should be <= 30 because we do bitwise ops
+    // on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)
+    function am2(i,x,w,j,c,n) {
+      var xl = x&0x7fff, xh = x>>15;
+      while(--n >= 0) {
+        var l = this[i]&0x7fff;
+        var h = this[i++]>>15;
+        var m = xh*l+h*xl;
+        l = xl*l+((m&0x7fff)<<15)+w[j]+(c&0x3fffffff);
+        c = (l>>>30)+(m>>>15)+xh*h+(c>>>30);
+        w[j++] = l&0x3fffffff;
+      }
+      return c;
+    }
+    // Alternately, set max digit bits to 28 since some
+    // browsers slow down when dealing with 32-bit numbers.
+    function am3(i,x,w,j,c,n) {
+      var xl = x&0x3fff, xh = x>>14;
+      while(--n >= 0) {
+        var l = this[i]&0x3fff;
+        var h = this[i++]>>14;
+        var m = xh*l+h*xl;
+        l = xl*l+((m&0x3fff)<<14)+w[j]+c;
+        c = (l>>28)+(m>>14)+xh*h;
+        w[j++] = l&0xfffffff;
+      }
+      return c;
+    }
+    var inBrowser = typeof navigator !== "undefined";
+    if(inBrowser && j_lm && (navigator.appName == "Microsoft Internet Explorer")) {
+      BigInteger.prototype.am = am2;
+      dbits = 30;
+    }
+    else if(inBrowser && j_lm && (navigator.appName != "Netscape")) {
+      BigInteger.prototype.am = am1;
+      dbits = 26;
+    }
+    else { // Mozilla/Netscape seems to prefer am3
+      BigInteger.prototype.am = am3;
+      dbits = 28;
+    }
+
+    BigInteger.prototype.DB = dbits;
+    BigInteger.prototype.DM = ((1<<dbits)-1);
+    BigInteger.prototype.DV = (1<<dbits);
+
+    var BI_FP = 52;
+    BigInteger.prototype.FV = Math.pow(2,BI_FP);
+    BigInteger.prototype.F1 = BI_FP-dbits;
+    BigInteger.prototype.F2 = 2*dbits-BI_FP;
+
+    // Digit conversions
+    var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";
+    var BI_RC = new Array();
+    var rr,vv;
+    rr = "0".charCodeAt(0);
+    for(vv = 0; vv <= 9; ++vv) BI_RC[rr++] = vv;
+    rr = "a".charCodeAt(0);
+    for(vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;
+    rr = "A".charCodeAt(0);
+    for(vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;
+
+    function int2char(n) { return BI_RM.charAt(n); }
+    function intAt(s,i) {
+      var c = BI_RC[s.charCodeAt(i)];
+      return (c==null)?-1:c;
+    }
+
+    // (protected) copy this to r
+    function bnpCopyTo(r) {
+      for(var i = this.t-1; i >= 0; --i) r[i] = this[i];
+      r.t = this.t;
+      r.s = this.s;
+    }
+
+    // (protected) set from integer value x, -DV <= x < DV
+    function bnpFromInt(x) {
+      this.t = 1;
+      this.s = (x<0)?-1:0;
+      if(x > 0) this[0] = x;
+      else if(x < -1) this[0] = x+this.DV;
+      else this.t = 0;
+    }
+
+    // return bigint initialized to value
+    function nbv(i) { var r = nbi(); r.fromInt(i); return r; }
+
+    // (protected) set from string and radix
+    function bnpFromString(s,b) {
+      var k;
+      if(b == 16) k = 4;
+      else if(b == 8) k = 3;
+      else if(b == 256) k = 8; // byte array
+      else if(b == 2) k = 1;
+      else if(b == 32) k = 5;
+      else if(b == 4) k = 2;
+      else { this.fromRadix(s,b); return; }
+      this.t = 0;
+      this.s = 0;
+      var i = s.length, mi = false, sh = 0;
+      while(--i >= 0) {
+        var x = (k==8)?s[i]&0xff:intAt(s,i);
+        if(x < 0) {
+          if(s.charAt(i) == "-") mi = true;
+          continue;
+        }
+        mi = false;
+        if(sh == 0)
+          this[this.t++] = x;
+        else if(sh+k > this.DB) {
+          this[this.t-1] |= (x&((1<<(this.DB-sh))-1))<<sh;
+          this[this.t++] = (x>>(this.DB-sh));
+        }
+        else
+          this[this.t-1] |= x<<sh;
+        sh += k;
+        if(sh >= this.DB) sh -= this.DB;
+      }
+      if(k == 8 && (s[0]&0x80) != 0) {
+        this.s = -1;
+        if(sh > 0) this[this.t-1] |= ((1<<(this.DB-sh))-1)<<sh;
+      }
+      this.clamp();
+      if(mi) BigInteger.ZERO.subTo(this,this);
+    }
+
+    // (protected) clamp off excess high words
+    function bnpClamp() {
+      var c = this.s&this.DM;
+      while(this.t > 0 && this[this.t-1] == c) --this.t;
+    }
+
+    // (public) return string representation in given radix
+    function bnToString(b) {
+      if(this.s < 0) return "-"+this.negate().toString(b);
+      var k;
+      if(b == 16) k = 4;
+      else if(b == 8) k = 3;
+      else if(b == 2) k = 1;
+      else if(b == 32) k = 5;
+      else if(b == 4) k = 2;
+      else return this.toRadix(b);
+      var km = (1<<k)-1, d, m = false, r = "", i = this.t;
+      var p = this.DB-(i*this.DB)%k;
+      if(i-- > 0) {
+        if(p < this.DB && (d = this[i]>>p) > 0) { m = true; r = int2char(d); }
+        while(i >= 0) {
+          if(p < k) {
+            d = (this[i]&((1<<p)-1))<<(k-p);
+            d |= this[--i]>>(p+=this.DB-k);
+          }
+          else {
+            d = (this[i]>>(p-=k))&km;
+            if(p <= 0) { p += this.DB; --i; }
+          }
+          if(d > 0) m = true;
+          if(m) r += int2char(d);
+        }
+      }
+      return m?r:"0";
+    }
+
+    // (public) -this
+    function bnNegate() { var r = nbi(); BigInteger.ZERO.subTo(this,r); return r; }
+
+    // (public) |this|
+    function bnAbs() { return (this.s<0)?this.negate():this; }
+
+    // (public) return + if this > a, - if this < a, 0 if equal
+    function bnCompareTo(a) {
+      var r = this.s-a.s;
+      if(r != 0) return r;
+      var i = this.t;
+      r = i-a.t;
+      if(r != 0) return (this.s<0)?-r:r;
+      while(--i >= 0) if((r=this[i]-a[i]) != 0) return r;
+      return 0;
+    }
+
+    // returns bit length of the integer x
+    function nbits(x) {
+      var r = 1, t;
+      if((t=x>>>16) != 0) { x = t; r += 16; }
+      if((t=x>>8) != 0) { x = t; r += 8; }
+      if((t=x>>4) != 0) { x = t; r += 4; }
+      if((t=x>>2) != 0) { x = t; r += 2; }
+      if((t=x>>1) != 0) { x = t; r += 1; }
+      return r;
+    }
+
+    // (public) return the number of bits in "this"
+    function bnBitLength() {
+      if(this.t <= 0) return 0;
+      return this.DB*(this.t-1)+nbits(this[this.t-1]^(this.s&this.DM));
+    }
+
+    // (protected) r = this << n*DB
+    function bnpDLShiftTo(n,r) {
+      var i;
+      for(i = this.t-1; i >= 0; --i) r[i+n] = this[i];
+      for(i = n-1; i >= 0; --i) r[i] = 0;
+      r.t = this.t+n;
+      r.s = this.s;
+    }
+
+    // (protected) r = this >> n*DB
+    function bnpDRShiftTo(n,r) {
+      for(var i = n; i < this.t; ++i) r[i-n] = this[i];
+      r.t = Math.max(this.t-n,0);
+      r.s = this.s;
+    }
+
+    // (protected) r = this << n
+    function bnpLShiftTo(n,r) {
+      var bs = n%this.DB;
+      var cbs = this.DB-bs;
+      var bm = (1<<cbs)-1;
+      var ds = Math.floor(n/this.DB), c = (this.s<<bs)&this.DM, i;
+      for(i = this.t-1; i >= 0; --i) {
+        r[i+ds+1] = (this[i]>>cbs)|c;
+        c = (this[i]&bm)<<bs;
+      }
+      for(i = ds-1; i >= 0; --i) r[i] = 0;
+      r[ds] = c;
+      r.t = this.t+ds+1;
+      r.s = this.s;
+      r.clamp();
+    }
+
+    // (protected) r = this >> n
+    function bnpRShiftTo(n,r) {
+      r.s = this.s;
+      var ds = Math.floor(n/this.DB);
+      if(ds >= this.t) { r.t = 0; return; }
+      var bs = n%this.DB;
+      var cbs = this.DB-bs;
+      var bm = (1<<bs)-1;
+      r[0] = this[ds]>>bs;
+      for(var i = ds+1; i < this.t; ++i) {
+        r[i-ds-1] |= (this[i]&bm)<<cbs;
+        r[i-ds] = this[i]>>bs;
+      }
+      if(bs > 0) r[this.t-ds-1] |= (this.s&bm)<<cbs;
+      r.t = this.t-ds;
+      r.clamp();
+    }
+
+    // (protected) r = this - a
+    function bnpSubTo(a,r) {
+      var i = 0, c = 0, m = Math.min(a.t,this.t);
+      while(i < m) {
+        c += this[i]-a[i];
+        r[i++] = c&this.DM;
+        c >>= this.DB;
+      }
+      if(a.t < this.t) {
+        c -= a.s;
+        while(i < this.t) {
+          c += this[i];
+          r[i++] = c&this.DM;
+          c >>= this.DB;
+        }
+        c += this.s;
+      }
+      else {
+        c += this.s;
+        while(i < a.t) {
+          c -= a[i];
+          r[i++] = c&this.DM;
+          c >>= this.DB;
+        }
+        c -= a.s;
+      }
+      r.s = (c<0)?-1:0;
+      if(c < -1) r[i++] = this.DV+c;
+      else if(c > 0) r[i++] = c;
+      r.t = i;
+      r.clamp();
+    }
+
+    // (protected) r = this * a, r != this,a (HAC 14.12)
+    // "this" should be the larger one if appropriate.
+    function bnpMultiplyTo(a,r) {
+      var x = this.abs(), y = a.abs();
+      var i = x.t;
+      r.t = i+y.t;
+      while(--i >= 0) r[i] = 0;
+      for(i = 0; i < y.t; ++i) r[i+x.t] = x.am(0,y[i],r,i,0,x.t);
+      r.s = 0;
+      r.clamp();
+      if(this.s != a.s) BigInteger.ZERO.subTo(r,r);
+    }
+
+    // (protected) r = this^2, r != this (HAC 14.16)
+    function bnpSquareTo(r) {
+      var x = this.abs();
+      var i = r.t = 2*x.t;
+      while(--i >= 0) r[i] = 0;
+      for(i = 0; i < x.t-1; ++i) {
+        var c = x.am(i,x[i],r,2*i,0,1);
+        if((r[i+x.t]+=x.am(i+1,2*x[i],r,2*i+1,c,x.t-i-1)) >= x.DV) {
+          r[i+x.t] -= x.DV;
+          r[i+x.t+1] = 1;
+        }
+      }
+      if(r.t > 0) r[r.t-1] += x.am(i,x[i],r,2*i,0,1);
+      r.s = 0;
+      r.clamp();
+    }
+
+    // (protected) divide this by m, quotient and remainder to q, r (HAC 14.20)
+    // r != q, this != m.  q or r may be null.
+    function bnpDivRemTo(m,q,r) {
+      var pm = m.abs();
+      if(pm.t <= 0) return;
+      var pt = this.abs();
+      if(pt.t < pm.t) {
+        if(q != null) q.fromInt(0);
+        if(r != null) this.copyTo(r);
+        return;
+      }
+      if(r == null) r = nbi();
+      var y = nbi(), ts = this.s, ms = m.s;
+      var nsh = this.DB-nbits(pm[pm.t-1]);   // normalize modulus
+      if(nsh > 0) { pm.lShiftTo(nsh,y); pt.lShiftTo(nsh,r); }
+      else { pm.copyTo(y); pt.copyTo(r); }
+      var ys = y.t;
+      var y0 = y[ys-1];
+      if(y0 == 0) return;
+      var yt = y0*(1<<this.F1)+((ys>1)?y[ys-2]>>this.F2:0);
+      var d1 = this.FV/yt, d2 = (1<<this.F1)/yt, e = 1<<this.F2;
+      var i = r.t, j = i-ys, t = (q==null)?nbi():q;
+      y.dlShiftTo(j,t);
+      if(r.compareTo(t) >= 0) {
+        r[r.t++] = 1;
+        r.subTo(t,r);
+      }
+      BigInteger.ONE.dlShiftTo(ys,t);
+      t.subTo(y,y);  // "negative" y so we can replace sub with am later
+      while(y.t < ys) y[y.t++] = 0;
+      while(--j >= 0) {
+        // Estimate quotient digit
+        var qd = (r[--i]==y0)?this.DM:Math.floor(r[i]*d1+(r[i-1]+e)*d2);
+        if((r[i]+=y.am(0,qd,r,j,0,ys)) < qd) {   // Try it out
+          y.dlShiftTo(j,t);
+          r.subTo(t,r);
+          while(r[i] < --qd) r.subTo(t,r);
+        }
+      }
+      if(q != null) {
+        r.drShiftTo(ys,q);
+        if(ts != ms) BigInteger.ZERO.subTo(q,q);
+      }
+      r.t = ys;
+      r.clamp();
+      if(nsh > 0) r.rShiftTo(nsh,r); // Denormalize remainder
+      if(ts < 0) BigInteger.ZERO.subTo(r,r);
+    }
+
+    // (public) this mod a
+    function bnMod(a) {
+      var r = nbi();
+      this.abs().divRemTo(a,null,r);
+      if(this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) a.subTo(r,r);
+      return r;
+    }
+
+    // Modular reduction using "classic" algorithm
+    function Classic(m) { this.m = m; }
+    function cConvert(x) {
+      if(x.s < 0 || x.compareTo(this.m) >= 0) return x.mod(this.m);
+      else return x;
+    }
+    function cRevert(x) { return x; }
+    function cReduce(x) { x.divRemTo(this.m,null,x); }
+    function cMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }
+    function cSqrTo(x,r) { x.squareTo(r); this.reduce(r); }
+
+    Classic.prototype.convert = cConvert;
+    Classic.prototype.revert = cRevert;
+    Classic.prototype.reduce = cReduce;
+    Classic.prototype.mulTo = cMulTo;
+    Classic.prototype.sqrTo = cSqrTo;
+
+    // (protected) return "-1/this % 2^DB"; useful for Mont. reduction
+    // justification:
+    //         xy == 1 (mod m)
+    //         xy =  1+km
+    //   xy(2-xy) = (1+km)(1-km)
+    // x[y(2-xy)] = 1-k^2m^2
+    // x[y(2-xy)] == 1 (mod m^2)
+    // if y is 1/x mod m, then y(2-xy) is 1/x mod m^2
+    // should reduce x and y(2-xy) by m^2 at each step to keep size bounded.
+    // JS multiply "overflows" differently from C/C++, so care is needed here.
+    function bnpInvDigit() {
+      if(this.t < 1) return 0;
+      var x = this[0];
+      if((x&1) == 0) return 0;
+      var y = x&3;       // y == 1/x mod 2^2
+      y = (y*(2-(x&0xf)*y))&0xf; // y == 1/x mod 2^4
+      y = (y*(2-(x&0xff)*y))&0xff;   // y == 1/x mod 2^8
+      y = (y*(2-(((x&0xffff)*y)&0xffff)))&0xffff;    // y == 1/x mod 2^16
+      // last step - calculate inverse mod DV directly;
+      // assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints
+      y = (y*(2-x*y%this.DV))%this.DV;       // y == 1/x mod 2^dbits
+      // we really want the negative inverse, and -DV < y < DV
+      return (y>0)?this.DV-y:-y;
+    }
+
+    // Montgomery reduction
+    function Montgomery(m) {
+      this.m = m;
+      this.mp = m.invDigit();
+      this.mpl = this.mp&0x7fff;
+      this.mph = this.mp>>15;
+      this.um = (1<<(m.DB-15))-1;
+      this.mt2 = 2*m.t;
+    }
+
+    // xR mod m
+    function montConvert(x) {
+      var r = nbi();
+      x.abs().dlShiftTo(this.m.t,r);
+      r.divRemTo(this.m,null,r);
+      if(x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r,r);
+      return r;
+    }
+
+    // x/R mod m
+    function montRevert(x) {
+      var r = nbi();
+      x.copyTo(r);
+      this.reduce(r);
+      return r;
+    }
+
+    // x = x/R mod m (HAC 14.32)
+    function montReduce(x) {
+      while(x.t <= this.mt2) // pad x so am has enough room later
+        x[x.t++] = 0;
+      for(var i = 0; i < this.m.t; ++i) {
+        // faster way of calculating u0 = x[i]*mp mod DV
+        var j = x[i]&0x7fff;
+        var u0 = (j*this.mpl+(((j*this.mph+(x[i]>>15)*this.mpl)&this.um)<<15))&x.DM;
+        // use am to combine the multiply-shift-add into one call
+        j = i+this.m.t;
+        x[j] += this.m.am(0,u0,x,i,0,this.m.t);
+        // propagate carry
+        while(x[j] >= x.DV) { x[j] -= x.DV; x[++j]++; }
+      }
+      x.clamp();
+      x.drShiftTo(this.m.t,x);
+      if(x.compareTo(this.m) >= 0) x.subTo(this.m,x);
+    }
+
+    // r = "x^2/R mod m"; x != r
+    function montSqrTo(x,r) { x.squareTo(r); this.reduce(r); }
+
+    // r = "xy/R mod m"; x,y != r
+    function montMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }
+
+    Montgomery.prototype.convert = montConvert;
+    Montgomery.prototype.revert = montRevert;
+    Montgomery.prototype.reduce = montReduce;
+    Montgomery.prototype.mulTo = montMulTo;
+    Montgomery.prototype.sqrTo = montSqrTo;
+
+    // (protected) true iff this is even
+    function bnpIsEven() { return ((this.t>0)?(this[0]&1):this.s) == 0; }
+
+    // (protected) this^e, e < 2^32, doing sqr and mul with "r" (HAC 14.79)
+    function bnpExp(e,z) {
+      if(e > 0xffffffff || e < 1) return BigInteger.ONE;
+      var r = nbi(), r2 = nbi(), g = z.convert(this), i = nbits(e)-1;
+      g.copyTo(r);
+      while(--i >= 0) {
+        z.sqrTo(r,r2);
+        if((e&(1<<i)) > 0) z.mulTo(r2,g,r);
+        else { var t = r; r = r2; r2 = t; }
+      }
+      return z.revert(r);
+    }
+
+    // (public) this^e % m, 0 <= e < 2^32
+    function bnModPowInt(e,m) {
+      var z;
+      if(e < 256 || m.isEven()) z = new Classic(m); else z = new Montgomery(m);
+      return this.exp(e,z);
+    }
+
+    // protected
+    BigInteger.prototype.copyTo = bnpCopyTo;
+    BigInteger.prototype.fromInt = bnpFromInt;
+    BigInteger.prototype.fromString = bnpFromString;
+    BigInteger.prototype.clamp = bnpClamp;
+    BigInteger.prototype.dlShiftTo = bnpDLShiftTo;
+    BigInteger.prototype.drShiftTo = bnpDRShiftTo;
+    BigInteger.prototype.lShiftTo = bnpLShiftTo;
+    BigInteger.prototype.rShiftTo = bnpRShiftTo;
+    BigInteger.prototype.subTo = bnpSubTo;
+    BigInteger.prototype.multiplyTo = bnpMultiplyTo;
+    BigInteger.prototype.squareTo = bnpSquareTo;
+    BigInteger.prototype.divRemTo = bnpDivRemTo;
+    BigInteger.prototype.invDigit = bnpInvDigit;
+    BigInteger.prototype.isEven = bnpIsEven;
+    BigInteger.prototype.exp = bnpExp;
+
+    // public
+    BigInteger.prototype.toString = bnToString;
+    BigInteger.prototype.negate = bnNegate;
+    BigInteger.prototype.abs = bnAbs;
+    BigInteger.prototype.compareTo = bnCompareTo;
+    BigInteger.prototype.bitLength = bnBitLength;
+    BigInteger.prototype.mod = bnMod;
+    BigInteger.prototype.modPowInt = bnModPowInt;
+
+    // "constants"
+    BigInteger.ZERO = nbv(0);
+    BigInteger.ONE = nbv(1);
+
+    // Copyright (c) 2005-2009  Tom Wu
+    // All Rights Reserved.
+    // See "LICENSE" for details.
+
+    // Extended JavaScript BN functions, required for RSA private ops.
+
+    // Version 1.1: new BigInteger("0", 10) returns "proper" zero
+    // Version 1.2: square() API, isProbablePrime fix
+
+    // (public)
+    function bnClone() { var r = nbi(); this.copyTo(r); return r; }
+
+    // (public) return value as integer
+    function bnIntValue() {
+      if(this.s < 0) {
+        if(this.t == 1) return this[0]-this.DV;
+        else if(this.t == 0) return -1;
+      }
+      else if(this.t == 1) return this[0];
+      else if(this.t == 0) return 0;
+      // assumes 16 < DB < 32
+      return ((this[1]&((1<<(32-this.DB))-1))<<this.DB)|this[0];
+    }
+
+    // (public) return value as byte
+    function bnByteValue() { return (this.t==0)?this.s:(this[0]<<24)>>24; }
+
+    // (public) return value as short (assumes DB>=16)
+    function bnShortValue() { return (this.t==0)?this.s:(this[0]<<16)>>16; }
+
+    // (protected) return x s.t. r^x < DV
+    function bnpChunkSize(r) { return Math.floor(Math.LN2*this.DB/Math.log(r)); }
+
+    // (public) 0 if this == 0, 1 if this > 0
+    function bnSigNum() {
+      if(this.s < 0) return -1;
+      else if(this.t <= 0 || (this.t == 1 && this[0] <= 0)) return 0;
+      else return 1;
+    }
+
+    // (protected) convert to radix string
+    function bnpToRadix(b) {
+      if(b == null) b = 10;
+      if(this.signum() == 0 || b < 2 || b > 36) return "0";
+      var cs = this.chunkSize(b);
+      var a = Math.pow(b,cs);
+      var d = nbv(a), y = nbi(), z = nbi(), r = "";
+      this.divRemTo(d,y,z);
+      while(y.signum() > 0) {
+        r = (a+z.intValue()).toString(b).substr(1) + r;
+        y.divRemTo(d,y,z);
+      }
+      return z.intValue().toString(b) + r;
+    }
+
+    // (protected) convert from radix string
+    function bnpFromRadix(s,b) {
+      this.fromInt(0);
+      if(b == null) b = 10;
+      var cs = this.chunkSize(b);
+      var d = Math.pow(b,cs), mi = false, j = 0, w = 0;
+      for(var i = 0; i < s.length; ++i) {
+        var x = intAt(s,i);
+        if(x < 0) {
+          if(s.charAt(i) == "-" && this.signum() == 0) mi = true;
+          continue;
+        }
+        w = b*w+x;
+        if(++j >= cs) {
+          this.dMultiply(d);
+          this.dAddOffset(w,0);
+          j = 0;
+          w = 0;
+        }
+      }
+      if(j > 0) {
+        this.dMultiply(Math.pow(b,j));
+        this.dAddOffset(w,0);
+      }
+      if(mi) BigInteger.ZERO.subTo(this,this);
+    }
+
+    // (protected) alternate constructor
+    function bnpFromNumber(a,b,c) {
+      if("number" == typeof b) {
+        // new BigInteger(int,int,RNG)
+        if(a < 2) this.fromInt(1);
+        else {
+          this.fromNumber(a,c);
+          if(!this.testBit(a-1))    // force MSB set
+            this.bitwiseTo(BigInteger.ONE.shiftLeft(a-1),op_or,this);
+          if(this.isEven()) this.dAddOffset(1,0); // force odd
+          while(!this.isProbablePrime(b)) {
+            this.dAddOffset(2,0);
+            if(this.bitLength() > a) this.subTo(BigInteger.ONE.shiftLeft(a-1),this);
+          }
+        }
+      }
+      else {
+        // new BigInteger(int,RNG)
+        var x = new Array(), t = a&7;
+        x.length = (a>>3)+1;
+        b.nextBytes(x);
+        if(t > 0) x[0] &= ((1<<t)-1); else x[0] = 0;
+        this.fromString(x,256);
+      }
+    }
+
+    // (public) convert to bigendian byte array
+    function bnToByteArray() {
+      var i = this.t, r = new Array();
+      r[0] = this.s;
+      var p = this.DB-(i*this.DB)%8, d, k = 0;
+      if(i-- > 0) {
+        if(p < this.DB && (d = this[i]>>p) != (this.s&this.DM)>>p)
+          r[k++] = d|(this.s<<(this.DB-p));
+        while(i >= 0) {
+          if(p < 8) {
+            d = (this[i]&((1<<p)-1))<<(8-p);
+            d |= this[--i]>>(p+=this.DB-8);
+          }
+          else {
+            d = (this[i]>>(p-=8))&0xff;
+            if(p <= 0) { p += this.DB; --i; }
+          }
+          if((d&0x80) != 0) d |= -256;
+          if(k == 0 && (this.s&0x80) != (d&0x80)) ++k;
+          if(k > 0 || d != this.s) r[k++] = d;
+        }
+      }
+      return r;
+    }
+
+    function bnEquals(a) { return(this.compareTo(a)==0); }
+    function bnMin(a) { return(this.compareTo(a)<0)?this:a; }
+    function bnMax(a) { return(this.compareTo(a)>0)?this:a; }
+
+    // (protected) r = this op a (bitwise)
+    function bnpBitwiseTo(a,op,r) {
+      var i, f, m = Math.min(a.t,this.t);
+      for(i = 0; i < m; ++i) r[i] = op(this[i],a[i]);
+      if(a.t < this.t) {
+        f = a.s&this.DM;
+        for(i = m; i < this.t; ++i) r[i] = op(this[i],f);
+        r.t = this.t;
+      }
+      else {
+        f = this.s&this.DM;
+        for(i = m; i < a.t; ++i) r[i] = op(f,a[i]);
+        r.t = a.t;
+      }
+      r.s = op(this.s,a.s);
+      r.clamp();
+    }
+
+    // (public) this & a
+    function op_and(x,y) { return x&y; }
+    function bnAnd(a) { var r = nbi(); this.bitwiseTo(a,op_and,r); return r; }
+
+    // (public) this | a
+    function op_or(x,y) { return x|y; }
+    function bnOr(a) { var r = nbi(); this.bitwiseTo(a,op_or,r); return r; }
+
+    // (public) this ^ a
+    function op_xor(x,y) { return x^y; }
+    function bnXor(a) { var r = nbi(); this.bitwiseTo(a,op_xor,r); return r; }
+
+    // (public) this & ~a
+    function op_andnot(x,y) { return x&~y; }
+    function bnAndNot(a) { var r = nbi(); this.bitwiseTo(a,op_andnot,r); return r; }
+
+    // (public) ~this
+    function bnNot() {
+      var r = nbi();
+      for(var i = 0; i < this.t; ++i) r[i] = this.DM&~this[i];
+      r.t = this.t;
+      r.s = ~this.s;
+      return r;
+    }
+
+    // (public) this << n
+    function bnShiftLeft(n) {
+      var r = nbi();
+      if(n < 0) this.rShiftTo(-n,r); else this.lShiftTo(n,r);
+      return r;
+    }
+
+    // (public) this >> n
+    function bnShiftRight(n) {
+      var r = nbi();
+      if(n < 0) this.lShiftTo(-n,r); else this.rShiftTo(n,r);
+      return r;
+    }
+
+    // return index of lowest 1-bit in x, x < 2^31
+    function lbit(x) {
+      if(x == 0) return -1;
+      var r = 0;
+      if((x&0xffff) == 0) { x >>= 16; r += 16; }
+      if((x&0xff) == 0) { x >>= 8; r += 8; }
+      if((x&0xf) == 0) { x >>= 4; r += 4; }
+      if((x&3) == 0) { x >>= 2; r += 2; }
+      if((x&1) == 0) ++r;
+      return r;
+    }
+
+    // (public) returns index of lowest 1-bit (or -1 if none)
+    function bnGetLowestSetBit() {
+      for(var i = 0; i < this.t; ++i)
+        if(this[i] != 0) return i*this.DB+lbit(this[i]);
+      if(this.s < 0) return this.t*this.DB;
+      return -1;
+    }
+
+    // return number of 1 bits in x
+    function cbit(x) {
+      var r = 0;
+      while(x != 0) { x &= x-1; ++r; }
+      return r;
+    }
+
+    // (public) return number of set bits
+    function bnBitCount() {
+      var r = 0, x = this.s&this.DM;
+      for(var i = 0; i < this.t; ++i) r += cbit(this[i]^x);
+      return r;
+    }
+
+    // (public) true iff nth bit is set
+    function bnTestBit(n) {
+      var j = Math.floor(n/this.DB);
+      if(j >= this.t) return(this.s!=0);
+      return((this[j]&(1<<(n%this.DB)))!=0);
+    }
+
+    // (protected) this op (1<<n)
+    function bnpChangeBit(n,op) {
+      var r = BigInteger.ONE.shiftLeft(n);
+      this.bitwiseTo(r,op,r);
+      return r;
+    }
+
+    // (public) this | (1<<n)
+    function bnSetBit(n) { return this.changeBit(n,op_or); }
+
+    // (public) this & ~(1<<n)
+    function bnClearBit(n) { return this.changeBit(n,op_andnot); }
+
+    // (public) this ^ (1<<n)
+    function bnFlipBit(n) { return this.changeBit(n,op_xor); }
+
+    // (protected) r = this + a
+    function bnpAddTo(a,r) {
+      var i = 0, c = 0, m = Math.min(a.t,this.t);
+      while(i < m) {
+        c += this[i]+a[i];
+        r[i++] = c&this.DM;
+        c >>= this.DB;
+      }
+      if(a.t < this.t) {
+        c += a.s;
+        while(i < this.t) {
+          c += this[i];
+          r[i++] = c&this.DM;
+          c >>= this.DB;
+        }
+        c += this.s;
+      }
+      else {
+        c += this.s;
+        while(i < a.t) {
+          c += a[i];
+          r[i++] = c&this.DM;
+          c >>= this.DB;
+        }
+        c += a.s;
+      }
+      r.s = (c<0)?-1:0;
+      if(c > 0) r[i++] = c;
+      else if(c < -1) r[i++] = this.DV+c;
+      r.t = i;
+      r.clamp();
+    }
+
+    // (public) this + a
+    function bnAdd(a) { var r = nbi(); this.addTo(a,r); return r; }
+
+    // (public) this - a
+    function bnSubtract(a) { var r = nbi(); this.subTo(a,r); return r; }
+
+    // (public) this * a
+    function bnMultiply(a) { var r = nbi(); this.multiplyTo(a,r); return r; }
+
+    // (public) this^2
+    function bnSquare() { var r = nbi(); this.squareTo(r); return r; }
+
+    // (public) this / a
+    function bnDivide(a) { var r = nbi(); this.divRemTo(a,r,null); return r; }
+
+    // (public) this % a
+    function bnRemainder(a) { var r = nbi(); this.divRemTo(a,null,r); return r; }
+
+    // (public) [this/a,this%a]
+    function bnDivideAndRemainder(a) {
+      var q = nbi(), r = nbi();
+      this.divRemTo(a,q,r);
+      return new Array(q,r);
+    }
+
+    // (protected) this *= n, this >= 0, 1 < n < DV
+    function bnpDMultiply(n) {
+      this[this.t] = this.am(0,n-1,this,0,0,this.t);
+      ++this.t;
+      this.clamp();
+    }
+
+    // (protected) this += n << w words, this >= 0
+    function bnpDAddOffset(n,w) {
+      if(n == 0) return;
+      while(this.t <= w) this[this.t++] = 0;
+      this[w] += n;
+      while(this[w] >= this.DV) {
+        this[w] -= this.DV;
+        if(++w >= this.t) this[this.t++] = 0;
+        ++this[w];
+      }
+    }
+
+    // A "null" reducer
+    function NullExp() {}
+    function nNop(x) { return x; }
+    function nMulTo(x,y,r) { x.multiplyTo(y,r); }
+    function nSqrTo(x,r) { x.squareTo(r); }
+
+    NullExp.prototype.convert = nNop;
+    NullExp.prototype.revert = nNop;
+    NullExp.prototype.mulTo = nMulTo;
+    NullExp.prototype.sqrTo = nSqrTo;
+
+    // (public) this^e
+    function bnPow(e) { return this.exp(e,new NullExp()); }
+
+    // (protected) r = lower n words of "this * a", a.t <= n
+    // "this" should be the larger one if appropriate.
+    function bnpMultiplyLowerTo(a,n,r) {
+      var i = Math.min(this.t+a.t,n);
+      r.s = 0; // assumes a,this >= 0
+      r.t = i;
+      while(i > 0) r[--i] = 0;
+      var j;
+      for(j = r.t-this.t; i < j; ++i) r[i+this.t] = this.am(0,a[i],r,i,0,this.t);
+      for(j = Math.min(a.t,n); i < j; ++i) this.am(0,a[i],r,i,0,n-i);
+      r.clamp();
+    }
+
+    // (protected) r = "this * a" without lower n words, n > 0
+    // "this" should be the larger one if appropriate.
+    function bnpMultiplyUpperTo(a,n,r) {
+      --n;
+      var i = r.t = this.t+a.t-n;
+      r.s = 0; // assumes a,this >= 0
+      while(--i >= 0) r[i] = 0;
+      for(i = Math.max(n-this.t,0); i < a.t; ++i)
+        r[this.t+i-n] = this.am(n-i,a[i],r,0,0,this.t+i-n);
+      r.clamp();
+      r.drShiftTo(1,r);
+    }
+
+    // Barrett modular reduction
+    function Barrett(m) {
+      // setup Barrett
+      this.r2 = nbi();
+      this.q3 = nbi();
+      BigInteger.ONE.dlShiftTo(2*m.t,this.r2);
+      this.mu = this.r2.divide(m);
+      this.m = m;
+    }
+
+    function barrettConvert(x) {
+      if(x.s < 0 || x.t > 2*this.m.t) return x.mod(this.m);
+      else if(x.compareTo(this.m) < 0) return x;
+      else { var r = nbi(); x.copyTo(r); this.reduce(r); return r; }
+    }
+
+    function barrettRevert(x) { return x; }
+
+    // x = x mod m (HAC 14.42)
+    function barrettReduce(x) {
+      x.drShiftTo(this.m.t-1,this.r2);
+      if(x.t > this.m.t+1) { x.t = this.m.t+1; x.clamp(); }
+      this.mu.multiplyUpperTo(this.r2,this.m.t+1,this.q3);
+      this.m.multiplyLowerTo(this.q3,this.m.t+1,this.r2);
+      while(x.compareTo(this.r2) < 0) x.dAddOffset(1,this.m.t+1);
+      x.subTo(this.r2,x);
+      while(x.compareTo(this.m) >= 0) x.subTo(this.m,x);
+    }
+
+    // r = x^2 mod m; x != r
+    function barrettSqrTo(x,r) { x.squareTo(r); this.reduce(r); }
+
+    // r = x*y mod m; x,y != r
+    function barrettMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }
+
+    Barrett.prototype.convert = barrettConvert;
+    Barrett.prototype.revert = barrettRevert;
+    Barrett.prototype.reduce = barrettReduce;
+    Barrett.prototype.mulTo = barrettMulTo;
+    Barrett.prototype.sqrTo = barrettSqrTo;
+
+    // (public) this^e % m (HAC 14.85)
+    function bnModPow(e,m) {
+      var i = e.bitLength(), k, r = nbv(1), z;
+      if(i <= 0) return r;
+      else if(i < 18) k = 1;
+      else if(i < 48) k = 3;
+      else if(i < 144) k = 4;
+      else if(i < 768) k = 5;
+      else k = 6;
+      if(i < 8)
+        z = new Classic(m);
+      else if(m.isEven())
+        z = new Barrett(m);
+      else
+        z = new Montgomery(m);
+
+      // precomputation
+      var g = new Array(), n = 3, k1 = k-1, km = (1<<k)-1;
+      g[1] = z.convert(this);
+      if(k > 1) {
+        var g2 = nbi();
+        z.sqrTo(g[1],g2);
+        while(n <= km) {
+          g[n] = nbi();
+          z.mulTo(g2,g[n-2],g[n]);
+          n += 2;
+        }
+      }
+
+      var j = e.t-1, w, is1 = true, r2 = nbi(), t;
+      i = nbits(e[j])-1;
+      while(j >= 0) {
+        if(i >= k1) w = (e[j]>>(i-k1))&km;
+        else {
+          w = (e[j]&((1<<(i+1))-1))<<(k1-i);
+          if(j > 0) w |= e[j-1]>>(this.DB+i-k1);
+        }
+
+        n = k;
+        while((w&1) == 0) { w >>= 1; --n; }
+        if((i -= n) < 0) { i += this.DB; --j; }
+        if(is1) {    // ret == 1, don't bother squaring or multiplying it
+          g[w].copyTo(r);
+          is1 = false;
+        }
+        else {
+          while(n > 1) { z.sqrTo(r,r2); z.sqrTo(r2,r); n -= 2; }
+          if(n > 0) z.sqrTo(r,r2); else { t = r; r = r2; r2 = t; }
+          z.mulTo(r2,g[w],r);
+        }
+
+        while(j >= 0 && (e[j]&(1<<i)) == 0) {
+          z.sqrTo(r,r2); t = r; r = r2; r2 = t;
+          if(--i < 0) { i = this.DB-1; --j; }
+        }
+      }
+      return z.revert(r);
+    }
+
+    // (public) gcd(this,a) (HAC 14.54)
+    function bnGCD(a) {
+      var x = (this.s<0)?this.negate():this.clone();
+      var y = (a.s<0)?a.negate():a.clone();
+      if(x.compareTo(y) < 0) { var t = x; x = y; y = t; }
+      var i = x.getLowestSetBit(), g = y.getLowestSetBit();
+      if(g < 0) return x;
+      if(i < g) g = i;
+      if(g > 0) {
+        x.rShiftTo(g,x);
+        y.rShiftTo(g,y);
+      }
+      while(x.signum() > 0) {
+        if((i = x.getLowestSetBit()) > 0) x.rShiftTo(i,x);
+        if((i = y.getLowestSetBit()) > 0) y.rShiftTo(i,y);
+        if(x.compareTo(y) >= 0) {
+          x.subTo(y,x);
+          x.rShiftTo(1,x);
+        }
+        else {
+          y.subTo(x,y);
+          y.rShiftTo(1,y);
+        }
+      }
+      if(g > 0) y.lShiftTo(g,y);
+      return y;
+    }
+
+    // (protected) this % n, n < 2^26
+    function bnpModInt(n) {
+      if(n <= 0) return 0;
+      var d = this.DV%n, r = (this.s<0)?n-1:0;
+      if(this.t > 0)
+        if(d == 0) r = this[0]%n;
+        else for(var i = this.t-1; i >= 0; --i) r = (d*r+this[i])%n;
+      return r;
+    }
+
+    // (public) 1/this % m (HAC 14.61)
+    function bnModInverse(m) {
+      var ac = m.isEven();
+      if((this.isEven() && ac) || m.signum() == 0) return BigInteger.ZERO;
+      var u = m.clone(), v = this.clone();
+      var a = nbv(1), b = nbv(0), c = nbv(0), d = nbv(1);
+      while(u.signum() != 0) {
+        while(u.isEven()) {
+          u.rShiftTo(1,u);
+          if(ac) {
+            if(!a.isEven() || !b.isEven()) { a.addTo(this,a); b.subTo(m,b); }
+            a.rShiftTo(1,a);
+          }
+          else if(!b.isEven()) b.subTo(m,b);
+          b.rShiftTo(1,b);
+        }
+        while(v.isEven()) {
+          v.rShiftTo(1,v);
+          if(ac) {
+            if(!c.isEven() || !d.isEven()) { c.addTo(this,c); d.subTo(m,d); }
+            c.rShiftTo(1,c);
+          }
+          else if(!d.isEven()) d.subTo(m,d);
+          d.rShiftTo(1,d);
+        }
+        if(u.compareTo(v) >= 0) {
+          u.subTo(v,u);
+          if(ac) a.subTo(c,a);
+          b.subTo(d,b);
+        }
+        else {
+          v.subTo(u,v);
+          if(ac) c.subTo(a,c);
+          d.subTo(b,d);
+        }
+      }
+      if(v.compareTo(BigInteger.ONE) != 0) return BigInteger.ZERO;
+      if(d.compareTo(m) >= 0) return d.subtract(m);
+      if(d.signum() < 0) d.addTo(m,d); else return d;
+      if(d.signum() < 0) return d.add(m); else return d;
+    }
+
+    var lowprimes = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997];
+    var lplim = (1<<26)/lowprimes[lowprimes.length-1];
+
+    // (public) test primality with certainty >= 1-.5^t
+    function bnIsProbablePrime(t) {
+      var i, x = this.abs();
+      if(x.t == 1 && x[0] <= lowprimes[lowprimes.length-1]) {
+        for(i = 0; i < lowprimes.length; ++i)
+          if(x[0] == lowprimes[i]) return true;
+        return false;
+      }
+      if(x.isEven()) return false;
+      i = 1;
+      while(i < lowprimes.length) {
+        var m = lowprimes[i], j = i+1;
+        while(j < lowprimes.length && m < lplim) m *= lowprimes[j++];
+        m = x.modInt(m);
+        while(i < j) if(m%lowprimes[i++] == 0) return false;
+      }
+      return x.millerRabin(t);
+    }
+
+    // (protected) true if probably prime (HAC 4.24, Miller-Rabin)
+    function bnpMillerRabin(t) {
+      var n1 = this.subtract(BigInteger.ONE);
+      var k = n1.getLowestSetBit();
+      if(k <= 0) return false;
+      var r = n1.shiftRight(k);
+      t = (t+1)>>1;
+      if(t > lowprimes.length) t = lowprimes.length;
+      var a = nbi();
+      for(var i = 0; i < t; ++i) {
+        //Pick bases at random, instead of starting at 2
+        a.fromInt(lowprimes[Math.floor(Math.random()*lowprimes.length)]);
+        var y = a.modPow(r,this);
+        if(y.compareTo(BigInteger.ONE) != 0 && y.compareTo(n1) != 0) {
+          var j = 1;
+          while(j++ < k && y.compareTo(n1) != 0) {
+            y = y.modPowInt(2,this);
+            if(y.compareTo(BigInteger.ONE) == 0) return false;
+          }
+          if(y.compareTo(n1) != 0) return false;
+        }
+      }
+      return true;
+    }
+
+    // protected
+    BigInteger.prototype.chunkSize = bnpChunkSize;
+    BigInteger.prototype.toRadix = bnpToRadix;
+    BigInteger.prototype.fromRadix = bnpFromRadix;
+    BigInteger.prototype.fromNumber = bnpFromNumber;
+    BigInteger.prototype.bitwiseTo = bnpBitwiseTo;
+    BigInteger.prototype.changeBit = bnpChangeBit;
+    BigInteger.prototype.addTo = bnpAddTo;
+    BigInteger.prototype.dMultiply = bnpDMultiply;
+    BigInteger.prototype.dAddOffset = bnpDAddOffset;
+    BigInteger.prototype.multiplyLowerTo = bnpMultiplyLowerTo;
+    BigInteger.prototype.multiplyUpperTo = bnpMultiplyUpperTo;
+    BigInteger.prototype.modInt = bnpModInt;
+    BigInteger.prototype.millerRabin = bnpMillerRabin;
+
+    // public
+    BigInteger.prototype.clone = bnClone;
+    BigInteger.prototype.intValue = bnIntValue;
+    BigInteger.prototype.byteValue = bnByteValue;
+    BigInteger.prototype.shortValue = bnShortValue;
+    BigInteger.prototype.signum = bnSigNum;
+    BigInteger.prototype.toByteArray = bnToByteArray;
+    BigInteger.prototype.equals = bnEquals;
+    BigInteger.prototype.min = bnMin;
+    BigInteger.prototype.max = bnMax;
+    BigInteger.prototype.and = bnAnd;
+    BigInteger.prototype.or = bnOr;
+    BigInteger.prototype.xor = bnXor;
+    BigInteger.prototype.andNot = bnAndNot;
+    BigInteger.prototype.not = bnNot;
+    BigInteger.prototype.shiftLeft = bnShiftLeft;
+    BigInteger.prototype.shiftRight = bnShiftRight;
+    BigInteger.prototype.getLowestSetBit = bnGetLowestSetBit;
+    BigInteger.prototype.bitCount = bnBitCount;
+    BigInteger.prototype.testBit = bnTestBit;
+    BigInteger.prototype.setBit = bnSetBit;
+    BigInteger.prototype.clearBit = bnClearBit;
+    BigInteger.prototype.flipBit = bnFlipBit;
+    BigInteger.prototype.add = bnAdd;
+    BigInteger.prototype.subtract = bnSubtract;
+    BigInteger.prototype.multiply = bnMultiply;
+    BigInteger.prototype.divide = bnDivide;
+    BigInteger.prototype.remainder = bnRemainder;
+    BigInteger.prototype.divideAndRemainder = bnDivideAndRemainder;
+    BigInteger.prototype.modPow = bnModPow;
+    BigInteger.prototype.modInverse = bnModInverse;
+    BigInteger.prototype.pow = bnPow;
+    BigInteger.prototype.gcd = bnGCD;
+    BigInteger.prototype.isProbablePrime = bnIsProbablePrime;
+
+    // JSBN-specific extension
+    BigInteger.prototype.square = bnSquare;
+
+    // Expose the Barrett function
+    BigInteger.prototype.Barrett = Barrett
+
+    // BigInteger interfaces not implemented in jsbn:
+
+    // BigInteger(int signum, byte[] magnitude)
+    // double doubleValue()
+    // float floatValue()
+    // int hashCode()
+    // long longValue()
+    // static BigInteger valueOf(long val)
+
+    // Random number generator - requires a PRNG backend, e.g. prng4.js
+
+    // For best results, put code like
+    // <body onClick='rng_seed_time();' onKeyPress='rng_seed_time();'>
+    // in your main HTML document.
+
+    var rng_state;
+    var rng_pool;
+    var rng_pptr;
+
+    // Mix in a 32-bit integer into the pool
+    function rng_seed_int(x) {
+      rng_pool[rng_pptr++] ^= x & 255;
+      rng_pool[rng_pptr++] ^= (x >> 8) & 255;
+      rng_pool[rng_pptr++] ^= (x >> 16) & 255;
+      rng_pool[rng_pptr++] ^= (x >> 24) & 255;
+      if(rng_pptr >= rng_psize) rng_pptr -= rng_psize;
+    }
+
+    // Mix in the current time (w/milliseconds) into the pool
+    function rng_seed_time() {
+      rng_seed_int(new Date().getTime());
+    }
+
+    // Initialize the pool with junk if needed.
+    if(rng_pool == null) {
+      rng_pool = new Array();
+      rng_pptr = 0;
+      var t;
+      if(typeof window !== "undefined" && window.crypto) {
+        if (window.crypto.getRandomValues) {
+          // Use webcrypto if available
+          var ua = new Uint8Array(32);
+          window.crypto.getRandomValues(ua);
+          for(t = 0; t < 32; ++t)
+            rng_pool[rng_pptr++] = ua[t];
+        }
+        else if(navigator.appName == "Netscape" && navigator.appVersion < "5") {
+          // Extract entropy (256 bits) from NS4 RNG if available
+          var z = window.crypto.random(32);
+          for(t = 0; t < z.length; ++t)
+            rng_pool[rng_pptr++] = z.charCodeAt(t) & 255;
+        }
+      }
+      while(rng_pptr < rng_psize) {  // extract some randomness from Math.random()
+        t = Math.floor(65536 * Math.random());
+        rng_pool[rng_pptr++] = t >>> 8;
+        rng_pool[rng_pptr++] = t & 255;
+      }
+      rng_pptr = 0;
+      rng_seed_time();
+      //rng_seed_int(window.screenX);
+      //rng_seed_int(window.screenY);
+    }
+
+    function rng_get_byte() {
+      if(rng_state == null) {
+        rng_seed_time();
+        rng_state = prng_newstate();
+        rng_state.init(rng_pool);
+        for(rng_pptr = 0; rng_pptr < rng_pool.length; ++rng_pptr)
+          rng_pool[rng_pptr] = 0;
+        rng_pptr = 0;
+        //rng_pool = null;
+      }
+      // TODO: allow reseeding after first request
+      return rng_state.next();
+    }
+
+    function rng_get_bytes(ba) {
+      var i;
+      for(i = 0; i < ba.length; ++i) ba[i] = rng_get_byte();
+    }
+
+    function SecureRandom() {}
+
+    SecureRandom.prototype.nextBytes = rng_get_bytes;
+
+    // prng4.js - uses Arcfour as a PRNG
+
+    function Arcfour() {
+      this.i = 0;
+      this.j = 0;
+      this.S = new Array();
+    }
+
+    // Initialize arcfour context from key, an array of ints, each from [0..255]
+    function ARC4init(key) {
+      var i, j, t;
+      for(i = 0; i < 256; ++i)
+        this.S[i] = i;
+      j = 0;
+      for(i = 0; i < 256; ++i) {
+        j = (j + this.S[i] + key[i % key.length]) & 255;
+        t = this.S[i];
+        this.S[i] = this.S[j];
+        this.S[j] = t;
+      }
+      this.i = 0;
+      this.j = 0;
+    }
+
+    function ARC4next() {
+      var t;
+      this.i = (this.i + 1) & 255;
+      this.j = (this.j + this.S[this.i]) & 255;
+      t = this.S[this.i];
+      this.S[this.i] = this.S[this.j];
+      this.S[this.j] = t;
+      return this.S[(t + this.S[this.i]) & 255];
+    }
+
+    Arcfour.prototype.init = ARC4init;
+    Arcfour.prototype.next = ARC4next;
+
+    // Plug in your RNG constructor here
+    function prng_newstate() {
+      return new Arcfour();
+    }
+
+    // Pool size must be a multiple of 4 and greater than 32.
+    // An array of bytes the size of the pool will be passed to init()
+    var rng_psize = 256;
+
+    if (typeof exports !== 'undefined') {
+        exports = module.exports = {
+            default: BigInteger,
+            BigInteger: BigInteger,
+            SecureRandom: SecureRandom,
+        };
+    } else {
+        this.jsbn = {
+          BigInteger: BigInteger,
+          SecureRandom: SecureRandom
+        };
+    }
+
+}).call(this);

nodered/rootfs/data/node_modules/ip-address/node_modules/jsbn/package.json

@@ -0,0 +1,52 @@
+{
+  "_from": "jsbn@1.1.0",
+  "_id": "jsbn@1.1.0",
+  "_inBundle": false,
+  "_integrity": "sha1-sBMHyym2GKHtJux56RH4A8TaAEA=",
+  "_location": "/ip-address/jsbn",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "jsbn@1.1.0",
+    "name": "jsbn",
+    "escapedName": "jsbn",
+    "rawSpec": "1.1.0",
+    "saveSpec": null,
+    "fetchSpec": "1.1.0"
+  },
+  "_requiredBy": [
+    "/ip-address"
+  ],
+  "_resolved": "https://registry.npmjs.org/jsbn/-/jsbn-1.1.0.tgz",
+  "_shasum": "b01307cb29b618a1ed26ec79e911f803c4da0040",
+  "_spec": "jsbn@1.1.0",
+  "_where": "/data/node_modules/ip-address",
+  "author": {
+    "name": "Tom Wu"
+  },
+  "bugs": {
+    "url": "https://github.com/andyperlitch/jsbn/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "The jsbn library is a fast, portable implementation of large-number math in pure JavaScript, enabling public-key crypto and other applications on desktop and mobile browsers.",
+  "homepage": "https://github.com/andyperlitch/jsbn#readme",
+  "keywords": [
+    "biginteger",
+    "bignumber",
+    "big",
+    "integer"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "jsbn",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/andyperlitch/jsbn.git"
+  },
+  "scripts": {
+    "test": "mocha test.js"
+  },
+  "version": "1.1.0"
+}

nodered/rootfs/data/node_modules/ip-address/node_modules/jsbn/test/es6-import.js

@@ -0,0 +1,3 @@
+import {BigInteger} from '../';
+
+console.log(typeof BigInteger)

nodered/rootfs/data/node_modules/ip-address/package.json

@@ -0,0 +1,77 @@
+{
+  "_from": "ip-address@~6.1.0",
+  "_id": "ip-address@6.1.0",
+  "_inBundle": false,
+  "_integrity": "sha512-u9YYtb1p2fWSbzpKmZ/b3QXWA+diRYPxc2c4y5lFB/MMk5WZ7wNZv8S3CFcIGVJ5XtlaCAl/FQy/D3eQ2XtdOA==",
+  "_location": "/ip-address",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "ip-address@~6.1.0",
+    "name": "ip-address",
+    "escapedName": "ip-address",
+    "rawSpec": "~6.1.0",
+    "saveSpec": null,
+    "fetchSpec": "~6.1.0"
+  },
+  "_requiredBy": [
+    "/socks5-client"
+  ],
+  "_resolved": "https://registry.npmjs.org/ip-address/-/ip-address-6.1.0.tgz",
+  "_shasum": "3c3335bc90f22b3545a6eca5bffefabeb2ea6fd2",
+  "_spec": "ip-address@~6.1.0",
+  "_where": "/data/node_modules/socks5-client",
+  "author": {
+    "name": "Beau Gunderson",
+    "email": "beau@beaugunderson.com",
+    "url": "https://beaugunderson.com/"
+  },
+  "bugs": {
+    "url": "https://github.com/beaugunderson/ip-address/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "jsbn": "1.1.0",
+    "lodash": "^4.17.15",
+    "sprintf-js": "1.1.2"
+  },
+  "deprecated": false,
+  "description": "A library for parsing IPv4 and IPv6 IP addresses in node and the browser.",
+  "devDependencies": {
+    "browserify": "^16.3.0",
+    "chai": "^4.2.0",
+    "codecov.io": "^0.1.6",
+    "documentation": "^12.0.3",
+    "istanbul": "^0.4.5",
+    "mocha": "^6.2.0",
+    "mochify": "^6.3.0"
+  },
+  "engines": {
+    "node": ">= 0.10"
+  },
+  "files": [
+    "ip-address.js",
+    "ip-address-globals.js",
+    "lib/**/*"
+  ],
+  "homepage": "https://github.com/beaugunderson/ip-address#readme",
+  "keywords": [
+    "ipv6",
+    "ipv4",
+    "browser",
+    "validation"
+  ],
+  "license": "MIT",
+  "main": "ip-address.js",
+  "name": "ip-address",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/beaugunderson/ip-address.git"
+  },
+  "scripts": {
+    "docs": "documentation build --github --output docs --format html ./ip-address.js",
+    "test": "mocha -R spec"
+  },
+  "version": "6.1.0"
+}