uuid 13.0.0 → 14.0.0

package/README.md

@@ -32,32 +32,32 @@ npm install uuid
 **2. Create a UUID**
 
 ```javascript
-import { v4 as uuidv4 } from 'uuid';
+import { v4 as uuidv4 } from "uuid";
 
-uuidv4(); // ⇨ '9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d'
+uuidv4(); // ⇨ 'ab16e731-6cee-424d-81a0-5929e9bdb0cc'
 ```
 
 For timestamp UUIDs, namespace UUIDs, and other options read on ...
 
 ## API Summary
 
-|  |  |  |
-| --- | --- | --- |
-| [`uuid.NIL`](#uuidnil) | The nil UUID string (all zeros) | New in `uuid@8.3` |
-| [`uuid.MAX`](#uuidmax) | The max UUID string (all ones) | New in `uuid@9.1` |
-| [`uuid.parse()`](#uuidparsestr) | Convert UUID string to array of bytes | New in `uuid@8.3` |
-| [`uuid.stringify()`](#uuidstringifyarr-offset) | Convert array of bytes to UUID string | New in `uuid@8.3` |
-| [`uuid.v1()`](#uuidv1options-buffer-offset) | Create a version 1 (timestamp) UUID |  |
-| [`uuid.v1ToV6()`](#uuidv1tov6uuid) | Create a version 6 UUID from a version 1 UUID | New in `uuid@10` |
-| [`uuid.v3()`](#uuidv3name-namespace-buffer-offset) | Create a version 3 (namespace w/ MD5) UUID |  |
-| [`uuid.v4()`](#uuidv4options-buffer-offset) | Create a version 4 (random) UUID |  |
-| [`uuid.v5()`](#uuidv5name-namespace-buffer-offset) | Create a version 5 (namespace w/ SHA-1) UUID |  |
-| [`uuid.v6()`](#uuidv6options-buffer-offset) | Create a version 6 (timestamp, reordered) UUID | New in `uuid@10` |
-| [`uuid.v6ToV1()`](#uuidv6tov1uuid) | Create a version 1 UUID from a version 6 UUID | New in `uuid@10` |
-| [`uuid.v7()`](#uuidv7options-buffer-offset) | Create a version 7 (Unix Epoch time-based) UUID | New in `uuid@10` |
-| ~~[`uuid.v8()`](#uuidv8)~~ | "Intentionally left blank" |  |
-| [`uuid.validate()`](#uuidvalidatestr) | Test a string to see if it is a valid UUID | New in `uuid@8.3` |
-| [`uuid.version()`](#uuidversionstr) | Detect RFC version of a UUID | New in `uuid@8.3` |
+|                                                    |                                                 |                   |
+| -------------------------------------------------- | ----------------------------------------------- | ----------------- |
+| [`uuid.NIL`](#uuidnil)                             | The nil UUID string (all zeros)                 | New in `uuid@8.3` |
+| [`uuid.MAX`](#uuidmax)                             | The max UUID string (all ones)                  | New in `uuid@9.1` |
+| [`uuid.parse()`](#uuidparsestr)                    | Convert UUID string to array of bytes           | New in `uuid@8.3` |
+| [`uuid.stringify()`](#uuidstringifyarr-offset)     | Convert array of bytes to UUID string           | New in `uuid@8.3` |
+| [`uuid.v1()`](#uuidv1options-buffer-offset)        | Create a version 1 (timestamp) UUID             |                   |
+| [`uuid.v1ToV6()`](#uuidv1tov6uuid)                 | Create a version 6 UUID from a version 1 UUID   | New in `uuid@10`  |
+| [`uuid.v3()`](#uuidv3name-namespace-buffer-offset) | Create a version 3 (namespace w/ MD5) UUID      |                   |
+| [`uuid.v4()`](#uuidv4options-buffer-offset)        | Create a version 4 (random) UUID                |                   |
+| [`uuid.v5()`](#uuidv5name-namespace-buffer-offset) | Create a version 5 (namespace w/ SHA-1) UUID    |                   |
+| [`uuid.v6()`](#uuidv6options-buffer-offset)        | Create a version 6 (timestamp, reordered) UUID  | New in `uuid@10`  |
+| [`uuid.v6ToV1()`](#uuidv6tov1uuid)                 | Create a version 1 UUID from a version 6 UUID   | New in `uuid@10`  |
+| [`uuid.v7()`](#uuidv7options-buffer-offset)        | Create a version 7 (Unix Epoch time-based) UUID | New in `uuid@10`  |
+| ~~[`uuid.v8()`](#uuidv8)~~                         | "Intentionally left blank"                      |                   |
+| [`uuid.validate()`](#uuidvalidatestr)              | Test a string to see if it is a valid UUID      | New in `uuid@8.3` |
+| [`uuid.version()`](#uuidversionstr)                | Detect RFC version of a UUID                    | New in `uuid@8.3` |
 
 ## API
 
@@ -68,7 +68,7 @@ The nil UUID string (all zeros).
 Example:
 
 ```javascript
-import { NIL as NIL_UUID } from 'uuid';
+import { NIL as NIL_UUID } from "uuid";
 
 NIL_UUID; // ⇨ '00000000-0000-0000-0000-000000000000'
 ```
@@ -80,7 +80,7 @@ The max UUID string (all ones).
 Example:
 
 ```javascript
-import { MAX as MAX_UUID } from 'uuid';
+import { MAX as MAX_UUID } from "uuid";
 
 MAX_UUID; // ⇨ 'ffffffff-ffff-ffff-ffff-ffffffffffff'
 ```
@@ -102,10 +102,10 @@ Convert UUID string to array of bytes
 Example:
 
 ```javascript
-import { parse as uuidParse } from 'uuid';
+import { parse as uuidParse } from "uuid";
 
 // Parse a UUID
-uuidParse('6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b'); // ⇨
+uuidParse("6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b"); // ⇨
 // Uint8Array(16) [
 //   110, 192, 189, 127,  17,
 //   192,  67, 218, 151,  94,
@@ -132,7 +132,7 @@ Convert array of bytes to UUID string
 Example:
 
 ```javascript
-import { stringify as uuidStringify } from 'uuid';
+import { stringify as uuidStringify } from "uuid";
 
 const uuidBytes = Uint8Array.of(
   0x6e,
@@ -150,7 +150,7 @@ const uuidBytes = Uint8Array.of(
   0xd9,
   0xeb,
   0xae,
-  0x0b
+  0x0b,
 );
 
 uuidStringify(uuidBytes); // ⇨ '6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b'
@@ -160,45 +160,37 @@ uuidStringify(uuidBytes); // ⇨ '6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b'
 
 Create an RFC version 1 (timestamp) UUID
 
-|  |  |
-| --- | --- |
-| [`options`] | `Object` with one or more of the following properties: |
-| [`options.node = (random)` ] | RFC "node" field as an `Array[6]` of byte values (per 4.1.6) |
-| [`options.clockseq = (random)`] | RFC "clock sequence" as a `Number` between 0 - 0x3fff |
-| [`options.msecs = (current time)`] | RFC "timestamp" field (`Number` of milliseconds, unix epoch) |
-| [`options.nsecs = 0`] | RFC "timestamp" field (`Number` of nanoseconds to add to `msecs`, should be 0-10,000) |
-| [`options.random = (random)`] | `Array` of 16 random bytes (0-255) used to generate other fields, above |
-| [`options.rng`] | Alternative to `options.random`, a `Function` that returns an `Array` of 16 random bytes (0-255) |
-| [`buffer`] | `Uint8Array` or `Uint8Array` subtype (e.g. Node.js `Buffer`). If provided, binary UUID is written into the array, starting at `offset` |
-| [`offset` = 0] | `Number` Index to start writing UUID bytes in `buffer` |
-| _returns_ | UUID `String` if no `buffer` is specified, otherwise returns `buffer` |
-| _throws_ | `Error` if more than 10M UUIDs/sec are requested |
-
-<!-- prettier-ignore -->
-> [!NOTE]
-> The default [node id](https://datatracker.ietf.org/doc/html/rfc9562#section-5.1) (the last 12 digits in the UUID) is generated once, randomly, on process startup, and then remains unchanged for the duration of the process.
-
-<!-- prettier-ignore -->
-> [!NOTE]
-> `options.random` and `options.rng` are only meaningful on the very first call to `v1()`, where they may be passed to initialize the internal `node` and `clockseq` fields.
+|                                    |                                                                                                                                        |
+| ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
+| [`options`]                        | `Object` with one or more of the following properties:                                                                                 |
+| [`options.node = (random)` ]       | RFC "node" field as an `Array[6]` of byte values (per 4.1.6)                                                                           |
+| [`options.clockseq = (random)`]    | RFC "clock sequence" as a `Number` between 0 - 0x3fff                                                                                  |
+| [`options.msecs = (current time)`] | RFC "timestamp" field (`Number` of milliseconds, unix epoch)                                                                           |
+| [`options.nsecs = 0`]              | RFC "timestamp" field (`Number` of nanoseconds to add to `msecs`, should be 0-10,000)                                                  |
+| [`options.random = (random)`]      | `Array` of 16 random bytes (0-255) used to generate other fields, above                                                                |
+| [`options.rng`]                    | Alternative to `options.random`, a `Function` that returns an `Array` of 16 random bytes (0-255)                                       |
+| [`buffer`]                         | `Uint8Array` or `Uint8Array` subtype (e.g. Node.js `Buffer`). If provided, binary UUID is written into the array, starting at `offset` |
+| [`offset` = 0]                     | `Number` Index to start writing UUID bytes in `buffer`                                                                                 |
+| _returns_                          | UUID `String` if no `buffer` is specified, otherwise returns `buffer`                                                                  |
+| _throws_                           | `Error` if more than 10M UUIDs/sec are requested                                                                                       |
 
 Example:
 
 ```javascript
-import { v1 as uuidv1 } from 'uuid';
+import { v1 as uuidv1 } from "uuid";
 
-uuidv1(); // ⇨ '2c5ea4c0-4067-11e9-9b5d-ab8dfbbd4bed'
+uuidv1(); // ⇨ '4d9d2960-31d0-11f1-aba8-29728d41eeed'
 ```
 
 Example using `options`:
 
 ```javascript
-import { v1 as uuidv1 } from 'uuid';
+import { v1 as uuidv1 } from "uuid";
 
 const options = {
   node: Uint8Array.of(0x01, 0x23, 0x45, 0x67, 0x89, 0xab),
   clockseq: 0x1234,
-  msecs: new Date('2011-11-01').getTime(),
+  msecs: new Date("2011-11-01").getTime(),
   nsecs: 5678,
 };
 uuidv1(options); // ⇨ '710b962e-041c-11e1-9234-0123456789ab'
@@ -209,9 +201,9 @@ uuidv1(options); // ⇨ '710b962e-041c-11e1-9234-0123456789ab'
 Convert a UUID from version 1 to version 6
 
 ```javascript
-import { v1ToV6 } from 'uuid';
+import { v1ToV6 } from "uuid";
 
-v1ToV6('92f62d9e-22c4-11ef-97e9-325096b39f47'); // ⇨ '1ef22c49-2f62-6d9e-97e9-325096b39f47'
+v1ToV6("92f62d9e-22c4-11ef-97e9-325096b39f47"); // ⇨ '1ef22c49-2f62-6d9e-97e9-325096b39f47'
 ```
 
 ### uuid.v3(name, namespace[, buffer[, offset]])
@@ -228,27 +220,27 @@ API is identical to `v5()`, but uses "v3" instead.
 
 Create an RFC version 4 (random) UUID
 
-|  |  |
-| --- | --- |
-| [`options`] | `Object` with one or more of the following properties: |
-| [`options.random`] | `Array` of 16 random bytes (0-255) |
-| [`options.rng`] | Alternative to `options.random`, a `Function` that returns an `Array` of 16 random bytes (0-255) |
-| [`buffer`] | `Uint8Array` or `Uint8Array` subtype (e.g. Node.js `Buffer`). If provided, binary UUID is written into the array, starting at `offset` |
-| [`offset` = 0] | `Number` Index to start writing UUID bytes in `buffer` |
-| _returns_ | UUID `String` if no `buffer` is specified, otherwise returns `buffer` |
+|                    |                                                                                                                                        |
+| ------------------ | -------------------------------------------------------------------------------------------------------------------------------------- |
+| [`options`]        | `Object` with one or more of the following properties:                                                                                 |
+| [`options.random`] | `Array` of 16 random bytes (0-255)                                                                                                     |
+| [`options.rng`]    | Alternative to `options.random`, a `Function` that returns an `Array` of 16 random bytes (0-255)                                       |
+| [`buffer`]         | `Uint8Array` or `Uint8Array` subtype (e.g. Node.js `Buffer`). If provided, binary UUID is written into the array, starting at `offset` |
+| [`offset` = 0]     | `Number` Index to start writing UUID bytes in `buffer`                                                                                 |
+| _returns_          | UUID `String` if no `buffer` is specified, otherwise returns `buffer`                                                                  |
 
 Example:
 
 ```javascript
-import { v4 as uuidv4 } from 'uuid';
+import { v4 as uuidv4 } from "uuid";
 
-uuidv4(); // ⇨ '1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed'
+uuidv4(); // ⇨ '7934256a-bc92-4b69-b240-f9e463881aea'
 ```
 
 Example using predefined `random` values:
 
 ```javascript
-import { v4 as uuidv4 } from 'uuid';
+import { v4 as uuidv4 } from "uuid";
 
 const v4options = {
   random: Uint8Array.of(
@@ -267,7 +259,7 @@ const v4options = {
     0x67,
     0x1c,
     0x58,
-    0x36
+    0x36,
   ),
 };
 uuidv4(v4options); // ⇨ '109156be-c4fb-41ea-b1b4-efe1671c5836'
@@ -277,13 +269,13 @@ uuidv4(v4options); // ⇨ '109156be-c4fb-41ea-b1b4-efe1671c5836'
 
 Create an RFC version 5 (namespace w/ SHA-1) UUID
 
-|  |  |
-| --- | --- |
-| `name` | `String \| Array` |
-| `namespace` | `String \| Array[16]` Namespace UUID |
-| [`buffer`] | `Uint8Array` or `Uint8Array` subtype (e.g. Node.js `Buffer`). If provided, binary UUID is written into the array, starting at `offset` |
-| [`offset` = 0] | `Number` Index to start writing UUID bytes in `buffer` |
-| _returns_ | UUID `String` if no `buffer` is specified, otherwise returns `buffer` |
+|                |                                                                                                                                        |
+| -------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
+| `name`         | `String \| Array`                                                                                                                      |
+| `namespace`    | `String \| Array[16]` Namespace UUID                                                                                                   |
+| [`buffer`]     | `Uint8Array` or `Uint8Array` subtype (e.g. Node.js `Buffer`). If provided, binary UUID is written into the array, starting at `offset` |
+| [`offset` = 0] | `Number` Index to start writing UUID bytes in `buffer`                                                                                 |
+| _returns_      | UUID `String` if no `buffer` is specified, otherwise returns `buffer`                                                                  |
 
 <!-- prettier-ignore -->
 > [!NOTE]
@@ -292,21 +284,21 @@ Create an RFC version 5 (namespace w/ SHA-1) UUID
 Example with custom namespace:
 
 ```javascript
-import { v5 as uuidv5 } from 'uuid';
+import { v5 as uuidv5 } from "uuid";
 
 // Define a custom namespace.  Readers, create your own using something like
 // https://www.uuidgenerator.net/
-const MY_NAMESPACE = '1b671a64-40d5-491e-99b0-da01ff1f3341';
+const MY_NAMESPACE = "1b671a64-40d5-491e-99b0-da01ff1f3341";
 
-uuidv5('Hello, World!', MY_NAMESPACE); // ⇨ '630eb68f-e0fa-5ecc-887a-7c7a62614681'
+uuidv5("Hello, World!", MY_NAMESPACE); // ⇨ '630eb68f-e0fa-5ecc-887a-7c7a62614681'
 ```
 
 Example with RFC `URL` namespace:
 
 ```javascript
-import { v5 as uuidv5 } from 'uuid';
+import { v5 as uuidv5 } from "uuid";
 
-uuidv5('https://www.w3.org/', uuidv5.URL); // ⇨ 'c106a26a-21bb-5538-8bf2-57095d1976c1'
+uuidv5("https://www.w3.org/", uuidv5.URL); // ⇨ 'c106a26a-21bb-5538-8bf2-57095d1976c1'
 ```
 
 ### uuid.v6([options[, buffer[, offset]]])
@@ -316,20 +308,20 @@ Create an RFC version 6 (timestamp, reordered) UUID
 This method takes the same arguments as uuid.v1().
 
 ```javascript
-import { v6 as uuidv6 } from 'uuid';
+import { v6 as uuidv6 } from "uuid";
 
-uuidv6(); // ⇨ '1e940672-c5ea-64c1-9bdd-2b0d7b3dcb6d'
+uuidv6(); // ⇨ '1f131d04-d9dc-65a0-9516-5be66631ce97'
 ```
 
 Example using `options`:
 
 ```javascript
-import { v6 as uuidv6 } from 'uuid';
+import { v6 as uuidv6 } from "uuid";
 
 const options = {
   node: [0x01, 0x23, 0x45, 0x67, 0x89, 0xab],
   clockseq: 0x1234,
-  msecs: new Date('2011-11-01').getTime(),
+  msecs: new Date("2011-11-01").getTime(),
   nsecs: 5678,
 };
 uuidv6(options); // ⇨ '1e1041c7-10b9-662e-9234-0123456789ab'
@@ -340,32 +332,32 @@ uuidv6(options); // ⇨ '1e1041c7-10b9-662e-9234-0123456789ab'
 Convert a UUID from version 6 to version 1
 
 ```javascript
-import { v6ToV1 } from 'uuid';
+import { v6ToV1 } from "uuid";
 
-v6ToV1('1ef22c49-2f62-6d9e-97e9-325096b39f47'); // ⇨ '92f62d9e-22c4-11ef-97e9-325096b39f47'
+v6ToV1("1ef22c49-2f62-6d9e-97e9-325096b39f47"); // ⇨ '92f62d9e-22c4-11ef-97e9-325096b39f47'
 ```
 
 ### uuid.v7([options[, buffer[, offset]]])
 
 Create an RFC version 7 (random) UUID
 
-|  |  |
-| --- | --- |
-| [`options`] | `Object` with one or more of the following properties: |
-| [`options.msecs = (current time)`] | RFC "timestamp" field (`Number` of milliseconds, unix epoch) |
-| [`options.random = (random)`] | `Array` of 16 random bytes (0-255) used to generate other fields, above |
-| [`options.rng`] | Alternative to `options.random`, a `Function` that returns an `Array` of 16 random bytes (0-255) |
-| [`options.seq = (random)`] | 32-bit sequence `Number` between 0 - 0xffffffff. This may be provided to help ensure uniqueness for UUIDs generated within the same millisecond time interval. Default = random value. |
-| [`buffer`] | `Uint8Array` or `Uint8Array` subtype (e.g. Node.js `Buffer`). If provided, binary UUID is written into the array, starting at `offset` |
-| [`offset` = 0] | `Number` Index to start writing UUID bytes in `buffer` |
-| _returns_ | UUID `String` if no `buffer` is specified, otherwise returns `buffer` |
+|                                    |                                                                                                                                                                                        |
+| ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [`options`]                        | `Object` with one or more of the following properties:                                                                                                                                 |
+| [`options.msecs = (current time)`] | RFC "timestamp" field (`Number` of milliseconds, unix epoch)                                                                                                                           |
+| [`options.random = (random)`]      | `Array` of 16 random bytes (0-255) used to generate other fields, above                                                                                                                |
+| [`options.rng`]                    | Alternative to `options.random`, a `Function` that returns an `Array` of 16 random bytes (0-255)                                                                                       |
+| [`options.seq = (random)`]         | 32-bit sequence `Number` between 0 - 0xffffffff. This may be provided to help ensure uniqueness for UUIDs generated within the same millisecond time interval. Default = random value. |
+| [`buffer`]                         | `Uint8Array` or `Uint8Array` subtype (e.g. Node.js `Buffer`). If provided, binary UUID is written into the array, starting at `offset`                                                 |
+| [`offset` = 0]                     | `Number` Index to start writing UUID bytes in `buffer`                                                                                                                                 |
+| _returns_                          | UUID `String` if no `buffer` is specified, otherwise returns `buffer`                                                                                                                  |
 
 Example:
 
 ```javascript
-import { v7 as uuidv7 } from 'uuid';
+import { v7 as uuidv7 } from "uuid";
 
-uuidv7(); // ⇨ '01695553-c90c-745a-b76f-770d7b3dcb6d'
+uuidv7(); // ⇨ '019d637c-c6fb-74e9-8b9d-2f1d459a4201'
 ```
 
 ### ~~uuid.v8()~~
@@ -388,24 +380,24 @@ Test a string to see if it is a valid UUID
 Example:
 
 ```javascript
-import { validate as uuidValidate } from 'uuid';
+import { validate as uuidValidate } from "uuid";
 
-uuidValidate('not a UUID'); // ⇨ false
-uuidValidate('6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b'); // ⇨ true
+uuidValidate("not a UUID"); // ⇨ false
+uuidValidate("6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b"); // ⇨ true
 ```
 
 Using `validate` and `version` together it is possible to do per-version validation, e.g. validate for only v4 UUIds.
 
 ```javascript
-import { version as uuidVersion } from 'uuid';
-import { validate as uuidValidate } from 'uuid';
+import { version as uuidVersion } from "uuid";
+import { validate as uuidValidate } from "uuid";
 
 function uuidValidateV4(uuid) {
   return uuidValidate(uuid) && uuidVersion(uuid) === 4;
 }
 
-const v1Uuid = 'd9428888-122b-11e1-b85c-61cd3cbb3210';
-const v4Uuid = '109156be-c4fb-41ea-b1b4-efe1671c5836';
+const v1Uuid = "d9428888-122b-11e1-b85c-61cd3cbb3210";
+const v4Uuid = "109156be-c4fb-41ea-b1b4-efe1671c5836";
 
 uuidValidateV4(v4Uuid); // ⇨ true
 uuidValidateV4(v1Uuid); // ⇨ false
@@ -424,10 +416,10 @@ Detect RFC version of a UUID
 Example:
 
 ```javascript
-import { version as uuidVersion } from 'uuid';
+import { version as uuidVersion } from "uuid";
 
-uuidVersion('45637ec4-c85f-11ea-87d0-0242ac130003'); // ⇨ 1
-uuidVersion('6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b'); // ⇨ 4
+uuidVersion("45637ec4-c85f-11ea-87d0-0242ac130003"); // ⇨ 1
+uuidVersion("6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b"); // ⇨ 4
 ```
 
 <!-- prettier-ignore -->
@@ -472,13 +464,13 @@ Prior to `uuid@11`, it was possible for `options` state to interfere with the in
 
 **Browsers**: `uuid` [builds are tested](/uuidjs/uuid/blob/main/wdio.conf.js) against the latest version of desktop Chrome, Safari, Firefox, and Edge. Mobile versions of these same browsers are expected to work but aren't currently tested.
 
-**Node**: `uuid` [builds are tested](https://github.com/uuidjs/uuid/blob/main/.github/workflows/ci.yml#L26-L27) against node ([LTS releases](https://github.com/nodejs/Release)), plus one prior. E.g. At the time of this writing `node@20` is the "maintenance" release and `node@24` is the "current" release, so `uuid` supports `node@18`-`node@24`.
+**Node**: `uuid` [builds are tested](https://github.com/uuidjs/uuid/blob/main/.github/workflows/ci.yml#L26-L27) against node ([LTS releases](https://github.com/nodejs/Release)), plus one prior. E.g. At the time of this writing `node@20` is the "maintenance" release and `node@24` is the "current" release, so `uuid` supports `node@20`-`node@24`.
 
 **Typescript**: TS versions released within the past two years are supported. [source](https://github.com/microsoft/TypeScript/issues/49088#issuecomment-2468723715)
 
 ## Known issues
 
-<!-- This header is referenced as an anchor in src/rng-browser.ts -->
+<!-- This header is referenced as an anchor in src/rng.ts -->
 
 ### "getRandomValues() not supported"
 
@@ -490,8 +482,8 @@ This error occurs in environments where the standard [`crypto.getRandomValues()`
 1. Import it _before_ `uuid`. Since `uuid` might also appear as a transitive dependency of some other imports it's safest to just import `react-native-get-random-values` as the very first thing in your entry point:
 
 ```javascript
-import 'react-native-get-random-values';
-import { v4 as uuidv4 } from 'uuid';
+import "react-native-get-random-values";
+import { v4 as uuidv4 } from "uuid";
 ```
 
 ---

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-export type * from './types.js';
 export { default as MAX } from './max.js';
 export { default as NIL } from './nil.js';
 export { default as parse } from './parse.js';
 export { default as stringify } from './stringify.js';
+export type * from './types.js';
 export { default as v1 } from './v1.js';
 export { default as v1ToV6 } from './v1ToV6.js';
 export { default as v3 } from './v3.js';

package/dist/md5.js

@@ -16,7 +16,7 @@ function getOutputLength(inputLength8) {
 function wordsToMd5(x, len) {
     const xpad = new Uint32Array(getOutputLength(len)).fill(0);
     xpad.set(x);
-    xpad[len >> 5] |= 0x80 << len % 32;
+    xpad[len >> 5] |= 0x80 << (len % 32);
     xpad[xpad.length - 1] = len;
     x = xpad;
     let a = 1732584193;

package/dist/parse.d.ts

@@ -1,2 +1,3 @@
-declare function parse(uuid: string): Uint8Array;
+import type { NonSharedArrayBuffer } from './types.js';
+declare function parse(uuid: string): NonSharedArrayBuffer;
 export default parse;

package/dist/rng.js

@@ -1,11 +1,4 @@
-let getRandomValues;
 const rnds8 = new Uint8Array(16);
 export default function rng() {
-    if (!getRandomValues) {
-        if (typeof crypto === 'undefined' || !crypto.getRandomValues) {
-            throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
-        }
-        getRandomValues = crypto.getRandomValues.bind(crypto);
-    }
-    return getRandomValues(rnds8);
+    return crypto.getRandomValues(rnds8);
 }

package/dist/sha1.js

@@ -34,7 +34,7 @@ function sha1(bytes) {
         }
         M[i] = arr;
     }
-    M[N - 1][14] = ((bytes.length - 1) * 8) / Math.pow(2, 32);
+    M[N - 1][14] = ((bytes.length - 1) * 8) / 2 ** 32;
     M[N - 1][14] = Math.floor(M[N - 1][14]);
     M[N - 1][15] = ((bytes.length - 1) * 8) & 0xffffffff;
     for (let i = 0; i < N; ++i) {

package/dist/types.d.ts

@@ -19,3 +19,4 @@ export type Version7Options = {
     seq?: number;
     rng?: () => Uint8Array;
 };
+export type NonSharedArrayBuffer = ReturnType<typeof Uint8Array.of>;

package/dist/v1.d.ts

@@ -1,4 +1,4 @@
-import { Version1Options } from './types.js';
+import type { Version1Options } from './types.js';
 type V1State = {
     node?: Uint8Array;
     clockseq?: number;

package/dist/v1ToV6.d.ts

@@ -1,2 +1,3 @@
+import type { NonSharedArrayBuffer } from './types.js';
 export default function v1ToV6(uuid: string): string;
-export default function v1ToV6(uuid: Uint8Array): Uint8Array;
+export default function v1ToV6(uuid: Uint8Array): NonSharedArrayBuffer;

package/dist/v3.d.ts

@@ -1,4 +1,4 @@
-import { UUIDTypes } from './types.js';
+import type { UUIDTypes } from './types.js';
 export { DNS, URL } from './v35.js';
 declare function v3(value: string | Uint8Array, namespace: UUIDTypes, buf?: undefined, offset?: number): string;
 declare function v3<TBuf extends Uint8Array = Uint8Array>(value: string | Uint8Array, namespace: UUIDTypes, buf: TBuf, offset?: number): TBuf;

package/dist/v35.d.ts

@@ -1,4 +1,4 @@
-import { UUIDTypes } from './types.js';
+import type { UUIDTypes } from './types.js';
 export declare function stringToBytes(str: string): Uint8Array;
 export declare const DNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
 export declare const URL = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";

package/dist/v35.js

@@ -26,7 +26,10 @@ export default function v35(version, hash, value, namespace, buf, offset) {
     bytes[6] = (bytes[6] & 0x0f) | version;
     bytes[8] = (bytes[8] & 0x3f) | 0x80;
     if (buf) {
-        offset = offset || 0;
+        offset ??= 0;
+        if (offset < 0 || offset + 16 > buf.length) {
+            throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+        }
         for (let i = 0; i < 16; ++i) {
             buf[offset + i] = bytes[i];
         }

package/dist/v4.d.ts

@@ -1,4 +1,4 @@
-import { Version4Options } from './types.js';
+import type { Version4Options } from './types.js';
 declare function v4(options?: Version4Options, buf?: undefined, offset?: number): string;
 declare function v4<TBuf extends Uint8Array = Uint8Array>(options: Version4Options | undefined, buf: TBuf, offset?: number): TBuf;
 export default v4;

package/dist/v4.js

@@ -1,6 +1,11 @@
-import native from './native.js';
 import rng from './rng.js';
 import { unsafeStringify } from './stringify.js';
+function v4(options, buf, offset) {
+    if (!buf && !options && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
+    return _v4(options, buf, offset);
+}
 function _v4(options, buf, offset) {
     options = options || {};
     const rnds = options.random ?? options.rng?.() ?? rng();
@@ -21,10 +26,4 @@ function _v4(options, buf, offset) {
     }
     return unsafeStringify(rnds);
 }
-function v4(options, buf, offset) {
-    if (native.randomUUID && !buf && !options) {
-        return native.randomUUID();
-    }
-    return _v4(options, buf, offset);
-}
 export default v4;

package/dist/v5.d.ts

@@ -1,4 +1,4 @@
-import { UUIDTypes } from './types.js';
+import type { UUIDTypes } from './types.js';
 export { DNS, URL } from './v35.js';
 declare function v5(value: string | Uint8Array, namespace: UUIDTypes, buf?: undefined, offset?: number): string;
 declare function v5<TBuf extends Uint8Array = Uint8Array>(value: string | Uint8Array, namespace: UUIDTypes, buf: TBuf, offset?: number): TBuf;

package/dist/v6.d.ts

@@ -1,4 +1,4 @@
-import { Version6Options } from './types.js';
+import type { Version6Options } from './types.js';
 declare function v6(options?: Version6Options, buf?: undefined, offset?: number): string;
 declare function v6<TBuf extends Uint8Array = Uint8Array>(options: Version6Options | undefined, buf: TBuf, offset?: number): TBuf;
 export default v6;

package/dist/v6.js

@@ -7,6 +7,9 @@ function v6(options, buf, offset) {
     let bytes = v1({ ...options, _v6: true }, new Uint8Array(16));
     bytes = v1ToV6(bytes);
     if (buf) {
+        if (offset < 0 || offset + 16 > buf.length) {
+            throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+        }
         for (let i = 0; i < 16; i++) {
             buf[offset + i] = bytes[i];
         }

package/dist/v7.d.ts

@@ -1,4 +1,4 @@
-import { Version7Options } from './types.js';
+import type { Version7Options } from './types.js';
 type V7State = {
     msecs?: number;
     seq?: number;

package/dist-node/rng.js

@@ -1,10 +1,4 @@
-import { randomFillSync } from 'node:crypto';
-const rnds8Pool = new Uint8Array(256);
-let poolPtr = rnds8Pool.length;
+const rnds8 = new Uint8Array(16);
 export default function rng() {
-    if (poolPtr > rnds8Pool.length - 16) {
-        randomFillSync(rnds8Pool);
-        poolPtr = 0;
-    }
-    return rnds8Pool.slice(poolPtr, (poolPtr += 16));
+    return crypto.getRandomValues(rnds8);
 }

package/dist-node/v35.js

@@ -26,7 +26,10 @@ export default function v35(version, hash, value, namespace, buf, offset) {
     bytes[6] = (bytes[6] & 0x0f) | version;
     bytes[8] = (bytes[8] & 0x3f) | 0x80;
     if (buf) {
-        offset = offset || 0;
+        offset ??= 0;
+        if (offset < 0 || offset + 16 > buf.length) {
+            throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+        }
         for (let i = 0; i < 16; ++i) {
             buf[offset + i] = bytes[i];
         }

package/dist-node/v4.js

@@ -1,6 +1,11 @@
-import native from './native.js';
 import rng from './rng.js';
 import { unsafeStringify } from './stringify.js';
+function v4(options, buf, offset) {
+    if (!buf && !options && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
+    return _v4(options, buf, offset);
+}
 function _v4(options, buf, offset) {
     options = options || {};
     const rnds = options.random ?? options.rng?.() ?? rng();
@@ -21,10 +26,4 @@ function _v4(options, buf, offset) {
     }
     return unsafeStringify(rnds);
 }
-function v4(options, buf, offset) {
-    if (native.randomUUID && !buf && !options) {
-        return native.randomUUID();
-    }
-    return _v4(options, buf, offset);
-}
 export default v4;

package/dist-node/v6.js

@@ -7,6 +7,9 @@ function v6(options, buf, offset) {
     let bytes = v1({ ...options, _v6: true }, new Uint8Array(16));
     bytes = v1ToV6(bytes);
     if (buf) {
+        if (offset < 0 || offset + 16 > buf.length) {
+            throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+        }
         for (let i = 0; i < 16; i++) {
             buf[offset + i] = bytes[i];
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uuid",
-  "version": "13.0.0",
+  "version": "14.0.0",
   "description": "RFC9562 UUIDs",
   "type": "module",
   "funding": [
@@ -37,35 +37,29 @@
     "!**/test"
   ],
   "devDependencies": {
-    "@babel/eslint-parser": "7.27.1",
-    "@commitlint/cli": "19.8.0",
-    "@commitlint/config-conventional": "19.8.0",
-    "@eslint/js": "9.26.0",
+    "@biomejs/biome": "2.4.10",
+    "@commitlint/cli": "20.5.0",
+    "@commitlint/config-conventional": "20.5.0",
     "bundlewatch": "0.4.1",
-    "commander": "13.1.0",
-    "eslint": "9.26.0",
-    "eslint-config-prettier": "10.1.2",
-    "eslint-plugin-prettier": "5.4.0",
-    "globals": "16.0.0",
+    "commander": "14.0.3",
+    "globals": "17.4.0",
     "husky": "9.1.7",
-    "jest": "29.7.0",
-    "lint-staged": "15.5.2",
-    "neostandard": "0.12.1",
-    "npm-run-all": "4.1.5",
-    "prettier": "3.5.3",
-    "release-please": "17.0.0",
+    "jest": "30.3.0",
+    "lint-staged": "16.4.0",
+    "neostandard": "0.13.0",
+    "npm-run-all2": "8.0.4",
+    "release-please": "17.3.0",
     "runmd": "1.4.1",
     "standard-version": "9.5.0",
-    "typescript": "5.2.2",
-    "typescript-eslint": "8.32.0"
+    "typescript": "5.4.3"
   },
   "optionalDevDependencies": {
-    "@wdio/browserstack-service": "9.2.1",
-    "@wdio/cli": "9.2.1",
-    "@wdio/jasmine-framework": "9.2.1",
-    "@wdio/local-runner": "9.2.1",
-    "@wdio/spec-reporter": "9.1.3",
-    "@wdio/static-server-service": "9.1.3"
+    "@wdio/browserstack-service": "9.27.0",
+    "@wdio/cli": "9.27.0",
+    "@wdio/jasmine-framework": "9.27.0",
+    "@wdio/local-runner": "9.27.0",
+    "@wdio/spec-reporter": "9.27.0",
+    "@wdio/static-server-service": "9.27.0"
   },
   "scripts": {
     "build": "./scripts/build.sh",
@@ -73,14 +67,14 @@
     "bundlewatch": "npm run pretest:browser && bundlewatch --config bundlewatch.config.json",
     "docs:diff": "npm run docs && git diff --quiet -I \"[0-9a-f-]{36}\" README.md",
     "docs": "npm run build && npx runmd --output=README.md README_js.md",
-    "eslint:check": "eslint src/ test/ examples/ *.[jt]s",
-    "eslint:fix": "eslint --fix src/ test/ examples/ *.[jt]s",
+    "biome:check": "biome check .",
+    "biome:fix": "biome check --write .",
     "examples:browser:rollup:build": "cd examples/browser-rollup && npm run build",
     "examples:browser:webpack:build": "cd examples/browser-webpack && npm run build",
     "examples:node:esmodules:test": "cd examples/node-esmodules && npm test",
     "examples:node:jest:test": "cd examples/node-jest && npm test",
     "examples:node:typescript:test": "cd examples/typescript && npm test",
-    "lint": "npm run eslint:check && npm run prettier:check",
+    "lint": "npm run biome:check",
     "md": "runmd --watch --output=README.md README_js.md",
     "prepack": "npm run build -- --no-pack",
     "prepare": "husky",
@@ -89,8 +83,8 @@
     "pretest:browser": "./scripts/iodd && npm run build && npm-run-all --parallel examples:browser:**",
     "pretest:node": "npm run build",
     "pretest": "npm run build",
-    "prettier:check": "prettier --check .",
-    "prettier:fix": "prettier --write .",
+    "format": "biome format --write .",
+    "format:check": "biome format --check .",
     "release": "standard-version --no-verify",
     "test:benchmark": "cd examples/benchmark && npm test",
     "test:browser": "wdio run ./wdio.conf.js",
@@ -104,16 +98,13 @@
   },
   "lint-staged": {
     "*": [
-      "prettier --no-error-on-unmatched-pattern --write"
-    ],
-    "*.{js,jsx}": [
-      "eslint --no-error-on-unmatched-pattern --fix"
+      "biome check --write --no-errors-on-unmatched"
     ]
   },
   "standard-version": {
     "scripts": {
-      "postchangelog": "prettier --write CHANGELOG.md"
+      "postchangelog": "biome format --write CHANGELOG.md"
     }
   },
-  "packageManager": "npm@11.3.0"
+  "packageManager": "npm@11.12.1"
 }

package/dist/native.d.ts

@@ -1,4 +0,0 @@
-declare const _default: {
-    randomUUID: false | (() => `${string}-${string}-${string}-${string}-${string}`);
-};
-export default _default;

package/dist/native.js

@@ -1,2 +0,0 @@
-const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
-export default { randomUUID };

package/dist-node/native.js

@@ -1,2 +0,0 @@
-import { randomUUID } from 'node:crypto';
-export default { randomUUID };