first commit

vendor/ramsey/uuid/src/Generator/CombGenerator.php

@@ -0,0 +1,115 @@
+<?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\Generator;
+
+use Ramsey\Uuid\Converter\NumberConverterInterface;
+use Ramsey\Uuid\Exception\InvalidArgumentException;
+
+use function bin2hex;
+use function explode;
+use function hex2bin;
+use function microtime;
+use function str_pad;
+use function substr;
+
+use const STR_PAD_LEFT;
+
+/**
+ * CombGenerator generates COMBs (combined UUID/timestamp)
+ *
+ * The CombGenerator, when used with the StringCodec (and, by proxy, the
+ * TimestampLastCombCodec) or the TimestampFirstCombCodec, combines the current
+ * timestamp with a UUID (hence the name "COMB"). The timestamp either appears
+ * as the first or last 48 bits of the COMB, depending on the codec used.
+ *
+ * By default, COMBs will have the timestamp set as the last 48 bits of the
+ * identifier.
+ *
+ * ``` php
+ * $factory = new UuidFactory();
+ *
+ * $factory->setRandomGenerator(new CombGenerator(
+ *     $factory->getRandomGenerator(),
+ *     $factory->getNumberConverter()
+ * ));
+ *
+ * $comb = $factory->uuid4();
+ * ```
+ *
+ * To generate a COMB with the timestamp as the first 48 bits, set the
+ * TimestampFirstCombCodec as the codec.
+ *
+ * ``` php
+ * $factory->setCodec(new TimestampFirstCombCodec($factory->getUuidBuilder()));
+ * ```
+ *
+ * @link https://www.informit.com/articles/printerfriendly/25862 The Cost of GUIDs as Primary Keys
+ */
+class CombGenerator implements RandomGeneratorInterface
+{
+    public const TIMESTAMP_BYTES = 6;
+
+    public function __construct(
+        private RandomGeneratorInterface $generator,
+        private NumberConverterInterface $numberConverter
+    ) {
+    }
+
+    /**
+     * @throws InvalidArgumentException if $length is not a positive integer
+     *     greater than or equal to CombGenerator::TIMESTAMP_BYTES
+     *
+     * @inheritDoc
+     */
+    public function generate(int $length): string
+    {
+        if ($length < self::TIMESTAMP_BYTES) {
+            throw new InvalidArgumentException(
+                'Length must be a positive integer greater than or equal to ' . self::TIMESTAMP_BYTES
+            );
+        }
+
+        $hash = '';
+        if (self::TIMESTAMP_BYTES > 0 && $length > self::TIMESTAMP_BYTES) {
+            $hash = $this->generator->generate($length - self::TIMESTAMP_BYTES);
+        }
+
+        $lsbTime = str_pad(
+            $this->numberConverter->toHex($this->timestamp()),
+            self::TIMESTAMP_BYTES * 2,
+            '0',
+            STR_PAD_LEFT
+        );
+
+        return (string) hex2bin(
+            str_pad(
+                bin2hex($hash),
+                $length - self::TIMESTAMP_BYTES,
+                '0'
+            )
+            . $lsbTime
+        );
+    }
+
+    /**
+     * Returns current timestamp a string integer, precise to 0.00001 seconds
+     */
+    private function timestamp(): string
+    {
+        $time = explode(' ', microtime(false));
+
+        return $time[1] . substr($time[0], 2, 5);
+    }
+}

vendor/ramsey/uuid/src/Generator/DceSecurityGenerator.php

