Merge branch '5.2RC'5.2

14 files changed, 1138 insertions, 0 deletions

diff --git a/vendor/ramsey/uuid/src/Rfc4122/Fields.php b/vendor/ramsey/uuid/src/Rfc4122/Fields.php
new file mode 100644
index 000000000..0989d842a
--- /dev/null
+++ b/vendor/ramsey/uuid/src/Rfc4122/Fields.php
@@ -0,0 +1,193 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Rfc4122;
+
+use Ramsey\Uuid\Exception\InvalidArgumentException;
+use Ramsey\Uuid\Fields\SerializableFieldsTrait;
+use Ramsey\Uuid\Type\Hexadecimal;
+use Ramsey\Uuid\Uuid;
+
+use function bin2hex;
+use function dechex;
+use function hexdec;
+use function sprintf;
+use function str_pad;
+use function strlen;
+use function substr;
+use function unpack;
+
+use const STR_PAD_LEFT;
+
+/**
+ * RFC 4122 variant UUIDs are comprised of a set of named fields
+ *
+ * Internally, this class represents the fields together as a 16-byte binary
+ * string.
+ *
+ * @psalm-immutable
+ */
+final class Fields implements FieldsInterface
+{
+    use NilTrait;
+    use SerializableFieldsTrait;
+    use VariantTrait;
+    use VersionTrait;
+
+    /**
+     * @var string
+     */
+    private $bytes;
+
+    /**
+     * @param string $bytes A 16-byte binary string representation of a UUID
+     *
+     * @throws InvalidArgumentException if the byte string is not exactly 16 bytes
+     * @throws InvalidArgumentException if the byte string does not represent an RFC 4122 UUID
+     * @throws InvalidArgumentException if the byte string does not contain a valid version
+     */
+    public function __construct(string $bytes)
+    {
+        if (strlen($bytes) !== 16) {
+            throw new InvalidArgumentException(
+                'The byte string must be 16 bytes long; '
+                . 'received ' . strlen($bytes) . ' bytes'
+            );
+        }
+
+        $this->bytes = $bytes;
+
+        if (!$this->isCorrectVariant()) {
+            throw new InvalidArgumentException(
+                'The byte string received does not conform to the RFC 4122 variant'
+            );
+        }
+
+        if (!$this->isCorrectVersion()) {
+            throw new InvalidArgumentException(
+                'The byte string received does not contain a valid RFC 4122 version'
+            );
+        }
+    }
+
+    public function getBytes(): string
+    {
+        return $this->bytes;
+    }
+
+    public function getClockSeq(): Hexadecimal
+    {
+        $clockSeq = hexdec(bin2hex(substr($this->bytes, 8, 2))) & 0x3fff;
+
+        return new Hexadecimal(str_pad(dechex($clockSeq), 4, '0', STR_PAD_LEFT));
+    }
+
+    public function getClockSeqHiAndReserved(): Hexadecimal
+    {
+        return new Hexadecimal(bin2hex(substr($this->bytes, 8, 1)));
+    }
+
+    public function getClockSeqLow(): Hexadecimal
+    {
+        return new Hexadecimal(bin2hex(substr($this->bytes, 9, 1)));
+    }
+
+    public function getNode(): Hexadecimal
+    {
+        return new Hexadecimal(bin2hex(substr($this->bytes, 10)));
+    }
+
+    public function getTimeHiAndVersion(): Hexadecimal
+    {
+        return new Hexadecimal(bin2hex(substr($this->bytes, 6, 2)));
+    }
+
+    public function getTimeLow(): Hexadecimal
+    {
+        return new Hexadecimal(bin2hex(substr($this->bytes, 0, 4)));
+    }
+
+    public function getTimeMid(): Hexadecimal
+    {
+        return new Hexadecimal(bin2hex(substr($this->bytes, 4, 2)));
+    }
+
+    /**
+     * Returns the full 60-bit timestamp, without the version
+     *
+     * For version 2 UUIDs, the time_low field is the local identifier and
+     * should not be returned as part of the time. For this reason, we set the
+     * bottom 32 bits of the timestamp to 0's. As a result, there is some loss
+     * of fidelity of the timestamp, for version 2 UUIDs. The timestamp can be
+     * off by a range of 0 to 429.4967295 seconds (or 7 minutes, 9 seconds, and
+     * 496730 microseconds).
+     *
+     * For version 6 UUIDs, the timestamp order is reversed from the typical RFC
+     * 4122 order (the time bits are in the correct bit order, so that it is
+     * monotonically increasing). In returning the timestamp value, we put the
+     * bits in the order: time_low + time_mid + time_hi.
+     */
+    public function getTimestamp(): Hexadecimal
+    {
+        switch ($this->getVersion()) {
+            case Uuid::UUID_TYPE_DCE_SECURITY:
+                $timestamp = sprintf(
+                    '%03x%04s%08s',
+                    hexdec($this->getTimeHiAndVersion()->toString()) & 0x0fff,
+                    $this->getTimeMid()->toString(),
+                    ''
+                );
+
+                break;
+            case Uuid::UUID_TYPE_PEABODY:
+                $timestamp = sprintf(
+                    '%08s%04s%03x',
+                    $this->getTimeLow()->toString(),
+                    $this->getTimeMid()->toString(),
+                    hexdec($this->getTimeHiAndVersion()->toString()) & 0x0fff
+                );
+
+                break;
+            default:
+                $timestamp = sprintf(
+                    '%03x%04s%08s',
+                    hexdec($this->getTimeHiAndVersion()->toString()) & 0x0fff,
+                    $this->getTimeMid()->toString(),
+                    $this->getTimeLow()->toString()
+                );
+        }
+
+        return new Hexadecimal($timestamp);
+    }
+
+    public function getVersion(): ?int
+    {
+        if ($this->isNil()) {
+            return null;
+        }
+
+        $parts = unpack('n*', $this->bytes);
+
+        return (int) $parts[4] >> 12;
+    }
+
+    private function isCorrectVariant(): bool
+    {
+        if ($this->isNil()) {
+            return true;
+        }
+
+        return $this->getVariant() === Uuid::RFC_4122;
+    }
+}
diff --git a/vendor/ramsey/uuid/src/Rfc4122/FieldsInterface.php b/vendor/ramsey/uuid/src/Rfc4122/FieldsInterface.php
new file mode 100644
index 000000000..a303525d6
--- /dev/null
+++ b/vendor/ramsey/uuid/src/Rfc4122/FieldsInterface.php
@@ -0,0 +1,126 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Rfc4122;
+
+use Ramsey\Uuid\Fields\FieldsInterface as BaseFieldsInterface;
+use Ramsey\Uuid\Type\Hexadecimal;
+
+/**
+ * RFC 4122 defines fields for a specific variant of UUID
+ *
+ * The fields of an RFC 4122 variant UUID are:
+ *
+ * * **time_low**: The low field of the timestamp, an unsigned 32-bit integer
+ * * **time_mid**: The middle field of the timestamp, an unsigned 16-bit integer
+ * * **time_hi_and_version**: The high field of the timestamp multiplexed with
+ *   the version number, an unsigned 16-bit integer
+ * * **clock_seq_hi_and_reserved**: The high field of the clock sequence
+ *   multiplexed with the variant, an unsigned 8-bit integer
+ * * **clock_seq_low**: The low field of the clock sequence, an unsigned
+ *   8-bit integer
+ * * **node**: The spatially unique node identifier, an unsigned 48-bit
+ *   integer
+ *
+ * @link http://tools.ietf.org/html/rfc4122#section-4.1 RFC 4122, § 4.1: Format
+ *
+ * @psalm-immutable
+ */
+interface FieldsInterface extends BaseFieldsInterface
+{
+    /**
+     * Returns the full 16-bit clock sequence, with the variant bits (two most
+     * significant bits) masked out
+     */
+    public function getClockSeq(): Hexadecimal;
+
+    /**
+     * Returns the high field of the clock sequence multiplexed with the variant
+     */
+    public function getClockSeqHiAndReserved(): Hexadecimal;
+
+    /**
+     * Returns the low field of the clock sequence
+     */
+    public function getClockSeqLow(): Hexadecimal;
+
+    /**
+     * Returns the node field
+     */
+    public function getNode(): Hexadecimal;
+
+    /**
+     * Returns the high field of the timestamp multiplexed with the version
+     */
+    public function getTimeHiAndVersion(): Hexadecimal;
+
+    /**
+     * Returns the low field of the timestamp
+     */
+    public function getTimeLow(): Hexadecimal;
+
+    /**
+     * Returns the middle field of the timestamp
+     */
+    public function getTimeMid(): Hexadecimal;
+
+    /**
+     * Returns the full 60-bit timestamp, without the version
+     */
+    public function getTimestamp(): Hexadecimal;
+
+    /**
+     * Returns the variant
+     *
+     * The variant number describes the layout of the UUID. The variant
+     * number has the following meaning:
+     *
+     * - 0 - Reserved for NCS backward compatibility
+     * - 2 - The RFC 4122 variant
+     * - 6 - Reserved, Microsoft Corporation backward compatibility
+     * - 7 - Reserved for future definition
+     *
+     * For RFC 4122 variant UUIDs, this value should always be the integer `2`.
+     *
+     * @link http://tools.ietf.org/html/rfc4122#section-4.1.1 RFC 4122, § 4.1.1: Variant
+     */
+    public function getVariant(): int;
+
+    /**
+     * Returns the version
+     *
+     * The version number describes how the UUID was generated and has the
+     * following meaning:
+     *
+     * 1. Time-based UUID
+     * 2. DCE security UUID
+     * 3. Name-based UUID hashed with MD5
+     * 4. Randomly generated UUID
+     * 5. Name-based UUID hashed with SHA-1
+     *
+     * This returns `null` if the UUID is not an RFC 4122 variant, since version
+     * is only meaningful for this variant.
+     *
+     * @link http://tools.ietf.org/html/rfc4122#section-4.1.3 RFC 4122, § 4.1.3: Version
+     */
+    public function getVersion(): ?int;
+
+    /**
+     * Returns true if these fields represent a nil UUID
+     *
+     * The nil UUID is special form of UUID that is specified to have all 128
+     * bits set to zero.
+     */
+    public function isNil(): bool;
+}
diff --git a/vendor/ramsey/uuid/src/Rfc4122/NilTrait.php b/vendor/ramsey/uuid/src/Rfc4122/NilTrait.php
new file mode 100644
index 000000000..9a9774d89
--- /dev/null
+++ b/vendor/ramsey/uuid/src/Rfc4122/NilTrait.php
@@ -0,0 +1,41 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Rfc4122;
+
+/**
+ * Provides common functionality for nil UUIDs
+ *
+ * The nil UUID is special form of UUID that is specified to have all 128 bits
+ * set to zero.
+ *
+ * @link https://tools.ietf.org/html/rfc4122#section-4.1.7 RFC 4122, § 4.1.7: Nil UUID
+ *
+ * @psalm-immutable
+ */
+trait NilTrait
+{
+    /**
+     * Returns the bytes that comprise the fields
+     */
+    abstract public function getBytes(): string;
+
+    /**
+     * Returns true if the byte string represents a nil UUID
+     */
+    public function isNil(): bool
+    {
+        return $this->getBytes() === "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
+    }
+}
diff --git a/vendor/ramsey/uuid/src/Rfc4122/NilUuid.php b/vendor/ramsey/uuid/src/Rfc4122/NilUuid.php
new file mode 100644
index 000000000..c49b9945d
--- /dev/null
+++ b/vendor/ramsey/uuid/src/Rfc4122/NilUuid.php
@@ -0,0 +1,27 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Rfc4122;
+
+use Ramsey\Uuid\Uuid;
+
+/**
+ * The nil UUID is special form of UUID that is specified to have all 128 bits
+ * set to zero
+ *
+ * @psalm-immutable
+ */
+final class NilUuid extends Uuid implements UuidInterface
+{
+}
diff --git a/vendor/ramsey/uuid/src/Rfc4122/UuidBuilder.php b/vendor/ramsey/uuid/src/Rfc4122/UuidBuilder.php
new file mode 100644
index 000000000..736931af2
--- /dev/null
+++ b/vendor/ramsey/uuid/src/Rfc4122/UuidBuilder.php
@@ -0,0 +1,111 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Rfc4122;
+
+use Ramsey\Uuid\Builder\UuidBuilderInterface;
+use Ramsey\Uuid\Codec\CodecInterface;
+use Ramsey\Uuid\Converter\NumberConverterInterface;
+use Ramsey\Uuid\Converter\TimeConverterInterface;
+use Ramsey\Uuid\Exception\UnableToBuildUuidException;
+use Ramsey\Uuid\Exception\UnsupportedOperationException;
+use Ramsey\Uuid\Nonstandard\UuidV6;
+use Ramsey\Uuid\Rfc4122\UuidInterface as Rfc4122UuidInterface;
+use Ramsey\Uuid\UuidInterface;
+use Throwable;
+
+/**
+ * UuidBuilder builds instances of RFC 4122 UUIDs
+ *
+ * @psalm-immutable
+ */
+class UuidBuilder implements UuidBuilderInterface
+{
+    /**
+     * @var NumberConverterInterface
+     */
+    private $numberConverter;
+
+    /**
+     * @var TimeConverterInterface
+     */
+    private $timeConverter;
+
+    /**
+     * Constructs the DefaultUuidBuilder
+     *
+     * @param NumberConverterInterface $numberConverter The number converter to
+     *     use when constructing the Uuid
+     * @param TimeConverterInterface $timeConverter The time converter to use
+     *     for converting timestamps extracted from a UUID to Unix timestamps
+     */
+    public function __construct(
+        NumberConverterInterface $numberConverter,
+        TimeConverterInterface $timeConverter
+    ) {
+        $this->numberConverter = $numberConverter;
+        $this->timeConverter = $timeConverter;
+    }
+
+    /**
+     * Builds and returns a Uuid
+     *
+     * @param CodecInterface $codec The codec to use for building this Uuid instance
+     * @param string $bytes The byte string from which to construct a UUID
+     *
+     * @return Rfc4122UuidInterface UuidBuilder returns instances of Rfc4122UuidInterface
+     *
+     * @psalm-pure
+     */
+    public function build(CodecInterface $codec, string $bytes): UuidInterface
+    {
+        try {
+            $fields = $this->buildFields($bytes);
+
+            if ($fields->isNil()) {
+                return new NilUuid($fields, $this->numberConverter, $codec, $this->timeConverter);
+            }
+
+            switch ($fields->getVersion()) {
+                case 1:
+                    return new UuidV1($fields, $this->numberConverter, $codec, $this->timeConverter);
+                case 2:
+                    return new UuidV2($fields, $this->numberConverter, $codec, $this->timeConverter);
+                case 3:
+                    return new UuidV3($fields, $this->numberConverter, $codec, $this->timeConverter);
+                case 4:
+                    return new UuidV4($fields, $this->numberConverter, $codec, $this->timeConverter);
+                case 5:
+                    return new UuidV5($fields, $this->numberConverter, $codec, $this->timeConverter);
+                case 6:
+                    return new UuidV6($fields, $this->numberConverter, $codec, $this->timeConverter);
+            }
+
+            throw new UnsupportedOperationException(
+                'The UUID version in the given fields is not supported '
+                . 'by this UUID builder'
+            );
+        } catch (Throwable $e) {
+            throw new UnableToBuildUuidException($e->getMessage(), (int) $e->getCode(), $e);
+        }
+    }
+
+    /**
+     * Proxy method to allow injecting a mock, for testing
+     */
+    protected function buildFields(string $bytes): FieldsInterface
+    {
+        return new Fields($bytes);
+    }
+}
diff --git a/vendor/ramsey/uuid/src/Rfc4122/UuidInterface.php b/vendor/ramsey/uuid/src/Rfc4122/UuidInterface.php
new file mode 100644
index 000000000..3e4d9faee
--- /dev/null
+++ b/vendor/ramsey/uuid/src/Rfc4122/UuidInterface.php
@@ -0,0 +1,36 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Rfc4122;
+
+use Ramsey\Uuid\UuidInterface as BaseUuidInterface;
+
+/**
+ * Also known as a Leach-Salz variant UUID, an RFC 4122 variant UUID is a
+ * universally unique identifier defined by RFC 4122
+ *
+ * @link https://tools.ietf.org/html/rfc4122 RFC 4122
+ *
+ * @psalm-immutable
+ */
+interface UuidInterface extends BaseUuidInterface
+{
+    /**
+     * Returns the string standard representation of the UUID as a URN
+     *
+     * @link http://en.wikipedia.org/wiki/Uniform_Resource_Name Uniform Resource Name
+     * @link https://tools.ietf.org/html/rfc4122#section-3 RFC 4122, § 3: Namespace Registration Template
+     */
+    public function getUrn(): string;
+}
diff --git a/vendor/ramsey/uuid/src/Rfc4122/UuidV1.php b/vendor/ramsey/uuid/src/Rfc4122/UuidV1.php
new file mode 100644
index 000000000..764e42f84
--- /dev/null
+++ b/vendor/ramsey/uuid/src/Rfc4122/UuidV1.php
@@ -0,0 +1,92 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Rfc4122;
+
+use DateTimeImmutable;
+use DateTimeInterface;
+use Ramsey\Uuid\Codec\CodecInterface;
+use Ramsey\Uuid\Converter\NumberConverterInterface;
+use Ramsey\Uuid\Converter\TimeConverterInterface;
+use Ramsey\Uuid\Exception\DateTimeException;
+use Ramsey\Uuid\Exception\InvalidArgumentException;
+use Ramsey\Uuid\Rfc4122\FieldsInterface as Rfc4122FieldsInterface;
+use Ramsey\Uuid\Uuid;
+use Throwable;
+
+use function str_pad;
+
+use const STR_PAD_LEFT;
+
+/**
+ * Time-based, or version 1, UUIDs include timestamp, clock sequence, and node
+ * values that are combined into a 128-bit unsigned integer
+ *
+ * @psalm-immutable
+ */
+final class UuidV1 extends Uuid implements UuidInterface
+{
+    /**
+     * Creates a version 1 (time-based) UUID
+     *
+     * @param Rfc4122FieldsInterface $fields The fields from which to construct a UUID
+     * @param NumberConverterInterface $numberConverter The number converter to use
+     *     for converting hex values to/from integers
+     * @param CodecInterface $codec The codec to use when encoding or decoding
+     *     UUID strings
+     * @param TimeConverterInterface $timeConverter The time converter to use
+     *     for converting timestamps extracted from a UUID to unix timestamps
+     */
+    public function __construct(
+        Rfc4122FieldsInterface $fields,
+        NumberConverterInterface $numberConverter,
+        CodecInterface $codec,
+        TimeConverterInterface $timeConverter
+    ) {
+        if ($fields->getVersion() !== Uuid::UUID_TYPE_TIME) {
+            throw new InvalidArgumentException(
+                'Fields used to create a UuidV1 must represent a '
+                . 'version 1 (time-based) UUID'
+            );
+        }
+
+        parent::__construct($fields, $numberConverter, $codec, $timeConverter);
+    }
+
+    /**
+     * Returns a DateTimeInterface object representing the timestamp associated
+     * with the UUID
+     *
+     * The timestamp value is only meaningful in a time-based UUID, which
+     * has version type 1.
+     *
+     * @return DateTimeImmutable A PHP DateTimeImmutable instance representing
+     *     the timestamp of a version 1 UUID
+     */
+    public function getDateTime(): DateTimeInterface
+    {
+        $time = $this->timeConverter->convertTime($this->fields->getTimestamp());
+
+        try {
+            return new DateTimeImmutable(
+                '@'
+                . $time->getSeconds()->toString()
+                . '.'
+                . str_pad($time->getMicroseconds()->toString(), 6, '0', STR_PAD_LEFT)
+            );
+        } catch (Throwable $e) {
+            throw new DateTimeException($e->getMessage(), (int) $e->getCode(), $e);
+        }
+    }
+}
diff --git a/vendor/ramsey/uuid/src/Rfc4122/UuidV2.php b/vendor/ramsey/uuid/src/Rfc4122/UuidV2.php
new file mode 100644
index 000000000..74906f050
--- /dev/null
+++ b/vendor/ramsey/uuid/src/Rfc4122/UuidV2.php
@@ -0,0 +1,143 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Rfc4122;
+
+use DateTimeImmutable;
+use DateTimeInterface;
+use Ramsey\Uuid\Codec\CodecInterface;
+use Ramsey\Uuid\Converter\NumberConverterInterface;
+use Ramsey\Uuid\Converter\TimeConverterInterface;
+use Ramsey\Uuid\Exception\DateTimeException;
+use Ramsey\Uuid\Exception\InvalidArgumentException;
+use Ramsey\Uuid\Rfc4122\FieldsInterface as Rfc4122FieldsInterface;
+use Ramsey\Uuid\Type\Integer as IntegerObject;
+use Ramsey\Uuid\Uuid;
+use Throwable;
+
+use function hexdec;
+use function str_pad;
+
+use const STR_PAD_LEFT;
+
+/**
+ * DCE Security version, or version 2, UUIDs include local domain identifier,
+ * local ID for the specified domain, and node values that are combined into a
+ * 128-bit unsigned integer
+ *
+ * @link https://publications.opengroup.org/c311 DCE 1.1: Authentication and Security Services
+ * @link https://publications.opengroup.org/c706 DCE 1.1: Remote Procedure Call
+ * @link https://pubs.opengroup.org/onlinepubs/9696989899/chap5.htm#tagcjh_08_02_01_01 DCE 1.1: Auth & Sec, §5.2.1.1
+ * @link https://pubs.opengroup.org/onlinepubs/9696989899/chap11.htm#tagcjh_14_05_01_01 DCE 1.1: Auth & Sec, §11.5.1.1
+ * @link https://pubs.opengroup.org/onlinepubs/9629399/apdxa.htm DCE 1.1: RPC, Appendix A
+ * @link https://github.com/google/uuid Go package for UUIDs (includes DCE implementation)
+ *
+ * @psalm-immutable
+ */
+final class UuidV2 extends Uuid implements UuidInterface
+{
+    /**
+     * Creates a version 2 (DCE Security) UUID
+     *
+     * @param Rfc4122FieldsInterface $fields The fields from which to construct a UUID
+     * @param NumberConverterInterface $numberConverter The number converter to use
+     *     for converting hex values to/from integers
+     * @param CodecInterface $codec The codec to use when encoding or decoding
+     *     UUID strings
+     * @param TimeConverterInterface $timeConverter The time converter to use
+     *     for converting timestamps extracted from a UUID to unix timestamps
+     */
+    public function __construct(
+        Rfc4122FieldsInterface $fields,
+        NumberConverterInterface $numberConverter,
+        CodecInterface $codec,
+        TimeConverterInterface $timeConverter
+    ) {
+        if ($fields->getVersion() !== Uuid::UUID_TYPE_DCE_SECURITY) {
+            throw new InvalidArgumentException(
+                'Fields used to create a UuidV2 must represent a '
+                . 'version 2 (DCE Security) UUID'
+            );
+        }
+
+        parent::__construct($fields, $numberConverter, $codec, $timeConverter);
+    }
+
+    /**
+     * Returns a DateTimeInterface object representing the timestamp associated
+     * with the UUID
+     *
+     * It is important to note that a version 2 UUID suffers from some loss of
+     * fidelity of the timestamp, due to replacing the time_low field with the
+     * local identifier. When constructing the timestamp value for date
+     * purposes, we replace the local identifier bits with zeros. As a result,
+     * the timestamp can be off by a range of 0 to 429.4967295 seconds (or 7
+     * minutes, 9 seconds, and 496730 microseconds).
+     *
+     * Astute observers might note this value directly corresponds to 2^32 - 1,
+     * or 0xffffffff. The local identifier is 32-bits, and we have set each of
+     * these bits to 0, so the maximum range of timestamp drift is 0x00000000
+     * to 0xffffffff (counted in 100-nanosecond intervals).
+     *
+     * @return DateTimeImmutable A PHP DateTimeImmutable instance representing
+     *     the timestamp of a version 2 UUID
+     */
+    public function getDateTime(): DateTimeInterface
+    {
+        $time = $this->timeConverter->convertTime($this->fields->getTimestamp());
+
+        try {
+            return new DateTimeImmutable(
+                '@'
+                . $time->getSeconds()->toString()
+                . '.'
+                . str_pad($time->getMicroseconds()->toString(), 6, '0', STR_PAD_LEFT)
+            );
+        } catch (Throwable $e) {
+            throw new DateTimeException($e->getMessage(), (int) $e->getCode(), $e);
+        }
+    }
+
+    /**
+     * Returns the local domain used to create this version 2 UUID
+     */
+    public function getLocalDomain(): int
+    {
+        /** @var Rfc4122FieldsInterface $fields */
+        $fields = $this->getFields();
+
+        return (int) hexdec($fields->getClockSeqLow()->toString());
+    }
+
+    /**
+     * Returns the string name of the local domain
+     */
+    public function getLocalDomainName(): string
+    {
+        return Uuid::DCE_DOMAIN_NAMES[$this->getLocalDomain()];
+    }
+
+    /**
+     * Returns the local identifier for the domain used to create this version 2 UUID
+     */
+    public function getLocalIdentifier(): IntegerObject
+    {
+        /** @var Rfc4122FieldsInterface $fields */
+        $fields = $this->getFields();
+
+        return new IntegerObject(
+            $this->numberConverter->fromHex($fields->getTimeLow()->toString())
+        );
+    }
+}
diff --git a/vendor/ramsey/uuid/src/Rfc4122/UuidV3.php b/vendor/ramsey/uuid/src/Rfc4122/UuidV3.php
new file mode 100644
index 000000000..deaa54eb0
--- /dev/null
+++ b/vendor/ramsey/uuid/src/Rfc4122/UuidV3.php
@@ -0,0 +1,58 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Rfc4122;
+
+use Ramsey\Uuid\Codec\CodecInterface;
+use Ramsey\Uuid\Converter\NumberConverterInterface;
+use Ramsey\Uuid\Converter\TimeConverterInterface;
+use Ramsey\Uuid\Exception\InvalidArgumentException;
+use Ramsey\Uuid\Rfc4122\FieldsInterface as Rfc4122FieldsInterface;
+use Ramsey\Uuid\Uuid;
+
+/**
+ * Version 3 UUIDs are named-based, using combination of a namespace and name
+ * that are hashed into a 128-bit unsigned integer using MD5
+ *
+ * @psalm-immutable
+ */
+final class UuidV3 extends Uuid implements UuidInterface
+{
+    /**
+     * Creates a version 3 (name-based, MD5-hashed) UUID
+     *
+     * @param Rfc4122FieldsInterface $fields The fields from which to construct a UUID
+     * @param NumberConverterInterface $numberConverter The number converter to use
+     *     for converting hex values to/from integers
+     * @param CodecInterface $codec The codec to use when encoding or decoding
+     *     UUID strings
+     * @param TimeConverterInterface $timeConverter The time converter to use
+     *     for converting timestamps extracted from a UUID to unix timestamps
+     */
+    public function __construct(
+        Rfc4122FieldsInterface $fields,
+        NumberConverterInterface $numberConverter,
+        CodecInterface $codec,
+        TimeConverterInterface $timeConverter
+    ) {
+        if ($fields->getVersion() !== Uuid::UUID_TYPE_HASH_MD5) {
+            throw new InvalidArgumentException(
+                'Fields used to create a UuidV3 must represent a '
+                . 'version 3 (name-based, MD5-hashed) UUID'
+            );
+        }
+
+        parent::__construct($fields, $numberConverter, $codec, $timeConverter);
+    }
+}
diff --git a/vendor/ramsey/uuid/src/Rfc4122/UuidV4.php b/vendor/ramsey/uuid/src/Rfc4122/UuidV4.php
new file mode 100644
index 000000000..2e5724620
--- /dev/null
+++ b/vendor/ramsey/uuid/src/Rfc4122/UuidV4.php
@@ -0,0 +1,58 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Rfc4122;
+
+use Ramsey\Uuid\Codec\CodecInterface;
+use Ramsey\Uuid\Converter\NumberConverterInterface;
+use Ramsey\Uuid\Converter\TimeConverterInterface;
+use Ramsey\Uuid\Exception\InvalidArgumentException;
+use Ramsey\Uuid\Rfc4122\FieldsInterface as Rfc4122FieldsInterface;
+use Ramsey\Uuid\Uuid;
+
+/**
+ * Random, or version 4, UUIDs are randomly or pseudo-randomly generated 128-bit
+ * integers
+ *
+ * @psalm-immutable
+ */
+final class UuidV4 extends Uuid implements UuidInterface
+{
+    /**
+     * Creates a version 4 (random) UUID
+     *
+     * @param Rfc4122FieldsInterface $fields The fields from which to construct a UUID
+     * @param NumberConverterInterface $numberConverter The number converter to use
+     *     for converting hex values to/from integers
+     * @param CodecInterface $codec The codec to use when encoding or decoding
+     *     UUID strings
+     * @param TimeConverterInterface $timeConverter The time converter to use
+     *     for converting timestamps extracted from a UUID to unix timestamps
+     */
+    public function __construct(
+        Rfc4122FieldsInterface $fields,
+        NumberConverterInterface $numberConverter,
+        CodecInterface $codec,
+        TimeConverterInterface $timeConverter
+    ) {
+        if ($fields->getVersion() !== Uuid::UUID_TYPE_RANDOM) {
+            throw new InvalidArgumentException(
+                'Fields used to create a UuidV4 must represent a '
+                . 'version 4 (random) UUID'
+            );
+        }
+
+        parent::__construct($fields, $numberConverter, $codec, $timeConverter);
+    }
+}
diff --git a/vendor/ramsey/uuid/src/Rfc4122/UuidV5.php b/vendor/ramsey/uuid/src/Rfc4122/UuidV5.php
new file mode 100644
index 000000000..2ef6ab3f1
--- /dev/null
+++ b/vendor/ramsey/uuid/src/Rfc4122/UuidV5.php
@@ -0,0 +1,58 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Rfc4122;
+
+use Ramsey\Uuid\Codec\CodecInterface;
+use Ramsey\Uuid\Converter\NumberConverterInterface;
+use Ramsey\Uuid\Converter\TimeConverterInterface;
+use Ramsey\Uuid\Exception\InvalidArgumentException;
+use Ramsey\Uuid\Rfc4122\FieldsInterface as Rfc4122FieldsInterface;
+use Ramsey\Uuid\Uuid;
+
+/**
+ * Version 5 UUIDs are named-based, using combination of a namespace and name
+ * that are hashed into a 128-bit unsigned integer using SHA1
+ *
+ * @psalm-immutable
+ */
+final class UuidV5 extends Uuid implements UuidInterface
+{
+    /**
+     * Creates a version 5 (name-based, SHA1-hashed) UUID
+     *
+     * @param Rfc4122FieldsInterface $fields The fields from which to construct a UUID
+     * @param NumberConverterInterface $numberConverter The number converter to use
+     *     for converting hex values to/from integers
+     * @param CodecInterface $codec The codec to use when encoding or decoding
+     *     UUID strings
+     * @param TimeConverterInterface $timeConverter The time converter to use
+     *     for converting timestamps extracted from a UUID to unix timestamps
+     */
+    public function __construct(
+        Rfc4122FieldsInterface $fields,
+        NumberConverterInterface $numberConverter,
+        CodecInterface $codec,
+        TimeConverterInterface $timeConverter
+    ) {
+        if ($fields->getVersion() !== Uuid::UUID_TYPE_HASH_SHA1) {
+            throw new InvalidArgumentException(
+                'Fields used to create a UuidV5 must represent a '
+                . 'version 5 (named-based, SHA1-hashed) UUID'
+            );
+        }
+
+        parent::__construct($fields, $numberConverter, $codec, $timeConverter);
+    }
+}
diff --git a/vendor/ramsey/uuid/src/Rfc4122/Validator.php b/vendor/ramsey/uuid/src/Rfc4122/Validator.php
new file mode 100644
index 000000000..ed43c982f
--- /dev/null
+++ b/vendor/ramsey/uuid/src/Rfc4122/Validator.php
@@ -0,0 +1,49 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Rfc4122;
+
+use Ramsey\Uuid\Uuid;
+use Ramsey\Uuid\Validator\ValidatorInterface;
+
+use function preg_match;
+use function str_replace;
+
+/**
+ * Rfc4122\Validator validates strings as UUIDs of the RFC 4122 variant
+ *
+ * @psalm-immutable
+ */
+final class Validator implements ValidatorInterface
+{
+    private const VALID_PATTERN = '\A[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-'
+        . '[1-5]{1}[0-9A-Fa-f]{3}-[ABab89]{1}[0-9A-Fa-f]{3}-[0-9A-Fa-f]{12}\z';
+
+    /**
+     * @psalm-return non-empty-string
+     * @psalm-suppress MoreSpecificReturnType we know that the retrieved `string` is never empty
+     * @psalm-suppress LessSpecificReturnStatement we know that the retrieved `string` is never empty
+     */
+    public function getPattern(): string
+    {
+        return self::VALID_PATTERN;
+    }
+
+    public function validate(string $uuid): bool
+    {
+        $uuid = str_replace(['urn:', 'uuid:', 'URN:', 'UUID:', '{', '}'], '', $uuid);
+
+        return $uuid === Uuid::NIL || preg_match('/' . self::VALID_PATTERN . '/Dms', $uuid);
+    }
+}
diff --git a/vendor/ramsey/uuid/src/Rfc4122/VariantTrait.php b/vendor/ramsey/uuid/src/Rfc4122/VariantTrait.php
new file mode 100644
index 000000000..c32a8ce80
--- /dev/null
+++ b/vendor/ramsey/uuid/src/Rfc4122/VariantTrait.php
@@ -0,0 +1,89 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Rfc4122;
+
+use Ramsey\Uuid\Exception\InvalidBytesException;
+use Ramsey\Uuid\Uuid;
+
+use function decbin;
+use function str_pad;
+use function strlen;
+use function strpos;
+use function substr;
+use function unpack;
+
+use const STR_PAD_LEFT;
+
+/**
+ * Provides common functionality for handling the variant, as defined by RFC 4122
+ *
+ * @psalm-immutable
+ */
+trait VariantTrait
+{
+    /**
+     * Returns the bytes that comprise the fields
+     */
+    abstract public function getBytes(): string;
+
+    /**
+     * Returns the variant identifier, according to RFC 4122, for the given bytes
+     *
+     * The following values may be returned:
+     *
+     * - `0` -- Reserved, NCS backward compatibility.
+     * - `2` -- The variant specified in RFC 4122.
+     * - `6` -- Reserved, Microsoft Corporation backward compatibility.
+     * - `7` -- Reserved for future definition.
+     *
+     * @link https://tools.ietf.org/html/rfc4122#section-4.1.1 RFC 4122, § 4.1.1: Variant
+     *
+     * @return int The variant identifier, according to RFC 4122
+     */
+    public function getVariant(): int
+    {
+        if (strlen($this->getBytes()) !== 16) {
+            throw new InvalidBytesException('Invalid number of bytes');
+        }
+
+        $parts = unpack('n*', $this->getBytes());
+
+        // $parts[5] is a 16-bit, unsigned integer containing the variant bits
+        // of the UUID. We convert this integer into a string containing a
+        // binary representation, padded to 16 characters. We analyze the first
+        // three characters (three most-significant bits) to determine the
+        // variant.
+        $binary = str_pad(
+            decbin((int) $parts[5]),
+            16,
+            '0',
+            STR_PAD_LEFT
+        );
+
+        $msb = substr($binary, 0, 3);
+
+        if ($msb === '111') {
+            $variant = Uuid::RESERVED_FUTURE;
+        } elseif ($msb === '110') {
+            $variant = Uuid::RESERVED_MICROSOFT;
+        } elseif (strpos($msb, '10') === 0) {
+            $variant = Uuid::RFC_4122;
+        } else {
+            $variant = Uuid::RESERVED_NCS;
+        }
+
+        return $variant;
+    }
+}
diff --git a/vendor/ramsey/uuid/src/Rfc4122/VersionTrait.php b/vendor/ramsey/uuid/src/Rfc4122/VersionTrait.php
new file mode 100644
index 000000000..cee55fbef
--- /dev/null
+++ b/vendor/ramsey/uuid/src/Rfc4122/VersionTrait.php
@@ -0,0 +1,57 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Rfc4122;
+
+/**
+ * Provides common functionality for handling the version, as defined by RFC 4122
+ *
+ * @psalm-immutable
+ */
+trait VersionTrait
+{
+    /**
+     * Returns the version
+     */
+    abstract public function getVersion(): ?int;
+
+    /**
+     * Returns true if these fields represent a nil UUID
+     */
+    abstract public function isNil(): bool;
+
+    /**
+     * Returns true if the version matches one of those defined by RFC 4122
+     *
+     * @return bool True if the UUID version is valid, false otherwise
+     */
+    private function isCorrectVersion(): bool
+    {
+        if ($this->isNil()) {
+            return true;
+        }
+
+        switch ($this->getVersion()) {
+            case 1:
+            case 2:
+            case 3:
+            case 4:
+            case 5:
+            case 6:
+                return true;
+        }
+
+        return false;
+    }
+}