diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8e416b9..0a8ed40 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,7 +5,9 @@
     * ADDED: new HTTP headers improving security (#765)
     * ADDED: Download button for paste text (#774)
     * ADDED: Opt-out of federated learning of cohorts (FLoC) (#776)
+    * ADDED: Configuration option to exempt ips from the rate-limiter (#787)
     * CHANGED: Language selection cookie only transmitted over HTTPS (#472)
+    * CHANGED: Upgrading libraries to: random_compat 2.0.20
   * **1.3.5 (2021-04-05)**
     * ADDED: Translation for Hebrew, Lithuanian, Indonesian and Catalan
     * ADDED: Make the project info configurable (#681)
diff --git a/CREDITS.md b/CREDITS.md
index 1aabf6f..338c2df 100644
--- a/CREDITS.md
+++ b/CREDITS.md
@@ -27,6 +27,7 @@ Sébastien Sauvage - original idea and main developer
 * Harald Leithner - base58 encoding of key
 * Haocen - lots of bugfixes and UI improvements
 * Lucas Savva - configurable config file location, NixOS packaging
+* rodehoed - option to exempt ips from the rate-limiter
 
 ## Translations
 * Hexalyse - French
diff --git a/cfg/conf.sample.php b/cfg/conf.sample.php
index ceddad6..e9e500b 100644
--- a/cfg/conf.sample.php
+++ b/cfg/conf.sample.php
@@ -135,6 +135,10 @@ markdown = "Markdown"
 ; Set this to 0 to disable rate limiting.
 limit = 10
 
+; Set ips (v4|v6) which should be exempted for the rate-limit. CIDR also supported. Needed to be comma separated.
+; Unset for enabling and invalid values will be ignored
+; eg: exemptedIp = '1.2.3.4,10.10.10/24'
+
 ; (optional) if your website runs behind a reverse proxy or load balancer,
 ; set the HTTP header containing the visitors IP address, i.e. X_FORWARDED_FOR
 ; header = "X_FORWARDED_FOR"
diff --git a/composer.json b/composer.json
index 899c863..a8e98aa 100644
--- a/composer.json
+++ b/composer.json
@@ -25,8 +25,9 @@
 	},
 	"require" : {
 		"php" : "^5.6.0 || ^7.0 || ^8.0",
-		"paragonie/random_compat" : "2.0.19",
-		"yzalis/identicon" : "2.0.0"
+		"paragonie/random_compat" : "2.0.20",
+		"yzalis/identicon" : "2.0.0",
+		"mlocati/ip-lib" : "1.14.0"
 	},
 	"require-dev" : {
 		"phpunit/phpunit" : "^4.6 || ^5.0"
diff --git a/composer.lock b/composer.lock
index 80d2276..931c92f 100644
--- a/composer.lock
+++ b/composer.lock
@@ -4,20 +4,88 @@
         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
         "This file is @generated automatically"
     ],
-    "content-hash": "9d110873bf15a6abd66734e8a818134c",
+    "content-hash": "217f0ba9bdac1014a332a8ba390be949",
     "packages": [
         {
-            "name": "paragonie/random_compat",
-            "version": "v2.0.19",
+            "name": "mlocati/ip-lib",
+            "version": "1.14.0",
             "source": {
                 "type": "git",
-                "url": "https://github.com/paragonie/random_compat.git",
-                "reference": "446fc9faa5c2a9ddf65eb7121c0af7e857295241"
+                "url": "https://github.com/mlocati/ip-lib.git",
+                "reference": "882bc0e115970a536b13bcfa59f312783fce08c8"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/paragonie/random_compat/zipball/446fc9faa5c2a9ddf65eb7121c0af7e857295241",
-                "reference": "446fc9faa5c2a9ddf65eb7121c0af7e857295241",
+                "url": "https://api.github.com/repos/mlocati/ip-lib/zipball/882bc0e115970a536b13bcfa59f312783fce08c8",
+                "reference": "882bc0e115970a536b13bcfa59f312783fce08c8",
+                "shasum": ""
+            },
+            "require": {
+                "php": ">=5.3.3"
+            },
+            "require-dev": {
+                "ext-pdo_sqlite": "*",
+                "phpunit/dbunit": "^1.4 || ^2 || ^3 || ^4",
+                "phpunit/phpunit": "^4.8 || ^5.7 || ^6.5"
+            },
+            "type": "library",
+            "autoload": {
+                "psr-4": {
+                    "IPLib\\": "src/"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Michele Locati",
+                    "email": "mlocati@gmail.com",
+                    "homepage": "https://github.com/mlocati",
+                    "role": "Author"
+                }
+            ],
+            "description": "Handle IPv4, IPv6 addresses and ranges",
+            "homepage": "https://github.com/mlocati/ip-lib",
+            "keywords": [
+                "IP",
+                "address",
+                "addresses",
+                "ipv4",
+                "ipv6",
+                "manage",
+                "managing",
+                "matching",
+                "network",
+                "networking",
+                "range",
+                "subnet"
+            ],
+            "funding": [
+                {
+                    "url": "https://github.com/sponsors/mlocati",
+                    "type": "github"
+                },
+                {
+                    "url": "https://paypal.me/mlocati",
+                    "type": "other"
+                }
+            ],
+            "time": "2020-12-31T11:30:02+00:00"
+        },
+        {
+            "name": "paragonie/random_compat",
+            "version": "v2.0.20",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/paragonie/random_compat.git",
+                "reference": "0f1f60250fccffeaf5dda91eea1c018aed1adc2a"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/paragonie/random_compat/zipball/0f1f60250fccffeaf5dda91eea1c018aed1adc2a",
+                "reference": "0f1f60250fccffeaf5dda91eea1c018aed1adc2a",
                 "shasum": ""
             },
             "require": {
@@ -53,7 +121,7 @@
                 "pseudorandom",
                 "random"
             ],
-            "time": "2020-10-15T10:06:57+00:00"
+            "time": "2021-04-17T09:33:01+00:00"
         },
         {
             "name": "yzalis/identicon",
@@ -1427,16 +1495,16 @@
         },
         {
             "name": "symfony/yaml",
-            "version": "v4.4.21",
+            "version": "v4.4.24",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/yaml.git",
-                "reference": "3871c720871029f008928244e56cf43497da7e9d"
+                "reference": "8b6d1b97521e2f125039b3fcb4747584c6dfa0ef"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/symfony/yaml/zipball/3871c720871029f008928244e56cf43497da7e9d",
-                "reference": "3871c720871029f008928244e56cf43497da7e9d",
+                "url": "https://api.github.com/repos/symfony/yaml/zipball/8b6d1b97521e2f125039b3fcb4747584c6dfa0ef",
+                "reference": "8b6d1b97521e2f125039b3fcb4747584c6dfa0ef",
                 "shasum": ""
             },
             "require": {
@@ -1491,7 +1559,7 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2021-03-05T17:58:50+00:00"
+            "time": "2021-05-16T09:52:47+00:00"
         },
         {
             "name": "webmozart/assert",
diff --git a/lib/Configuration.php b/lib/Configuration.php
index e509d98..5de6de3 100644
--- a/lib/Configuration.php
+++ b/lib/Configuration.php
@@ -79,9 +79,10 @@ class Configuration
             'markdown'           => 'Markdown',
         ),
         'traffic' => array(
-            'limit'  => 10,
-            'header' => null,
-            'dir'    => 'data',
+            'limit'      => 10,
+            'header'     => null,
+            'dir'        => 'data',
+            'exemptedIp' => null,
         ),
         'purge' => array(
             'limit'     => 300,
diff --git a/lib/Persistence/TrafficLimiter.php b/lib/Persistence/TrafficLimiter.php
index a16cd0b..dedf588 100644
--- a/lib/Persistence/TrafficLimiter.php
+++ b/lib/Persistence/TrafficLimiter.php
@@ -1,4 +1,5 @@
 <?php
+
 /**
  * PrivateBin
  *
@@ -12,6 +13,8 @@
 
 namespace PrivateBin\Persistence;
 
+use Exception;
+use IPLib\Factory;
 use PrivateBin\Configuration;
 
 /**
@@ -30,6 +33,15 @@ class TrafficLimiter extends AbstractPersistence
      */
     private static $_limit = 10;
 
+    /**
+     * listed ips are exempted from limits, defaults to null
+     *
+     * @access private
+     * @static
+     * @var    array
+     */
+    private static $_exemptedIp = null;
+
     /**
      * key to fetch IP address
      *
@@ -51,6 +63,18 @@ class TrafficLimiter extends AbstractPersistence
         self::$_limit = $limit;
     }
 
+    /**
+     * set a list of ip(ranges) as string
+     *
+     * @access public
+     * @static
+     * @param string $exemptedIps
+     */
+    public static function setExemptedIp($exemptedIp)
+    {
+        self::$_exemptedIp = $exemptedIp;
+    }
+
     /**
      * set configuration options of the traffic limiter
      *
@@ -62,6 +86,8 @@ class TrafficLimiter extends AbstractPersistence
     {
         self::setLimit($conf->getKey('limit', 'traffic'));
         self::setPath($conf->getKey('dir', 'traffic'));
+        self::setExemptedIp($conf->getKey('exemptedIp', 'traffic'));
+
         if (($option = $conf->getKey('header', 'traffic')) !== null) {
             $httpHeader = 'HTTP_' . $option;
             if (array_key_exists($httpHeader, $_SERVER) && !empty($_SERVER[$httpHeader])) {
@@ -83,6 +109,38 @@ class TrafficLimiter extends AbstractPersistence
         return hash_hmac($algo, $_SERVER[self::$_ipKey], ServerSalt::get());
     }
 
+    /**
+     * Validate $_ipKey against configured ipranges. If matched ratelimiter will ignore ip
+     *
+     * @access private
+     * @static
+     * @param  string $ipRange
+     * @return bool
+     */
+    private static function matchIp($ipRange = null)
+    {
+        // Match $_ipKey to $ipRange and if it matches it will return with a true
+        $address = Factory::addressFromString($_SERVER[self::$_ipKey]);
+        $range   = Factory::rangeFromString(trim($ipRange));
+
+        // address could not be parsed, we might not be in IP space and try a string comparison instead
+        if ($address == null) {
+            return $_SERVER[self::$_ipKey] === $ipRange;
+        }
+        // range could not be parsed, possibly an invalid ip range given in config
+        if ($range == null) {
+            return false;
+        }
+
+        // Ip-lib throws an exception when something goes wrong, if so we want to catch it and set contained to false
+        try {
+            return $address->matches($range);
+        } catch (Exception $e) {
+            // If something is wrong with matching the ip, we assume it doesn't match
+            return false;
+        }
+    }
+
     /**
      * traffic limiter
      *
@@ -100,6 +158,16 @@ class TrafficLimiter extends AbstractPersistence
             return true;
         }
 
+        // Check if $_ipKey is exempted from ratelimiting
+        if (!is_null(self::$_exemptedIp)) {
+            $exIp_array = explode(',', self::$_exemptedIp);
+            foreach ($exIp_array as $ipRange) {
+                if (self::matchIp($ipRange) === true) {
+                    return true;
+                }
+            }
+        }
+
         $file = 'traffic_limiter.php';
         if (self::_exists($file)) {
             require self::getPath($file);
diff --git a/tst/Persistence/TrafficLimiterTest.php b/tst/Persistence/TrafficLimiterTest.php
index 7376938..4101301 100644
--- a/tst/Persistence/TrafficLimiterTest.php
+++ b/tst/Persistence/TrafficLimiterTest.php
@@ -35,5 +35,20 @@ class TrafficLimiterTest extends PHPUnit_Framework_TestCase
         $this->assertTrue(TrafficLimiter::canPass(), 'fourth request has different ip and may pass');
         $_SERVER['REMOTE_ADDR'] = '127.0.0.1';
         $this->assertFalse(TrafficLimiter::canPass(), 'fifth request is to fast, may not pass');
+
+        // exempted IPs configuration
+        TrafficLimiter::setExemptedIp('1.2.3.4,10.10.10.0/24,2001:1620:2057::/48');
+        $this->assertFalse(TrafficLimiter::canPass(), 'still too fast and not exempted');
+        $_SERVER['REMOTE_ADDR'] = '10.10.10.10';
+        $this->assertTrue(TrafficLimiter::canPass(), 'IPv4 in exempted range');
+        $this->assertTrue(TrafficLimiter::canPass(), 'request is to fast, but IPv4 in exempted range');
+        $_SERVER['REMOTE_ADDR'] = '2001:1620:2057:dead:beef::cafe:babe';
+        $this->assertTrue(TrafficLimiter::canPass(), 'IPv6 in exempted range');
+        $this->assertTrue(TrafficLimiter::canPass(), 'request is to fast, but IPv6 in exempted range');
+        TrafficLimiter::setExemptedIp('127.*,foobar');
+        $this->assertFalse(TrafficLimiter::canPass(), 'request is to fast, invalid range');
+        $_SERVER['REMOTE_ADDR'] = 'foobar';
+        $this->assertTrue(TrafficLimiter::canPass(), 'non-IP address');
+        $this->assertTrue(TrafficLimiter::canPass(), 'request is to fast, but non-IP address matches exempted range');
     }
 }
diff --git a/vendor/composer/autoload_classmap.php b/vendor/composer/autoload_classmap.php
index b98b672..81358f5 100644
--- a/vendor/composer/autoload_classmap.php
+++ b/vendor/composer/autoload_classmap.php
@@ -6,6 +6,20 @@ $vendorDir = dirname(dirname(__FILE__));
 $baseDir = dirname($vendorDir);
 
 return array(
+    'IPLib\\Address\\AddressInterface' => $vendorDir . '/mlocati/ip-lib/src/Address/AddressInterface.php',
+    'IPLib\\Address\\AssignedRange' => $vendorDir . '/mlocati/ip-lib/src/Address/AssignedRange.php',
+    'IPLib\\Address\\IPv4' => $vendorDir . '/mlocati/ip-lib/src/Address/IPv4.php',
+    'IPLib\\Address\\IPv6' => $vendorDir . '/mlocati/ip-lib/src/Address/IPv6.php',
+    'IPLib\\Address\\Type' => $vendorDir . '/mlocati/ip-lib/src/Address/Type.php',
+    'IPLib\\Factory' => $vendorDir . '/mlocati/ip-lib/src/Factory.php',
+    'IPLib\\Range\\AbstractRange' => $vendorDir . '/mlocati/ip-lib/src/Range/AbstractRange.php',
+    'IPLib\\Range\\Pattern' => $vendorDir . '/mlocati/ip-lib/src/Range/Pattern.php',
+    'IPLib\\Range\\RangeInterface' => $vendorDir . '/mlocati/ip-lib/src/Range/RangeInterface.php',
+    'IPLib\\Range\\Single' => $vendorDir . '/mlocati/ip-lib/src/Range/Single.php',
+    'IPLib\\Range\\Subnet' => $vendorDir . '/mlocati/ip-lib/src/Range/Subnet.php',
+    'IPLib\\Range\\Type' => $vendorDir . '/mlocati/ip-lib/src/Range/Type.php',
+    'IPLib\\Service\\BinaryMath' => $vendorDir . '/mlocati/ip-lib/src/Service/BinaryMath.php',
+    'IPLib\\Service\\RangesFromBounradyCalculator' => $vendorDir . '/mlocati/ip-lib/src/Service/RangesFromBounradyCalculator.php',
     'Identicon\\Generator\\BaseGenerator' => $vendorDir . '/yzalis/identicon/src/Identicon/Generator/BaseGenerator.php',
     'Identicon\\Generator\\GdGenerator' => $vendorDir . '/yzalis/identicon/src/Identicon/Generator/GdGenerator.php',
     'Identicon\\Generator\\GeneratorInterface' => $vendorDir . '/yzalis/identicon/src/Identicon/Generator/GeneratorInterface.php',
diff --git a/vendor/composer/autoload_psr4.php b/vendor/composer/autoload_psr4.php
index 313097d..9bd3702 100644
--- a/vendor/composer/autoload_psr4.php
+++ b/vendor/composer/autoload_psr4.php
@@ -8,4 +8,5 @@ $baseDir = dirname($vendorDir);
 return array(
     'PrivateBin\\' => array($baseDir . '/lib'),
     'Identicon\\' => array($vendorDir . '/yzalis/identicon/src/Identicon'),
+    'IPLib\\' => array($vendorDir . '/mlocati/ip-lib/src'),
 );
diff --git a/vendor/composer/autoload_static.php b/vendor/composer/autoload_static.php
index 604d6bb..9197c94 100644
--- a/vendor/composer/autoload_static.php
+++ b/vendor/composer/autoload_static.php
@@ -18,6 +18,7 @@ class ComposerStaticInitDontChange
         'I' => 
         array (
             'Identicon\\' => 10,
+            'IPLib\\' => 6,
         ),
     );
 
@@ -30,9 +31,27 @@ class ComposerStaticInitDontChange
         array (
             0 => __DIR__ . '/..' . '/yzalis/identicon/src/Identicon',
         ),
+        'IPLib\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/mlocati/ip-lib/src',
+        ),
     );
 
     public static $classMap = array (
+        'IPLib\\Address\\AddressInterface' => __DIR__ . '/..' . '/mlocati/ip-lib/src/Address/AddressInterface.php',
+        'IPLib\\Address\\AssignedRange' => __DIR__ . '/..' . '/mlocati/ip-lib/src/Address/AssignedRange.php',
+        'IPLib\\Address\\IPv4' => __DIR__ . '/..' . '/mlocati/ip-lib/src/Address/IPv4.php',
+        'IPLib\\Address\\IPv6' => __DIR__ . '/..' . '/mlocati/ip-lib/src/Address/IPv6.php',
+        'IPLib\\Address\\Type' => __DIR__ . '/..' . '/mlocati/ip-lib/src/Address/Type.php',
+        'IPLib\\Factory' => __DIR__ . '/..' . '/mlocati/ip-lib/src/Factory.php',
+        'IPLib\\Range\\AbstractRange' => __DIR__ . '/..' . '/mlocati/ip-lib/src/Range/AbstractRange.php',
+        'IPLib\\Range\\Pattern' => __DIR__ . '/..' . '/mlocati/ip-lib/src/Range/Pattern.php',
+        'IPLib\\Range\\RangeInterface' => __DIR__ . '/..' . '/mlocati/ip-lib/src/Range/RangeInterface.php',
+        'IPLib\\Range\\Single' => __DIR__ . '/..' . '/mlocati/ip-lib/src/Range/Single.php',
+        'IPLib\\Range\\Subnet' => __DIR__ . '/..' . '/mlocati/ip-lib/src/Range/Subnet.php',
+        'IPLib\\Range\\Type' => __DIR__ . '/..' . '/mlocati/ip-lib/src/Range/Type.php',
+        'IPLib\\Service\\BinaryMath' => __DIR__ . '/..' . '/mlocati/ip-lib/src/Service/BinaryMath.php',
+        'IPLib\\Service\\RangesFromBounradyCalculator' => __DIR__ . '/..' . '/mlocati/ip-lib/src/Service/RangesFromBounradyCalculator.php',
         'Identicon\\Generator\\BaseGenerator' => __DIR__ . '/..' . '/yzalis/identicon/src/Identicon/Generator/BaseGenerator.php',
         'Identicon\\Generator\\GdGenerator' => __DIR__ . '/..' . '/yzalis/identicon/src/Identicon/Generator/GdGenerator.php',
         'Identicon\\Generator\\GeneratorInterface' => __DIR__ . '/..' . '/yzalis/identicon/src/Identicon/Generator/GeneratorInterface.php',
diff --git a/vendor/mlocati/ip-lib/ip-lib.php b/vendor/mlocati/ip-lib/ip-lib.php
new file mode 100644
index 0000000..c34d0b4
--- /dev/null
+++ b/vendor/mlocati/ip-lib/ip-lib.php
@@ -0,0 +1,13 @@
+<?php
+
+spl_autoload_register(
+    function ($class) {
+        if (strpos($class, 'IPLib\\') !== 0) {
+            return;
+        }
+        $file = __DIR__ . DIRECTORY_SEPARATOR . 'src' . str_replace('\\', DIRECTORY_SEPARATOR, substr($class, strlen('IPLib'))) . '.php';
+        if (is_file($file)) {
+            require_once $file;
+        }
+    }
+);
diff --git a/vendor/mlocati/ip-lib/src/Address/AddressInterface.php b/vendor/mlocati/ip-lib/src/Address/AddressInterface.php
new file mode 100644
index 0000000..3b254c4
--- /dev/null
+++ b/vendor/mlocati/ip-lib/src/Address/AddressInterface.php
@@ -0,0 +1,125 @@
+<?php
+
+namespace IPLib\Address;
+
+use IPLib\Range\RangeInterface;
+
+/**
+ * Interface of all the IP address types.
+ */
+interface AddressInterface
+{
+    /**
+     * Get the short string representation of this address.
+     *
+     * @return string
+     */
+    public function __toString();
+
+    /**
+     * Get the number of bits representing this address type.
+     *
+     * @return int
+     *
+     * @example 32 for IPv4
+     * @example 128 for IPv6
+     */
+    public static function getNumberOfBits();
+
+    /**
+     * Get the string representation of this address.
+     *
+     * @param bool $long set to true to have a long/full representation, false otherwise
+     *
+     * @return string
+     *
+     * @example If $long is true, you'll get '0000:0000:0000:0000:0000:0000:0000:0001', '::1' otherwise.
+     */
+    public function toString($long = false);
+
+    /**
+     * Get the byte list of the IP address.
+     *
+     * @return int[]
+     *
+     * @example For localhost: for IPv4 you'll get array(127, 0, 0, 1), for IPv6 array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1)
+     */
+    public function getBytes();
+
+    /**
+     * Get the full bit list the IP address.
+     *
+     * @return string
+     *
+     * @example For localhost: For IPv4 you'll get '01111111000000000000000000000001' (32 digits), for IPv6 '00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001' (128 digits)
+     */
+    public function getBits();
+
+    /**
+     * Get the type of the IP address.
+     *
+     * @return int One of the \IPLib\Address\Type::T_... constants
+     */
+    public function getAddressType();
+
+    /**
+     * Get the default RFC reserved range type.
+     *
+     * @return int One of the \IPLib\Range\Type::T_... constants
+     */
+    public static function getDefaultReservedRangeType();
+
+    /**
+     * Get the RFC reserved ranges (except the ones of type getDefaultReservedRangeType).
+     *
+     * @return \IPLib\Address\AssignedRange[] ranges are sorted
+     */
+    public static function getReservedRanges();
+
+    /**
+     * Get the type of range of the IP address.
+     *
+     * @return int One of the \IPLib\Range\Type::T_... constants
+     */
+    public function getRangeType();
+
+    /**
+     * Get a string representation of this address than can be used when comparing addresses and ranges.
+     *
+     * @return string
+     */
+    public function getComparableString();
+
+    /**
+     * Check if this address is contained in an range.
+     *
+     * @param \IPLib\Range\RangeInterface $range
+     *
+     * @return bool
+     */
+    public function matches(RangeInterface $range);
+
+    /**
+     * Get the address right after this IP address (if available).
+     *
+     * @return \IPLib\Address\AddressInterface|null
+     */
+    public function getNextAddress();
+
+    /**
+     * Get the address right before this IP address (if available).
+     *
+     * @return \IPLib\Address\AddressInterface|null
+     */
+    public function getPreviousAddress();
+
+    /**
+     * Get the Reverse DNS Lookup Address of this IP address.
+     *
+     * @return string
+     *
+     * @example for IPv4 it returns something like x.x.x.x.in-addr.arpa
+     * @example for IPv6 it returns something like x.x.x.x..x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.ip6.arpa
+     */
+    public function getReverseDNSLookupName();
+}
diff --git a/vendor/mlocati/ip-lib/src/Address/AssignedRange.php b/vendor/mlocati/ip-lib/src/Address/AssignedRange.php
new file mode 100644
index 0000000..c5db08d
--- /dev/null
+++ b/vendor/mlocati/ip-lib/src/Address/AssignedRange.php
@@ -0,0 +1,138 @@
+<?php
+
+namespace IPLib\Address;
+
+use IPLib\Range\RangeInterface;
+
+/**
+ * Represents an IP address range with an assigned range type.
+ */
+class AssignedRange
+{
+    /**
+     * The range definition.
+     *
+     * @var \IPLib\Range\RangeInterface
+     */
+    protected $range;
+
+    /**
+     * The range type.
+     *
+     * @var int one of the \IPLib\Range\Type::T_ constants
+     */
+    protected $type;
+
+    /**
+     * The list of exceptions for this range type.
+     *
+     * @var \IPLib\Address\AssignedRange[]
+     */
+    protected $exceptions;
+
+    /**
+     * Initialize the instance.
+     *
+     * @param \IPLib\Range\RangeInterface $range the range definition
+     * @param int $type The range type (one of the \IPLib\Range\Type::T_ constants)
+     * @param \IPLib\Address\AssignedRange[] $exceptions the list of exceptions for this range type
+     */
+    public function __construct(RangeInterface $range, $type, array $exceptions = array())
+    {
+        $this->range = $range;
+        $this->type = $type;
+        $this->exceptions = $exceptions;
+    }
+
+    /**
+     * Get the range definition.
+     *
+     * @return \IPLib\Range\RangeInterface
+     */
+    public function getRange()
+    {
+        return $this->range;
+    }
+
+    /**
+     * Get the range type.
+     *
+     * @return int one of the \IPLib\Range\Type::T_ constants
+     */
+    public function getType()
+    {
+        return $this->type;
+    }
+
+    /**
+     * Get the list of exceptions for this range type.
+     *
+     * @return \IPLib\Address\AssignedRange[]
+     */
+    public function getExceptions()
+    {
+        return $this->exceptions;
+    }
+
+    /**
+     * Get the assigned type for a specific address.
+     *
+     * @param \IPLib\Address\AddressInterface $address
+     *
+     * @return int|null return NULL of the address is outside this address; a \IPLib\Range\Type::T_ constant otherwise
+     */
+    public function getAddressType(AddressInterface $address)
+    {
+        $result = null;
+        if ($this->range->contains($address)) {
+            foreach ($this->exceptions as $exception) {
+                $result = $exception->getAddressType($address);
+                if ($result !== null) {
+                    break;
+                }
+            }
+            if ($result === null) {
+                $result = $this->type;
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * Get the assigned type for a specific address range.
+     *
+     * @param \IPLib\Range\RangeInterface $range
+     *
+     * @return int|false|null return NULL of the range is fully outside this range; false if it's partly crosses this range (or it contains mixed types); a \IPLib\Range\Type::T_ constant otherwise
+     */
+    public function getRangeType(RangeInterface $range)
+    {
+        $myStart = $this->range->getComparableStartString();
+        $rangeEnd = $range->getComparableEndString();
+        if ($myStart > $rangeEnd) {
+            $result = null;
+        } else {
+            $myEnd = $this->range->getComparableEndString();
+            $rangeStart = $range->getComparableStartString();
+            if ($myEnd < $rangeStart) {
+                $result = null;
+            } elseif ($rangeStart < $myStart || $rangeEnd > $myEnd) {
+                $result = false;
+            } else {
+                $result = null;
+                foreach ($this->exceptions as $exception) {
+                    $result = $exception->getRangeType($range);
+                    if ($result !== null) {
+                        break;
+                    }
+                }
+                if ($result === null) {
+                    $result = $this->getType();
+                }
+            }
+        }
+
+        return $result;
+    }
+}
diff --git a/vendor/mlocati/ip-lib/src/Address/IPv4.php b/vendor/mlocati/ip-lib/src/Address/IPv4.php
new file mode 100644
index 0000000..d31338e
--- /dev/null
+++ b/vendor/mlocati/ip-lib/src/Address/IPv4.php
@@ -0,0 +1,465 @@
+<?php
+
+namespace IPLib\Address;
+
+use IPLib\Range\RangeInterface;
+use IPLib\Range\Subnet;
+use IPLib\Range\Type as RangeType;
+
+/**
+ * An IPv4 address.
+ */
+class IPv4 implements AddressInterface
+{
+    /**
+     * The string representation of the address.
+     *
+     * @var string
+     *
+     * @example '127.0.0.1'
+     */
+    protected $address;
+
+    /**
+     * The byte list of the IP address.
+     *
+     * @var int[]|null
+     */
+    protected $bytes;
+
+    /**
+     * The type of the range of this IP address.
+     *
+     * @var int|null
+     */
+    protected $rangeType;
+
+    /**
+     * A string representation of this address than can be used when comparing addresses and ranges.
+     *
+     * @var string
+     */
+    protected $comparableString;
+
+    /**
+     * An array containing RFC designated address ranges.
+     *
+     * @var array|null
+     */
+    private static $reservedRanges = null;
+
+    /**
+     * Initializes the instance.
+     *
+     * @param string $address
+     */
+    protected function __construct($address)
+    {
+        $this->address = $address;
+        $this->bytes = null;
+        $this->rangeType = null;
+        $this->comparableString = null;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::__toString()
+     */
+    public function __toString()
+    {
+        return $this->address;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getNumberOfBits()
+     */
+    public static function getNumberOfBits()
+    {
+        return 32;
+    }
+
+    /**
+     * Parse a string and returns an IPv4 instance if the string is valid, or null otherwise.
+     *
+     * @param string|mixed $address the address to parse
+     * @param bool $mayIncludePort set to false to avoid parsing addresses with ports
+     * @param bool $supportNonDecimalIPv4 set to true to support parsing non decimal (that is, octal and hexadecimal) IPv4 addresses
+     *
+     * @return static|null
+     */
+    public static function fromString($address, $mayIncludePort = true, $supportNonDecimalIPv4 = false)
+    {
+        if (!is_string($address) || !strpos($address, '.')) {
+            return null;
+        }
+        $rxChunk = '0?[0-9]{1,3}';
+        if ($supportNonDecimalIPv4) {
+            $rxChunk = "(?:0[Xx]0*[0-9A-Fa-f]{1,2})|(?:{$rxChunk})";
+        }
+        $rx = "0*?({$rxChunk})\.0*?({$rxChunk})\.0*?({$rxChunk})\.0*?({$rxChunk})";
+        if ($mayIncludePort) {
+            $rx .= '(?::\d+)?';
+        }
+        $matches = null;
+        if (!preg_match('/^' . $rx . '$/', $address, $matches)) {
+            return null;
+        }
+        $nums = array();
+        for ($i = 1; $i <= 4; $i++) {
+            $s = $matches[$i];
+            if ($supportNonDecimalIPv4) {
+                if (stripos($s, '0x') === 0) {
+                    $n = hexdec(substr($s, 2));
+                } elseif ($s[0] === '0') {
+                    if (!preg_match('/^[0-7]+$/', $s)) {
+                        return null;
+                    }
+                    $n = octdec(substr($s, 1));
+                } else {
+                    $n = (int) $s;
+                }
+            } else {
+                $n = (int) $s;
+            }
+            if ($n < 0 || $n > 255) {
+                return null;
+            }
+            $nums[] = (string) $n;
+        }
+
+        return new static(implode('.', $nums));
+    }
+
+    /**
+     * Parse an array of bytes and returns an IPv4 instance if the array is valid, or null otherwise.
+     *
+     * @param int[]|array $bytes
+     *
+     * @return static|null
+     */
+    public static function fromBytes(array $bytes)
+    {
+        $result = null;
+        if (count($bytes) === 4) {
+            $chunks = array_map(
+                function ($byte) {
+                    return (is_int($byte) && $byte >= 0 && $byte <= 255) ? (string) $byte : false;
+                },
+                $bytes
+            );
+            if (in_array(false, $chunks, true) === false) {
+                $result = new static(implode('.', $chunks));
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::toString()
+     */
+    public function toString($long = false)
+    {
+        if ($long) {
+            return $this->getComparableString();
+        }
+
+        return $this->address;
+    }
+
+    /**
+     * Get the octal representation of this IP address.
+     *
+     * @param bool $long
+     *
+     * @return string
+     *
+     * @example if $long == false: if the decimal representation is '0.7.8.255': '0.7.010.0377'
+     * @example if $long == true: if the decimal representation is '0.7.8.255': '0000.0007.0010.0377'
+     */
+    public function toOctal($long = false)
+    {
+        $chunks = array();
+        foreach ($this->getBytes() as $byte) {
+            if ($long) {
+                $chunks[] = sprintf('%04o', $byte);
+            } else {
+                $chunks[] = '0' . decoct($byte);
+            }
+        }
+
+        return implode('.', $chunks);
+    }
+
+    /**
+     * Get the hexadecimal representation of this IP address.
+     *
+     * @param bool $long
+     *
+     * @return string
+     *
+     * @example if $long == false: if the decimal representation is '0.9.10.255': '0.9.0xa.0xff'
+     * @example if $long == true: if the decimal representation is '0.9.10.255': '0x00.0x09.0x0a.0xff'
+     */
+    public function toHexadecimal($long = false)
+    {
+        $chunks = array();
+        foreach ($this->getBytes() as $byte) {
+            if ($long) {
+                $chunks[] = sprintf('0x%02x', $byte);
+            } else {
+                $chunks[] = '0x' . dechex($byte);
+            }
+        }
+
+        return implode('.', $chunks);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getBytes()
+     */
+    public function getBytes()
+    {
+        if ($this->bytes === null) {
+            $this->bytes = array_map(
+                function ($chunk) {
+                    return (int) $chunk;
+                },
+                explode('.', $this->address)
+            );
+        }
+
+        return $this->bytes;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getBits()
+     */
+    public function getBits()
+    {
+        $parts = array();
+        foreach ($this->getBytes() as $byte) {
+            $parts[] = sprintf('%08b', $byte);
+        }
+
+        return implode('', $parts);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getAddressType()
+     */
+    public function getAddressType()
+    {
+        return Type::T_IPv4;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getDefaultReservedRangeType()
+     */
+    public static function getDefaultReservedRangeType()
+    {
+        return RangeType::T_PUBLIC;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getReservedRanges()
+     */
+    public static function getReservedRanges()
+    {
+        if (self::$reservedRanges === null) {
+            $reservedRanges = array();
+            foreach (array(
+                // RFC 5735
+                '0.0.0.0/8' => array(RangeType::T_THISNETWORK, array('0.0.0.0/32' => RangeType::T_UNSPECIFIED)),
+                // RFC 5735
+                '10.0.0.0/8' => array(RangeType::T_PRIVATENETWORK),
+                // RFC 6598
+                '100.64.0.0/10' => array(RangeType::T_CGNAT),
+                // RFC 5735
+                '127.0.0.0/8' => array(RangeType::T_LOOPBACK),
+                // RFC 5735
+                '169.254.0.0/16' => array(RangeType::T_LINKLOCAL),
+                // RFC 5735
+                '172.16.0.0/12' => array(RangeType::T_PRIVATENETWORK),
+                // RFC 5735
+                '192.0.0.0/24' => array(RangeType::T_RESERVED),
+                // RFC 5735
+                '192.0.2.0/24' => array(RangeType::T_RESERVED),
+                // RFC 5735
+                '192.88.99.0/24' => array(RangeType::T_ANYCASTRELAY),
+                // RFC 5735
+                '192.168.0.0/16' => array(RangeType::T_PRIVATENETWORK),
+                // RFC 5735
+                '198.18.0.0/15' => array(RangeType::T_RESERVED),
+                // RFC 5735
+                '198.51.100.0/24' => array(RangeType::T_RESERVED),
+                // RFC 5735
+                '203.0.113.0/24' => array(RangeType::T_RESERVED),
+                // RFC 5735
+                '224.0.0.0/4' => array(RangeType::T_MULTICAST),
+                // RFC 5735
+                '240.0.0.0/4' => array(RangeType::T_RESERVED, array('255.255.255.255/32' => RangeType::T_LIMITEDBROADCAST)),
+            ) as $range => $data) {
+                $exceptions = array();
+                if (isset($data[1])) {
+                    foreach ($data[1] as $exceptionRange => $exceptionType) {
+                        $exceptions[] = new AssignedRange(Subnet::fromString($exceptionRange), $exceptionType);
+                    }
+                }
+                $reservedRanges[] = new AssignedRange(Subnet::fromString($range), $data[0], $exceptions);
+            }
+            self::$reservedRanges = $reservedRanges;
+        }
+
+        return self::$reservedRanges;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getRangeType()
+     */
+    public function getRangeType()
+    {
+        if ($this->rangeType === null) {
+            $rangeType = null;
+            foreach (static::getReservedRanges() as $reservedRange) {
+                $rangeType = $reservedRange->getAddressType($this);
+                if ($rangeType !== null) {
+                    break;
+                }
+            }
+            $this->rangeType = $rangeType === null ? static::getDefaultReservedRangeType() : $rangeType;
+        }
+
+        return $this->rangeType;
+    }
+
+    /**
+     * Create an IPv6 representation of this address (in 6to4 notation).
+     *
+     * @return \IPLib\Address\IPv6
+     */
+    public function toIPv6()
+    {
+        $myBytes = $this->getBytes();
+
+        return IPv6::fromString('2002:' . sprintf('%02x', $myBytes[0]) . sprintf('%02x', $myBytes[1]) . ':' . sprintf('%02x', $myBytes[2]) . sprintf('%02x', $myBytes[3]) . '::');
+    }
+
+    /**
+     * Create an IPv6 representation of this address (in IPv6 IPv4-mapped notation).
+     *
+     * @return \IPLib\Address\IPv6
+     */
+    public function toIPv6IPv4Mapped()
+    {
+        return IPv6::fromBytes(array_merge(array(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff), $this->getBytes()));
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getComparableString()
+     */
+    public function getComparableString()
+    {
+        if ($this->comparableString === null) {
+            $chunks = array();
+            foreach ($this->getBytes() as $byte) {
+                $chunks[] = sprintf('%03d', $byte);
+            }
+            $this->comparableString = implode('.', $chunks);
+        }
+
+        return $this->comparableString;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::matches()
+     */
+    public function matches(RangeInterface $range)
+    {
+        return $range->contains($this);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getNextAddress()
+     */
+    public function getNextAddress()
+    {
+        $overflow = false;
+        $bytes = $this->getBytes();
+        for ($i = count($bytes) - 1; $i >= 0; $i--) {
+            if ($bytes[$i] === 255) {
+                if ($i === 0) {
+                    $overflow = true;
+                    break;
+                }
+                $bytes[$i] = 0;
+            } else {
+                $bytes[$i]++;
+                break;
+            }
+        }
+
+        return $overflow ? null : static::fromBytes($bytes);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getPreviousAddress()
+     */
+    public function getPreviousAddress()
+    {
+        $overflow = false;
+        $bytes = $this->getBytes();
+        for ($i = count($bytes) - 1; $i >= 0; $i--) {
+            if ($bytes[$i] === 0) {
+                if ($i === 0) {
+                    $overflow = true;
+                    break;
+                }
+                $bytes[$i] = 255;
+            } else {
+                $bytes[$i]--;
+                break;
+            }
+        }
+
+        return $overflow ? null : static::fromBytes($bytes);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getReverseDNSLookupName()
+     */
+    public function getReverseDNSLookupName()
+    {
+        return implode(
+            '.',
+            array_reverse($this->getBytes())
+        ) . '.in-addr.arpa';
+    }
+}
diff --git a/vendor/mlocati/ip-lib/src/Address/IPv6.php b/vendor/mlocati/ip-lib/src/Address/IPv6.php
new file mode 100644
index 0000000..3666487
--- /dev/null
+++ b/vendor/mlocati/ip-lib/src/Address/IPv6.php
@@ -0,0 +1,568 @@
+<?php
+
+namespace IPLib\Address;
+
+use IPLib\Range\RangeInterface;
+use IPLib\Range\Subnet;
+use IPLib\Range\Type as RangeType;
+
+/**
+ * An IPv6 address.
+ */
+class IPv6 implements AddressInterface
+{
+    /**
+     * The long string representation of the address.
+     *
+     * @var string
+     *
+     * @example '0000:0000:0000:0000:0000:0000:0000:0001'
+     */
+    protected $longAddress;
+
+    /**
+     * The long string representation of the address.
+     *
+     * @var string|null
+     *
+     * @example '::1'
+     */
+    protected $shortAddress;
+
+    /**
+     * The byte list of the IP address.
+     *
+     * @var int[]|null
+     */
+    protected $bytes;
+
+    /**
+     * The word list of the IP address.
+     *
+     * @var int[]|null
+     */
+    protected $words;
+
+    /**
+     * The type of the range of this IP address.
+     *
+     * @var int|null
+     */
+    protected $rangeType;
+
+    /**
+     * An array containing RFC designated address ranges.
+     *
+     * @var array|null
+     */
+    private static $reservedRanges = null;
+
+    /**
+     * Initializes the instance.
+     *
+     * @param string $longAddress
+     */
+    public function __construct($longAddress)
+    {
+        $this->longAddress = $longAddress;
+        $this->shortAddress = null;
+        $this->bytes = null;
+        $this->words = null;
+        $this->rangeType = null;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::__toString()
+     */
+    public function __toString()
+    {
+        return $this->toString();
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getNumberOfBits()
+     */
+    public static function getNumberOfBits()
+    {
+        return 128;
+    }
+
+    /**
+     * Parse a string and returns an IPv6 instance if the string is valid, or null otherwise.
+     *
+     * @param string|mixed $address the address to parse
+     * @param bool $mayIncludePort set to false to avoid parsing addresses with ports
+     * @param bool $mayIncludeZoneID set to false to avoid parsing addresses with zone IDs (see RFC 4007)
+     *
+     * @return static|null
+     */
+    public static function fromString($address, $mayIncludePort = true, $mayIncludeZoneID = true)
+    {
+        $result = null;
+        if (is_string($address) && strpos($address, ':') !== false && strpos($address, ':::') === false) {
+            $matches = null;
+            if ($mayIncludePort && $address[0] === '[' && preg_match('/^\[(.+)]:\d+$/', $address, $matches)) {
+                $address = $matches[1];
+            }
+            if ($mayIncludeZoneID) {
+                $percentagePos = strpos($address, '%');
+                if ($percentagePos > 0) {
+                    $address = substr($address, 0, $percentagePos);
+                }
+            }
+            if (preg_match('/^((?:[0-9a-f]*:+)+)(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/i', $address, $matches)) {
+                $address6 = static::fromString($matches[1] . '0:0', false);
+                if ($address6 !== null) {
+                    $address4 = IPv4::fromString($matches[2], false);
+                    if ($address4 !== null) {
+                        $bytes4 = $address4->getBytes();
+                        $address6->longAddress = substr($address6->longAddress, 0, -9) . sprintf('%02x%02x:%02x%02x', $bytes4[0], $bytes4[1], $bytes4[2], $bytes4[3]);
+                        $result = $address6;
+                    }
+                }
+            } else {
+                if (strpos($address, '::') === false) {
+                    $chunks = explode(':', $address);
+                } else {
+                    $chunks = array();
+                    $parts = explode('::', $address);
+                    if (count($parts) === 2) {
+                        $before = ($parts[0] === '') ? array() : explode(':', $parts[0]);
+                        $after = ($parts[1] === '') ? array() : explode(':', $parts[1]);
+                        $missing = 8 - count($before) - count($after);
+                        if ($missing >= 0) {
+                            $chunks = $before;
+                            if ($missing !== 0) {
+                                $chunks = array_merge($chunks, array_fill(0, $missing, '0'));
+                            }
+                            $chunks = array_merge($chunks, $after);
+                        }
+                    }
+                }
+                if (count($chunks) === 8) {
+                    $nums = array_map(
+                        function ($chunk) {
+                            return preg_match('/^[0-9A-Fa-f]{1,4}$/', $chunk) ? hexdec($chunk) : false;
+                        },
+                        $chunks
+                    );
+                    if (!in_array(false, $nums, true)) {
+                        $longAddress = implode(
+                            ':',
+                            array_map(
+                                function ($num) {
+                                    return sprintf('%04x', $num);
+                                },
+                                $nums
+                            )
+                        );
+                        $result = new static($longAddress);
+                    }
+                }
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * Parse an array of bytes and returns an IPv6 instance if the array is valid, or null otherwise.
+     *
+     * @param int[]|array $bytes
+     *
+     * @return static|null
+     */
+    public static function fromBytes(array $bytes)
+    {
+        $result = null;
+        if (count($bytes) === 16) {
+            $address = '';
+            for ($i = 0; $i < 16; $i++) {
+                if ($i !== 0 && $i % 2 === 0) {
+                    $address .= ':';
+                }
+                $byte = $bytes[$i];
+                if (is_int($byte) && $byte >= 0 && $byte <= 255) {
+                    $address .= sprintf('%02x', $byte);
+                } else {
+                    $address = null;
+                    break;
+                }
+            }
+            if ($address !== null) {
+                $result = new static($address);
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * Parse an array of words and returns an IPv6 instance if the array is valid, or null otherwise.
+     *
+     * @param int[]|array $words
+     *
+     * @return static|null
+     */
+    public static function fromWords(array $words)
+    {
+        $result = null;
+        if (count($words) === 8) {
+            $chunks = array();
+            for ($i = 0; $i < 8; $i++) {
+                $word = $words[$i];
+                if (is_int($word) && $word >= 0 && $word <= 0xffff) {
+                    $chunks[] = sprintf('%04x', $word);
+                } else {
+                    $chunks = null;
+                    break;
+                }
+            }
+            if ($chunks !== null) {
+                $result = new static(implode(':', $chunks));
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::toString()
+     */
+    public function toString($long = false)
+    {
+        if ($long) {
+            $result = $this->longAddress;
+        } else {
+            if ($this->shortAddress === null) {
+                if (strpos($this->longAddress, '0000:0000:0000:0000:0000:ffff:') === 0) {
+                    $lastBytes = array_slice($this->getBytes(), -4);
+                    $this->shortAddress = '::ffff:' . implode('.', $lastBytes);
+                } else {
+                    $chunks = array_map(
+                        function ($word) {
+                            return dechex($word);
+                        },
+                        $this->getWords()
+                    );
+                    $shortAddress = implode(':', $chunks);
+                    $matches = null;
+                    for ($i = 8; $i > 1; $i--) {
+                        $search = '(?:^|:)' . rtrim(str_repeat('0:', $i), ':') . '(?:$|:)';
+                        if (preg_match('/^(.*?)' . $search . '(.*)$/', $shortAddress, $matches)) {
+                            $shortAddress = $matches[1] . '::' . $matches[2];
+                            break;
+                        }
+                    }
+                    $this->shortAddress = $shortAddress;
+                }
+            }
+            $result = $this->shortAddress;
+        }
+
+        return $result;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getBytes()
+     */
+    public function getBytes()
+    {
+        if ($this->bytes === null) {
+            $bytes = array();
+            foreach ($this->getWords() as $word) {
+                $bytes[] = $word >> 8;
+                $bytes[] = $word & 0xff;
+            }
+            $this->bytes = $bytes;
+        }
+
+        return $this->bytes;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getBits()
+     */
+    public function getBits()
+    {
+        $parts = array();
+        foreach ($this->getBytes() as $byte) {
+            $parts[] = sprintf('%08b', $byte);
+        }
+
+        return implode('', $parts);
+    }
+
+    /**
+     * Get the word list of the IP address.
+     *
+     * @return int[]
+     */
+    public function getWords()
+    {
+        if ($this->words === null) {
+            $this->words = array_map(
+                function ($chunk) {
+                    return hexdec($chunk);
+                },
+                explode(':', $this->longAddress)
+            );
+        }
+
+        return $this->words;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getAddressType()
+     */
+    public function getAddressType()
+    {
+        return Type::T_IPv6;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getDefaultReservedRangeType()
+     */
+    public static function getDefaultReservedRangeType()
+    {
+        return RangeType::T_RESERVED;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getReservedRanges()
+     */
+    public static function getReservedRanges()
+    {
+        if (self::$reservedRanges === null) {
+            $reservedRanges = array();
+            foreach (array(
+                // RFC 4291
+                '::/128' => array(RangeType::T_UNSPECIFIED),
+                // RFC 4291
+                '::1/128' => array(RangeType::T_LOOPBACK),
+                // RFC 4291
+                '100::/8' => array(RangeType::T_DISCARD, array('100::/64' => RangeType::T_DISCARDONLY)),
+                //'2002::/16' => array(RangeType::),
+                // RFC 4291
+                '2000::/3' => array(RangeType::T_PUBLIC),
+                // RFC 4193
+                'fc00::/7' => array(RangeType::T_PRIVATENETWORK),
+                // RFC 4291
+                'fe80::/10' => array(RangeType::T_LINKLOCAL_UNICAST),
+                // RFC 4291
+                'ff00::/8' => array(RangeType::T_MULTICAST),
+                // RFC 4291
+                //'::/8' => array(RangeType::T_RESERVED),
+                // RFC 4048
+                //'200::/7' => array(RangeType::T_RESERVED),
+                // RFC 4291
+                //'400::/6' => array(RangeType::T_RESERVED),
+                // RFC 4291
+                //'800::/5' => array(RangeType::T_RESERVED),
+                // RFC 4291
+                //'1000::/4' => array(RangeType::T_RESERVED),
+                // RFC 4291
+                //'4000::/3' => array(RangeType::T_RESERVED),
+                // RFC 4291
+                //'6000::/3' => array(RangeType::T_RESERVED),
+                // RFC 4291
+                //'8000::/3' => array(RangeType::T_RESERVED),
+                // RFC 4291
+                //'a000::/3' => array(RangeType::T_RESERVED),
+                // RFC 4291
+                //'c000::/3' => array(RangeType::T_RESERVED),
+                // RFC 4291
+                //'e000::/4' => array(RangeType::T_RESERVED),
+                // RFC 4291
+                //'f000::/5' => array(RangeType::T_RESERVED),
+                // RFC 4291
+                //'f800::/6' => array(RangeType::T_RESERVED),
+                // RFC 4291
+                //'fe00::/9' => array(RangeType::T_RESERVED),
+                // RFC 3879
+                //'fec0::/10' => array(RangeType::T_RESERVED),
+            ) as $range => $data) {
+                $exceptions = array();
+                if (isset($data[1])) {
+                    foreach ($data[1] as $exceptionRange => $exceptionType) {
+                        $exceptions[] = new AssignedRange(Subnet::fromString($exceptionRange), $exceptionType);
+                    }
+                }
+                $reservedRanges[] = new AssignedRange(Subnet::fromString($range), $data[0], $exceptions);
+            }
+            self::$reservedRanges = $reservedRanges;
+        }
+
+        return self::$reservedRanges;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getRangeType()
+     */
+    public function getRangeType()
+    {
+        if ($this->rangeType === null) {
+            $ipv4 = $this->toIPv4();
+            if ($ipv4 !== null) {
+                $this->rangeType = $ipv4->getRangeType();
+            } else {
+                $rangeType = null;
+                foreach (static::getReservedRanges() as $reservedRange) {
+                    $rangeType = $reservedRange->getAddressType($this);
+                    if ($rangeType !== null) {
+                        break;
+                    }
+                }
+                $this->rangeType = $rangeType === null ? static::getDefaultReservedRangeType() : $rangeType;
+            }
+        }
+
+        return $this->rangeType;
+    }
+
+    /**
+     * Create an IPv4 representation of this address (if possible, otherwise returns null).
+     *
+     * @return \IPLib\Address\IPv4|null
+     */
+    public function toIPv4()
+    {
+        if (strpos($this->longAddress, '2002:') === 0) {
+            // 6to4
+            return IPv4::fromBytes(array_slice($this->getBytes(), 2, 4));
+        }
+        if (strpos($this->longAddress, '0000:0000:0000:0000:0000:ffff:') === 0) {
+            // IPv4-mapped IPv6 addresses
+            return IPv4::fromBytes(array_slice($this->getBytes(), -4));
+        }
+
+        return null;
+    }
+
+    /**
+     * Render this IPv6 address in the "mixed" IPv6 (first 12 bytes) + IPv4 (last 4 bytes) mixed syntax.
+     *
+     * @param bool $ipV6Long render the IPv6 part in "long" format?
+     * @param bool $ipV4Long render the IPv4 part in "long" format?
+     *
+     * @return string
+     *
+     * @example '::13.1.68.3'
+     * @example '0000:0000:0000:0000:0000:0000:13.1.68.3' when $ipV6Long is true
+     * @example '::013.001.068.003' when $ipV4Long is true
+     * @example '0000:0000:0000:0000:0000:0000:013.001.068.003' when $ipV6Long and $ipV4Long are true
+     *
+     * @see https://tools.ietf.org/html/rfc4291#section-2.2 point 3.
+     */
+    public function toMixedIPv6IPv4String($ipV6Long = false, $ipV4Long = false)
+    {
+        $myBytes = $this->getBytes();
+        $ipv6Bytes = array_merge(array_slice($myBytes, 0, 12), array(0xff, 0xff, 0xff, 0xff));
+        $ipv6String = static::fromBytes($ipv6Bytes)->toString($ipV6Long);
+        $ipv4Bytes = array_slice($myBytes, 12, 4);
+        $ipv4String = IPv4::fromBytes($ipv4Bytes)->toString($ipV4Long);
+
+        return preg_replace('/((ffff:ffff)|(\d+(\.\d+){3}))$/i', $ipv4String, $ipv6String);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getComparableString()
+     */
+    public function getComparableString()
+    {
+        return $this->longAddress;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::matches()
+     */
+    public function matches(RangeInterface $range)
+    {
+        return $range->contains($this);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getNextAddress()
+     */
+    public function getNextAddress()
+    {
+        $overflow = false;
+        $words = $this->getWords();
+        for ($i = count($words) - 1; $i >= 0; $i--) {
+            if ($words[$i] === 0xffff) {
+                if ($i === 0) {
+                    $overflow = true;
+                    break;
+                }
+                $words[$i] = 0;
+            } else {
+                $words[$i]++;
+                break;
+            }
+        }
+
+        return $overflow ? null : static::fromWords($words);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getPreviousAddress()
+     */
+    public function getPreviousAddress()
+    {
+        $overflow = false;
+        $words = $this->getWords();
+        for ($i = count($words) - 1; $i >= 0; $i--) {
+            if ($words[$i] === 0) {
+                if ($i === 0) {
+                    $overflow = true;
+                    break;
+                }
+                $words[$i] = 0xffff;
+            } else {
+                $words[$i]--;
+                break;
+            }
+        }
+
+        return $overflow ? null : static::fromWords($words);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Address\AddressInterface::getReverseDNSLookupName()
+     */
+    public function getReverseDNSLookupName()
+    {
+        return implode(
+            '.',
+            array_reverse(str_split(str_replace(':', '', $this->toString(true)), 1))
+        ) . '.ip6.arpa';
+    }
+}
diff --git a/vendor/mlocati/ip-lib/src/Address/Type.php b/vendor/mlocati/ip-lib/src/Address/Type.php
new file mode 100644
index 0000000..06b0753
--- /dev/null
+++ b/vendor/mlocati/ip-lib/src/Address/Type.php
@@ -0,0 +1,42 @@
+<?php
+
+namespace IPLib\Address;
+
+/**
+ * Types of IP addresses.
+ */
+class Type
+{
+    /**
+     * IPv4 address.
+     *
+     * @var int
+     */
+    const T_IPv4 = 4;
+
+    /**
+     * IPv6 address.
+     *
+     * @var int
+     */
+    const T_IPv6 = 6;
+
+    /**
+     * Get the name of a type.
+     *
+     * @param int $type
+     *
+     * @return string
+     */
+    public static function getName($type)
+    {
+        switch ($type) {
+            case static::T_IPv4:
+                return 'IP v4';
+            case static::T_IPv6:
+                return 'IP v6';
+            default:
+                return sprintf('Unknown type (%s)', $type);
+        }
+    }
+}
diff --git a/vendor/mlocati/ip-lib/src/Factory.php b/vendor/mlocati/ip-lib/src/Factory.php
new file mode 100644
index 0000000..76b6e1e
--- /dev/null
+++ b/vendor/mlocati/ip-lib/src/Factory.php
@@ -0,0 +1,205 @@
+<?php
+
+namespace IPLib;
+
+use IPLib\Address\AddressInterface;
+use IPLib\Range\Subnet;
+use IPLib\Service\RangesFromBounradyCalculator;
+
+/**
+ * Factory methods to build class instances.
+ */
+class Factory
+{
+    /**
+     * Parse an IP address string.
+     *
+     * @param string $address the address to parse
+     * @param bool $mayIncludePort set to false to avoid parsing addresses with ports
+     * @param bool $mayIncludeZoneID set to false to avoid parsing IPv6 addresses with zone IDs (see RFC 4007)
+     * @param bool $supportNonDecimalIPv4 set to true to support parsing non decimal (that is, octal and hexadecimal) IPv4 addresses
+     *
+     * @return \IPLib\Address\AddressInterface|null
+     */
+    public static function addressFromString($address, $mayIncludePort = true, $mayIncludeZoneID = true, $supportNonDecimalIPv4 = false)
+    {
+        $result = null;
+        if ($result === null) {
+            $result = Address\IPv4::fromString($address, $mayIncludePort, $supportNonDecimalIPv4);
+        }
+        if ($result === null) {
+            $result = Address\IPv6::fromString($address, $mayIncludePort, $mayIncludeZoneID);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Convert a byte array to an address instance.
+     *
+     * @param int[]|array $bytes
+     *
+     * @return \IPLib\Address\AddressInterface|null
+     */
+    public static function addressFromBytes(array $bytes)
+    {
+        $result = null;
+        if ($result === null) {
+            $result = Address\IPv4::fromBytes($bytes);
+        }
+        if ($result === null) {
+            $result = Address\IPv6::fromBytes($bytes);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Parse an IP range string.
+     *
+     * @param string $range
+     * @param bool $supportNonDecimalIPv4 set to true to support parsing non decimal (that is, octal and hexadecimal) IPv4 addresses
+     *
+     * @return \IPLib\Range\RangeInterface|null
+     */
+    public static function rangeFromString($range, $supportNonDecimalIPv4 = false)
+    {
+        $result = null;
+        if ($result === null) {
+            $result = Range\Subnet::fromString($range, $supportNonDecimalIPv4);
+        }
+        if ($result === null) {
+            $result = Range\Pattern::fromString($range, $supportNonDecimalIPv4);
+        }
+        if ($result === null) {
+            $result = Range\Single::fromString($range, $supportNonDecimalIPv4);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Create the smallest address range that comprises two addresses.
+     *
+     * @param string|\IPLib\Address\AddressInterface $from
+     * @param string|\IPLib\Address\AddressInterface $to
+     * @param bool $supportNonDecimalIPv4 set to true to support parsing non decimal (that is, octal and hexadecimal) IPv4 addresses
+     *
+     * @return \IPLib\Range\RangeInterface|null return NULL if $from and/or $to are invalid addresses, or if both are NULL or empty strings, or if they are addresses of different types
+     */
+    public static function rangeFromBoundaries($from, $to, $supportNonDecimalIPv4 = false)
+    {
+        list($from, $to) = self::parseBoundaries($from, $to, $supportNonDecimalIPv4);
+
+        return $from === false || $to === false ? null : static::rangeFromBoundaryAddresses($from, $to);
+    }
+
+    /**
+     * Create a list of Range instances that exactly describes all the addresses between the two provided addresses.
+     *
+     * @param string|\IPLib\Address\AddressInterface $from
+     * @param string|\IPLib\Address\AddressInterface $to
+     * @param bool $supportNonDecimalIPv4 set to true to support parsing non decimal (that is, octal and hexadecimal) IPv4 addresses
+     *
+     * @return \IPLib\Range\Subnet[]|null return NULL if $from and/or $to are invalid addresses, or if both are NULL or empty strings, or if they are addresses of different types
+     */
+    public static function rangesFromBoundaries($from, $to, $supportNonDecimalIPv4 = false)
+    {
+        list($from, $to) = self::parseBoundaries($from, $to, $supportNonDecimalIPv4);
+        if (($from === false || $to === false) || ($from === null && $to === null)) {
+            return null;
+        }
+        if ($from === null || $to === null) {
+            $address = $from ? $from : $to;
+
+            return array(new Subnet($address, $address, $address->getNumberOfBits()));
+        }
+        $numberOfBits = $from->getNumberOfBits();
+        if ($to->getNumberOfBits() !== $numberOfBits) {
+            return null;
+        }
+        $calculator = new RangesFromBounradyCalculator($numberOfBits);
+
+        return $calculator->getRanges($from, $to);
+    }
+
+    /**
+     * @param \IPLib\Address\AddressInterface $from
+     * @param \IPLib\Address\AddressInterface $to
+     *
+     * @return \IPLib\Range\RangeInterface|null
+     */
+    protected static function rangeFromBoundaryAddresses(AddressInterface $from = null, AddressInterface $to = null)
+    {
+        if ($from === null && $to === null) {
+            $result = null;
+        } elseif ($to === null) {
+            $result = Range\Single::fromAddress($from);
+        } elseif ($from === null) {
+            $result = Range\Single::fromAddress($to);
+        } else {
+            $result = null;
+            $addressType = $from->getAddressType();
+            if ($addressType === $to->getAddressType()) {
+                $cmp = strcmp($from->getComparableString(), $to->getComparableString());
+                if ($cmp === 0) {
+                    $result = Range\Single::fromAddress($from);
+                } else {
+                    if ($cmp > 0) {
+                        list($from, $to) = array($to, $from);
+                    }
+                    $fromBytes = $from->getBytes();
+                    $toBytes = $to->getBytes();
+                    $numBytes = count($fromBytes);
+                    $sameBits = 0;
+                    for ($byteIndex = 0; $byteIndex < $numBytes; $byteIndex++) {
+                        $fromByte = $fromBytes[$byteIndex];
+                        $toByte = $toBytes[$byteIndex];
+                        if ($fromByte === $toByte) {
+                            $sameBits += 8;
+                        } else {
+                            $differentBitsInByte = decbin($fromByte ^ $toByte);
+                            $sameBits += 8 - strlen($differentBitsInByte);
+                            break;
+                        }
+                    }
+                    $result = static::rangeFromString($from->toString(true) . '/' . (string) $sameBits);
+                }
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * @param string|\IPLib\Address\AddressInterface $from
+     * @param string|\IPLib\Address\AddressInterface $to
+     * @param bool $supportNonDecimalIPv4
+     *
+     * @return \IPLib\Address\AddressInterface[]|null[]|false[]
+     */
+    private static function parseBoundaries($from, $to, $supportNonDecimalIPv4 = false)
+    {
+        $result = array();
+        foreach (array('from', 'to') as $param) {
+            $value = $$param;
+            if (!($value instanceof AddressInterface)) {
+                $value = (string) $value;
+                if ($value === '') {
+                    $value = null;
+                } else {
+                    $value = static::addressFromString($value, true, true, $supportNonDecimalIPv4);
+                    if ($value === null) {
+                        $value = false;
+                    }
+                }
+            }
+            $result[] = $value;
+        }
+        if ($result[0] && $result[1] && strcmp($result[0]->getComparableString(), $result[1]->getComparableString()) > 0) {
+            $result = array($result[1], $result[0]);
+        }
+
+        return $result;
+    }
+}
diff --git a/vendor/mlocati/ip-lib/src/Range/AbstractRange.php b/vendor/mlocati/ip-lib/src/Range/AbstractRange.php
new file mode 100644
index 0000000..1da94d0
--- /dev/null
+++ b/vendor/mlocati/ip-lib/src/Range/AbstractRange.php
@@ -0,0 +1,95 @@
+<?php
+
+namespace IPLib\Range;
+
+use IPLib\Address\AddressInterface;
+use IPLib\Address\IPv4;
+use IPLib\Address\IPv6;
+use IPLib\Address\Type as AddressType;
+use IPLib\Factory;
+
+abstract class AbstractRange implements RangeInterface
+{
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::getRangeType()
+     */
+    public function getRangeType()
+    {
+        if ($this->rangeType === null) {
+            $addressType = $this->getAddressType();
+            if ($addressType === AddressType::T_IPv6 && Subnet::get6to4()->containsRange($this)) {
+                $this->rangeType = Factory::rangeFromBoundaries($this->fromAddress->toIPv4(), $this->toAddress->toIPv4())->getRangeType();
+            } else {
+                switch ($addressType) {
+                    case AddressType::T_IPv4:
+                        $defaultType = IPv4::getDefaultReservedRangeType();
+                        $reservedRanges = IPv4::getReservedRanges();
+                        break;
+                    case AddressType::T_IPv6:
+                        $defaultType = IPv6::getDefaultReservedRangeType();
+                        $reservedRanges = IPv6::getReservedRanges();
+                        break;
+                    default:
+                        throw new \Exception('@todo'); // @codeCoverageIgnore
+                }
+                $rangeType = null;
+                foreach ($reservedRanges as $reservedRange) {
+                    $rangeType = $reservedRange->getRangeType($this);
+                    if ($rangeType !== null) {
+                        break;
+                    }
+                }
+                $this->rangeType = $rangeType === null ? $defaultType : $rangeType;
+            }
+        }
+
+        return $this->rangeType === false ? null : $this->rangeType;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::contains()
+     */
+    public function contains(AddressInterface $address)
+    {
+        $result = false;
+        if ($address->getAddressType() === $this->getAddressType()) {
+            $cmp = $address->getComparableString();
+            $from = $this->getComparableStartString();
+            if ($cmp >= $from) {
+                $to = $this->getComparableEndString();
+                if ($cmp <= $to) {
+                    $result = true;
+                }
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::containsRange()
+     */
+    public function containsRange(RangeInterface $range)
+    {
+        $result = false;
+        if ($range->getAddressType() === $this->getAddressType()) {
+            $myStart = $this->getComparableStartString();
+            $itsStart = $range->getComparableStartString();
+            if ($itsStart >= $myStart) {
+                $myEnd = $this->getComparableEndString();
+                $itsEnd = $range->getComparableEndString();
+                if ($itsEnd <= $myEnd) {
+                    $result = true;
+                }
+            }
+        }
+
+        return $result;
+    }
+}
diff --git a/vendor/mlocati/ip-lib/src/Range/Pattern.php b/vendor/mlocati/ip-lib/src/Range/Pattern.php
new file mode 100644
index 0000000..fc19d1e
--- /dev/null
+++ b/vendor/mlocati/ip-lib/src/Range/Pattern.php
@@ -0,0 +1,275 @@
+<?php
+
+namespace IPLib\Range;
+
+use IPLib\Address\AddressInterface;
+use IPLib\Address\IPv4;
+use IPLib\Address\IPv6;
+use IPLib\Address\Type as AddressType;
+
+/**
+ * Represents an address range in pattern format (only ending asterisks are supported).
+ *
+ * @example 127.0.*.*
+ * @example ::/8
+ */
+class Pattern extends AbstractRange
+{
+    /**
+     * Starting address of the range.
+     *
+     * @var \IPLib\Address\AddressInterface
+     */
+    protected $fromAddress;
+
+    /**
+     * Final address of the range.
+     *
+     * @var \IPLib\Address\AddressInterface
+     */
+    protected $toAddress;
+
+    /**
+     * Number of ending asterisks.
+     *
+     * @var int
+     */
+    protected $asterisksCount;
+
+    /**
+     * The type of the range of this IP range.
+     *
+     * @var int|false|null false if this range crosses multiple range types, null if yet to be determined
+     */
+    protected $rangeType;
+
+    /**
+     * Initializes the instance.
+     *
+     * @param \IPLib\Address\AddressInterface $fromAddress
+     * @param \IPLib\Address\AddressInterface $toAddress
+     * @param int $asterisksCount
+     */
+    public function __construct(AddressInterface $fromAddress, AddressInterface $toAddress, $asterisksCount)
+    {
+        $this->fromAddress = $fromAddress;
+        $this->toAddress = $toAddress;
+        $this->asterisksCount = $asterisksCount;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::__toString()
+     */
+    public function __toString()
+    {
+        return $this->toString();
+    }
+
+    /**
+     * Try get the range instance starting from its string representation.
+     *
+     * @param string|mixed $range
+     * @param bool $supportNonDecimalIPv4 set to true to support parsing non decimal (that is, octal and hexadecimal) IPv4 addresses
+     *
+     * @return static|null
+     */
+    public static function fromString($range, $supportNonDecimalIPv4 = false)
+    {
+        if (!is_string($range) || strpos($range, '*') === false) {
+            return null;
+        }
+        if ($range === '*.*.*.*') {
+            return new static(IPv4::fromString('0.0.0.0'), IPv4::fromString('255.255.255.255'), 4);
+        }
+        if ($range === '*:*:*:*:*:*:*:*') {
+            return new static(IPv6::fromString('::'), IPv6::fromString('ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff'), 8);
+        }
+        $matches = null;
+        if (strpos($range, '.') !== false && preg_match('/^[^*]+((?:\.\*)+)$/', $range, $matches)) {
+            $asterisksCount = strlen($matches[1]) >> 1;
+            if ($asterisksCount > 0) {
+                $missingDots = 3 - substr_count($range, '.');
+                if ($missingDots > 0) {
+                    $range .= str_repeat('.*', $missingDots);
+                    $asterisksCount += $missingDots;
+                }
+            }
+            $fromAddress = IPv4::fromString(str_replace('*', '0', $range), true, $supportNonDecimalIPv4);
+            if ($fromAddress === null) {
+                return null;
+            }
+            $fixedBytes = array_slice($fromAddress->getBytes(), 0, -$asterisksCount);
+            $otherBytes = array_fill(0, $asterisksCount, 255);
+            $toAddress = IPv4::fromBytes(array_merge($fixedBytes, $otherBytes));
+
+            return new static($fromAddress, $toAddress, $asterisksCount);
+        }
+        if (strpos($range, ':') !== false && preg_match('/^[^*]+((?::\*)+)$/', $range, $matches)) {
+            $asterisksCount = strlen($matches[1]) >> 1;
+            $fromAddress = IPv6::fromString(str_replace('*', '0', $range));
+            if ($fromAddress === null) {
+                return null;
+            }
+            $fixedWords = array_slice($fromAddress->getWords(), 0, -$asterisksCount);
+            $otherWords = array_fill(0, $asterisksCount, 0xffff);
+            $toAddress = IPv6::fromWords(array_merge($fixedWords, $otherWords));
+
+            return new static($fromAddress, $toAddress, $asterisksCount);
+        }
+
+        return null;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::toString()
+     */
+    public function toString($long = false)
+    {
+        if ($this->asterisksCount === 0) {
+            return $this->fromAddress->toString($long);
+        }
+        switch (true) {
+            case $this->fromAddress instanceof \IPLib\Address\IPv4:
+                $chunks = explode('.', $this->fromAddress->toString());
+                $chunks = array_slice($chunks, 0, -$this->asterisksCount);
+                $chunks = array_pad($chunks, 4, '*');
+                $result = implode('.', $chunks);
+                break;
+            case $this->fromAddress instanceof \IPLib\Address\IPv6:
+                if ($long) {
+                    $chunks = explode(':', $this->fromAddress->toString(true));
+                    $chunks = array_slice($chunks, 0, -$this->asterisksCount);
+                    $chunks = array_pad($chunks, 8, '*');
+                    $result = implode(':', $chunks);
+                } elseif ($this->asterisksCount === 8) {
+                    $result = '*:*:*:*:*:*:*:*';
+                } else {
+                    $bytes = $this->toAddress->getBytes();
+                    $bytes = array_slice($bytes, 0, -$this->asterisksCount * 2);
+                    $bytes = array_pad($bytes, 16, 1);
+                    $address = IPv6::fromBytes($bytes);
+                    $before = substr($address->toString(false), 0, -strlen(':101') * $this->asterisksCount);
+                    $result = $before . str_repeat(':*', $this->asterisksCount);
+                }
+                break;
+            default:
+                throw new \Exception('@todo'); // @codeCoverageIgnore
+        }
+
+        return $result;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::getAddressType()
+     */
+    public function getAddressType()
+    {
+        return $this->fromAddress->getAddressType();
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::getStartAddress()
+     */
+    public function getStartAddress()
+    {
+        return $this->fromAddress;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::getEndAddress()
+     */
+    public function getEndAddress()
+    {
+        return $this->toAddress;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::getComparableStartString()
+     */
+    public function getComparableStartString()
+    {
+        return $this->fromAddress->getComparableString();
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::getComparableEndString()
+     */
+    public function getComparableEndString()
+    {
+        return $this->toAddress->getComparableString();
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::asSubnet()
+     */
+    public function asSubnet()
+    {
+        switch ($this->getAddressType()) {
+            case AddressType::T_IPv4:
+                return new Subnet($this->getStartAddress(), $this->getEndAddress(), 8 * (4 - $this->asterisksCount));
+            case AddressType::T_IPv6:
+                return new Subnet($this->getStartAddress(), $this->getEndAddress(), 16 * (8 - $this->asterisksCount));
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::asPattern()
+     */
+    public function asPattern()
+    {
+        return $this;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::getSubnetMask()
+     */
+    public function getSubnetMask()
+    {
+        if ($this->getAddressType() !== AddressType::T_IPv4) {
+            return null;
+        }
+        switch ($this->asterisksCount) {
+            case 0:
+                $bytes = array(255, 255, 255, 255);
+                break;
+            case 4:
+                $bytes = array(0, 0, 0, 0);
+                break;
+            default:
+                $bytes = array_pad(array_fill(0, 4 - $this->asterisksCount, 255), 4, 0);
+                break;
+        }
+
+        return IPv4::fromBytes($bytes);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::getReverseDNSLookupName()
+     */
+    public function getReverseDNSLookupName()
+    {
+        return $this->asterisksCount === 0 ? array($this->getStartAddress()->getReverseDNSLookupName()) : $this->asSubnet()->getReverseDNSLookupName();
+    }
+}
diff --git a/vendor/mlocati/ip-lib/src/Range/RangeInterface.php b/vendor/mlocati/ip-lib/src/Range/RangeInterface.php
new file mode 100644
index 0000000..468df3e
--- /dev/null
+++ b/vendor/mlocati/ip-lib/src/Range/RangeInterface.php
@@ -0,0 +1,120 @@
+<?php
+
+namespace IPLib\Range;
+
+use IPLib\Address\AddressInterface;
+
+/**
+ * Interface of all the range types.
+ */
+interface RangeInterface
+{
+    /**
+     * Get the short string representation of this address.
+     *
+     * @return string
+     */
+    public function __toString();
+
+    /**
+     * Get the string representation of this address.
+     *
+     * @param bool $long set to true to have a long/full representation, false otherwise
+     *
+     * @return string
+     *
+     * @example If $long is true, you'll get '0000:0000:0000:0000:0000:0000:0000:0001/128', '::1/128' otherwise.
+     */
+    public function toString($long = false);
+
+    /**
+     * Get the type of the IP addresses contained in this range.
+     *
+     * @return int One of the \IPLib\Address\Type::T_... constants
+     */
+    public function getAddressType();
+
+    /**
+     * Get the type of range of the IP address.
+     *
+     * @return int One of the \IPLib\Range\Type::T_... constants
+     */
+    public function getRangeType();
+
+    /**
+     * Check if this range contains an IP address.
+     *
+     * @param \IPLib\Address\AddressInterface $address
+     *
+     * @return bool
+     */
+    public function contains(AddressInterface $address);
+
+    /**
+     * Check if this range contains another range.
+     *
+     * @param \IPLib\Range\RangeInterface $range
+     *
+     * @return bool
+     */
+    public function containsRange(RangeInterface $range);
+
+    /**
+     * Get the initial address contained in this range.
+     *
+     * @return \IPLib\Address\AddressInterface
+     */
+    public function getStartAddress();
+
+    /**
+     * Get the final address contained in this range.
+     *
+     * @return \IPLib\Address\AddressInterface
+     */
+    public function getEndAddress();
+
+    /**
+     * Get a string representation of the starting address of this range than can be used when comparing addresses and ranges.
+     *
+     * @return string
+     */
+    public function getComparableStartString();
+
+    /**
+     * Get a string representation of the final address of this range than can be used when comparing addresses and ranges.
+     *
+     * @return string
+     */
+    public function getComparableEndString();
+
+    /**
+     * Get the subnet mask representing this range (only for IPv4 ranges).
+     *
+     * @return \IPLib\Address\IPv4|null return NULL if the range is an IPv6 range, the subnet mask otherwise
+     */
+    public function getSubnetMask();
+
+    /**
+     * Get the subnet/CIDR representation of this range.
+     *
+     * @return \IPLib\Range\Subnet
+     */
+    public function asSubnet();
+
+    /**
+     * Get the pattern/asterisk representation (if applicable) of this range.
+     *
+     * @return \IPLib\Range\Pattern|null return NULL if this range can't be represented by a pattern notation
+     */
+    public function asPattern();
+
+    /**
+     * Get the Reverse DNS Lookup Addresses of this IP range.
+     *
+     * @return string[]
+     *
+     * @example for IPv4 it returns something like array('x.x.x.x.in-addr.arpa', 'x.x.x.x.in-addr.arpa') (where the number of 'x.' ranges from 1 to 4)
+     * @example for IPv6 it returns something like array('x.x.x.x..x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.ip6.arpa', 'x.x.x.x..x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.ip6.arpa') (where the number of 'x.' ranges from 1 to 32)
+     */
+    public function getReverseDNSLookupName();
+}
diff --git a/vendor/mlocati/ip-lib/src/Range/Single.php b/vendor/mlocati/ip-lib/src/Range/Single.php
new file mode 100644
index 0000000..6f08850
--- /dev/null
+++ b/vendor/mlocati/ip-lib/src/Range/Single.php
@@ -0,0 +1,226 @@
+<?php
+
+namespace IPLib\Range;
+
+use IPLib\Address\AddressInterface;
+use IPLib\Address\IPv4;
+use IPLib\Address\Type as AddressType;
+use IPLib\Factory;
+
+/**
+ * Represents a single address (eg a range that contains just one address).
+ *
+ * @example 127.0.0.1
+ * @example ::1
+ */
+class Single extends AbstractRange
+{
+    /**
+     * @var \IPLib\Address\AddressInterface
+     */
+    protected $address;
+
+    /**
+     * Initializes the instance.
+     *
+     * @param \IPLib\Address\AddressInterface $address
+     */
+    protected function __construct(AddressInterface $address)
+    {
+        $this->address = $address;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::__toString()
+     */
+    public function __toString()
+    {
+        return $this->address->__toString();
+    }
+
+    /**
+     * Try get the range instance starting from its string representation.
+     *
+     * @param string|mixed $range
+     * @param bool $supportNonDecimalIPv4 set to true to support parsing non decimal (that is, octal and hexadecimal) IPv4 addresses
+     *
+     * @return static|null
+     */
+    public static function fromString($range, $supportNonDecimalIPv4 = false)
+    {
+        $result = null;
+        $address = Factory::addressFromString($range, true, true, $supportNonDecimalIPv4);
+        if ($address !== null) {
+            $result = new static($address);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Create the range instance starting from an address instance.
+     *
+     * @param \IPLib\Address\AddressInterface $address
+     *
+     * @return static
+     */
+    public static function fromAddress(AddressInterface $address)
+    {
+        return new static($address);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::toString()
+     */
+    public function toString($long = false)
+    {
+        return $this->address->toString($long);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::getAddressType()
+     */
+    public function getAddressType()
+    {
+        return $this->address->getAddressType();
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::getRangeType()
+     */
+    public function getRangeType()
+    {
+        return $this->address->getRangeType();
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::contains()
+     */
+    public function contains(AddressInterface $address)
+    {
+        $result = false;
+        if ($address->getAddressType() === $this->getAddressType()) {
+            if ($address->toString(false) === $this->address->toString(false)) {
+                $result = true;
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::containsRange()
+     */
+    public function containsRange(RangeInterface $range)
+    {
+        $result = false;
+        if ($range->getAddressType() === $this->getAddressType()) {
+            if ($range->toString(false) === $this->toString(false)) {
+                $result = true;
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::getStartAddress()
+     */
+    public function getStartAddress()
+    {
+        return $this->address;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::getEndAddress()
+     */
+    public function getEndAddress()
+    {
+        return $this->address;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::getComparableStartString()
+     */
+    public function getComparableStartString()
+    {
+        return $this->address->getComparableString();
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::getComparableEndString()
+     */
+    public function getComparableEndString()
+    {
+        return $this->address->getComparableString();
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::asSubnet()
+     */
+    public function asSubnet()
+    {
+        $networkPrefixes = array(
+            AddressType::T_IPv4 => 32,
+            AddressType::T_IPv6 => 128,
+        );
+
+        return new Subnet($this->address, $this->address, $networkPrefixes[$this->address->getAddressType()]);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::asPattern()
+     */
+    public function asPattern()
+    {
+        return new Pattern($this->address, $this->address, 0);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::getSubnetMask()
+     */
+    public function getSubnetMask()
+    {
+        if ($this->getAddressType() !== AddressType::T_IPv4) {
+            return null;
+        }
+
+        return IPv4::fromBytes(array(255, 255, 255, 255));
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::getReverseDNSLookupName()
+     */
+    public function getReverseDNSLookupName()
+    {
+        return array($this->getStartAddress()->getReverseDNSLookupName());
+    }
+}
diff --git a/vendor/mlocati/ip-lib/src/Range/Subnet.php b/vendor/mlocati/ip-lib/src/Range/Subnet.php
new file mode 100644
index 0000000..2ce166b
--- /dev/null
+++ b/vendor/mlocati/ip-lib/src/Range/Subnet.php
@@ -0,0 +1,305 @@
+<?php
+
+namespace IPLib\Range;
+
+use IPLib\Address\AddressInterface;
+use IPLib\Address\IPv4;
+use IPLib\Address\IPv6;
+use IPLib\Address\Type as AddressType;
+use IPLib\Factory;
+
+/**
+ * Represents an address range in subnet format (eg CIDR).
+ *
+ * @example 127.0.0.1/32
+ * @example ::/8
+ */
+class Subnet extends AbstractRange
+{
+    /**
+     * Starting address of the range.
+     *
+     * @var \IPLib\Address\AddressInterface
+     */
+    protected $fromAddress;
+
+    /**
+     * Final address of the range.
+     *
+     * @var \IPLib\Address\AddressInterface
+     */
+    protected $toAddress;
+
+    /**
+     * Number of the same bits of the range.
+     *
+     * @var int
+     */
+    protected $networkPrefix;
+
+    /**
+     * The type of the range of this IP range.
+     *
+     * @var int|null
+     */
+    protected $rangeType;
+
+    /**
+     * The 6to4 address IPv6 address range.
+     *
+     * @var self|null
+     */
+    private static $sixToFour;
+
+    /**
+     * Initializes the instance.
+     *
+     * @param \IPLib\Address\AddressInterface $fromAddress
+     * @param \IPLib\Address\AddressInterface $toAddress
+     * @param int $networkPrefix
+     *
+     * @internal
+     */
+    public function __construct(AddressInterface $fromAddress, AddressInterface $toAddress, $networkPrefix)
+    {
+        $this->fromAddress = $fromAddress;
+        $this->toAddress = $toAddress;
+        $this->networkPrefix = $networkPrefix;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::__toString()
+     */
+    public function __toString()
+    {
+        return $this->toString();
+    }
+
+    /**
+     * Try get the range instance starting from its string representation.
+     *
+     * @param string|mixed $range
+     * @param bool $supportNonDecimalIPv4 set to true to support parsing non decimal (that is, octal and hexadecimal) IPv4 addresses
+     *
+     * @return static|null
+     */
+    public static function fromString($range, $supportNonDecimalIPv4 = false)
+    {
+        if (!is_string($range)) {
+            return null;
+        }
+        $parts = explode('/', $range);
+        if (count($parts) !== 2) {
+            return null;
+        }
+        $address = Factory::addressFromString($parts[0], true, true, $supportNonDecimalIPv4);
+        if ($address === null) {
+            return null;
+        }
+        if (!preg_match('/^[0-9]{1,9}$/', $parts[1])) {
+            return null;
+        }
+        $networkPrefix = (int) $parts[1];
+        $addressBytes = $address->getBytes();
+        $totalBytes = count($addressBytes);
+        $numDifferentBits = $totalBytes * 8 - $networkPrefix;
+        if ($numDifferentBits < 0) {
+            return null;
+        }
+        $numSameBytes = $networkPrefix >> 3;
+        $sameBytes = array_slice($addressBytes, 0, $numSameBytes);
+        $differentBytesStart = ($totalBytes === $numSameBytes) ? array() : array_fill(0, $totalBytes - $numSameBytes, 0);
+        $differentBytesEnd = ($totalBytes === $numSameBytes) ? array() : array_fill(0, $totalBytes - $numSameBytes, 255);
+        $startSameBits = $networkPrefix % 8;
+        if ($startSameBits !== 0) {
+            $varyingByte = $addressBytes[$numSameBytes];
+            $differentBytesStart[0] = $varyingByte & bindec(str_pad(str_repeat('1', $startSameBits), 8, '0', STR_PAD_RIGHT));
+            $differentBytesEnd[0] = $differentBytesStart[0] + bindec(str_repeat('1', 8 - $startSameBits));
+        }
+
+        return new static(
+            Factory::addressFromBytes(array_merge($sameBytes, $differentBytesStart)),
+            Factory::addressFromBytes(array_merge($sameBytes, $differentBytesEnd)),
+            $networkPrefix
+        );
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::toString()
+     */
+    public function toString($long = false)
+    {
+        return $this->fromAddress->toString($long) . '/' . $this->networkPrefix;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::getAddressType()
+     */
+    public function getAddressType()
+    {
+        return $this->fromAddress->getAddressType();
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::getStartAddress()
+     */
+    public function getStartAddress()
+    {
+        return $this->fromAddress;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::getEndAddress()
+     */
+    public function getEndAddress()
+    {
+        return $this->toAddress;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::getComparableStartString()
+     */
+    public function getComparableStartString()
+    {
+        return $this->fromAddress->getComparableString();
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::getComparableEndString()
+     */
+    public function getComparableEndString()
+    {
+        return $this->toAddress->getComparableString();
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::asSubnet()
+     */
+    public function asSubnet()
+    {
+        return $this;
+    }
+
+    /**
+     * Get the pattern (asterisk) representation (if applicable) of this range.
+     *
+     * @return \IPLib\Range\Pattern|null return NULL if this range can't be represented by a pattern notation
+     */
+    public function asPattern()
+    {
+        $address = $this->getStartAddress();
+        $networkPrefix = $this->getNetworkPrefix();
+        switch ($address->getAddressType()) {
+            case AddressType::T_IPv4:
+                return $networkPrefix % 8 === 0 ? new Pattern($address, $address, 4 - $networkPrefix / 8) : null;
+            case AddressType::T_IPv6:
+                return $networkPrefix % 16 === 0 ? new Pattern($address, $address, 8 - $networkPrefix / 16) : null;
+        }
+    }
+
+    /**
+     * Get the 6to4 address IPv6 address range.
+     *
+     * @return self
+     */
+    public static function get6to4()
+    {
+        if (self::$sixToFour === null) {
+            self::$sixToFour = self::fromString('2002::/16');
+        }
+
+        return self::$sixToFour;
+    }
+
+    /**
+     * Get subnet prefix.
+     *
+     * @return int
+     */
+    public function getNetworkPrefix()
+    {
+        return $this->networkPrefix;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::getSubnetMask()
+     */
+    public function getSubnetMask()
+    {
+        if ($this->getAddressType() !== AddressType::T_IPv4) {
+            return null;
+        }
+        $bytes = array();
+        $prefix = $this->getNetworkPrefix();
+        while ($prefix >= 8) {
+            $bytes[] = 255;
+            $prefix -= 8;
+        }
+        if ($prefix !== 0) {
+            $bytes[] = bindec(str_pad(str_repeat('1', $prefix), 8, '0'));
+        }
+        $bytes = array_pad($bytes, 4, 0);
+
+        return IPv4::fromBytes($bytes);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \IPLib\Range\RangeInterface::getReverseDNSLookupName()
+     */
+    public function getReverseDNSLookupName()
+    {
+        switch ($this->getAddressType()) {
+            case AddressType::T_IPv4:
+                $unitSize = 8; // bytes
+                $maxUnits = 4;
+                $isHex = false;
+                $rxUnit = '\d+';
+                break;
+            case AddressType::T_IPv6:
+                $unitSize = 4; // nibbles
+                $maxUnits = 32;
+                $isHex = true;
+                $rxUnit = '[0-9A-Fa-f]';
+                break;
+        }
+        $totBits = $unitSize * $maxUnits;
+        $prefixUnits = (int) ($this->networkPrefix / $unitSize);
+        $extraBits = ($totBits - $this->networkPrefix) % $unitSize;
+        if ($extraBits !== 0) {
+            $prefixUnits += 1;
+        }
+        $numVariants = 1 << $extraBits;
+        $result = array();
+        $unitsToRemove = $maxUnits - $prefixUnits;
+        $initialPointer = preg_replace("/^(({$rxUnit})\.){{$unitsToRemove}}/", '', $this->getStartAddress()->getReverseDNSLookupName());
+        $chunks = explode('.', $initialPointer, 2);
+        for ($index = 0; $index < $numVariants; $index++) {
+            if ($index !== 0) {
+                $chunks[0] = $isHex ? dechex(1 + hexdec($chunks[0])) : (string) (1 + (int) $chunks[0]);
+            }
+            $result[] = implode('.', $chunks);
+        }
+
+        return $result;
+    }
+}
diff --git a/vendor/mlocati/ip-lib/src/Range/Type.php b/vendor/mlocati/ip-lib/src/Range/Type.php
new file mode 100644
index 0000000..cfc268b
--- /dev/null
+++ b/vendor/mlocati/ip-lib/src/Range/Type.php
@@ -0,0 +1,150 @@
+<?php
+
+namespace IPLib\Range;
+
+/**
+ * Types of IP address classes.
+ */
+class Type
+{
+    /**
+     * Unspecified/unknown address.
+     *
+     * @var int
+     */
+    const T_UNSPECIFIED = 1;
+
+    /**
+     * Reserved/internal use only.
+     *
+     * @var int
+     */
+    const T_RESERVED = 2;
+
+    /**
+     * Refer to source hosts on "this" network.
+     *
+     * @var int
+     */
+    const T_THISNETWORK = 3;
+
+    /**
+     * Internet host loopback address.
+     *
+     * @var int
+     */
+    const T_LOOPBACK = 4;
+
+    /**
+     * Relay anycast address.
+     *
+     * @var int
+     */
+    const T_ANYCASTRELAY = 5;
+
+    /**
+     * "Limited broadcast" destination address.
+     *
+     * @var int
+     */
+    const T_LIMITEDBROADCAST = 6;
+
+    /**
+     * Multicast address assignments - Indentify a group of interfaces.
+     *
+     * @var int
+     */
+    const T_MULTICAST = 7;
+
+    /**
+     * "Link local" address, allocated for communication between hosts on a single link.
+     *
+     * @var int
+     */
+    const T_LINKLOCAL = 8;
+
+    /**
+     * Link local unicast / Linked-scoped unicast.
+     *
+     * @var int
+     */
+    const T_LINKLOCAL_UNICAST = 9;
+
+    /**
+     * Discard-Only address.
+     *
+     * @var int
+     */
+    const T_DISCARDONLY = 10;
+
+    /**
+     * Discard address.
+     *
+     * @var int
+     */
+    const T_DISCARD = 11;
+
+    /**
+     * For use in private networks.
+     *
+     * @var int
+     */
+    const T_PRIVATENETWORK = 12;
+
+    /**
+     * Public address.
+     *
+     * @var int
+     */
+    const T_PUBLIC = 13;
+
+    /**
+     * Carrier-grade NAT address.
+     *
+     * @var int
+     */
+    const T_CGNAT = 14;
+
+    /**
+     * Get the name of a type.
+     *
+     * @param int $type
+     *
+     * @return string
+     */
+    public static function getName($type)
+    {
+        switch ($type) {
+            case static::T_UNSPECIFIED:
+                return 'Unspecified/unknown address';
+            case static::T_RESERVED:
+                 return 'Reserved/internal use only';
+            case static::T_THISNETWORK:
+                 return 'Refer to source hosts on "this" network';
+            case static::T_LOOPBACK:
+                 return 'Internet host loopback address';
+            case static::T_ANYCASTRELAY:
+                 return 'Relay anycast address';
+            case static::T_LIMITEDBROADCAST:
+                 return '"Limited broadcast" destination address';
+            case static::T_MULTICAST:
+                 return 'Multicast address assignments - Indentify a group of interfaces';
+            case static::T_LINKLOCAL:
+                 return '"Link local" address, allocated for communication between hosts on a single link';
+            case static::T_LINKLOCAL_UNICAST:
+                return 'Link local unicast / Linked-scoped unicast';
+            case static::T_DISCARDONLY:
+                 return 'Discard only';
+            case static::T_DISCARD:
+                 return 'Discard';
+            case static::T_PRIVATENETWORK:
+                 return 'For use in private networks';
+            case static::T_PUBLIC:
+                 return 'Public address';
+            case static::T_CGNAT:
+                return 'Carrier-grade NAT';
+            default:
+                return $type === null ? 'Unknown type' : sprintf('Unknown type (%s)', $type);
+        }
+    }
+}
diff --git a/vendor/mlocati/ip-lib/src/Service/BinaryMath.php b/vendor/mlocati/ip-lib/src/Service/BinaryMath.php
new file mode 100644
index 0000000..ec73c8a
--- /dev/null
+++ b/vendor/mlocati/ip-lib/src/Service/BinaryMath.php
@@ -0,0 +1,118 @@
+<?php
+
+namespace IPLib\Service;
+
+/**
+ * Helper class to work with unsigned binary integers.
+ */
+class BinaryMath
+{
+    /**
+     * Trim the leading zeroes from a non-negative integer represented in binary form.
+     *
+     * @param string $value
+     *
+     * @return string
+     */
+    public function reduce($value)
+    {
+        $value = ltrim($value, '0');
+
+        return $value === '' ? '0' : $value;
+    }
+
+    /**
+     * Compare two non-negative integers represented in binary form.
+     *
+     * @param string $a
+     * @param string $b
+     *
+     * @return int 1 if $a is greater than $b, -1 if $b is greater than $b, 0 if they are the same
+     */
+    public function compare($a, $b)
+    {
+        list($a, $b) = $this->toSameLength($a, $b);
+
+        return $a < $b ? -1 : ($a > $b ? 1 : 0);
+    }
+
+    /**
+     * Add 1 to a non-negative integer represented in binary form.
+     *
+     * @param string $value
+     *
+     * @return string
+     */
+    public function increment($value)
+    {
+        $lastZeroIndex = strrpos($value, '0');
+        if ($lastZeroIndex === false) {
+            return '1' . str_repeat('0', strlen($value));
+        }
+
+        return ltrim(substr($value, 0, $lastZeroIndex), '0') . '1' . str_repeat('0', strlen($value) - $lastZeroIndex - 1);
+    }
+
+    /**
+     * Calculate the bitwise AND of two non-negative integers represented in binary form.
+     *
+     * @param string $operand1
+     * @param string $operand2
+     *
+     * @return string
+     */
+    public function andX($operand1, $operand2)
+    {
+        $operand1 = $this->reduce($operand1);
+        $operand2 = $this->reduce($operand2);
+        $numBits = min(strlen($operand1), strlen($operand2));
+        $operand1 = substr(str_pad($operand1, $numBits, '0', STR_PAD_LEFT), -$numBits);
+        $operand2 = substr(str_pad($operand2, $numBits, '0', STR_PAD_LEFT), -$numBits);
+        $result = '';
+        for ($index = 0; $index < $numBits; $index++) {
+            $result .= $operand1[$index] === '1' && $operand2[$index] === '1' ? '1' : '0';
+        }
+
+        return $this->reduce($result);
+    }
+
+    /**
+     * Calculate the bitwise OR of two non-negative integers represented in binary form.
+     *
+     * @param string $operand1
+     * @param string $operand2
+     *
+     * @return string
+     */
+    public function orX($operand1, $operand2)
+    {
+        list($operand1, $operand2, $numBits) = $this->toSameLength($operand1, $operand2);
+        $result = '';
+        for ($index = 0; $index < $numBits; $index++) {
+            $result .= $operand1[$index] === '1' || $operand2[$index] === '1' ? '1' : '0';
+        }
+
+        return $result;
+    }
+
+    /**
+     * Zero-padding of two non-negative integers represented in binary form, so that they have the same length.
+     *
+     * @param string $num1
+     * @param string $num2
+     *
+     * @return string[],int[] The first array element is $num1 (padded), the first array element is $num2 (padded), the third array element is the number of bits
+     */
+    private function toSameLength($num1, $num2)
+    {
+        $num1 = $this->reduce($num1);
+        $num2 = $this->reduce($num2);
+        $numBits = max(strlen($num1), strlen($num2));
+
+        return array(
+            str_pad($num1, $numBits, '0', STR_PAD_LEFT),
+            str_pad($num2, $numBits, '0', STR_PAD_LEFT),
+            $numBits,
+        );
+    }
+}
diff --git a/vendor/mlocati/ip-lib/src/Service/RangesFromBounradyCalculator.php b/vendor/mlocati/ip-lib/src/Service/RangesFromBounradyCalculator.php
new file mode 100644
index 0000000..c1d29d6
--- /dev/null
+++ b/vendor/mlocati/ip-lib/src/Service/RangesFromBounradyCalculator.php
@@ -0,0 +1,161 @@
+<?php
+
+namespace IPLib\Service;
+
+use IPLib\Address\AddressInterface;
+use IPLib\Factory;
+use IPLib\Range\Subnet;
+
+/**
+ * Helper class to calculate the subnets describing all (and only all) the addresses between two bouundaries.
+ */
+class RangesFromBounradyCalculator
+{
+    /**
+     * The BinaryMath instance to be used to perform bitwise poerations.
+     *
+     * @var \IPLib\Service\BinaryMath
+     */
+    private $math;
+
+    /**
+     * The number of bits used to represent addresses.
+     *
+     * @var int
+     *
+     * @example 32 for IPv4, 128 for IPv6
+     */
+    private $numBits;
+
+    /**
+     * The bit masks for every bit index.
+     *
+     * @var string[]
+     */
+    private $masks;
+
+    /**
+     * The bit unmasks for every bit index.
+     *
+     * @var string[]
+     */
+    private $unmasks;
+
+    /**
+     * Initializes the instance.
+     *
+     * @param int $numBits the number of bits used to represent addresses (32 for IPv4, 128 for IPv6)
+     */
+    public function __construct($numBits)
+    {
+        $this->math = new BinaryMath();
+        $this->setNumBits($numBits);
+    }
+
+    /**
+     * Calculate the subnets describing all (and only all) the addresses between two bouundaries.
+     *
+     * @param \IPLib\Address\AddressInterface $from
+     * @param \IPLib\Address\AddressInterface $to
+     *
+     * @return \IPLib\Range\Subnet[]|null return NULL if the two addresses have an invalid number of bits (that is, different from the one passed to the constructor of this class)
+     */
+    public function getRanges(AddressInterface $from, AddressInterface $to)
+    {
+        if ($from->getNumberOfBits() !== $this->numBits || $to->getNumberOfBits() !== $this->numBits) {
+            return null;
+        }
+        if ($from->getComparableString() > $to->getComparableString()) {
+            list($from, $to) = array($to, $from);
+        }
+        $result = array();
+        $this->calculate($this->math->reduce($from->getBits()), $this->math->reduce($to->getBits()), $this->numBits, $result);
+
+        return $result;
+    }
+
+    /**
+     * Set the number of bits used to represent addresses (32 for IPv4, 128 for IPv6).
+     *
+     * @param int $numBits
+     */
+    private function setNumBits($numBits)
+    {
+        $numBits = (int) $numBits;
+        $masks = array();
+        $unmasks = array();
+        for ($bit = 0; $bit < $numBits; $bit++) {
+            $masks[$bit] = str_repeat('1', $numBits - $bit) . str_repeat('0', $bit);
+            $unmasks[$bit] = $bit === 0 ? '0' : str_repeat('1', $bit);
+        }
+        $this->numBits = $numBits;
+        $this->masks = $masks;
+        $this->unmasks = $unmasks;
+    }
+
+    /**
+     * Calculate the subnets.
+     *
+     * @param string $start the start address (represented in reduced bit form)
+     * @param string $end the end address (represented in reduced bit form)
+     * @param int $position the number of bits in the mask we are comparing at this cycle
+     * @param \IPLib\Range\Subnet[] $result found ranges will be added to this variable
+     */
+    private function calculate($start, $end, $position, array &$result)
+    {
+        if ($start === $end) {
+            $result[] = $this->subnetFromBits($start, $this->numBits);
+
+            return;
+        }
+        for ($index = $position - 1; $index >= 0; $index--) {
+            $startMasked = $this->math->andX($start, $this->masks[$index]);
+            $endMasked = $this->math->andX($end, $this->masks[$index]);
+            if ($startMasked !== $endMasked) {
+                $position = $index;
+                break;
+            }
+        }
+        if ($startMasked === $start && $this->math->andX($this->math->increment($end), $this->unmasks[$position]) === '0') {
+            $result[] = $this->subnetFromBits($start, $this->numBits - 1 - $position);
+
+            return;
+        }
+        $middleAddress = $this->math->orX($start, $this->unmasks[$position]);
+        $this->calculate($start, $middleAddress, $position, $result);
+        $this->calculate($this->math->increment($middleAddress), $end, $position, $result);
+    }
+
+    /**
+     * Create an address instance starting from its bits.
+     *
+     * @param string $bits the bits of the address (represented in reduced bit form)
+     *
+     * @return \IPLib\Address\AddressInterface
+     */
+    private function addressFromBits($bits)
+    {
+        $bits = str_pad($bits, $this->numBits, '0', STR_PAD_LEFT);
+        $bytes = array();
+        foreach (explode("\n", trim(chunk_split($bits, 8, "\n"))) as $byteBits) {
+            $bytes[] = bindec($byteBits);
+        }
+
+        return Factory::addressFromBytes($bytes);
+    }
+
+    /**
+     * Create an range instance starting from the bits if the address and the length of the network prefix.
+     *
+     * @param string $bits the bits of the address (represented in reduced bit form)
+     * @param int $networkPrefix the length of the network prefix
+     *
+     * @return \IPLib\Range\Subnet
+     */
+    private function subnetFromBits($bits, $networkPrefix)
+    {
+        $address = $this->addressFromBits($bits);
+
+        return new Subnet($address, $address, $networkPrefix);
+    }
+}
diff --git a/vendor/paragonie/random_compat/lib/random.php b/vendor/paragonie/random_compat/lib/random.php
index 36245f5..6df1cb0 100644
--- a/vendor/paragonie/random_compat/lib/random.php
+++ b/vendor/paragonie/random_compat/lib/random.php
@@ -54,9 +54,9 @@ if (!defined('RANDOM_COMPAT_READ_BUFFER')) {
 
 $RandomCompatDIR = dirname(__FILE__);
 
-require_once $RandomCompatDIR . DIRECTORY_SEPARATOR . 'byte_safe_strings.php';
-require_once $RandomCompatDIR . DIRECTORY_SEPARATOR . 'cast_to_int.php';
-require_once $RandomCompatDIR . DIRECTORY_SEPARATOR . 'error_polyfill.php';
+require_once $RandomCompatDIR.DIRECTORY_SEPARATOR.'byte_safe_strings.php';
+require_once $RandomCompatDIR.DIRECTORY_SEPARATOR.'cast_to_int.php';
+require_once $RandomCompatDIR.DIRECTORY_SEPARATOR.'error_polyfill.php';
 
 if (!is_callable('random_bytes')) {
     /**
@@ -76,9 +76,9 @@ if (!is_callable('random_bytes')) {
     if (extension_loaded('libsodium')) {
         // See random_bytes_libsodium.php
         if (PHP_VERSION_ID >= 50300 && is_callable('\\Sodium\\randombytes_buf')) {
-            require_once $RandomCompatDIR . DIRECTORY_SEPARATOR . 'random_bytes_libsodium.php';
+            require_once $RandomCompatDIR.DIRECTORY_SEPARATOR.'random_bytes_libsodium.php';
         } elseif (method_exists('Sodium', 'randombytes_buf')) {
-            require_once $RandomCompatDIR . DIRECTORY_SEPARATOR . 'random_bytes_libsodium_legacy.php';
+            require_once $RandomCompatDIR.DIRECTORY_SEPARATOR.'random_bytes_libsodium_legacy.php';
         }
     }
 
@@ -117,7 +117,7 @@ if (!is_callable('random_bytes')) {
             // place, that is not helpful to us here.
 
             // See random_bytes_dev_urandom.php
-            require_once $RandomCompatDIR . DIRECTORY_SEPARATOR . 'random_bytes_dev_urandom.php';
+            require_once $RandomCompatDIR.DIRECTORY_SEPARATOR.'random_bytes_dev_urandom.php';
         }
         // Unset variables after use
         $RandomCompat_basedir = null;
@@ -159,7 +159,7 @@ if (!is_callable('random_bytes')) {
         extension_loaded('mcrypt')
     ) {
         // See random_bytes_mcrypt.php
-        require_once $RandomCompatDIR . DIRECTORY_SEPARATOR . 'random_bytes_mcrypt.php';
+        require_once $RandomCompatDIR.DIRECTORY_SEPARATOR.'random_bytes_mcrypt.php';
     }
     $RandomCompatUrandom = null;
 
@@ -182,9 +182,10 @@ if (!is_callable('random_bytes')) {
         if (!in_array('com', $RandomCompat_disabled_classes)) {
             try {
                 $RandomCompatCOMtest = new COM('CAPICOM.Utilities.1');
+                /** @psalm-suppress TypeDoesNotContainType */
                 if (method_exists($RandomCompatCOMtest, 'GetRandom')) {
                     // See random_bytes_com_dotnet.php
-                    require_once $RandomCompatDIR . DIRECTORY_SEPARATOR . 'random_bytes_com_dotnet.php';
+                    require_once $RandomCompatDIR.DIRECTORY_SEPARATOR.'random_bytes_com_dotnet.php';
                 }
             } catch (com_exception $e) {
                 // Don't try to use it.
@@ -219,7 +220,7 @@ if (!is_callable('random_bytes')) {
 }
 
 if (!is_callable('random_int')) {
-    require_once $RandomCompatDIR . DIRECTORY_SEPARATOR . 'random_int.php';
+    require_once $RandomCompatDIR.DIRECTORY_SEPARATOR.'random_int.php';
 }
 
 $RandomCompatDIR = null;
diff --git a/vendor/paragonie/random_compat/phpunit-autoload.php b/vendor/paragonie/random_compat/phpunit-autoload.php
deleted file mode 100644
index 87b01aa..0000000
--- a/vendor/paragonie/random_compat/phpunit-autoload.php
+++ /dev/null
@@ -1,14 +0,0 @@
-<?php
-
-require_once __DIR__ . '/psalm-autoload.php';
-
-/**
- * This is necessary for PHPUnit on PHP >= 5.3
- *
- * Class PHPUnit_Framework_TestCase
- */
-if (PHP_VERSION_ID >= 50300) {
-    if (!class_exists('PHPUnit_Framework_TestCase')) {
-        require_once __DIR__ . '/other/phpunit-shim.php';
-    }
-}