@@ -0,0 +1,141 @@
+<?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\Generator;
+
+use Ramsey\Uuid\Converter\NumberConverterInterface;
+use Ramsey\Uuid\Exception\DceSecurityException;
+use Ramsey\Uuid\Provider\DceSecurityProviderInterface;
+use Ramsey\Uuid\Type\Hexadecimal;
+use Ramsey\Uuid\Type\Integer as IntegerObject;
+use Ramsey\Uuid\Uuid;
+
+use function hex2bin;
+use function in_array;
+use function pack;
+use function str_pad;
+use function strlen;
+use function substr_replace;
+
+use const STR_PAD_LEFT;
+
+/**
+ * DceSecurityGenerator generates strings of binary data based on a local
+ * domain, local identifier, node ID, clock sequence, and the current time
+ */
+class DceSecurityGenerator implements DceSecurityGeneratorInterface
+{
+    private const DOMAINS = [
+        Uuid::DCE_DOMAIN_PERSON,
+        Uuid::DCE_DOMAIN_GROUP,
+        Uuid::DCE_DOMAIN_ORG,
+    ];
+
+    /**
+     * Upper bounds for the clock sequence in DCE Security UUIDs.
+     */
+    private const CLOCK_SEQ_HIGH = 63;
+
+    /**
+     * Lower bounds for the clock sequence in DCE Security UUIDs.
+     */
+    private const CLOCK_SEQ_LOW = 0;
+
+    public function __construct(
+        private NumberConverterInterface $numberConverter,
+        private TimeGeneratorInterface $timeGenerator,
+        private DceSecurityProviderInterface $dceSecurityProvider
+    ) {
+    }
+
+    public function generate(
+        int $localDomain,
+        ?IntegerObject $localIdentifier = null,
+        ?Hexadecimal $node = null,
+        ?int $clockSeq = null
+    ): string {
+        if (!in_array($localDomain, self::DOMAINS)) {
+            throw new DceSecurityException(
+                'Local domain must be a valid DCE Security domain'
+            );
+        }
+
+        if ($localIdentifier && $localIdentifier->isNegative()) {
+            throw new DceSecurityException(
+                'Local identifier out of bounds; it must be a value between 0 and 4294967295'
+            );
+        }
+
+        if ($clockSeq > self::CLOCK_SEQ_HIGH || $clockSeq < self::CLOCK_SEQ_LOW) {
+            throw new DceSecurityException(
+                'Clock sequence out of bounds; it must be a value between 0 and 63'
+            );
+        }
+
+        switch ($localDomain) {
+            case Uuid::DCE_DOMAIN_ORG:
+                if ($localIdentifier === null) {
+                    throw new DceSecurityException(
+                        'A local identifier must be provided for the org domain'
+                    );
+                }
+
+                break;
+            case Uuid::DCE_DOMAIN_PERSON:
+                if ($localIdentifier === null) {
+                    $localIdentifier = $this->dceSecurityProvider->getUid();
+                }
+
+                break;
+            case Uuid::DCE_DOMAIN_GROUP:
+            default:
+                if ($localIdentifier === null) {
+                    $localIdentifier = $this->dceSecurityProvider->getGid();
+                }
+
+                break;
+        }
+
+        $identifierHex = $this->numberConverter->toHex($localIdentifier->toString());
+
+        // The maximum value for the local identifier is 0xffffffff, or
+        // 4294967295. This is 8 hexadecimal digits, so if the length of
+        // hexadecimal digits is greater than 8, we know the value is greater
+        // than 0xffffffff.
+        if (strlen($identifierHex) > 8) {
+            throw new DceSecurityException(
+                'Local identifier out of bounds; it must be a value between 0 and 4294967295'
+            );
+        }
+
+        $domainByte = pack('n', $localDomain)[1];
+        $identifierBytes = (string) hex2bin(str_pad($identifierHex, 8, '0', STR_PAD_LEFT));
+
+        if ($node instanceof Hexadecimal) {
+            $node = $node->toString();
+        }
+
+        // Shift the clock sequence 8 bits to the left, so it matches 0x3f00.
+        if ($clockSeq !== null) {
+            $clockSeq = $clockSeq << 8;
+        }
+
+        $bytes = $this->timeGenerator->generate($node, $clockSeq);
+
+        // Replace bytes in the time-based UUID with DCE Security values.
+        $bytes = substr_replace($bytes, $identifierBytes, 0, 4);
+
+        return substr_replace($bytes, $domainByte, 9, 1);
+    }
+}

vendor/ramsey/uuid/src/Generator/DceSecurityGeneratorInterface.php

@@ -0,0 +1,53 @@
+<?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\Generator;
+
+use Ramsey\Uuid\Rfc4122\UuidV2;
+use Ramsey\Uuid\Type\Hexadecimal;
+use Ramsey\Uuid\Type\Integer as IntegerObject;
+
+/**
+ * A DCE Security generator generates strings of binary data based on a local
+ * domain, local identifier, node ID, clock sequence, and the current time
+ *
+ * @see UuidV2
+ */
+interface DceSecurityGeneratorInterface
+{
+    /**
+     * Generate a binary string from a local domain, local identifier, node ID,
+     * clock sequence, and current time
+     *
+     * @param int $localDomain The local domain to use when generating bytes,
+     *     according to DCE Security
+     * @param IntegerObject|null $localIdentifier The local identifier for the
+     *     given domain; this may be a UID or GID on POSIX systems, if the local
+     *     domain is person or group, or it may be a site-defined identifier
+     *     if the local domain is org
+     * @param Hexadecimal|null $node A 48-bit number representing the hardware
+     *     address
+     * @param int|null $clockSeq A 14-bit number used to help avoid duplicates
+     *     that could arise when the clock is set backwards in time or if the
+     *     node ID changes
+     *
+     * @return string A binary string
+     */
+    public function generate(
+        int $localDomain,
+        ?IntegerObject $localIdentifier = null,
+        ?Hexadecimal $node = null,
+        ?int $clockSeq = null
+    ): string;
+}

vendor/ramsey/uuid/src/Generator/DefaultNameGenerator.php

@@ -0,0 +1,48 @@
+<?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\Generator;
+
+use Ramsey\Uuid\Exception\NameException;
+use Ramsey\Uuid\UuidInterface;
+use ValueError;
+
+use function hash;
+
+/**
+ * DefaultNameGenerator generates strings of binary data based on a namespace,
+ * name, and hashing algorithm
+ */
+class DefaultNameGenerator implements NameGeneratorInterface
+{
+    /** @psalm-pure */
+    public function generate(UuidInterface $ns, string $name, string $hashAlgorithm): string
+    {
+        try {
+            /** @var string|bool $bytes */
+            $bytes = @hash($hashAlgorithm, $ns->getBytes() . $name, true);
+        } catch (ValueError $e) {
+            $bytes = false; // keep same behavior than PHP 7
+        }
+
+        if ($bytes === false) {
+            throw new NameException(sprintf(
+                'Unable to hash namespace and name with algorithm \'%s\'',
+                $hashAlgorithm
+            ));
+        }
+
+        return (string) $bytes;
+    }
+}

vendor/ramsey/uuid/src/Generator/DefaultTimeGenerator.php

@@ -0,0 +1,129 @@
+<?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\Generator;
+
+use Ramsey\Uuid\Converter\TimeConverterInterface;
+use Ramsey\Uuid\Exception\InvalidArgumentException;
+use Ramsey\Uuid\Exception\RandomSourceException;
+use Ramsey\Uuid\Exception\TimeSourceException;
+use Ramsey\Uuid\Provider\NodeProviderInterface;
+use Ramsey\Uuid\Provider\TimeProviderInterface;
+use Ramsey\Uuid\Type\Hexadecimal;
+use Throwable;
+
+use function dechex;
+use function hex2bin;
+use function is_int;
+use function pack;
+use function preg_match;
+use function sprintf;
+use function str_pad;
+use function strlen;
+
+use const STR_PAD_LEFT;
+
+/**
+ * DefaultTimeGenerator generates strings of binary data based on a node ID,
+ * clock sequence, and the current time
+ */
+class DefaultTimeGenerator implements TimeGeneratorInterface
+{
+    public function __construct(
+        private NodeProviderInterface $nodeProvider,
+        private TimeConverterInterface $timeConverter,
+        private TimeProviderInterface $timeProvider
+    ) {
+    }
+
+    /**
+     * @throws InvalidArgumentException if the parameters contain invalid values
+     * @throws RandomSourceException if random_int() throws an exception/error
+     *
+     * @inheritDoc
+     */
+    public function generate($node = null, ?int $clockSeq = null): string
+    {
+        if ($node instanceof Hexadecimal) {
+            $node = $node->toString();
+        }
+
+        $node = $this->getValidNode($node);
+
+        if ($clockSeq === null) {
+            try {
+                // This does not use "stable storage"; see RFC 4122, Section 4.2.1.1.
+                $clockSeq = random_int(0, 0x3fff);
+            } catch (Throwable $exception) {
+                throw new RandomSourceException(
+                    $exception->getMessage(),
+                    (int) $exception->getCode(),
+                    $exception
+                );
+            }
+        }
+
+        $time = $this->timeProvider->getTime();
+
+        $uuidTime = $this->timeConverter->calculateTime(
+            $time->getSeconds()->toString(),
+            $time->getMicroseconds()->toString()
+        );
+
+        $timeHex = str_pad($uuidTime->toString(), 16, '0', STR_PAD_LEFT);
+
+        if (strlen($timeHex) !== 16) {
+            throw new TimeSourceException(sprintf(
+                'The generated time of \'%s\' is larger than expected',
+                $timeHex
+            ));
+        }
+
+        $timeBytes = (string) hex2bin($timeHex);
+
+        return $timeBytes[4] . $timeBytes[5] . $timeBytes[6] . $timeBytes[7]
+            . $timeBytes[2] . $timeBytes[3]
+            . $timeBytes[0] . $timeBytes[1]
+            . pack('n*', $clockSeq)
+            . $node;
+    }
+
+    /**
+     * Uses the node provider given when constructing this instance to get
+     * the node ID (usually a MAC address)
+     *
+     * @param int|string|null $node A node value that may be used to override the node provider
+     *
+     * @return string 6-byte binary string representation of the node
+     *
+     * @throws InvalidArgumentException
+     */
+    private function getValidNode(int | string | null $node): string
+    {
+        if ($node === null) {
+            $node = $this->nodeProvider->getNode();
+        }
+
+        // Convert the node to hex, if it is still an integer.
+        if (is_int($node)) {
+            $node = dechex($node);
+        }
+
+        if (!preg_match('/^[A-Fa-f0-9]+$/', (string) $node) || strlen((string) $node) > 12) {
+            throw new InvalidArgumentException('Invalid node value');
+        }
+
+        return (string) hex2bin(str_pad((string) $node, 12, '0', STR_PAD_LEFT));
+    }
+}

vendor/ramsey/uuid/src/Generator/NameGeneratorFactory.php

@@ -0,0 +1,30 @@
+<?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\Generator;
+
+/**
+ * NameGeneratorFactory retrieves a default name generator, based on the
+ * environment
+ */
+class NameGeneratorFactory
+{
+    /**
+     * Returns a default name generator, based on the current environment
+     */
+    public function getGenerator(): NameGeneratorInterface
+    {
+        return new DefaultNameGenerator();
+    }
+}

vendor/ramsey/uuid/src/Generator/NameGeneratorInterface.php

@@ -0,0 +1,38 @@
+<?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\Generator;
+
+use Ramsey\Uuid\UuidInterface;
+
+/**
+ * A name generator generates strings of binary data created by hashing together
+ * a namespace with a name, according to a hashing algorithm
+ */
+interface NameGeneratorInterface
+{
+    /**
+     * Generate a binary string from a namespace and name hashed together with
+     * the specified hashing algorithm
+     *
+     * @param UuidInterface $ns The namespace
+     * @param string $name The name to use for creating a UUID
+     * @param string $hashAlgorithm The hashing algorithm to use
+     *
+     * @return string A binary string
+     *
+     * @psalm-pure
+     */
+    public function generate(UuidInterface $ns, string $name, string $hashAlgorithm): string;
+}

vendor/ramsey/uuid/src/Generator/PeclUuidNameGenerator.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\Generator;
+
+use Ramsey\Uuid\Exception\NameException;
+use Ramsey\Uuid\UuidInterface;
+
+use function sprintf;
+use function uuid_generate_md5;
+use function uuid_generate_sha1;
+use function uuid_parse;
+
+/**
+ * PeclUuidNameGenerator generates strings of binary data from a namespace and a
+ * name, using ext-uuid
+ *
+ * @link https://pecl.php.net/package/uuid ext-uuid
+ */
+class PeclUuidNameGenerator implements NameGeneratorInterface
+{
+    /** @psalm-pure */
+    public function generate(UuidInterface $ns, string $name, string $hashAlgorithm): string
+    {
+        $uuid = match ($hashAlgorithm) {
+            'md5' => uuid_generate_md5($ns->toString(), $name),
+            'sha1' => uuid_generate_sha1($ns->toString(), $name),
+            default => throw new NameException(
+                sprintf(
+                    'Unable to hash namespace and name with algorithm \'%s\'',
+                    $hashAlgorithm
+                )
+            ),
+        };
+
+        return uuid_parse($uuid);
+    }
+}

vendor/ramsey/uuid/src/Generator/PeclUuidRandomGenerator.php

@@ -0,0 +1,35 @@
+<?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\Generator;
+
+use function uuid_create;
+use function uuid_parse;
+
+use const UUID_TYPE_RANDOM;
+
+/**
+ * PeclUuidRandomGenerator generates strings of random binary data using ext-uuid
+ *
+ * @link https://pecl.php.net/package/uuid ext-uuid
+ */
+class PeclUuidRandomGenerator implements RandomGeneratorInterface
+{
+    public function generate(int $length): string
+    {
+        $uuid = uuid_create(UUID_TYPE_RANDOM);
+
+        return uuid_parse($uuid);
+    }
+}

vendor/ramsey/uuid/src/Generator/PeclUuidTimeGenerator.php

@@ -0,0 +1,39 @@
+<?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\Generator;
+
+use function uuid_create;
+use function uuid_parse;
+
+use const UUID_TYPE_TIME;
+
+/**
+ * PeclUuidTimeGenerator generates strings of binary data for time-base UUIDs,
+ * using ext-uuid
+ *
+ * @link https://pecl.php.net/package/uuid ext-uuid
+ */
+class PeclUuidTimeGenerator implements TimeGeneratorInterface
+{
+    /**
+     * @inheritDoc
+     */
+    public function generate($node = null, ?int $clockSeq = null): string
+    {
+        $uuid = uuid_create(UUID_TYPE_TIME);
+
+        return uuid_parse($uuid);
+    }
+}

vendor/ramsey/uuid/src/Generator/RandomBytesGenerator.php

@@ -0,0 +1,45 @@
+<?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\Generator;
+
+use Ramsey\Uuid\Exception\RandomSourceException;
+use Throwable;
+
+/**
+ * RandomBytesGenerator generates strings of random binary data using the
+ * built-in `random_bytes()` PHP function
+ *
+ * @link http://php.net/random_bytes random_bytes()
+ */
+class RandomBytesGenerator implements RandomGeneratorInterface
+{
+    /**
+     * @throws RandomSourceException if random_bytes() throws an exception/error
+     *
+     * @inheritDoc
+     */
+    public function generate(int $length): string
+    {
+        try {
+            return random_bytes($length);
+        } catch (Throwable $exception) {
+            throw new RandomSourceException(
+                $exception->getMessage(),
+                (int) $exception->getCode(),
+                $exception
+            );
+        }
+    }
+}

vendor/ramsey/uuid/src/Generator/RandomGeneratorFactory.php

@@ -0,0 +1,30 @@
+<?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\Generator;
+
+/**
+ * RandomGeneratorFactory retrieves a default random generator, based on the
+ * environment
+ */
+class RandomGeneratorFactory
+{
+    /**
+     * Returns a default random generator, based on the current environment
+     */
+    public function getGenerator(): RandomGeneratorInterface
+    {
+        return new RandomBytesGenerator();
+    }
+}

vendor/ramsey/uuid/src/Generator/RandomGeneratorInterface.php

@@ -0,0 +1,30 @@
+<?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\Generator;
+
+/**
+ * A random generator generates strings of random binary data
+ */
+interface RandomGeneratorInterface
+{
+    /**
+     * Generates a string of randomized binary data
+     *
+     * @param int<1, max> $length The number of bytes of random binary data to generate
+     *
+     * @return string A binary string
+     */
+    public function generate(int $length): string;
+}

vendor/ramsey/uuid/src/Generator/RandomLibAdapter.php

@@ -0,0 +1,56 @@
+<?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\Generator;
+
+use RandomLib\Factory;
+use RandomLib\Generator;
+
+/**
+ * RandomLibAdapter generates strings of random binary data using the
+ * paragonie/random-lib library
+ *
+ * @deprecated This class will be removed in 5.0.0. Use the default
+ *     RandomBytesGenerator or implement your own generator that implements
+ *     RandomGeneratorInterface.
+ *
+ * @link https://packagist.org/packages/paragonie/random-lib paragonie/random-lib
+ */
+class RandomLibAdapter implements RandomGeneratorInterface
+{
+    private Generator $generator;
+
+    /**
+     * Constructs a RandomLibAdapter
+     *
+     * By default, if no Generator is passed in, this creates a high-strength
+     * generator to use when generating random binary data.
+     *
+     * @param Generator|null $generator The generator to use when generating binary data
+     */
+    public function __construct(?Generator $generator = null)
+    {
+        if ($generator === null) {
+            $factory = new Factory();
+            $generator = $factory->getHighStrengthGenerator();
+        }
+
+        $this->generator = $generator;
+    }
+
+    public function generate(int $length): string
+    {
+        return $this->generator->generate($length);
+    }
+}

vendor/ramsey/uuid/src/Generator/TimeGeneratorFactory.php

@@ -0,0 +1,45 @@
+<?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\Generator;
+
+use Ramsey\Uuid\Converter\TimeConverterInterface;
+use Ramsey\Uuid\Provider\NodeProviderInterface;
+use Ramsey\Uuid\Provider\TimeProviderInterface;
+
+/**
+ * TimeGeneratorFactory retrieves a default time generator, based on the
+ * environment
+ */
+class TimeGeneratorFactory
+{
+    public function __construct(
+        private NodeProviderInterface $nodeProvider,
+        private TimeConverterInterface $timeConverter,
+        private TimeProviderInterface $timeProvider
+    ) {
+    }
+
+    /**
+     * Returns a default time generator, based on the current environment
+     */
+    public function getGenerator(): TimeGeneratorInterface
+    {
+        return new DefaultTimeGenerator(
+            $this->nodeProvider,
+            $this->timeConverter,
+            $this->timeProvider
+        );
+    }
+}

vendor/ramsey/uuid/src/Generator/TimeGeneratorInterface.php

@@ -0,0 +1,38 @@
+<?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\Generator;
+
+use Ramsey\Uuid\Type\Hexadecimal;
+
+/**
+ * A time generator generates strings of binary data based on a node ID,
+ * clock sequence, and the current time
+ */
+interface TimeGeneratorInterface
+{
+    /**
+     * Generate a binary string from a node ID, clock sequence, and current time
+     *
+     * @param Hexadecimal|int|string|null $node A 48-bit number representing the
+     *     hardware address; this number may be represented as an integer or a
+     *     hexadecimal string
+     * @param int|null $clockSeq A 14-bit number used to help avoid duplicates
+     *     that could arise when the clock is set backwards in time or if the
+     *     node ID changes
+     *
+     * @return string A binary string
+     */
+    public function generate($node = null, ?int $clockSeq = null): string;
+}

vendor/ramsey/uuid/src/Generator/UnixTimeGenerator.php

@@ -0,0 +1,169 @@
+<?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\Generator;
+
+use Brick\Math\BigInteger;
+use DateTimeImmutable;
+use DateTimeInterface;
+use Ramsey\Uuid\Type\Hexadecimal;
+
+use function hash;
+use function pack;
+use function str_pad;
+use function strlen;
+use function substr;
+use function substr_replace;
+use function unpack;
+
+use const PHP_INT_SIZE;
+use const STR_PAD_LEFT;
+
+/**
+ * UnixTimeGenerator generates bytes that combine a 48-bit timestamp in
+ * milliseconds since the Unix Epoch with 80 random bits
+ *
+ * Code and concepts within this class are borrowed from the symfony/uid package
+ * and are used under the terms of the MIT license distributed with symfony/uid.
+ *
+ * symfony/uid is copyright (c) Fabien Potencier.
+ *
+ * @link https://symfony.com/components/Uid Symfony Uid component
+ * @link https://github.com/symfony/uid/blob/4f9f537e57261519808a7ce1d941490736522bbc/UuidV7.php Symfony UuidV7 class
+ * @link https://github.com/symfony/uid/blob/6.2/LICENSE MIT License
+ */
+class UnixTimeGenerator implements TimeGeneratorInterface
+{
+    private static string $time = '';
+    private static ?string $seed = null;
+    private static int $seedIndex = 0;
+
+    /** @var int[] */
+    private static array $rand = [];
+
+    /** @var int[] */
+    private static array $seedParts;
+
+    public function __construct(
+        private RandomGeneratorInterface $randomGenerator,
+        private int $intSize = PHP_INT_SIZE
+    ) {
+    }
+
+    /**
+     * @param Hexadecimal|int|string|null $node Unused in this generator
+     * @param int|null $clockSeq Unused in this generator
+     * @param DateTimeInterface $dateTime A date-time instance to use when
+     *     generating bytes
+     *
+     * @inheritDoc
+     */
+    public function generate($node = null, ?int $clockSeq = null, ?DateTimeInterface $dateTime = null): string
+    {
+        $time = ($dateTime ?? new DateTimeImmutable('now'))->format('Uv');
+
+        if ($time > self::$time || ($dateTime !== null && $time !== self::$time)) {
+            $this->randomize($time);
+        } else {
+            $time = $this->increment();
+        }
+
+        if ($this->intSize >= 8) {
+            $time = substr(pack('J', (int) $time), -6);
+        } else {
+            $time = str_pad(BigInteger::of($time)->toBytes(false), 6, "\x00", STR_PAD_LEFT);
+        }
+
+        /** @var non-empty-string */
+        return $time . pack('n*', self::$rand[1], self::$rand[2], self::$rand[3], self::$rand[4], self::$rand[5]);
+    }
+
+    private function randomize(string $time): void
+    {
+        if (self::$seed === null) {
+            $seed = $this->randomGenerator->generate(16);
+            self::$seed = $seed;
+        } else {
+            $seed = $this->randomGenerator->generate(10);
+        }
+
+        /** @var int[] $rand */
+        $rand = unpack('n*', $seed);
+        $rand[1] &= 0x03ff;
+
+        self::$rand = $rand;
+        self::$time = $time;
+    }
+
+    /**
+     * Special thanks to Nicolas Grekas for sharing the following information:
+     *
+     * Within the same ms, we increment the rand part by a random 24-bit number.
+     *
+     * Instead of getting this number from random_bytes(), which is slow, we get
+     * it by sha512-hashing self::$seed. This produces 64 bytes of entropy,
+     * which we need to split in a list of 24-bit numbers. unpack() first splits
+     * them into 16 x 32-bit numbers; we take the first byte of each of these
+     * numbers to get 5 extra 24-bit numbers. Then, we consume those numbers
+     * one-by-one and run this logic every 21 iterations.
+     *
+     * self::$rand holds the random part of the UUID, split into 5 x 16-bit
+     * numbers for x86 portability. We increment this random part by the next
+     * 24-bit number in the self::$seedParts list and decrement
+     * self::$seedIndex.
+     *
+     * @link https://twitter.com/nicolasgrekas/status/1583356938825261061 Tweet from Nicolas Grekas
+     */
+    private function increment(): string
+    {
+        if (self::$seedIndex === 0 && self::$seed !== null) {
+            self::$seed = hash('sha512', self::$seed, true);
+
+            /** @var int[] $s */
+            $s = unpack('l*', self::$seed);
+            $s[] = ($s[1] >> 8 & 0xff0000) | ($s[2] >> 16 & 0xff00) | ($s[3] >> 24 & 0xff);
+            $s[] = ($s[4] >> 8 & 0xff0000) | ($s[5] >> 16 & 0xff00) | ($s[6] >> 24 & 0xff);
+            $s[] = ($s[7] >> 8 & 0xff0000) | ($s[8] >> 16 & 0xff00) | ($s[9] >> 24 & 0xff);
+            $s[] = ($s[10] >> 8 & 0xff0000) | ($s[11] >> 16 & 0xff00) | ($s[12] >> 24 & 0xff);
+            $s[] = ($s[13] >> 8 & 0xff0000) | ($s[14] >> 16 & 0xff00) | ($s[15] >> 24 & 0xff);
+
+            self::$seedParts = $s;
+            self::$seedIndex = 21;
+        }
+
+        self::$rand[5] = 0xffff & $carry = self::$rand[5] + 1 + (self::$seedParts[self::$seedIndex--] & 0xffffff);
+        self::$rand[4] = 0xffff & $carry = self::$rand[4] + ($carry >> 16);
+        self::$rand[3] = 0xffff & $carry = self::$rand[3] + ($carry >> 16);
+        self::$rand[2] = 0xffff & $carry = self::$rand[2] + ($carry >> 16);
+        self::$rand[1] += $carry >> 16;
+
+        if (0xfc00 & self::$rand[1]) {
+            $time = self::$time;
+            $mtime = (int) substr($time, -9);
+
+            if ($this->intSize >= 8 || strlen($time) < 10) {
+                $time = (string) ((int) $time + 1);
+            } elseif ($mtime === 999999999) {
+                $time = (1 + (int) substr($time, 0, -9)) . '000000000';
+            } else {
+                $mtime++;
+                $time = substr_replace($time, str_pad((string) $mtime, 9, '0', STR_PAD_LEFT), -9);
+            }
+
+            $this->randomize($time);
+        }
+
+        return self::$time;
+    }
+}